Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 15575) +++ /trunk/ippdb/Makefile.am (revision 15576) @@ -59,8 +59,10 @@ $(top_builddir)/docs/man/man3/magicSkyfileMaskRow.3 \ $(top_builddir)/docs/man/man3/calDBRow.3 \ - $(top_builddir)/docs/man/man3/calRunRow.3 + $(top_builddir)/docs/man/man3/calRunRow.3 \ + $(top_builddir)/docs/man/man3/flatcorrRunRow.3 \ + $(top_builddir)/docs/man/man3/flatcorrExpRow.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 docs/man/man3/calDBRow.3 docs/man/man3/calRunRow.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 docs/man/man3/calDBRow.3 docs/man/man3/calRunRow.3 docs/man/man3/flatcorrRunRow.3 docs/man/man3/flatcorrExpRow.3: $(DOXYGEN) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 15575) +++ /trunk/ippdb/src/ippdb.c (revision 15576) @@ -81,4 +81,6 @@ #define CALDB_TABLE_NAME "calDB" #define CALRUN_TABLE_NAME "calRun" +#define FLATCORRRUN_TABLE_NAME "flatcorrRun" +#define FLATCORREXP_TABLE_NAME "flatcorrExp" #define MAX_STRING_LENGTH 1024 @@ -22700,2 +22702,679 @@ return true; } +static void flatcorrRunRowFree(flatcorrRunRow *object); + +flatcorrRunRow *flatcorrRunRowAlloc(psS64 corr_id, const char *dvodb, const char *state, const char *workdir, const char *label) +{ + flatcorrRunRow *_object; + + _object = psAlloc(sizeof(flatcorrRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)flatcorrRunRowFree); + + _object->corr_id = corr_id; + _object->dvodb = psStringCopy(dvodb); + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->label = psStringCopy(label); + + return _object; +} + +static void flatcorrRunRowFree(flatcorrRunRow *object) +{ + psFree(object->dvodb); + psFree(object->state); + psFree(object->workdir); + psFree(object->label); +} + +bool flatcorrRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, FLATCORRRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool flatcorrRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, FLATCORRRUN_TABLE_NAME); +} + +bool flatcorrRunInsert(psDB * dbh, psS64 corr_id, const char *dvodb, const char *state, const char *workdir, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + 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, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, FLATCORRRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long flatcorrRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, FLATCORRRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool flatcorrRunInsertObject(psDB *dbh, flatcorrRunRow *object) +{ + return flatcorrRunInsert(dbh, object->corr_id, object->dvodb, object->state, object->workdir, object->label); +} + +bool flatcorrRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!flatcorrRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool flatcorrRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named FLATCORRRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, FLATCORRRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", FLATCORRRUN_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, FLATCORRRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool flatcorrRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, FLATCORRRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, FLATCORRRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *flatcorrRunMetadataFromObject(const flatcorrRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + + return md; +} + +flatcorrRunRow *flatcorrRunObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return flatcorrRunRowAlloc(corr_id, dvodb, state, workdir, label); +} +psArray *flatcorrRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, FLATCORRRUN_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++) { + flatcorrRunRow *object = flatcorrRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool flatcorrRunDeleteObject(psDB *dbh, const flatcorrRunRow *object) +{ + psMetadata *where = flatcorrRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, FLATCORRRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrRun"); + 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, "flatcorrRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long flatcorrRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + flatcorrRunRow *object = objects->data[i]; + psMetadata *where = flatcorrRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, FLATCORRRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool flatcorrRunPrintObjects(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 = flatcorrRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + FLATCORRRUN_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 flatcorrRunPrintObject(FILE *stream, flatcorrRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = flatcorrRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void flatcorrExpRowFree(flatcorrExpRow *object); + +flatcorrExpRow *flatcorrExpRowAlloc(psS64 corr_id, psS64 chip_id, const char *state) +{ + flatcorrExpRow *_object; + + _object = psAlloc(sizeof(flatcorrExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)flatcorrExpRowFree); + + _object->corr_id = corr_id; + _object->chip_id = chip_id; + _object->state = psStringCopy(state); + + return _object; +} + +static void flatcorrExpRowFree(flatcorrExpRow *object) +{ + psFree(object->state); +} + +bool flatcorrExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "corr_id", PS_DATA_S64, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "fkey(corr_id) ref flatcorrRun(corr_id)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, FLATCORREXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool flatcorrExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, FLATCORREXP_TABLE_NAME); +} + +bool flatcorrExpInsert(psDB * dbh, psS64 corr_id, psS64 chip_id, const char *state) +{ + psMetadata *md = psMetadataAlloc(); + 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, "chip_id", PS_DATA_S64, NULL, chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, FLATCORREXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long flatcorrExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, FLATCORREXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool flatcorrExpInsertObject(psDB *dbh, flatcorrExpRow *object) +{ + return flatcorrExpInsert(dbh, object->corr_id, object->chip_id, object->state); +} + +bool flatcorrExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!flatcorrExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool flatcorrExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named FLATCORREXP_TABLE_NAME + if (!psFitsMoveExtName(fits, FLATCORREXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", FLATCORREXP_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, FLATCORREXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool flatcorrExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, FLATCORREXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, FLATCORREXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *flatcorrExpMetadataFromObject(const flatcorrExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "chip_id", PS_DATA_S64, NULL, object->chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + + + return md; +} + +flatcorrExpRow *flatcorrExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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; + } + psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + + return flatcorrExpRowAlloc(corr_id, chip_id, state); +} +psArray *flatcorrExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, FLATCORREXP_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++) { + flatcorrExpRow *object = flatcorrExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool flatcorrExpDeleteObject(psDB *dbh, const flatcorrExpRow *object) +{ + psMetadata *where = flatcorrExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, FLATCORREXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrExp"); + 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, "flatcorrExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long flatcorrExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + flatcorrExpRow *object = objects->data[i]; + psMetadata *where = flatcorrExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, FLATCORREXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from flatcorrExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool flatcorrExpPrintObjects(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 = flatcorrExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + FLATCORREXP_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 flatcorrExpPrintObject(FILE *stream, flatcorrExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = flatcorrExpMetadataFromObject(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 15575) +++ /trunk/ippdb/src/ippdb.h (revision 15576) @@ -11105,4 +11105,412 @@ bool mdcf ///< format as mdconfig or simple ); +/** flatcorrRunRow data structure + * + * Structure for representing a single row of flatcorrRun table data. + */ + +typedef struct { + psS64 corr_id; + char *dvodb; + char *state; + char *workdir; + char *label; +} flatcorrRunRow; + +/** Creates a new flatcorrRunRow object + * + * @return A new flatcorrRunRow object or NULL on failure. + */ + +flatcorrRunRow *flatcorrRunRowAlloc( + psS64 corr_id, + const char *dvodb, + const char *state, + const char *workdir, + const char *label +); + +/** Creates a new flatcorrRun table + * + * @return true on success + */ + +bool flatcorrRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a flatcorrRun table + * + * @return true on success + */ + +bool flatcorrRunDropTable( + 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 flatcorrRunInsert( + psDB *dbh, ///< Database handle + psS64 corr_id, + const char *dvodb, + const char *state, + const char *workdir, + const char *label +); + +/** 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 flatcorrRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single flatcorrRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool flatcorrRunInsertObject( + psDB *dbh, ///< Database handle + flatcorrRunRow *object ///< flatcorrRunRow object +); + +/** Insert an array of flatcorrRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool flatcorrRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of flatcorrRunRow objects +); + +/** Insert data from a binary FITS table flatcorrRunRow 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 flatcorrRunInsertFits( + 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 flatcorrRunSelectRowsFits( + 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 flatcorrRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *flatcorrRunMetadataFromObject( + const flatcorrRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A flatcorrRunRow pointer or NULL on error + */ + +flatcorrRunRow *flatcorrRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as flatcorrRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *flatcorrRunSelectRowObjects( + 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 flatcorrRun + * + * 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 flatcorrRunDeleteObject( + psDB *dbh, ///< Database handle + const flatcorrRunRow *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 flatcorrRunDeleteRowObjects( + 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 flatcorrRunRow 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 flatcorrRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of flatcorrRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an flatcorrRunRow 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 flatcorrRunPrintObject( + FILE *stream, ///< a stream + flatcorrRunRow *object, ///< an flatcorrRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** flatcorrExpRow data structure + * + * Structure for representing a single row of flatcorrExp table data. + */ + +typedef struct { + psS64 corr_id; + psS64 chip_id; + char *state; +} flatcorrExpRow; + +/** Creates a new flatcorrExpRow object + * + * @return A new flatcorrExpRow object or NULL on failure. + */ + +flatcorrExpRow *flatcorrExpRowAlloc( + psS64 corr_id, + psS64 chip_id, + const char *state +); + +/** Creates a new flatcorrExp table + * + * @return true on success + */ + +bool flatcorrExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a flatcorrExp table + * + * @return true on success + */ + +bool flatcorrExpDropTable( + 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 flatcorrExpInsert( + psDB *dbh, ///< Database handle + psS64 corr_id, + psS64 chip_id, + const char *state +); + +/** 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 flatcorrExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single flatcorrExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool flatcorrExpInsertObject( + psDB *dbh, ///< Database handle + flatcorrExpRow *object ///< flatcorrExpRow object +); + +/** Insert an array of flatcorrExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool flatcorrExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of flatcorrExpRow objects +); + +/** Insert data from a binary FITS table flatcorrExpRow 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 flatcorrExpInsertFits( + 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 flatcorrExpSelectRowsFits( + 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 flatcorrExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *flatcorrExpMetadataFromObject( + const flatcorrExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A flatcorrExpRow pointer or NULL on error + */ + +flatcorrExpRow *flatcorrExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as flatcorrExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *flatcorrExpSelectRowObjects( + 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 flatcorrExp + * + * 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 flatcorrExpDeleteObject( + psDB *dbh, ///< Database handle + const flatcorrExpRow *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 flatcorrExpDeleteRowObjects( + 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 flatcorrExpRow 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 flatcorrExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of flatcorrExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an flatcorrExpRow 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 flatcorrExpPrintObject( + FILE *stream, ///< a stream + flatcorrExpRow *object, ///< an flatcorrExpRow object + bool mdcf ///< format as mdconfig or simple +); /// @} @@ -11112,3 +11520,3 @@ #endif -#endif // CALRUN_DB_H +#endif // FLATCORREXP_DB_H Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 15575) +++ /trunk/ippdb/tests/alloc.c (revision 15576) @@ -2486,4 +2486,62 @@ } + { + flatcorrRunRow *object; + + object = flatcorrRunRowAlloc(-64, "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->corr_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + flatcorrExpRow *object; + + object = flatcorrExpRowAlloc(-64, -64, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->corr_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->chip_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/createtable.c =================================================================== --- /trunk/ippdb/tests/createtable.c (revision 15575) +++ /trunk/ippdb/tests/createtable.c (revision 15576) @@ -755,4 +755,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!flatcorrRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!flatcorrExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 15575) +++ /trunk/ippdb/tests/dbcleanup.c (revision 15576) @@ -61,4 +61,6 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS calDB"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS calRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS flatcorrRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS flatcorrExp"); psDBCleanup(dbh); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 15575) +++ /trunk/ippdb/tests/dbsetup.c (revision 15576) @@ -163,4 +163,10 @@ calRunCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS flatcorrRun"); + flatcorrRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS flatcorrExp"); + flatcorrExpCreateTable(dbh); + psDBCleanup(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 15575) +++ /trunk/ippdb/tests/droptable.c (revision 15576) @@ -755,4 +755,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!flatcorrRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!flatcorrExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 15575) +++ /trunk/ippdb/tests/insert.c (revision 15576) @@ -755,4 +755,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!flatcorrRunInsert(dbh, -64, "a string", "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 (!flatcorrExpInsert(dbh, -64, -64, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insertfits.c =================================================================== --- /trunk/ippdb/tests/insertfits.c (revision 15575) +++ /trunk/ippdb/tests/insertfits.c (revision 15576) @@ -1309,4 +1309,56 @@ } + { + 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 (!flatcorrRunInsertFits(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 (!flatcorrExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insertobject.c =================================================================== --- /trunk/ippdb/tests/insertobject.c (revision 15575) +++ /trunk/ippdb/tests/insertobject.c (revision 15576) @@ -1105,4 +1105,48 @@ } + { + psDB *dbh; + flatcorrRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = flatcorrRunRowAlloc(-64, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!flatcorrRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + flatcorrExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = flatcorrExpRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!flatcorrExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 15575) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 15576) @@ -2805,4 +2805,75 @@ } + { + psMetadata *md; + flatcorrRunRow *object; + bool status; + + object = flatcorrRunRowAlloc(-64, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = flatcorrRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + flatcorrExpRow *object; + bool status; + + object = flatcorrExpRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = flatcorrExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/objectfrommetadata.c =================================================================== --- /trunk/ippdb/tests/objectfrommetadata.c (revision 15575) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 15576) @@ -4402,4 +4402,98 @@ } + { + psMetadata *md; + flatcorrRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = flatcorrRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + flatcorrExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = flatcorrExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/selectrowsfits.c =================================================================== --- /trunk/ippdb/tests/selectrowsfits.c (revision 15575) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 15576) @@ -1107,4 +1107,48 @@ } + { + 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 (!flatcorrRunSelectRowsFits(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 (!flatcorrExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); }