Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 8367) +++ /trunk/ippdb/Makefile.am (revision 8368) @@ -36,4 +36,5 @@ $(top_builddir)/docs/man/man3/detProcessedImfileRow.3 \ $(top_builddir)/docs/man/man3/detStackedImfileRow.3 \ + $(top_builddir)/docs/man/man3/detNormalizedStatImfileRow.3 \ $(top_builddir)/docs/man/man3/detNormalizedImfileRow.3 \ $(top_builddir)/docs/man/man3/detMasterFrameRow.3 \ @@ -43,5 +44,5 @@ -docs/man/man3/ippdb.3 docs/man/man3/weatherRow.3 docs/man/man3/skyp_transparencyRow.3 docs/man/man3/skyp_absorptionRow.3 docs/man/man3/skyp_emissionRow.3 docs/man/man3/dimmRow.3 docs/man/man3/skyp_irRow.3 docs/man/man3/domeRow.3 docs/man/man3/telescopeRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2DoneExpRow.3 docs/man/man3/p2DoneImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detMasterFrameRow.3 docs/man/man3/detMasterImfileRow.3 docs/man/man3/detResidImfileAnalysisRow.3 docs/man/man3/detResidExpAnalysisRow.3: +docs/man/man3/ippdb.3 docs/man/man3/weatherRow.3 docs/man/man3/skyp_transparencyRow.3 docs/man/man3/skyp_absorptionRow.3 docs/man/man3/skyp_emissionRow.3 docs/man/man3/dimmRow.3 docs/man/man3/skyp_irRow.3 docs/man/man3/domeRow.3 docs/man/man3/telescopeRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2DoneExpRow.3 docs/man/man3/p2DoneImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detMasterFrameRow.3 docs/man/man3/detMasterImfileRow.3 docs/man/man3/detResidImfileAnalysisRow.3 docs/man/man3/detResidExpAnalysisRow.3: $(DOXYGEN) Index: /trunk/ippdb/configure.ac =================================================================== --- /trunk/ippdb/configure.ac (revision 8367) +++ /trunk/ippdb/configure.ac (revision 8368) @@ -1,5 +1,5 @@ AC_PREREQ(2.59) -AC_INIT([ippdb], [0.0.28], [pan-starrs.ifa.hawaii.edu]) +AC_INIT([ippdb], [0.0.29], [pan-starrs.ifa.hawaii.edu]) AC_CONFIG_SRCDIR([ippdb.pc.in]) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 8367) +++ /trunk/ippdb/src/ippdb.c (revision 8368) @@ -56,4 +56,6 @@ #define DETSTACKEDIMFILE_TABLE_NAME "detStackedImfile" #define DETSTACKEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME +#define DETNORMALIZEDSTATIMFILE_TABLE_NAME "detNormalizedStatImfile" +#define DETNORMALIZEDSTATIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME #define DETNORMALIZEDIMFILE_TABLE_NAME "detNormalizedImfile" #define DETNORMALIZEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME @@ -14583,4 +14585,476 @@ return true; } +static void detNormalizedStatImfileRowFree(detNormalizedStatImfileRow *object); + +detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc(psS32 det_id, psS32 iteration, const char *class_id, psF32 norm) +{ + detNormalizedStatImfileRow *object; + + object = psAlloc(sizeof(detNormalizedStatImfileRow)); + psMemSetDeallocator(object, (psFreeFunc)detNormalizedStatImfileRowFree); + + object->det_id = det_id; + object->iteration = iteration; + object->class_id = psStringCopy(class_id); + object->norm = norm; + + return object; +} + +static void detNormalizedStatImfileRowFree(detNormalizedStatImfileRow *object) +{ + psFree(object->class_id); +} + +bool detNormalizedStatImfileCreateTable(psDB *dbh) +{ + psMetadata *md; + bool status; + + md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, DETNORMALIZEDSTATIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME); + psFree(md); + return false; + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "norm", 0, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return false; + } + + status = psDBCreateTable(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detNormalizedStatImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME); +} + +bool detNormalizedStatImfileInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *class_id, psF32 norm) +{ + psMetadata *md; + bool status; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "norm", 0, NULL, norm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return false; + } + + status = psDBInsertOneRow(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detNormalizedStatImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detNormalizedStatImfilePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **class_id, psF32 *norm) +{ + psArray *rowSet; + psMetadata *row; + psMetadata *popped; + long deleted; + bool status; + int rowID; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, NULL, 1); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME); + psFree(rowSet); + return NULL; + } + + row = psArrayGet(rowSet, 0); + psMemIncrRefCounter(row); + if (!row) { + psError(PS_ERR_UNKNOWN, true, "database error or table is empty"); + return NULL; + } + psFree(rowSet); + + rowID = psMetadataLookupS32(&status, row, DETNORMALIZEDSTATIMFILE_INDEX_NAME); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME); + psFree(row); + return NULL; + } + + popped = psMetadataAlloc(); + psMetadataAddS32(popped, PS_LIST_TAIL, DETNORMALIZEDSTATIMFILE_INDEX_NAME, 0, NULL, rowID); + + deleted = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, popped, 0); + if (deleted != 1) { + psError(PS_ERR_UNKNOWN, false, "database failed to delete row"); + psFree(popped); + psFree(row); + return NULL; + } + + psFree(popped); + + *det_id = psMetadataLookupS32(&status, row, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + psFree(row); + return false; + } + *iteration = psMetadataLookupS32(&status, row, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + psFree(row); + return false; + } + *class_id = psMetadataLookupPtr(&status, row, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + psFree(row); + return false; + } + *norm = psMetadataLookupF32(&status, row, "norm"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item norm"); + psFree(row); + return false; + } + + psFree(row); + + return true; +} + +bool detNormalizedStatImfileInsertObject(psDB *dbh, detNormalizedStatImfileRow *object) +{ + return detNormalizedStatImfileInsert(dbh, object->det_id, object->iteration, object->class_id, object->norm); +} + +bool detNormalizedStatImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detNormalizedStatImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +detNormalizedStatImfileRow *detNormalizedStatImfilePopObject(psDB *dbh) +{ + psS32 det_id; + psS32 iteration; + char class_id[256]; + psF32 norm; + + if (!detNormalizedStatImfilePop(dbh, &det_id, &iteration, (char **)&class_id, &norm)) { + psError(PS_ERR_UNKNOWN, false, "failed to pop a database row"); + return NULL; + } + + return detNormalizedStatImfileRowAlloc(det_id, iteration, class_id, norm); +} + +bool detNormalizedStatImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETNORMALIZEDSTATIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETNORMALIZEDSTATIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETNORMALIZEDSTATIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detNormalizedStatImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit) +{ + char query[MAX_STRING_LENGTH]; + + if (!detNormalizedStatImfileSelectRowsFits(dbh, fits, NULL, limit)) { + psError(PS_ERR_UNKNOWN, true, "database error or table is empty"); + return false; + } + + // remove limit rows from the end of the database + if (snprintf(query, MAX_STRING_LENGTH, + "DELETE FROM %s ORDER BY %s DESC LIMIT %lld", + DETNORMALIZEDSTATIMFILE_TABLE_NAME, DETNORMALIZEDSTATIMFILE_INDEX_NAME, limit) < 0) { + psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %s bytes", MAX_STRING_LENGTH); + return false; + } + + if (!p_psDBRunQuery(dbh, query)) { + psError(PS_ERR_UNKNOWN, false, "database query failed"); + return false; + } + + return true; +} + +bool detNormalizedStatImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // strip index column + for (i = 0; i < rowSet->n; i++) { + if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETNORMALIZEDSTATIMFILE_INDEX_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME); + psFree(rowSet); + return false; + } + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETNORMALIZEDSTATIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detNormalizedStatImfileMetadataFromObject(const detNormalizedStatImfileRow *object) +{ + psMetadata *md; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return NULL; + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return NULL; + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return NULL; + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "norm", 0, NULL, object->norm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return NULL; + } + + return md; +} + +detNormalizedStatImfileRow *detNormalizedStatImfileObjectFromMetadata(psMetadata *md) +{ + bool status; + psS32 det_id; + psS32 iteration; + char *class_id; + psF32 norm; + + det_id = psMetadataLookupS32(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + norm = psMetadataLookupF32(&status, md, "norm"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item norm"); + return false; + } + + return detNormalizedStatImfileRowAlloc(det_id, iteration, class_id, norm); +} +psArray *detNormalizedStatImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // strip index column + for (i = 0; i < rowSet->n; i++) { + if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETNORMALIZEDSTATIMFILE_INDEX_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME); + psFree(rowSet); + return false; + } + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAlloc(rowSet->n); + returnSet->n = 0; + + for (i = 0; i < rowSet->n; i++) { + detNormalizedStatImfileRow *object = detNormalizedStatImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detNormalizedStatImfileDeleteObject(psDB *dbh, const detNormalizedStatImfileRow *object) +{ + psMetadata *where = detNormalizedStatImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detNormalizedStatImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detNormalizedStatImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detNormalizedStatImfileRow *object = objects->data[i]; + psMetadata *where = detNormalizedStatImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detNormalizedStatImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detNormalizedStatImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETNORMALIZEDSTATIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} static void detNormalizedImfileRowFree(detNormalizedImfileRow *object); Index: /trunk/ippdb/src/ippdb.h =================================================================== --- /trunk/ippdb/src/ippdb.h (revision 8367) +++ /trunk/ippdb/src/ippdb.h (revision 8368) @@ -6279,4 +6279,231 @@ bool mdcf ///< format as mdconfig or simple ); +/** detNormalizedStatImfileRow data structure + * + * Structure for representing a single row of detNormalizedStatImfile table data. + */ + +typedef struct { + psS32 det_id; + psS32 iteration; + char *class_id; + psF32 norm; +} detNormalizedStatImfileRow; + +/** Creates a new detNormalizedStatImfileRow object + * + * @return A new detNormalizedStatImfileRow object or NULL on failure. + */ + +detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc( + psS32 det_id, + psS32 iteration, + const char *class_id, + psF32 norm +); + +/** Creates a new detNormalizedStatImfile table + * + * @return true on success + */ + +bool detNormalizedStatImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detNormalizedStatImfile table + * + * @return true on success + */ + +bool detNormalizedStatImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsert( + psDB *dbh, ///< Database handle + psS32 det_id, + psS32 iteration, + const char *class_id, + psF32 norm +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedStatImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Removes the last row from the database and returns it + * + * @return true on success + */ + +bool detNormalizedStatImfilePop( + psDB *dbh, ///< Database handle + psS32 *det_id, + psS32 *iteration, + char **class_id, + psF32 *norm +); + +/** Insert a single detNormalizedStatImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertObject( + psDB *dbh, ///< Database handle + detNormalizedStatImfileRow *object ///< detNormalizedStatImfileRow object +); + +/** Insert an array of detNormalizedStatImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detNormalizedStatImfileRow objects +); + +/** Removes the last row from the database and returns it + * + * @return A new detNormalizedStatImfileRow on success or NULL on failure. + */ + +detNormalizedStatImfileRow *detNormalizedStatImfilePopObject( + psDB *dbh ///< Database handle +); + +/** Insert data from a binary FITS table detNormalizedStatImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Removes the last limit row from the database and returns them in a binary FITS table. + * + * This function assumes an empty psFits object and will create a FITS table as + * the first extension. + * + * @return true on success + */ + +bool detNormalizedStatImfilePopFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + unsigned long long limit ///< Maximum number of elements to return +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detNormalizedStatImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detNormalizedStatImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detNormalizedStatImfileMetadataFromObject( + const detNormalizedStatImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detNormalizedStatImfileRow pointer or NULL on error + */ + +detNormalizedStatImfileRow *detNormalizedStatImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detNormalizedStatImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detNormalizedStatImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detNormalizedStatImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detNormalizedStatImfileDeleteObject( + psDB *dbh, ///< Database handle + const detNormalizedStatImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedStatImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detNormalizedStatImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedStatImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detNormalizedStatImfileRow objects + bool mdcf ///< format as mdconfig or simple +); /** detNormalizedImfileRow data structure * Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 8367) +++ /trunk/ippdb/tests/alloc.c (revision 8368) @@ -1042,4 +1042,33 @@ { + detNormalizedStatImfileRow *object; + + object = detNormalizedStatImfileRowAlloc(-32, -32, "a string", 32.32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->norm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { detNormalizedImfileRow *object; Index: /trunk/ippdb/tests/createtable.c =================================================================== --- /trunk/ippdb/tests/createtable.c (revision 8367) +++ /trunk/ippdb/tests/createtable.c (revision 8368) @@ -403,4 +403,19 @@ } + if(!detNormalizedStatImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if(!detNormalizedImfileCreateTable(dbh)) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 8367) +++ /trunk/ippdb/tests/dbcleanup.c (revision 8368) @@ -37,4 +37,5 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detProcessedImfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detStackedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedStatImfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedImfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detMasterFrame"); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 8367) +++ /trunk/ippdb/tests/dbsetup.c (revision 8368) @@ -91,4 +91,7 @@ detStackedImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedStatImfile"); + detNormalizedStatImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedImfile"); detNormalizedImfileCreateTable(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 8367) +++ /trunk/ippdb/tests/droptable.c (revision 8368) @@ -403,4 +403,19 @@ } + if (!detNormalizedStatImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!detNormalizedImfileDropTable(dbh)) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 8367) +++ /trunk/ippdb/tests/insert.c (revision 8368) @@ -403,4 +403,19 @@ } + if (!detNormalizedStatImfileInsert(dbh, -32, -32, "a string", 32.32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!detNormalizedImfileInsert(dbh, -32, -32, "a string", "a string", "a string")) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/insertfits.c =================================================================== --- /trunk/ippdb/tests/insertfits.c (revision 8367) +++ /trunk/ippdb/tests/insertfits.c (revision 8368) @@ -700,4 +700,30 @@ } + if (!detNormalizedStatImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + if (!detNormalizedImfileInsertFits(dbh, fits)) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/insertobject.c =================================================================== --- /trunk/ippdb/tests/insertobject.c (revision 8367) +++ /trunk/ippdb/tests/insertobject.c (revision 8368) @@ -579,4 +579,26 @@ { psDB *dbh; + detNormalizedStatImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detNormalizedStatImfileRowAlloc(-32, -32, "a string", 32.32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; detNormalizedImfileRow *object; Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 8367) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 8368) @@ -1252,4 +1252,41 @@ { psMetadata *md; + detNormalizedStatImfileRow *object; + bool status; + + object = detNormalizedStatImfileRowAlloc(-32, -32, "a string", 32.32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedStatImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "norm") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; detNormalizedImfileRow *object; bool status; Index: /trunk/ippdb/tests/objectfrommetadata.c =================================================================== --- /trunk/ippdb/tests/objectfrommetadata.c (revision 8367) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 8368) @@ -1870,4 +1870,54 @@ { psMetadata *md; + detNormalizedStatImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "norm", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = detNormalizedStatImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->norm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; detNormalizedImfileRow *object; Index: /trunk/ippdb/tests/pop.c =================================================================== --- /trunk/ippdb/tests/pop.c (revision 8367) +++ /trunk/ippdb/tests/pop.c (revision 8368) @@ -574,4 +574,23 @@ psS32 iteration; char class_id[256]; + psF32 norm; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfilePop(dbh, &det_id, &iteration, (char **)&class_id, &norm)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psS32 det_id; + psS32 iteration; + char class_id[256]; char uri[256]; char recipe[256]; Index: /trunk/ippdb/tests/popfits.c =================================================================== --- /trunk/ippdb/tests/popfits.c (revision 8367) +++ /trunk/ippdb/tests/popfits.c (revision 8368) @@ -700,4 +700,30 @@ } + if (!detNormalizedStatImfilePopFits(dbh, fits, 1)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // allocate a temp + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + if (!detNormalizedImfilePopFits(dbh, fits, 1)) { exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/popobject.c =================================================================== --- /trunk/ippdb/tests/popobject.c (revision 8367) +++ /trunk/ippdb/tests/popobject.c (revision 8368) @@ -475,4 +475,22 @@ { psDB *dbh; + detNormalizedStatImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detNormalizedStatImfilePopObject(dbh); + if (!object) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; detNormalizedImfileRow *object; Index: /trunk/ippdb/tests/selectrowsfits.c =================================================================== --- /trunk/ippdb/tests/selectrowsfits.c (revision 8367) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 8368) @@ -593,4 +593,26 @@ } + if (!detNormalizedStatImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + if (!detNormalizedImfileSelectRowsFits(dbh, fits, NULL, 1)) { exit(EXIT_FAILURE);