Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 15342) +++ /trunk/ippdb/Makefile.am (revision 15343) @@ -10,4 +10,5 @@ man_MANS = \ $(top_builddir)/docs/man/man3/ippdb.3 \ + $(top_builddir)/docs/man/man3/pzDataStoreRow.3 \ $(top_builddir)/docs/man/man3/summitExpRow.3 \ $(top_builddir)/docs/man/man3/summitImfileRow.3 \ @@ -49,12 +50,15 @@ $(top_builddir)/docs/man/man3/detRunSummaryRow.3 \ $(top_builddir)/docs/man/man3/detRegisteredImfileRow.3 \ + $(top_builddir)/docs/man/man3/detCorrectedExpRow.3 \ + $(top_builddir)/docs/man/man3/detCorrectedImfileRow.3 \ $(top_builddir)/docs/man/man3/magicRunRow.3 \ $(top_builddir)/docs/man/man3/magicInputSkyfileRow.3 \ $(top_builddir)/docs/man/man3/magicTreeRow.3 \ $(top_builddir)/docs/man/man3/magicNodeResultRow.3 \ - $(top_builddir)/docs/man/man3/magicMaskRow.3 + $(top_builddir)/docs/man/man3/magicMaskRow.3 \ + $(top_builddir)/docs/man/man3/magicSkyfileMaskRow.3 -docs/man/man3/ippdb.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/guidePendingExpRow.3 docs/man/man3/chipRunRow.3 docs/man/man3/chipProcessedImfileRow.3 docs/man/man3/chipMaskRow.3 docs/man/man3/camRunRow.3 docs/man/man3/camProcessedExpRow.3 docs/man/man3/camMaskRow.3 docs/man/man3/warpRunRow.3 docs/man/man3/warpInputExpRow.3 docs/man/man3/warpSkyCellMapRow.3 docs/man/man3/warpSkyfileRow.3 docs/man/man3/diffRunRow.3 docs/man/man3/diffInputSkyfileRow.3 docs/man/man3/diffSkyfileRow.3 docs/man/man3/stackRunRow.3 docs/man/man3/stackInputSkyfileRow.3 docs/man/man3/stackSumSkyfileRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/detRegisteredImfileRow.3 docs/man/man3/magicRunRow.3 docs/man/man3/magicInputSkyfileRow.3 docs/man/man3/magicTreeRow.3 docs/man/man3/magicNodeResultRow.3 docs/man/man3/magicMaskRow.3: +docs/man/man3/ippdb.3 docs/man/man3/pzDataStoreRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/guidePendingExpRow.3 docs/man/man3/chipRunRow.3 docs/man/man3/chipProcessedImfileRow.3 docs/man/man3/chipMaskRow.3 docs/man/man3/camRunRow.3 docs/man/man3/camProcessedExpRow.3 docs/man/man3/camMaskRow.3 docs/man/man3/warpRunRow.3 docs/man/man3/warpInputExpRow.3 docs/man/man3/warpSkyCellMapRow.3 docs/man/man3/warpSkyfileRow.3 docs/man/man3/diffRunRow.3 docs/man/man3/diffInputSkyfileRow.3 docs/man/man3/diffSkyfileRow.3 docs/man/man3/stackRunRow.3 docs/man/man3/stackInputSkyfileRow.3 docs/man/man3/stackSumSkyfileRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/detRegisteredImfileRow.3 docs/man/man3/detCorrectedExpRow.3 docs/man/man3/detCorrectedImfileRow.3 docs/man/man3/magicRunRow.3 docs/man/man3/magicInputSkyfileRow.3 docs/man/man3/magicTreeRow.3 docs/man/man3/magicNodeResultRow.3 docs/man/man3/magicMaskRow.3 docs/man/man3/magicSkyfileMaskRow.3: $(DOXYGEN) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 15342) +++ /trunk/ippdb/src/ippdb.c (revision 15343) @@ -31,4 +31,5 @@ #include "ippdb.h" +#define PZDATASTORE_TABLE_NAME "pzDataStore" #define SUMMITEXP_TABLE_NAME "summitExp" #define SUMMITIMFILE_TABLE_NAME "summitImfile" @@ -70,4 +71,6 @@ #define DETRUNSUMMARY_TABLE_NAME "detRunSummary" #define DETREGISTEREDIMFILE_TABLE_NAME "detRegisteredImfile" +#define DETCORRECTEDEXP_TABLE_NAME "detCorrectedExp" +#define DETCORRECTEDIMFILE_TABLE_NAME "detCorrectedImfile" #define MAGICRUN_TABLE_NAME "magicRun" #define MAGICINPUTSKYFILE_TABLE_NAME "magicInputSkyfile" @@ -75,4 +78,5 @@ #define MAGICNODERESULT_TABLE_NAME "magicNodeResult" #define MAGICMASK_TABLE_NAME "magicMask" +#define MAGICSKYFILEMASK_TABLE_NAME "magicSkyfileMask" #define MAX_STRING_LENGTH 1024 @@ -251,4 +255,322 @@ } +static void pzDataStoreRowFree(pzDataStoreRow *object); + +pzDataStoreRow *pzDataStoreRowAlloc(const char *camera, const char *telescope, const char *uri) +{ + pzDataStoreRow *_object; + + _object = psAlloc(sizeof(pzDataStoreRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzDataStoreRowFree); + + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void pzDataStoreRowFree(pzDataStoreRow *object) +{ + psFree(object->camera); + psFree(object->telescope); + psFree(object->uri); +} + +bool pzDataStoreCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, PZDATASTORE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool pzDataStoreDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, PZDATASTORE_TABLE_NAME); +} + +bool pzDataStoreInsert(psDB * dbh, const char *camera, const char *telescope, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, PZDATASTORE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long pzDataStoreDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, PZDATASTORE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDataStore"); + return count; + + deleted += count; + } + + return deleted; +} +bool pzDataStoreInsertObject(psDB *dbh, pzDataStoreRow *object) +{ + return pzDataStoreInsert(dbh, object->camera, object->telescope, object->uri); +} + +bool pzDataStoreInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!pzDataStoreInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool pzDataStoreInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named PZDATASTORE_TABLE_NAME + if (!psFitsMoveExtName(fits, PZDATASTORE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZDATASTORE_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, PZDATASTORE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool pzDataStoreSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, PZDATASTORE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, PZDATASTORE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *pzDataStoreMetadataFromObject(const pzDataStoreRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +pzDataStoreRow *pzDataStoreObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return pzDataStoreRowAlloc(camera, telescope, uri); +} +psArray *pzDataStoreSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, PZDATASTORE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + pzDataStoreRow *object = pzDataStoreObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool pzDataStoreDeleteObject(psDB *dbh, const pzDataStoreRow *object) +{ + psMetadata *where = pzDataStoreMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDATASTORE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDataStore"); + 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, "pzDataStoreRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long pzDataStoreDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + pzDataStoreRow *object = objects->data[i]; + psMetadata *where = pzDataStoreMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDATASTORE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDataStore"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool pzDataStorePrintObjects(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 = pzDataStoreMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + PZDATASTORE_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; +} +bool pzDataStorePrintObject(FILE *stream, pzDataStoreRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = pzDataStoreMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} static void summitExpRowFree(summitExpRow *object); @@ -18886,4 +19208,809 @@ return true; } +static void detCorrectedExpRowFree(detCorrectedExpRow *object); + +detCorrectedExpRow *detCorrectedExpRowAlloc(psS64 det_id, psS64 exp_id, const char *uri, psS64 corr_id, const char *corr_type, const char *recipe, const char *path_base, psS16 fault) +{ + detCorrectedExpRow *_object; + + _object = psAlloc(sizeof(detCorrectedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detCorrectedExpRowFree); + + _object->det_id = det_id; + _object->exp_id = exp_id; + _object->uri = psStringCopy(uri); + _object->corr_id = corr_id; + _object->corr_type = psStringCopy(corr_type); + _object->recipe = psStringCopy(recipe); + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detCorrectedExpRowFree(detCorrectedExpRow *object) +{ + psFree(object->uri); + psFree(object->corr_type); + psFree(object->recipe); + psFree(object->path_base); +} + +bool detCorrectedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, "INDEX(det_id, exp_id)", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_id", PS_DATA_S64, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_type", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETCORRECTEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detCorrectedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETCORRECTEDEXP_TABLE_NAME); +} + +bool detCorrectedExpInsert(psDB * dbh, psS64 det_id, psS64 exp_id, const char *uri, psS64 corr_id, const char *corr_type, const char *recipe, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_id", PS_DATA_S64, NULL, corr_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_type", PS_DATA_STRING, NULL, corr_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETCORRECTEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detCorrectedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETCORRECTEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool detCorrectedExpInsertObject(psDB *dbh, detCorrectedExpRow *object) +{ + return detCorrectedExpInsert(dbh, object->det_id, object->exp_id, object->uri, object->corr_id, object->corr_type, object->recipe, object->path_base, object->fault); +} + +bool detCorrectedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detCorrectedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detCorrectedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETCORRECTEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, DETCORRECTEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETCORRECTEDEXP_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, DETCORRECTEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detCorrectedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETCORRECTEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETCORRECTEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detCorrectedExpMetadataFromObject(const detCorrectedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_id", PS_DATA_S64, NULL, object->corr_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_type", PS_DATA_STRING, NULL, object->corr_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detCorrectedExpRow *detCorrectedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psS64 corr_id = psMetadataLookupS64(&status, md, "corr_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item corr_id"); + return false; + } + char* corr_type = psMetadataLookupPtr(&status, md, "corr_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item corr_type"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detCorrectedExpRowAlloc(det_id, exp_id, uri, corr_id, corr_type, recipe, path_base, fault); +} +psArray *detCorrectedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETCORRECTEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detCorrectedExpRow *object = detCorrectedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detCorrectedExpDeleteObject(psDB *dbh, const detCorrectedExpRow *object) +{ + psMetadata *where = detCorrectedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETCORRECTEDEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedExp"); + 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, "detCorrectedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detCorrectedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detCorrectedExpRow *object = objects->data[i]; + psMetadata *where = detCorrectedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETCORRECTEDEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detCorrectedExpPrintObjects(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 = detCorrectedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETCORRECTEDEXP_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; +} +bool detCorrectedExpPrintObject(FILE *stream, detCorrectedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detCorrectedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detCorrectedImfileRowFree(detCorrectedImfileRow *object); + +detCorrectedImfileRow *detCorrectedImfileRowAlloc(psS64 det_id, psS64 exp_id, const char *class_id, const char *uri, const char *path_base, psS16 fault) +{ + detCorrectedImfileRow *_object; + + _object = psAlloc(sizeof(detCorrectedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detCorrectedImfileRowFree); + + _object->det_id = det_id; + _object->exp_id = exp_id; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detCorrectedImfileRowFree(detCorrectedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->path_base); +} + +bool detCorrectedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key INDEX(det_id, class_id)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, "INDEX(det_id, exp_id)", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETCORRECTEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detCorrectedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETCORRECTEDIMFILE_TABLE_NAME); +} + +bool detCorrectedImfileInsert(psDB * dbh, psS64 det_id, psS64 exp_id, const char *class_id, const char *uri, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETCORRECTEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detCorrectedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETCORRECTEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detCorrectedImfileInsertObject(psDB *dbh, detCorrectedImfileRow *object) +{ + return detCorrectedImfileInsert(dbh, object->det_id, object->exp_id, object->class_id, object->uri, object->path_base, object->fault); +} + +bool detCorrectedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detCorrectedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detCorrectedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETCORRECTEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETCORRECTEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETCORRECTEDIMFILE_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, DETCORRECTEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detCorrectedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETCORRECTEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETCORRECTEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detCorrectedImfileMetadataFromObject(const detCorrectedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detCorrectedImfileRow *detCorrectedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detCorrectedImfileRowAlloc(det_id, exp_id, class_id, uri, path_base, fault); +} +psArray *detCorrectedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETCORRECTEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detCorrectedImfileRow *object = detCorrectedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detCorrectedImfileDeleteObject(psDB *dbh, const detCorrectedImfileRow *object) +{ + psMetadata *where = detCorrectedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETCORRECTEDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedImfile"); + 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, "detCorrectedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detCorrectedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detCorrectedImfileRow *object = objects->data[i]; + psMetadata *where = detCorrectedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETCORRECTEDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detCorrectedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detCorrectedImfilePrintObjects(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 = detCorrectedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETCORRECTEDIMFILE_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; +} +bool detCorrectedImfilePrintObject(FILE *stream, detCorrectedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detCorrectedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} static void magicRunRowFree(magicRunRow *object); @@ -19320,10 +20447,10 @@ return false; } - if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Key fkey(diff_id) ref diffRun(diff_id)", 0)) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key fkey(diff_id) ref diffRun(diff_id)", 0)) { psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); psFree(md); return false; } - if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "INDEX(magic_id, node)", "64")) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, NULL, "64")) { psError(PS_ERR_UNKNOWN, false, "failed to add item node"); psFree(md); @@ -19632,15 +20759,15 @@ { psMetadata *md = psMetadataAlloc(); - if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Key fkey(magic_id) ref magicRun(magic_id)", 0)) { psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); psFree(md); return false; } - if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node)", "64")) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Key INDEX(magic_id, node)", "64")) { psError(PS_ERR_UNKNOWN, false, "failed to add item node"); psFree(md); return false; } - if (!psMetadataAdd(md, PS_LIST_TAIL, "dep", PS_DATA_STRING, "fkey(magic_id, dep) ref magicInputSkyfile(magic_id, node)", "64")) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "dep", PS_DATA_STRING, "Key", "64")) { psError(PS_ERR_UNKNOWN, false, "failed to add item dep"); psFree(md); @@ -19954,5 +21081,5 @@ return false; } - if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node)", "64")) { + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Primary Key fkey(magic_id, node) ref magicTree(magic_id, node)", "64")) { psError(PS_ERR_UNKNOWN, false, "failed to add item node"); psFree(md); @@ -20536,2 +21663,318 @@ return true; } +static void magicSkyfileMaskRowFree(magicSkyfileMaskRow *object); + +magicSkyfileMaskRow *magicSkyfileMaskRowAlloc(psS64 magic_id, psS64 diff_id, const char *uri) +{ + magicSkyfileMaskRow *_object; + + _object = psAlloc(sizeof(magicSkyfileMaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicSkyfileMaskRowFree); + + _object->magic_id = magic_id; + _object->diff_id = diff_id; + _object->uri = psStringCopy(uri); + + return _object; +} + +static void magicSkyfileMaskRowFree(magicSkyfileMaskRow *object) +{ + psFree(object->uri); +} + +bool magicSkyfileMaskCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key fkey(diff_id) ref magicInputSkyfile(magic_id, diff_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, "fkey(magic_id) ref magicMask(magic_id)", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICSKYFILEMASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicSkyfileMaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICSKYFILEMASK_TABLE_NAME); +} + +bool magicSkyfileMaskInsert(psDB * dbh, psS64 magic_id, psS64 diff_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICSKYFILEMASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicSkyfileMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICSKYFILEMASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicSkyfileMask"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicSkyfileMaskInsertObject(psDB *dbh, magicSkyfileMaskRow *object) +{ + return magicSkyfileMaskInsert(dbh, object->magic_id, object->diff_id, object->uri); +} + +bool magicSkyfileMaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicSkyfileMaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicSkyfileMaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICSKYFILEMASK_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICSKYFILEMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICSKYFILEMASK_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, MAGICSKYFILEMASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicSkyfileMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICSKYFILEMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICSKYFILEMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicSkyfileMaskMetadataFromObject(const magicSkyfileMaskRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +magicSkyfileMaskRow *magicSkyfileMaskObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return magicSkyfileMaskRowAlloc(magic_id, diff_id, uri); +} +psArray *magicSkyfileMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICSKYFILEMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicSkyfileMaskRow *object = magicSkyfileMaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicSkyfileMaskDeleteObject(psDB *dbh, const magicSkyfileMaskRow *object) +{ + psMetadata *where = magicSkyfileMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICSKYFILEMASK_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicSkyfileMask"); + 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, "magicSkyfileMaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicSkyfileMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicSkyfileMaskRow *object = objects->data[i]; + psMetadata *where = magicSkyfileMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICSKYFILEMASK_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicSkyfileMask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicSkyfileMaskPrintObjects(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 = magicSkyfileMaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICSKYFILEMASK_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; +} +bool magicSkyfileMaskPrintObject(FILE *stream, magicSkyfileMaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicSkyfileMaskMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} Index: /trunk/ippdb/src/ippdb.h =================================================================== --- /trunk/ippdb/src/ippdb.h (revision 15342) +++ /trunk/ippdb/src/ippdb.h (revision 15343) @@ -125,4 +125,205 @@ ); +/** pzDataStoreRow data structure + * + * Structure for representing a single row of pzDataStore table data. + */ + +typedef struct { + char *camera; + char *telescope; + char *uri; +} pzDataStoreRow; + +/** Creates a new pzDataStoreRow object + * + * @return A new pzDataStoreRow object or NULL on failure. + */ + +pzDataStoreRow *pzDataStoreRowAlloc( + const char *camera, + const char *telescope, + const char *uri +); + +/** Creates a new pzDataStore table + * + * @return true on success + */ + +bool pzDataStoreCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a pzDataStore table + * + * @return true on success + */ + +bool pzDataStoreDropTable( + 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 pzDataStoreInsert( + psDB *dbh, ///< Database handle + const char *camera, + const char *telescope, + const char *uri +); + +/** 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 pzDataStoreDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single pzDataStoreRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzDataStoreInsertObject( + psDB *dbh, ///< Database handle + pzDataStoreRow *object ///< pzDataStoreRow object +); + +/** Insert an array of pzDataStoreRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool pzDataStoreInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of pzDataStoreRow objects +); + +/** Insert data from a binary FITS table pzDataStoreRow 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 pzDataStoreInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** 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 pzDataStoreSelectRowsFits( + 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 pzDataStoreRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *pzDataStoreMetadataFromObject( + const pzDataStoreRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A pzDataStoreRow pointer or NULL on error + */ + +pzDataStoreRow *pzDataStoreObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as pzDataStoreRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *pzDataStoreSelectRowObjects( + 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 pzDataStore + * + * 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 pzDataStoreDeleteObject( + psDB *dbh, ///< Database handle + const pzDataStoreRow *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 pzDataStoreDeleteRowObjects( + 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 pzDataStoreRow 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 pzDataStorePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of pzDataStoreRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an pzDataStoreRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzDataStorePrintObject( + FILE *stream, ///< a stream + pzDataStoreRow *object, ///< an pzDataStoreRow object + bool mdcf ///< format as mdconfig or simple +); /** summitExpRow data structure * @@ -8849,4 +9050,430 @@ bool mdcf ///< format as mdconfig or simple ); +/** detCorrectedExpRow data structure + * + * Structure for representing a single row of detCorrectedExp table data. + */ + +typedef struct { + psS64 det_id; + psS64 exp_id; + char *uri; + psS64 corr_id; + char *corr_type; + char *recipe; + char *path_base; + psS16 fault; +} detCorrectedExpRow; + +/** Creates a new detCorrectedExpRow object + * + * @return A new detCorrectedExpRow object or NULL on failure. + */ + +detCorrectedExpRow *detCorrectedExpRowAlloc( + psS64 det_id, + psS64 exp_id, + const char *uri, + psS64 corr_id, + const char *corr_type, + const char *recipe, + const char *path_base, + psS16 fault +); + +/** Creates a new detCorrectedExp table + * + * @return true on success + */ + +bool detCorrectedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detCorrectedExp table + * + * @return true on success + */ + +bool detCorrectedExpDropTable( + 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 detCorrectedExpInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS64 exp_id, + const char *uri, + psS64 corr_id, + const char *corr_type, + const char *recipe, + const char *path_base, + psS16 fault +); + +/** 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 detCorrectedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detCorrectedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detCorrectedExpInsertObject( + psDB *dbh, ///< Database handle + detCorrectedExpRow *object ///< detCorrectedExpRow object +); + +/** Insert an array of detCorrectedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detCorrectedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detCorrectedExpRow objects +); + +/** Insert data from a binary FITS table detCorrectedExpRow 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 detCorrectedExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** 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 detCorrectedExpSelectRowsFits( + 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 detCorrectedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detCorrectedExpMetadataFromObject( + const detCorrectedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detCorrectedExpRow pointer or NULL on error + */ + +detCorrectedExpRow *detCorrectedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detCorrectedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detCorrectedExpSelectRowObjects( + 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 detCorrectedExp + * + * 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 detCorrectedExpDeleteObject( + psDB *dbh, ///< Database handle + const detCorrectedExpRow *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 detCorrectedExpDeleteRowObjects( + 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 detCorrectedExpRow 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 detCorrectedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detCorrectedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detCorrectedExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detCorrectedExpPrintObject( + FILE *stream, ///< a stream + detCorrectedExpRow *object, ///< an detCorrectedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** detCorrectedImfileRow data structure + * + * Structure for representing a single row of detCorrectedImfile table data. + */ + +typedef struct { + psS64 det_id; + psS64 exp_id; + char *class_id; + char *uri; + char *path_base; + psS16 fault; +} detCorrectedImfileRow; + +/** Creates a new detCorrectedImfileRow object + * + * @return A new detCorrectedImfileRow object or NULL on failure. + */ + +detCorrectedImfileRow *detCorrectedImfileRowAlloc( + psS64 det_id, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *path_base, + psS16 fault +); + +/** Creates a new detCorrectedImfile table + * + * @return true on success + */ + +bool detCorrectedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detCorrectedImfile table + * + * @return true on success + */ + +bool detCorrectedImfileDropTable( + 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 detCorrectedImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *path_base, + psS16 fault +); + +/** 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 detCorrectedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detCorrectedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detCorrectedImfileInsertObject( + psDB *dbh, ///< Database handle + detCorrectedImfileRow *object ///< detCorrectedImfileRow object +); + +/** Insert an array of detCorrectedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detCorrectedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detCorrectedImfileRow objects +); + +/** Insert data from a binary FITS table detCorrectedImfileRow 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 detCorrectedImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** 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 detCorrectedImfileSelectRowsFits( + 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 detCorrectedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detCorrectedImfileMetadataFromObject( + const detCorrectedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detCorrectedImfileRow pointer or NULL on error + */ + +detCorrectedImfileRow *detCorrectedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detCorrectedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detCorrectedImfileSelectRowObjects( + 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 detCorrectedImfile + * + * 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 detCorrectedImfileDeleteObject( + psDB *dbh, ///< Database handle + const detCorrectedImfileRow *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 detCorrectedImfileDeleteRowObjects( + 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 detCorrectedImfileRow 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 detCorrectedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detCorrectedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detCorrectedImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detCorrectedImfilePrintObject( + FILE *stream, ///< a stream + detCorrectedImfileRow *object, ///< an detCorrectedImfileRow object + bool mdcf ///< format as mdconfig or simple +); /** magicRunRow data structure * @@ -9863,4 +10490,205 @@ bool mdcf ///< format as mdconfig or simple ); +/** magicSkyfileMaskRow data structure + * + * Structure for representing a single row of magicSkyfileMask table data. + */ + +typedef struct { + psS64 magic_id; + psS64 diff_id; + char *uri; +} magicSkyfileMaskRow; + +/** Creates a new magicSkyfileMaskRow object + * + * @return A new magicSkyfileMaskRow object or NULL on failure. + */ + +magicSkyfileMaskRow *magicSkyfileMaskRowAlloc( + psS64 magic_id, + psS64 diff_id, + const char *uri +); + +/** Creates a new magicSkyfileMask table + * + * @return true on success + */ + +bool magicSkyfileMaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicSkyfileMask table + * + * @return true on success + */ + +bool magicSkyfileMaskDropTable( + 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 magicSkyfileMaskInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + psS64 diff_id, + const char *uri +); + +/** 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 magicSkyfileMaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicSkyfileMaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicSkyfileMaskInsertObject( + psDB *dbh, ///< Database handle + magicSkyfileMaskRow *object ///< magicSkyfileMaskRow object +); + +/** Insert an array of magicSkyfileMaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicSkyfileMaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicSkyfileMaskRow objects +); + +/** Insert data from a binary FITS table magicSkyfileMaskRow 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 magicSkyfileMaskInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** 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 magicSkyfileMaskSelectRowsFits( + 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 magicSkyfileMaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicSkyfileMaskMetadataFromObject( + const magicSkyfileMaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicSkyfileMaskRow pointer or NULL on error + */ + +magicSkyfileMaskRow *magicSkyfileMaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicSkyfileMaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicSkyfileMaskSelectRowObjects( + 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 magicSkyfileMask + * + * 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 magicSkyfileMaskDeleteObject( + psDB *dbh, ///< Database handle + const magicSkyfileMaskRow *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 magicSkyfileMaskDeleteRowObjects( + 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 magicSkyfileMaskRow 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 magicSkyfileMaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicSkyfileMaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicSkyfileMaskRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicSkyfileMaskPrintObject( + FILE *stream, ///< a stream + magicSkyfileMaskRow *object, ///< an magicSkyfileMaskRow object + bool mdcf ///< format as mdconfig or simple +); /// @} @@ -9870,3 +10698,3 @@ #endif -#endif // MAGICMASK_DB_H +#endif // MAGICSKYFILEMASK_DB_H Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 15342) +++ /trunk/ippdb/tests/alloc.c (revision 15343) @@ -9,4 +9,29 @@ { { + pzDataStoreRow *object; + + object = pzDataStoreRowAlloc("a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { summitExpRow *object; @@ -2153,4 +2178,86 @@ { + detCorrectedExpRow *object; + + object = detCorrectedExpRowAlloc(-64, -64, "a string", -64, "a string", "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->corr_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->corr_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detCorrectedImfileRow *object; + + object = detCorrectedImfileRowAlloc(-64, -64, "a string", "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { magicRunRow *object; @@ -2277,4 +2384,29 @@ if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicSkyfileMaskRow *object; + + object = magicSkyfileMaskRowAlloc(-64, -64, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->diff_id == -64) { psFree(object); exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/createtable.c =================================================================== --- /trunk/ippdb/tests/createtable.c (revision 15342) +++ /trunk/ippdb/tests/createtable.c (revision 15343) @@ -13,4 +13,19 @@ } + if(!pzDataStoreCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if(!summitExpCreateTable(dbh)) { exit(EXIT_FAILURE); @@ -598,4 +613,34 @@ } + if(!detCorrectedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detCorrectedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if(!magicRunCreateTable(dbh)) { exit(EXIT_FAILURE); @@ -659,4 +704,19 @@ if(!magicMaskCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicSkyfileMaskCreateTable(dbh)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 15342) +++ /trunk/ippdb/tests/dbcleanup.c (revision 15343) @@ -11,4 +11,5 @@ } + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDataStore"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitImfile"); @@ -50,4 +51,6 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRegisteredImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detCorrectedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detCorrectedImfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicRun"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicInputSkyfile"); @@ -55,4 +58,5 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicNodeResult"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicMask"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicSkyfileMask"); psDBCleanup(dbh); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 15342) +++ /trunk/ippdb/tests/dbsetup.c (revision 15343) @@ -13,4 +13,7 @@ // remove the table if it already exists + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDataStore"); + pzDataStoreCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp"); summitExpCreateTable(dbh); @@ -130,4 +133,10 @@ detRegisteredImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detCorrectedExp"); + detCorrectedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detCorrectedImfile"); + detCorrectedImfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicRun"); magicRunCreateTable(dbh); @@ -145,4 +154,7 @@ magicMaskCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicSkyfileMask"); + magicSkyfileMaskCreateTable(dbh); + psDBCleanup(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 15342) +++ /trunk/ippdb/tests/droptable.c (revision 15343) @@ -13,4 +13,19 @@ } + if (!pzDataStoreDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!summitExpDropTable(dbh)) { exit(EXIT_FAILURE); @@ -598,4 +613,34 @@ } + if (!detCorrectedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detCorrectedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!magicRunDropTable(dbh)) { exit(EXIT_FAILURE); @@ -659,4 +704,19 @@ if (!magicMaskDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicSkyfileMaskDropTable(dbh)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 15342) +++ /trunk/ippdb/tests/insert.c (revision 15343) @@ -13,4 +13,19 @@ } + if (!pzDataStoreInsert(dbh, "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!summitExpInsert(dbh, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32)) { exit(EXIT_FAILURE); @@ -598,4 +613,34 @@ } + if (!detCorrectedExpInsert(dbh, -64, -64, "a string", -64, "a string", "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detCorrectedImfileInsert(dbh, -64, -64, "a string", "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + if (!magicRunInsert(dbh, -64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z")) { exit(EXIT_FAILURE); @@ -659,4 +704,19 @@ if (!magicMaskInsert(dbh, -64, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicSkyfileMaskInsert(dbh, -64, -64, "a string")) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insertfits.c =================================================================== --- /trunk/ippdb/tests/insertfits.c (revision 15342) +++ /trunk/ippdb/tests/insertfits.c (revision 15343) @@ -24,4 +24,30 @@ } + if (!pzDataStoreInsertFits(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 (!summitExpInsertFits(dbh, fits)) { exit(EXIT_FAILURE); @@ -1038,4 +1064,56 @@ } + if (!detCorrectedExpInsertFits(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 (!detCorrectedImfileInsertFits(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 (!magicRunInsertFits(dbh, fits)) { exit(EXIT_FAILURE); @@ -1143,4 +1221,30 @@ if (!magicMaskInsertFits(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 (!magicSkyfileMaskInsertFits(dbh, fits)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/insertobject.c =================================================================== --- /trunk/ippdb/tests/insertobject.c (revision 15342) +++ /trunk/ippdb/tests/insertobject.c (revision 15343) @@ -7,4 +7,26 @@ { psDB *dbh; + pzDataStoreRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = pzDataStoreRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!pzDataStoreInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; summitExpRow *object; @@ -865,4 +887,48 @@ { psDB *dbh; + detCorrectedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detCorrectedExpRowAlloc(-64, -64, "a string", -64, "a string", "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detCorrectedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detCorrectedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detCorrectedImfileRowAlloc(-64, -64, "a string", "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detCorrectedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; magicRunRow *object; @@ -966,4 +1032,26 @@ if (!magicMaskInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicSkyfileMaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicSkyfileMaskRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicSkyfileMaskInsertObject(dbh, object)) { exit(EXIT_FAILURE); } Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 15342) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 15343) @@ -10,4 +10,37 @@ { psMetadata *md; + pzDataStoreRow *object; + bool status; + + object = pzDataStoreRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzDataStoreMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; summitExpRow *object; bool status; @@ -2402,4 +2435,95 @@ { psMetadata *md; + detCorrectedExpRow *object; + bool status; + + object = detCorrectedExpRowAlloc(-64, -64, "a string", -64, "a string", "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detCorrectedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "corr_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detCorrectedImfileRow *object; + bool status; + + object = detCorrectedImfileRowAlloc(-64, -64, "a string", "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detCorrectedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; magicRunRow *object; bool status; @@ -2559,4 +2683,35 @@ psFree(object); + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicSkyfileMaskRow *object; + bool status; + + object = magicSkyfileMaskRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicSkyfileMaskMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } psFree(md); exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/objectfrommetadata.c =================================================================== --- /trunk/ippdb/tests/objectfrommetadata.c (revision 15342) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 15343) @@ -10,4 +10,46 @@ { psMetadata *md; + pzDataStoreRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = pzDataStoreObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; summitExpRow *object; @@ -3858,4 +3900,138 @@ { psMetadata *md; + detCorrectedExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "corr_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detCorrectedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->corr_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detCorrectedImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detCorrectedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; magicRunRow *object; @@ -4065,4 +4241,42 @@ psFree(md); + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicSkyfileMaskRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicSkyfileMaskObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } psFree(object); exit(EXIT_FAILURE); Index: /trunk/ippdb/tests/selectrowsfits.c =================================================================== --- /trunk/ippdb/tests/selectrowsfits.c (revision 15342) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 15343) @@ -21,4 +21,26 @@ } + if (!pzDataStoreSelectRowsFits(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 (!summitExpSelectRowsFits(dbh, fits, NULL, 1)) { exit(EXIT_FAILURE); @@ -879,4 +901,48 @@ } + if (!detCorrectedExpSelectRowsFits(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 (!detCorrectedImfileSelectRowsFits(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 (!magicRunSelectRowsFits(dbh, fits, NULL, 1)) { exit(EXIT_FAILURE); @@ -968,4 +1034,26 @@ if (!magicMaskSelectRowsFits(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 (!magicSkyfileMaskSelectRowsFits(dbh, fits, NULL, 1)) { exit(EXIT_FAILURE); }