Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 11808) +++ /trunk/ippdb/Makefile.am (revision 11809) @@ -44,8 +44,11 @@ $(top_builddir)/docs/man/man3/p4InputExpRow.3 \ $(top_builddir)/docs/man/man3/p4SkyCellMapRow.3 \ - $(top_builddir)/docs/man/man3/p4ScfileRow.3 + $(top_builddir)/docs/man/man3/p4ScfileRow.3 \ + $(top_builddir)/docs/man/man3/p5RunRow.3 \ + $(top_builddir)/docs/man/man3/p5InputScfileRow.3 \ + $(top_builddir)/docs/man/man3/p5DiffScfileRow.3 -docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.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/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.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/p4RunRow.3 docs/man/man3/p4InputExpRow.3 docs/man/man3/p4SkyCellMapRow.3 docs/man/man3/p4ScfileRow.3: +docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.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/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.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/p4RunRow.3 docs/man/man3/p4InputExpRow.3 docs/man/man3/p4SkyCellMapRow.3 docs/man/man3/p4ScfileRow.3 docs/man/man3/p5RunRow.3 docs/man/man3/p5InputScfileRow.3 docs/man/man3/p5DiffScfileRow.3: $(DOXYGEN) Index: /trunk/ippdb/configure.ac =================================================================== --- /trunk/ippdb/configure.ac (revision 11808) +++ /trunk/ippdb/configure.ac (revision 11809) @@ -7,5 +7,5 @@ AC_PREREQ(2.59) -AC_INIT([ippdb], [1.1.5], [pan-starrs.ifa.hawaii.edu]) +AC_INIT([ippdb], [1.1.6], [pan-starrs.ifa.hawaii.edu]) AC_CONFIG_SRCDIR([ippdb.pc.in]) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 11808) +++ /trunk/ippdb/src/ippdb.c (revision 11809) @@ -66,4 +66,7 @@ #define P4SKYCELLMAP_TABLE_NAME "p4SkyCellMap" #define P4SCFILE_TABLE_NAME "p4Scfile" +#define P5RUN_TABLE_NAME "p5Run" +#define P5INPUTSCFILE_TABLE_NAME "p5InputScfile" +#define P5DIFFSCFILE_TABLE_NAME "p5DiffScfile" #define MAX_STRING_LENGTH 1024 @@ -14960,2 +14963,1146 @@ return true; } +static void p5RunRowFree(p5RunRow *object); + +p5RunRow *p5RunRowAlloc(psS32 p5_id, const char *state, const char *workdir, psTime* registered) +{ + p5RunRow *_object; + + _object = psAlloc(sizeof(p5RunRow)); + psMemSetDeallocator(_object, (psFreeFunc)p5RunRowFree); + + _object->p5_id = p5_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->registered = psTimeCopy(registered); + + return _object; +} + +static void p5RunRowFree(p5RunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->registered); +} + +bool p5RunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "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, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P5RUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p5RunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P5RUN_TABLE_NAME); +} + +bool p5RunInsert(psDB * dbh, psS32 p5_id, const char *state, const char *workdir, psTime* registered) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_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; + } + 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, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P5RUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p5RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run"); + return count; + + deleted += count; + } + + return deleted; +} +bool p5RunInsertObject(psDB *dbh, p5RunRow *object) +{ + return p5RunInsert(dbh, object->p5_id, object->state, object->workdir, object->registered); +} + +bool p5RunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p5RunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p5RunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P5RUN_TABLE_NAME + if (!psFitsMoveExtName(fits, P5RUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5RUN_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, P5RUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p5RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P5RUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P5RUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p5RunMetadataFromObject(const p5RunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_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; + } + 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, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + + return md; +} + +p5RunRow *p5RunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_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; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + + return p5RunRowAlloc(p5_id, state, workdir, registered); +} +psArray *p5RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P5RUN_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++) { + p5RunRow *object = p5RunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p5RunDeleteObject(psDB *dbh, const p5RunRow *object) +{ + psMetadata *where = p5RunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run"); + 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, "p5RunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p5RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p5RunRow *object = objects->data[i]; + psMetadata *where = p5RunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p5RunPrintObjects(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 = p5RunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P5RUN_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 p5RunPrintObject(FILE *stream, p5RunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p5RunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p5InputScfileRowFree(p5InputScfileRow *object); + +p5InputScfileRow *p5InputScfileRowAlloc(psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind, bool template) +{ + p5InputScfileRow *_object; + + _object = psAlloc(sizeof(p5InputScfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p5InputScfileRowFree); + + _object->p5_id = p5_id; + _object->p4_id = p4_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->exp_tag = psStringCopy(exp_tag); + _object->p3_version = p3_version; + _object->kind = psStringCopy(kind); + _object->template = template; + + return _object; +} + +static void p5InputScfileRowFree(p5InputScfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->exp_tag); + psFree(object->kind); +} + +bool p5InputScfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P5INPUTSCFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p5InputScfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P5INPUTSCFILE_TABLE_NAME); +} + +bool p5InputScfileInsert(psDB * dbh, psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind, bool template) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, template)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P5INPUTSCFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p5InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p5InputScfileInsertObject(psDB *dbh, p5InputScfileRow *object) +{ + return p5InputScfileInsert(dbh, object->p5_id, object->p4_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind, object->template); +} + +bool p5InputScfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p5InputScfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p5InputScfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P5INPUTSCFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P5INPUTSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5INPUTSCFILE_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, P5INPUTSCFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p5InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P5INPUTSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p5InputScfileMetadataFromObject(const p5InputScfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, object->template)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + + + return md; +} + +p5InputScfileRow *p5InputScfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_id"); + return false; + } + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* kind = psMetadataLookupPtr(&status, md, "kind"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind"); + return false; + } + bool template = psMetadataLookupBool(&status, md, "template"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item template"); + return false; + } + + return p5InputScfileRowAlloc(p5_id, p4_id, skycell_id, tess_id, exp_tag, p3_version, kind, template); +} +psArray *p5InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P5INPUTSCFILE_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++) { + p5InputScfileRow *object = p5InputScfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p5InputScfileDeleteObject(psDB *dbh, const p5InputScfileRow *object) +{ + psMetadata *where = p5InputScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile"); + 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, "p5InputScfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p5InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p5InputScfileRow *object = objects->data[i]; + psMetadata *where = p5InputScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p5InputScfilePrintObjects(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 = p5InputScfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P5INPUTSCFILE_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 p5InputScfilePrintObject(FILE *stream, p5InputScfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p5InputScfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p5DiffScfileRowFree(p5DiffScfileRow *object); + +p5DiffScfileRow *p5DiffScfileRowAlloc(psS32 p5_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev) +{ + p5DiffScfileRow *_object; + + _object = psAlloc(sizeof(p5DiffScfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p5DiffScfileRowFree); + + _object->p5_id = p5_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->uri = psStringCopy(uri); + _object->bg = bg; + _object->bg_mean_stdev = bg_mean_stdev; + + return _object; +} + +static void p5DiffScfileRowFree(p5DiffScfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->uri); +} + +bool p5DiffScfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + 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; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P5DIFFSCFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p5DiffScfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P5DIFFSCFILE_TABLE_NAME); +} + +bool p5DiffScfileInsert(psDB * dbh, psS32 p5_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_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, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P5DIFFSCFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p5DiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p5DiffScfileInsertObject(psDB *dbh, p5DiffScfileRow *object) +{ + return p5DiffScfileInsert(dbh, object->p5_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev); +} + +bool p5DiffScfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p5DiffScfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p5DiffScfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P5DIFFSCFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P5DIFFSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5DIFFSCFILE_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, P5DIFFSCFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p5DiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P5DIFFSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p5DiffScfileMetadataFromObject(const p5DiffScfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_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, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + + + return md; +} + +p5DiffScfileRow *p5DiffScfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_id"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_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; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + + return p5DiffScfileRowAlloc(p5_id, skycell_id, tess_id, uri, bg, bg_mean_stdev); +} +psArray *p5DiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P5DIFFSCFILE_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++) { + p5DiffScfileRow *object = p5DiffScfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p5DiffScfileDeleteObject(psDB *dbh, const p5DiffScfileRow *object) +{ + psMetadata *where = p5DiffScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile"); + 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, "p5DiffScfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p5DiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p5DiffScfileRow *object = objects->data[i]; + psMetadata *where = p5DiffScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p5DiffScfilePrintObjects(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 = p5DiffScfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P5DIFFSCFILE_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 p5DiffScfilePrintObject(FILE *stream, p5DiffScfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p5DiffScfileMetadataFromObject(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 11808) +++ /trunk/ippdb/src/ippdb.h (revision 11809) @@ -7667,4 +7667,634 @@ bool mdcf ///< format as mdconfig or simple ); +/** p5RunRow data structure + * + * Structure for representing a single row of p5Run table data. + */ + +typedef struct { + psS32 p5_id; + char *state; + char *workdir; + psTime* registered; +} p5RunRow; + +/** Creates a new p5RunRow object + * + * @return A new p5RunRow object or NULL on failure. + */ + +p5RunRow *p5RunRowAlloc( + psS32 p5_id, + const char *state, + const char *workdir, + psTime* registered +); + +/** Creates a new p5Run table + * + * @return true on success + */ + +bool p5RunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p5Run table + * + * @return true on success + */ + +bool p5RunDropTable( + 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 p5RunInsert( + psDB *dbh, ///< Database handle + psS32 p5_id, + const char *state, + const char *workdir, + psTime* registered +); + +/** 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 p5RunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p5RunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p5RunInsertObject( + psDB *dbh, ///< Database handle + p5RunRow *object ///< p5RunRow object +); + +/** Insert an array of p5RunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p5RunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p5RunRow objects +); + +/** Insert data from a binary FITS table p5RunRow 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 p5RunInsertFits( + 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 p5RunSelectRowsFits( + 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 p5RunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p5RunMetadataFromObject( + const p5RunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p5RunRow pointer or NULL on error + */ + +p5RunRow *p5RunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p5RunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p5RunSelectRowObjects( + 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 p5Run + * + * 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 p5RunDeleteObject( + psDB *dbh, ///< Database handle + const p5RunRow *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 p5RunDeleteRowObjects( + 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 p5RunRow 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 p5RunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p5RunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p5RunRow 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 p5RunPrintObject( + FILE *stream, ///< a stream + p5RunRow *object, ///< an p5RunRow object + bool mdcf ///< format as mdconfig or simple +); +/** p5InputScfileRow data structure + * + * Structure for representing a single row of p5InputScfile table data. + */ + +typedef struct { + psS32 p5_id; + psS32 p4_id; + char *skycell_id; + char *tess_id; + char *exp_tag; + psS32 p3_version; + char *kind; + bool template; +} p5InputScfileRow; + +/** Creates a new p5InputScfileRow object + * + * @return A new p5InputScfileRow object or NULL on failure. + */ + +p5InputScfileRow *p5InputScfileRowAlloc( + psS32 p5_id, + psS32 p4_id, + const char *skycell_id, + const char *tess_id, + const char *exp_tag, + psS32 p3_version, + const char *kind, + bool template +); + +/** Creates a new p5InputScfile table + * + * @return true on success + */ + +bool p5InputScfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p5InputScfile table + * + * @return true on success + */ + +bool p5InputScfileDropTable( + 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 p5InputScfileInsert( + psDB *dbh, ///< Database handle + psS32 p5_id, + psS32 p4_id, + const char *skycell_id, + const char *tess_id, + const char *exp_tag, + psS32 p3_version, + const char *kind, + bool template +); + +/** 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 p5InputScfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p5InputScfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p5InputScfileInsertObject( + psDB *dbh, ///< Database handle + p5InputScfileRow *object ///< p5InputScfileRow object +); + +/** Insert an array of p5InputScfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p5InputScfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p5InputScfileRow objects +); + +/** Insert data from a binary FITS table p5InputScfileRow 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 p5InputScfileInsertFits( + 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 p5InputScfileSelectRowsFits( + 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 p5InputScfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p5InputScfileMetadataFromObject( + const p5InputScfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p5InputScfileRow pointer or NULL on error + */ + +p5InputScfileRow *p5InputScfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p5InputScfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p5InputScfileSelectRowObjects( + 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 p5InputScfile + * + * 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 p5InputScfileDeleteObject( + psDB *dbh, ///< Database handle + const p5InputScfileRow *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 p5InputScfileDeleteRowObjects( + 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 p5InputScfileRow 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 p5InputScfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p5InputScfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p5InputScfileRow 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 p5InputScfilePrintObject( + FILE *stream, ///< a stream + p5InputScfileRow *object, ///< an p5InputScfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p5DiffScfileRow data structure + * + * Structure for representing a single row of p5DiffScfile table data. + */ + +typedef struct { + psS32 p5_id; + char *skycell_id; + char *tess_id; + char *uri; + psF64 bg; + psF64 bg_mean_stdev; +} p5DiffScfileRow; + +/** Creates a new p5DiffScfileRow object + * + * @return A new p5DiffScfileRow object or NULL on failure. + */ + +p5DiffScfileRow *p5DiffScfileRowAlloc( + psS32 p5_id, + const char *skycell_id, + const char *tess_id, + const char *uri, + psF64 bg, + psF64 bg_mean_stdev +); + +/** Creates a new p5DiffScfile table + * + * @return true on success + */ + +bool p5DiffScfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p5DiffScfile table + * + * @return true on success + */ + +bool p5DiffScfileDropTable( + 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 p5DiffScfileInsert( + psDB *dbh, ///< Database handle + psS32 p5_id, + const char *skycell_id, + const char *tess_id, + const char *uri, + psF64 bg, + psF64 bg_mean_stdev +); + +/** 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 p5DiffScfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p5DiffScfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p5DiffScfileInsertObject( + psDB *dbh, ///< Database handle + p5DiffScfileRow *object ///< p5DiffScfileRow object +); + +/** Insert an array of p5DiffScfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p5DiffScfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p5DiffScfileRow objects +); + +/** Insert data from a binary FITS table p5DiffScfileRow 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 p5DiffScfileInsertFits( + 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 p5DiffScfileSelectRowsFits( + 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 p5DiffScfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p5DiffScfileMetadataFromObject( + const p5DiffScfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p5DiffScfileRow pointer or NULL on error + */ + +p5DiffScfileRow *p5DiffScfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p5DiffScfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p5DiffScfileSelectRowObjects( + 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 p5DiffScfile + * + * 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 p5DiffScfileDeleteObject( + psDB *dbh, ///< Database handle + const p5DiffScfileRow *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 p5DiffScfileDeleteRowObjects( + 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 p5DiffScfileRow 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 p5DiffScfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p5DiffScfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p5DiffScfileRow 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 p5DiffScfilePrintObject( + FILE *stream, ///< a stream + p5DiffScfileRow *object, ///< an p5DiffScfileRow object + bool mdcf ///< format as mdconfig or simple +); /// @} @@ -7674,3 +8304,3 @@ #endif -#endif // P4SCFILE_DB_H +#endif // P5DIFFSCFILE_DB_H Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 11808) +++ /trunk/ippdb/tests/alloc.c (revision 11809) @@ -1550,4 +1550,114 @@ } + { + p5RunRow *object; + + object = p5RunRowAlloc(-32, "a string", "a string", "0001-01-01T00:00:00Z" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p5_id == -32) { + 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); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p5InputScfileRow *object; + + object = p5InputScfileRowAlloc(-32, -32, "a string", "a string", "a string", -32, "a string", true ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p5_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->template == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p5DiffScfileRow *object; + + object = p5DiffScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p5_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_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 (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/createtable.c =================================================================== --- /trunk/ippdb/tests/createtable.c (revision 11808) +++ /trunk/ippdb/tests/createtable.c (revision 11809) @@ -530,4 +530,49 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p5RunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p5InputScfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p5DiffScfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 11808) +++ /trunk/ippdb/tests/dbcleanup.c (revision 11809) @@ -46,4 +46,7 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4SkyCellMap"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Scfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5Run"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5InputScfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5DiffScfile"); psDBCleanup(dbh); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 11808) +++ /trunk/ippdb/tests/dbsetup.c (revision 11809) @@ -118,4 +118,13 @@ p4ScfileCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5Run"); + p5RunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5InputScfile"); + p5InputScfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5DiffScfile"); + p5DiffScfileCreateTable(dbh); + psDBCleanup(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 11808) +++ /trunk/ippdb/tests/droptable.c (revision 11809) @@ -530,4 +530,49 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5RunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5InputScfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5DiffScfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 11808) +++ /trunk/ippdb/tests/insert.c (revision 11809) @@ -530,4 +530,49 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5RunInsert(dbh, -32, "a string", "a string", "0001-01-01T00:00:00Z")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5InputScfileInsert(dbh, -32, -32, "a string", "a string", "a string", -32, "a string", true)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p5DiffScfileInsert(dbh, -32, "a string", "a string", "a string", 64.64, 64.64)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insertfits.c =================================================================== --- /trunk/ippdb/tests/insertfits.c (revision 11808) +++ /trunk/ippdb/tests/insertfits.c (revision 11809) @@ -919,4 +919,82 @@ } + { + 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 (!p5RunInsertFits(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 (!p5InputScfileInsertFits(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 (!p5DiffScfileInsertFits(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 11808) +++ /trunk/ippdb/tests/insertobject.c (revision 11809) @@ -775,4 +775,70 @@ } + { + psDB *dbh; + p5RunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p5RunRowAlloc(-32, "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p5RunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p5InputScfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p5InputScfileRowAlloc(-32, -32, "a string", "a string", "a string", -32, "a string", true); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p5InputScfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p5DiffScfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p5DiffScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p5DiffScfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 11808) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 11809) @@ -1816,4 +1816,138 @@ } + { + psMetadata *md; + p5RunRow *object; + bool status; + + object = p5RunRowAlloc(-32, "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p5RunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p5_id") == -32) { + 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); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p5InputScfileRow *object; + bool status; + + object = p5InputScfileRowAlloc(-32, -32, "a string", "a string", "a string", -32, "a string", true); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p5InputScfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p5_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "template") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p5DiffScfileRow *object; + bool status; + + object = p5DiffScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p5DiffScfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p5_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_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 (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/objectfrommetadata.c =================================================================== --- /trunk/ippdb/tests/objectfrommetadata.c (revision 11808) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 11809) @@ -2784,4 +2784,200 @@ } + { + psMetadata *md; + p5RunRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p5_id", 0, NULL, -32)) { + 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); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = p5RunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p5_id == -32) { + 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); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p5InputScfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p5_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "kind", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p5InputScfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p5_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->template == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p5DiffScfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p5_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_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 (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p5DiffScfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p5_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_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 (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/selectrowsfits.c =================================================================== --- /trunk/ippdb/tests/selectrowsfits.c (revision 11808) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 11809) @@ -777,4 +777,70 @@ } + { + 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 (!p5RunSelectRowsFits(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 (!p5InputScfileSelectRowsFits(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 (!p5DiffScfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); }