Index: /trunk/dbconfig/p6.md =================================================================== --- /trunk/dbconfig/p6.md (revision 11866) +++ /trunk/dbconfig/p6.md (revision 11867) @@ -1,3 +1,3 @@ -# $Id: p6.md,v 1.2 2007-02-15 02:46:29 jhoblitt Exp $ +# $Id: p6.md,v 1.3 2007-02-17 02:42:39 jhoblitt Exp $ p6Run METADATA @@ -8,2 +8,17 @@ END +p6InputScfile METADATA + p6_id S32 0 # Primary Key + p4_id S32 0 # Primary Key + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key +END + +p6SumScfile METADATA + p6_id S32 0 # Primary Key + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key + uri STR 255 + bg F64 0.0 + bg_mean_stdev F64 0.0 +END Index: /trunk/ippTools/configure.ac =================================================================== --- /trunk/ippTools/configure.ac (revision 11866) +++ /trunk/ippTools/configure.ac (revision 11867) @@ -1,5 +1,5 @@ AC_PREREQ(2.59) -AC_INIT([ipptools], [1.1.7], [ipp-support@ifa.hawaii.edu]) +AC_INIT([ipptools], [1.1.8], [ipp-support@ifa.hawaii.edu]) AC_CONFIG_SRCDIR([autogen.sh]) @@ -18,5 +18,5 @@ PKG_CHECK_MODULES([PSLIB], [pslib >= 1.1.0]) PKG_CHECK_MODULES([PSMODULES], [psmodules >= 1.1.0]) -PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.7]) +PKG_CHECK_MODULES([IPPDB], [ippdb >= 1.1.8]) PXTOOLS_CFLAGS="${PSLIB_CFLAGS=} ${PSMODULES_CFLAGS=} ${IPPDB_CFLAGS=}" Index: /trunk/ippdb/Makefile.am =================================================================== --- /trunk/ippdb/Makefile.am (revision 11866) +++ /trunk/ippdb/Makefile.am (revision 11867) @@ -48,8 +48,10 @@ $(top_builddir)/docs/man/man3/p5InputScfileRow.3 \ $(top_builddir)/docs/man/man3/p5DiffScfileRow.3 \ - $(top_builddir)/docs/man/man3/p6RunRow.3 + $(top_builddir)/docs/man/man3/p6RunRow.3 \ + $(top_builddir)/docs/man/man3/p6InputScfileRow.3 \ + $(top_builddir)/docs/man/man3/p6SumScfileRow.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 docs/man/man3/p6RunRow.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 docs/man/man3/p6RunRow.3 docs/man/man3/p6InputScfileRow.3 docs/man/man3/p6SumScfileRow.3: $(DOXYGEN) Index: /trunk/ippdb/src/ippdb.c =================================================================== --- /trunk/ippdb/src/ippdb.c (revision 11866) +++ /trunk/ippdb/src/ippdb.c (revision 11867) @@ -70,4 +70,6 @@ #define P5DIFFSCFILE_TABLE_NAME "p5DiffScfile" #define P6RUN_TABLE_NAME "p6Run" +#define P6INPUTSCFILE_TABLE_NAME "p6InputScfile" +#define P6SUMSCFILE_TABLE_NAME "p6SumScfile" #define MAX_STRING_LENGTH 1024 @@ -16510,2 +16512,721 @@ return true; } +static void p6InputScfileRowFree(p6InputScfileRow *object); + +p6InputScfileRow *p6InputScfileRowAlloc(psS32 p6_id, psS32 p4_id, const char *skycell_id, const char *tess_id) +{ + p6InputScfileRow *_object; + + _object = psAlloc(sizeof(p6InputScfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p6InputScfileRowFree); + + _object->p6_id = p6_id; + _object->p4_id = p4_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + + return _object; +} + +static void p6InputScfileRowFree(p6InputScfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); +} + +bool p6InputScfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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; + } + + bool status = psDBCreateTable(dbh, P6INPUTSCFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p6InputScfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P6INPUTSCFILE_TABLE_NAME); +} + +bool p6InputScfileInsert(psDB * dbh, psS32 p6_id, psS32 p4_id, const char *skycell_id, const char *tess_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, p6_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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; + } + + bool status = psDBInsertOneRow(dbh, P6INPUTSCFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p6InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p6InputScfileInsertObject(psDB *dbh, p6InputScfileRow *object) +{ + return p6InputScfileInsert(dbh, object->p6_id, object->p4_id, object->skycell_id, object->tess_id); +} + +bool p6InputScfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p6InputScfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p6InputScfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P6INPUTSCFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P6INPUTSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6INPUTSCFILE_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, P6INPUTSCFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p6InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P6INPUTSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p6InputScfileMetadataFromObject(const p6InputScfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, object->p6_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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; + } + + + return md; +} + +p6InputScfileRow *p6InputScfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p6_id = psMetadataLookupS32(&status, md, "p6_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p6_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; + } + + return p6InputScfileRowAlloc(p6_id, p4_id, skycell_id, tess_id); +} +psArray *p6InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P6INPUTSCFILE_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++) { + p6InputScfileRow *object = p6InputScfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p6InputScfileDeleteObject(psDB *dbh, const p6InputScfileRow *object) +{ + psMetadata *where = p6InputScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile"); + 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, "p6InputScfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p6InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p6InputScfileRow *object = objects->data[i]; + psMetadata *where = p6InputScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p6InputScfilePrintObjects(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 = p6InputScfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P6INPUTSCFILE_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 p6InputScfilePrintObject(FILE *stream, p6InputScfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p6InputScfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p6SumScfileRowFree(p6SumScfileRow *object); + +p6SumScfileRow *p6SumScfileRowAlloc(psS32 p6_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev) +{ + p6SumScfileRow *_object; + + _object = psAlloc(sizeof(p6SumScfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p6SumScfileRowFree); + + _object->p6_id = p6_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 p6SumScfileRowFree(p6SumScfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->uri); +} + +bool p6SumScfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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, P6SUMSCFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p6SumScfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P6SUMSCFILE_TABLE_NAME); +} + +bool p6SumScfileInsert(psDB * dbh, psS32 p6_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, "p6_id", PS_DATA_S32, NULL, p6_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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, P6SUMSCFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p6SumScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p6SumScfileInsertObject(psDB *dbh, p6SumScfileRow *object) +{ + return p6SumScfileInsert(dbh, object->p6_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev); +} + +bool p6SumScfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p6SumScfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p6SumScfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P6SUMSCFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P6SUMSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6SUMSCFILE_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, P6SUMSCFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p6SumScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P6SUMSCFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p6SumScfileMetadataFromObject(const p6SumScfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, object->p6_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p6_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; +} + +p6SumScfileRow *p6SumScfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p6_id = psMetadataLookupS32(&status, md, "p6_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p6_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 p6SumScfileRowAlloc(p6_id, skycell_id, tess_id, uri, bg, bg_mean_stdev); +} +psArray *p6SumScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P6SUMSCFILE_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++) { + p6SumScfileRow *object = p6SumScfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p6SumScfileDeleteObject(psDB *dbh, const p6SumScfileRow *object) +{ + psMetadata *where = p6SumScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile"); + 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, "p6SumScfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p6SumScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p6SumScfileRow *object = objects->data[i]; + psMetadata *where = p6SumScfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p6SumScfilePrintObjects(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 = p6SumScfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P6SUMSCFILE_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 p6SumScfilePrintObject(FILE *stream, p6SumScfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p6SumScfileMetadataFromObject(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 11866) +++ /trunk/ippdb/src/ippdb.h (revision 11867) @@ -8510,4 +8510,418 @@ bool mdcf ///< format as mdconfig or simple ); +/** p6InputScfileRow data structure + * + * Structure for representing a single row of p6InputScfile table data. + */ + +typedef struct { + psS32 p6_id; + psS32 p4_id; + char *skycell_id; + char *tess_id; +} p6InputScfileRow; + +/** Creates a new p6InputScfileRow object + * + * @return A new p6InputScfileRow object or NULL on failure. + */ + +p6InputScfileRow *p6InputScfileRowAlloc( + psS32 p6_id, + psS32 p4_id, + const char *skycell_id, + const char *tess_id +); + +/** Creates a new p6InputScfile table + * + * @return true on success + */ + +bool p6InputScfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p6InputScfile table + * + * @return true on success + */ + +bool p6InputScfileDropTable( + 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 p6InputScfileInsert( + psDB *dbh, ///< Database handle + psS32 p6_id, + psS32 p4_id, + const char *skycell_id, + const char *tess_id +); + +/** 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 p6InputScfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p6InputScfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p6InputScfileInsertObject( + psDB *dbh, ///< Database handle + p6InputScfileRow *object ///< p6InputScfileRow object +); + +/** Insert an array of p6InputScfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p6InputScfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p6InputScfileRow objects +); + +/** Insert data from a binary FITS table p6InputScfileRow 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 p6InputScfileInsertFits( + 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 p6InputScfileSelectRowsFits( + 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 p6InputScfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p6InputScfileMetadataFromObject( + const p6InputScfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p6InputScfileRow pointer or NULL on error + */ + +p6InputScfileRow *p6InputScfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p6InputScfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p6InputScfileSelectRowObjects( + 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 p6InputScfile + * + * 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 p6InputScfileDeleteObject( + psDB *dbh, ///< Database handle + const p6InputScfileRow *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 p6InputScfileDeleteRowObjects( + 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 p6InputScfileRow 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 p6InputScfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p6InputScfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p6InputScfileRow 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 p6InputScfilePrintObject( + FILE *stream, ///< a stream + p6InputScfileRow *object, ///< an p6InputScfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p6SumScfileRow data structure + * + * Structure for representing a single row of p6SumScfile table data. + */ + +typedef struct { + psS32 p6_id; + char *skycell_id; + char *tess_id; + char *uri; + psF64 bg; + psF64 bg_mean_stdev; +} p6SumScfileRow; + +/** Creates a new p6SumScfileRow object + * + * @return A new p6SumScfileRow object or NULL on failure. + */ + +p6SumScfileRow *p6SumScfileRowAlloc( + psS32 p6_id, + const char *skycell_id, + const char *tess_id, + const char *uri, + psF64 bg, + psF64 bg_mean_stdev +); + +/** Creates a new p6SumScfile table + * + * @return true on success + */ + +bool p6SumScfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p6SumScfile table + * + * @return true on success + */ + +bool p6SumScfileDropTable( + 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 p6SumScfileInsert( + psDB *dbh, ///< Database handle + psS32 p6_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 p6SumScfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p6SumScfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p6SumScfileInsertObject( + psDB *dbh, ///< Database handle + p6SumScfileRow *object ///< p6SumScfileRow object +); + +/** Insert an array of p6SumScfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p6SumScfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p6SumScfileRow objects +); + +/** Insert data from a binary FITS table p6SumScfileRow 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 p6SumScfileInsertFits( + 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 p6SumScfileSelectRowsFits( + 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 p6SumScfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p6SumScfileMetadataFromObject( + const p6SumScfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p6SumScfileRow pointer or NULL on error + */ + +p6SumScfileRow *p6SumScfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p6SumScfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p6SumScfileSelectRowObjects( + 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 p6SumScfile + * + * 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 p6SumScfileDeleteObject( + psDB *dbh, ///< Database handle + const p6SumScfileRow *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 p6SumScfileDeleteRowObjects( + 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 p6SumScfileRow 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 p6SumScfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p6SumScfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p6SumScfileRow 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 p6SumScfilePrintObject( + FILE *stream, ///< a stream + p6SumScfileRow *object, ///< an p6SumScfileRow object + bool mdcf ///< format as mdconfig or simple +); /// @} @@ -8517,3 +8931,3 @@ #endif -#endif // P6RUN_DB_H +#endif // P6SUMSCFILE_DB_H Index: /trunk/ippdb/tests/alloc.c =================================================================== --- /trunk/ippdb/tests/alloc.c (revision 11866) +++ /trunk/ippdb/tests/alloc.c (revision 11867) @@ -1700,4 +1700,70 @@ } + { + p6InputScfileRow *object; + + object = p6InputScfileRowAlloc(-32, -32, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p6_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); + } + + psFree(object); + } + + { + p6SumScfileRow *object; + + object = p6SumScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p6_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 11866) +++ /trunk/ippdb/tests/createtable.c (revision 11867) @@ -590,4 +590,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p6InputScfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p6SumScfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/dbcleanup.c =================================================================== --- /trunk/ippdb/tests/dbcleanup.c (revision 11866) +++ /trunk/ippdb/tests/dbcleanup.c (revision 11867) @@ -50,4 +50,6 @@ p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p5DiffScfile"); p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p6Run"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p6InputScfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p6SumScfile"); psDBCleanup(dbh); Index: /trunk/ippdb/tests/dbsetup.c =================================================================== --- /trunk/ippdb/tests/dbsetup.c (revision 11866) +++ /trunk/ippdb/tests/dbsetup.c (revision 11867) @@ -130,4 +130,10 @@ p6RunCreateTable(dbh); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p6InputScfile"); + p6InputScfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p6SumScfile"); + p6SumScfileCreateTable(dbh); + psDBCleanup(dbh); Index: /trunk/ippdb/tests/droptable.c =================================================================== --- /trunk/ippdb/tests/droptable.c (revision 11866) +++ /trunk/ippdb/tests/droptable.c (revision 11867) @@ -590,4 +590,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p6InputScfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p6SumScfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/insert.c =================================================================== --- /trunk/ippdb/tests/insert.c (revision 11866) +++ /trunk/ippdb/tests/insert.c (revision 11867) @@ -590,4 +590,34 @@ } + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p6InputScfileInsert(dbh, -32, -32, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p6SumScfileInsert(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 11866) +++ /trunk/ippdb/tests/insertfits.c (revision 11867) @@ -1023,4 +1023,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 (!p6InputScfileInsertFits(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 (!p6SumScfileInsertFits(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 11866) +++ /trunk/ippdb/tests/insertobject.c (revision 11867) @@ -863,4 +863,48 @@ } + { + psDB *dbh; + p6InputScfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p6InputScfileRowAlloc(-32, -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p6InputScfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p6SumScfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p6SumScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p6SumScfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); } Index: /trunk/ippdb/tests/metadatafromobject.c =================================================================== --- /trunk/ippdb/tests/metadatafromobject.c (revision 11866) +++ /trunk/ippdb/tests/metadatafromobject.c (revision 11867) @@ -1998,4 +1998,86 @@ } + { + psMetadata *md; + p6InputScfileRow *object; + bool status; + + object = p6InputScfileRowAlloc(-32, -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p6InputScfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p6_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); + } + + psFree(md); + } + + { + psMetadata *md; + p6SumScfileRow *object; + bool status; + + object = p6SumScfileRowAlloc(-32, "a string", "a string", "a string", 64.64, 64.64); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p6SumScfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p6_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 11866) +++ /trunk/ippdb/tests/objectfrommetadata.c (revision 11867) @@ -3052,4 +3052,120 @@ } + { + psMetadata *md; + p6InputScfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p6_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); + } + + object = p6InputScfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p6_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); + } + + psFree(object); + } + + { + psMetadata *md; + p6SumScfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p6_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 = p6SumScfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p6_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 11866) +++ /trunk/ippdb/tests/selectrowsfits.c (revision 11867) @@ -865,4 +865,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 (!p6InputScfileSelectRowsFits(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 (!p6SumScfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + exit(EXIT_SUCCESS); }