IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 10060


Ignore:
Timestamp:
Nov 17, 2006, 2:19:43 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.56

Location:
trunk/ippdb
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/Makefile.am

    r9788 r10060  
    1111    $(top_builddir)/docs/man/man3/ippdb.3 \
    1212    $(top_builddir)/docs/man/man3/summitExpRow.3 \
     13    $(top_builddir)/docs/man/man3/summitImfileRow.3 \
    1314    $(top_builddir)/docs/man/man3/pzPendingExpRow.3 \
    1415    $(top_builddir)/docs/man/man3/pzPendingImfileRow.3 \
     16    $(top_builddir)/docs/man/man3/pzDoneExpRow.3 \
     17    $(top_builddir)/docs/man/man3/pzDoneImfileRow.3 \
    1518    $(top_builddir)/docs/man/man3/newExpRow.3 \
    1619    $(top_builddir)/docs/man/man3/newImfileRow.3 \
    … …  
    4245
    4346
    44 docs/man/man3/ippdb.3 docs/man/man3/summitExpRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/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/detMasterFrameRow.3 docs/man/man3/detMasterImfileRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3:
     47docs/man/man3/ippdb.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/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/detMasterFrameRow.3 docs/man/man3/detMasterImfileRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3:
    4548        $(DOXYGEN)
    4649

  • trunk/ippdb/configure.ac

    r9970 r10060  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [0.0.55], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [0.0.56], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • trunk/ippdb/src/ippdb.c

    r9970 r10060  
    3232
    3333#define SUMMITEXP_TABLE_NAME "summitExp"
     34#define SUMMITIMFILE_TABLE_NAME "summitImfile"
    3435#define PZPENDINGEXP_TABLE_NAME "pzPendingExp"
    3536#define PZPENDINGIMFILE_TABLE_NAME "pzPendingImfile"
     37#define PZDONEEXP_TABLE_NAME "pzDoneExp"
     38#define PZDONEIMFILE_TABLE_NAME "pzDoneImfile"
    3639#define NEWEXP_TABLE_NAME "newExp"
    3740#define NEWIMFILE_TABLE_NAME "newImfile"
    … …  
    234237static void summitExpRowFree(summitExpRow *object);
    235238
    236 summitExpRow *summitExpRowAlloc(const char *exp_id, const char *camera, const char *telescope, psTime* time, const char *exp_type, const char *uri)
     239summitExpRow *summitExpRowAlloc(const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, const char *uri, psS32 imfiles)
    237240{
    238241    summitExpRow    *_object;
    … …  
    244247    _object->camera = psStringCopy(camera);
    245248    _object->telescope = psStringCopy(telescope);
    246     _object->time = psTimeCopy(time);
     249    _object->dateobs = psTimeCopy(dateobs);
    247250    _object->exp_type = psStringCopy(exp_type);
    248251    _object->uri = psStringCopy(uri);
     252    _object->imfiles = imfiles;
    249253
    250254    return _object;
    … …  
    256260    psFree(object->camera);
    257261    psFree(object->telescope);
    258     psFree(object->time);
     262    psFree(object->dateobs);
    259263    psFree(object->exp_type);
    260264    psFree(object->uri);
    … …  
    279283        return false;
    280284    }
    281     psTime* time = psTimeFromISO("", PS_TIME_UTC);
    282     if (!psMetadataAdd(md, PS_LIST_TAIL, "time", PS_DATA_TIME, NULL, time)) {
    283         psFree(time);
    284         psError(PS_ERR_UNKNOWN, false, "failed to add item time");
    285         psFree(md);
    286         return false;
    287     }
    288     psFree(time);
     285    psTime* dateobs = psTimeFromISO("", PS_TIME_UTC);
     286    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
     287        psFree(dateobs);
     288        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
     289        psFree(md);
     290        return false;
     291    }
     292    psFree(dateobs);
    289293    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    290294        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    … …  
    297301        return false;
    298302    }
     303    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) {
     304        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
     305        psFree(md);
     306        return false;
     307    }
    299308
    300309    bool status = psDBCreateTable(dbh, SUMMITEXP_TABLE_NAME, md);
    … …  
    310319}
    311320
    312 bool summitExpInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, psTime* time, const char *exp_type, const char *uri)
     321bool summitExpInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, const char *uri, psS32 imfiles)
    313322{
    314323    psMetadata *md = psMetadataAlloc();
    … …  
    328337        return false;
    329338    }
    330     if (!psMetadataAdd(md, PS_LIST_TAIL, "time", PS_DATA_TIME, NULL, time)) {
    331         psError(PS_ERR_UNKNOWN, false, "failed to add item time");
     339    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
     340        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    332341        psFree(md);
    333342        return false;
    … …  
    340349    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    341350        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     351        psFree(md);
     352        return false;
     353    }
     354    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
     355        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    342356        psFree(md);
    343357        return false;
    … …  
    366380bool summitExpInsertObject(psDB *dbh, summitExpRow *object)
    367381{
    368     return summitExpInsert(dbh, object->exp_id, object->camera, object->telescope, object->time, object->exp_type, object->uri);
     382    return summitExpInsert(dbh, object->exp_id, object->camera, object->telescope, object->dateobs, object->exp_type, object->uri, object->imfiles);
    369383}
    370384
    … …  
    454468        return false;
    455469    }
    456     if (!psMetadataAdd(md, PS_LIST_TAIL, "time", PS_DATA_TIME, NULL, object->time)) {
    457         psError(PS_ERR_UNKNOWN, false, "failed to add item time");
     470    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) {
     471        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    458472        psFree(md);
    459473        return false;
    … …  
    469483        return false;
    470484    }
     485    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, object->imfiles)) {
     486        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
     487        psFree(md);
     488        return false;
     489    }
    471490
    472491
    … …  
    493512        return false;
    494513    }
    495     psTime* time = psMetadataLookupPtr(&status, md, "time");
    496     if (!status) {
    497         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item time");
     514    psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs");
     515    if (!status) {
     516        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs");
    498517        return false;
    499518    }
    … …  
    508527        return false;
    509528    }
    510 
    511     return summitExpRowAlloc(exp_id, camera, telescope, time, exp_type, uri);
     529    psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles");
     530    if (!status) {
     531        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
     532        return false;
     533    }
     534
     535    return summitExpRowAlloc(exp_id, camera, telescope, dateobs, exp_type, uri, imfiles);
    512536}
    513537psArray *summitExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    604628    return true;
    605629}
    606 static void pzPendingExpRowFree(pzPendingExpRow *object);
    607 
    608 pzPendingExpRow *pzPendingExpRowAlloc(const char *exp_id, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles)
    609 {
    610     pzPendingExpRow *_object;
    611 
    612     _object = psAlloc(sizeof(pzPendingExpRow));
    613     psMemSetDeallocator(_object, (psFreeFunc)pzPendingExpRowFree);
     630static void summitImfileRowFree(summitImfileRow *object);
     631
     632summitImfileRow *summitImfileRowAlloc(const char *exp_id, const char *camera, const char *telescope, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri)
     633{
     634    summitImfileRow *_object;
     635
     636    _object = psAlloc(sizeof(summitImfileRow));
     637    psMemSetDeallocator(_object, (psFreeFunc)summitImfileRowFree);
    614638
    615639    _object->exp_id = psStringCopy(exp_id);
    616640    _object->camera = psStringCopy(camera);
    617641    _object->telescope = psStringCopy(telescope);
    618     _object->exp_type = psStringCopy(exp_type);
    619     _object->imfiles = imfiles;
     642    _object->bytes = bytes;
     643    _object->md5sum = psStringCopy(md5sum);
     644    _object->class = psStringCopy(class);
     645    _object->class_id = psStringCopy(class_id);
     646    _object->uri = psStringCopy(uri);
    620647
    621648    return _object;
    622649}
    623650
    624 static void pzPendingExpRowFree(pzPendingExpRow *object)
     651static void summitImfileRowFree(summitImfileRow *object)
    625652{
    626653    psFree(object->exp_id);
    627654    psFree(object->camera);
    628655    psFree(object->telescope);
    629     psFree(object->exp_type);
    630 }
    631 
    632 bool pzPendingExpCreateTable(psDB *dbh)
     656    psFree(object->md5sum);
     657    psFree(object->class);
     658    psFree(object->class_id);
     659    psFree(object->uri);
     660}
     661
     662bool summitImfileCreateTable(psDB *dbh)
    633663{
    634664    psMetadata *md = psMetadataAlloc();
    … …  
    648678        return false;
    649679    }
    650     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    651         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    652         psFree(md);
    653         return false;
    654     }
    655     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) {
    656         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    657         psFree(md);
    658         return false;
    659     }
    660 
    661     bool status = psDBCreateTable(dbh, PZPENDINGEXP_TABLE_NAME, md);
     680    if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, 0)) {
     681        psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
     682        psFree(md);
     683        return false;
     684    }
     685    if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, "32")) {
     686        psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
     687        psFree(md);
     688        return false;
     689    }
     690    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) {
     691        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     692        psFree(md);
     693        return false;
     694    }
     695    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     696        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     697        psFree(md);
     698        return false;
     699    }
     700    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     701        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     702        psFree(md);
     703        return false;
     704    }
     705
     706    bool status = psDBCreateTable(dbh, SUMMITIMFILE_TABLE_NAME, md);
    662707
    663708    psFree(md);
    … …  
    666711}
    667712
    668 bool pzPendingExpDropTable(psDB *dbh)
    669 {
    670     return psDBDropTable(dbh, PZPENDINGEXP_TABLE_NAME);
    671 }
    672 
    673 bool pzPendingExpInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles)
     713bool summitImfileDropTable(psDB *dbh)
     714{
     715    return psDBDropTable(dbh, SUMMITIMFILE_TABLE_NAME);
     716}
     717
     718bool summitImfileInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri)
    674719{
    675720    psMetadata *md = psMetadataAlloc();
    … …  
    689734        return false;
    690735    }
    691     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) {
    692         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    693         psFree(md);
    694         return false;
    695     }
    696     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
    697         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    698         psFree(md);
    699         return false;
    700     }
    701 
    702     bool status = psDBInsertOneRow(dbh, PZPENDINGEXP_TABLE_NAME, md);
     736    if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, bytes)) {
     737        psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
     738        psFree(md);
     739        return false;
     740    }
     741    if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, md5sum)) {
     742        psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
     743        psFree(md);
     744        return false;
     745    }
     746    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) {
     747        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     748        psFree(md);
     749        return false;
     750    }
     751    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
     752        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     753        psFree(md);
     754        return false;
     755    }
     756    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
     757        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     758        psFree(md);
     759        return false;
     760    }
     761
     762    bool status = psDBInsertOneRow(dbh, SUMMITIMFILE_TABLE_NAME, md);
    703763    psFree(md);
    704764
    … …  
    706766}
    707767
    708 long long pzPendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     768long long summitImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    709769{
    710770    long long       deleted = 0;
    711771
    712     long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit);
     772    long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit);
    713773    if (count < 0) {
    714         psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp");
     774        psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile");
    715775        return count;
    716776
    … …  
    720780    return deleted;
    721781}
    722 bool pzPendingExpInsertObject(psDB *dbh, pzPendingExpRow *object)
    723 {
    724     return pzPendingExpInsert(dbh, object->exp_id, object->camera, object->telescope, object->exp_type, object->imfiles);
    725 }
    726 
    727 bool pzPendingExpInsertObjects(psDB *dbh, psArray *objects)
     782bool summitImfileInsertObject(psDB *dbh, summitImfileRow *object)
     783{
     784    return summitImfileInsert(dbh, object->exp_id, object->camera, object->telescope, object->bytes, object->md5sum, object->class, object->class_id, object->uri);
     785}
     786
     787bool summitImfileInsertObjects(psDB *dbh, psArray *objects)
    728788{
    729789    for (long i = 0; i < psArrayLength(objects); i++) {
    730         if (!pzPendingExpInsertObject(dbh, objects->data[i])) {
     790        if (!summitImfileInsertObject(dbh, objects->data[i])) {
    731791            return false;
    732792        }
    … …  
    736796}
    737797
    738 bool pzPendingExpInsertFits(psDB *dbh, const psFits *fits)
     798bool summitImfileInsertFits(psDB *dbh, const psFits *fits)
    739799{
    740800    psArray         *rowSet;
    741801
    742     // move to (the first?) extension named  PZPENDINGEXP_TABLE_NAME
    743     if (!psFitsMoveExtName(fits, PZPENDINGEXP_TABLE_NAME)) {
    744         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZPENDINGEXP_TABLE_NAME);
     802    // move to (the first?) extension named  SUMMITIMFILE_TABLE_NAME
     803    if (!psFitsMoveExtName(fits, SUMMITIMFILE_TABLE_NAME)) {
     804        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", SUMMITIMFILE_TABLE_NAME);
    745805        return false;
    746806    }
    … …  
    760820    }
    761821
     822    if (!psDBInsertRows(dbh, SUMMITIMFILE_TABLE_NAME, rowSet)) {
     823        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     824        psFree(rowSet);
     825        return false;
     826    }
     827
     828    psFree(rowSet);
     829
     830    return true;
     831}
     832
     833bool summitImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     834{
     835    psArray         *rowSet;
     836
     837    rowSet = psDBSelectRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit);
     838    if (!rowSet) {
     839        return false;
     840    }
     841
     842    // output to fits
     843    if (!psFitsWriteTable(fits, NULL, rowSet, SUMMITIMFILE_TABLE_NAME)) {
     844        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     845        psFree(rowSet);
     846        return false;
     847    }
     848
     849    psFree(rowSet);
     850
     851    return true;
     852}
     853
     854psMetadata *summitImfileMetadataFromObject(const summitImfileRow *object)
     855{
     856    psMetadata *md = psMetadataAlloc();
     857    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, object->exp_id)) {
     858        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     859        psFree(md);
     860        return false;
     861    }
     862    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) {
     863        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     864        psFree(md);
     865        return false;
     866    }
     867    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) {
     868        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     869        psFree(md);
     870        return false;
     871    }
     872    if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, object->bytes)) {
     873        psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
     874        psFree(md);
     875        return false;
     876    }
     877    if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, object->md5sum)) {
     878        psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
     879        psFree(md);
     880        return false;
     881    }
     882    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) {
     883        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     884        psFree(md);
     885        return false;
     886    }
     887    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
     888        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     889        psFree(md);
     890        return false;
     891    }
     892    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
     893        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     894        psFree(md);
     895        return false;
     896    }
     897
     898
     899    return md;
     900}
     901
     902summitImfileRow *summitImfileObjectFromMetadata(psMetadata *md)
     903{
     904
     905bool status = false;
     906    char* exp_id = psMetadataLookupPtr(&status, md, "exp_id");
     907    if (!status) {
     908        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
     909        return false;
     910    }
     911    char* camera = psMetadataLookupPtr(&status, md, "camera");
     912    if (!status) {
     913        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
     914        return false;
     915    }
     916    char* telescope = psMetadataLookupPtr(&status, md, "telescope");
     917    if (!status) {
     918        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
     919        return false;
     920    }
     921    psS32 bytes = psMetadataLookupS32(&status, md, "bytes");
     922    if (!status) {
     923        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bytes");
     924        return false;
     925    }
     926    char* md5sum = psMetadataLookupPtr(&status, md, "md5sum");
     927    if (!status) {
     928        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item md5sum");
     929        return false;
     930    }
     931    char* class = psMetadataLookupPtr(&status, md, "class");
     932    if (!status) {
     933        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class");
     934        return false;
     935    }
     936    char* class_id = psMetadataLookupPtr(&status, md, "class_id");
     937    if (!status) {
     938        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
     939        return false;
     940    }
     941    char* uri = psMetadataLookupPtr(&status, md, "uri");
     942    if (!status) {
     943        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     944        return false;
     945    }
     946
     947    return summitImfileRowAlloc(exp_id, camera, telescope, bytes, md5sum, class, class_id, uri);
     948}
     949psArray *summitImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     950{
     951    psArray         *rowSet;
     952    psArray         *returnSet;
     953    psU64           i;
     954
     955    rowSet = psDBSelectRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit);
     956    if (!rowSet) {
     957        return NULL;
     958    }
     959
     960    // convert psMetadata rows to row objects
     961
     962    returnSet = psArrayAllocEmpty(rowSet->n);
     963
     964    for (i = 0; i < rowSet->n; i++) {
     965        summitImfileRow *object = summitImfileObjectFromMetadata(rowSet->data[i]);
     966        psArrayAdd(returnSet, 0, object);
     967        psFree(object);
     968    }
     969
     970    psFree(rowSet);
     971
     972    return returnSet;
     973}
     974bool summitImfileDeleteObject(psDB *dbh, const summitImfileRow *object)
     975{
     976    psMetadata *where = summitImfileMetadataFromObject(object);
     977    long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, 0);
     978    psFree(where)
     979    if (count < 0) {
     980        psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile");
     981        return false;
     982    }
     983    if (count > 1) {
     984        // XXX should this be a psAbort() instead?  It is possible that
     985        // having an object match multiple rows was by design.
     986        psError(PS_ERR_UNKNOWN, true, "summitImfileRow object matched more then one row.  Check your database schema");
     987        return false;
     988    }
     989
     990    return true;
     991}
     992long long summitImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     993{
     994    long long       deleted = 0;
     995
     996    for (long long i = 0; i < objects->n; i++) {
     997        summitImfileRow *object = objects->data[i];
     998        psMetadata *where = summitImfileMetadataFromObject(object);
     999        long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit);
     1000        psFree(where)
     1001        if (count < 0) {
     1002            psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile");
     1003            return count;
     1004        }
     1005
     1006        deleted += count;
     1007    }
     1008
     1009    return deleted;
     1010}
     1011bool summitImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     1012{
     1013    PS_ASSERT_PTR_NON_NULL(objects, false);
     1014
     1015    psMetadata *output = psMetadataAlloc();
     1016    for (long i = 0; i < psArrayLength(objects); i++) {
     1017        psMetadata *md = summitImfileMetadataFromObject(objects->data[i]);
     1018        if (!psMetadataAddMetadata(
     1019            output,
     1020            PS_LIST_TAIL,
     1021            SUMMITIMFILE_TABLE_NAME,
     1022            PS_META_DUPLICATE_OK,
     1023            NULL,
     1024            md
     1025        )) {
     1026            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     1027            psFree(md);
     1028            psFree(output);
     1029            return false;
     1030        }
     1031        psFree(md);
     1032    }
     1033
     1034    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     1035        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     1036        psFree(output);
     1037    }
     1038    psFree(output);
     1039
     1040    return true;
     1041}
     1042static void pzPendingExpRowFree(pzPendingExpRow *object);
     1043
     1044pzPendingExpRow *pzPendingExpRowAlloc(const char *exp_id, const char *camera, const char *telescope)
     1045{
     1046    pzPendingExpRow *_object;
     1047
     1048    _object = psAlloc(sizeof(pzPendingExpRow));
     1049    psMemSetDeallocator(_object, (psFreeFunc)pzPendingExpRowFree);
     1050
     1051    _object->exp_id = psStringCopy(exp_id);
     1052    _object->camera = psStringCopy(camera);
     1053    _object->telescope = psStringCopy(telescope);
     1054
     1055    return _object;
     1056}
     1057
     1058static void pzPendingExpRowFree(pzPendingExpRow *object)
     1059{
     1060    psFree(object->exp_id);
     1061    psFree(object->camera);
     1062    psFree(object->telescope);
     1063}
     1064
     1065bool pzPendingExpCreateTable(psDB *dbh)
     1066{
     1067    psMetadata *md = psMetadataAlloc();
     1068    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) {
     1069        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1070        psFree(md);
     1071        return false;
     1072    }
     1073    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) {
     1074        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     1075        psFree(md);
     1076        return false;
     1077    }
     1078    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) {
     1079        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     1080        psFree(md);
     1081        return false;
     1082    }
     1083
     1084    bool status = psDBCreateTable(dbh, PZPENDINGEXP_TABLE_NAME, md);
     1085
     1086    psFree(md);
     1087
     1088    return status;
     1089}
     1090
     1091bool pzPendingExpDropTable(psDB *dbh)
     1092{
     1093    return psDBDropTable(dbh, PZPENDINGEXP_TABLE_NAME);
     1094}
     1095
     1096bool pzPendingExpInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope)
     1097{
     1098    psMetadata *md = psMetadataAlloc();
     1099    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) {
     1100        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1101        psFree(md);
     1102        return false;
     1103    }
     1104    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) {
     1105        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     1106        psFree(md);
     1107        return false;
     1108    }
     1109    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) {
     1110        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     1111        psFree(md);
     1112        return false;
     1113    }
     1114
     1115    bool status = psDBInsertOneRow(dbh, PZPENDINGEXP_TABLE_NAME, md);
     1116    psFree(md);
     1117
     1118    return status;
     1119}
     1120
     1121long long pzPendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     1122{
     1123    long long       deleted = 0;
     1124
     1125    long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit);
     1126    if (count < 0) {
     1127        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp");
     1128        return count;
     1129
     1130        deleted += count;
     1131    }
     1132
     1133    return deleted;
     1134}
     1135bool pzPendingExpInsertObject(psDB *dbh, pzPendingExpRow *object)
     1136{
     1137    return pzPendingExpInsert(dbh, object->exp_id, object->camera, object->telescope);
     1138}
     1139
     1140bool pzPendingExpInsertObjects(psDB *dbh, psArray *objects)
     1141{
     1142    for (long i = 0; i < psArrayLength(objects); i++) {
     1143        if (!pzPendingExpInsertObject(dbh, objects->data[i])) {
     1144            return false;
     1145        }
     1146    }
     1147
     1148    return true;
     1149}
     1150
     1151bool pzPendingExpInsertFits(psDB *dbh, const psFits *fits)
     1152{
     1153    psArray         *rowSet;
     1154
     1155    // move to (the first?) extension named  PZPENDINGEXP_TABLE_NAME
     1156    if (!psFitsMoveExtName(fits, PZPENDINGEXP_TABLE_NAME)) {
     1157        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZPENDINGEXP_TABLE_NAME);
     1158        return false;
     1159    }
     1160
     1161    // check HDU type
     1162    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     1163        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     1164        return false;
     1165    }
     1166
     1167    // read fits table
     1168    rowSet = psFitsReadTable(fits);
     1169    if (!rowSet) {
     1170        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     1171        psFree(rowSet);
     1172        return false;
     1173    }
     1174
    7621175    if (!psDBInsertRows(dbh, PZPENDINGEXP_TABLE_NAME, rowSet)) {
    7631176        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    … …  
    8101223        return false;
    8111224    }
    812     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) {
    813         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    814         psFree(md);
    815         return false;
    816     }
    817     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, object->imfiles)) {
    818         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    819         psFree(md);
    820         return false;
    821     }
    8221225
    8231226
    … …  
    8441247        return false;
    8451248    }
    846     char* exp_type = psMetadataLookupPtr(&status, md, "exp_type");
    847     if (!status) {
    848         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    849         return false;
    850     }
    851     psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles");
    852     if (!status) {
    853         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    854         return false;
    855     }
    856 
    857     return pzPendingExpRowAlloc(exp_id, camera, telescope, exp_type, imfiles);
     1249
     1250    return pzPendingExpRowAlloc(exp_id, camera, telescope);
    8581251}
    8591252psArray *pzPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    9521345static void pzPendingImfileRowFree(pzPendingImfileRow *object);
    9531346
    954 pzPendingImfileRow *pzPendingImfileRowAlloc(const char *exp_id, const char *camera, const char *telescope, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri)
     1347pzPendingImfileRow *pzPendingImfileRowAlloc(const char *exp_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag)
    9551348{
    9561349    pzPendingImfileRow *_object;
    … …  
    9621355    _object->camera = psStringCopy(camera);
    9631356    _object->telescope = psStringCopy(telescope);
    964     _object->bytes = bytes;
    965     _object->md5sum = psStringCopy(md5sum);
    9661357    _object->class = psStringCopy(class);
    9671358    _object->class_id = psStringCopy(class_id);
    968     _object->uri = psStringCopy(uri);
     1359    _object->exp_tag = psStringCopy(exp_tag);
    9691360
    9701361    return _object;
    … …  
    9761367    psFree(object->camera);
    9771368    psFree(object->telescope);
    978     psFree(object->md5sum);
    9791369    psFree(object->class);
    9801370    psFree(object->class_id);
    981     psFree(object->uri);
     1371    psFree(object->exp_tag);
    9821372}
    9831373
    … …  
    10001390        return false;
    10011391    }
    1002     if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, 0)) {
    1003         psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
    1004         psFree(md);
    1005         return false;
    1006     }
    1007     if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, "32")) {
    1008         psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
    1009         psFree(md);
    1010         return false;
    1011     }
    1012     if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, "64")) {
     1392    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) {
    10131393        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
    10141394        psFree(md);
    … …  
    10201400        return false;
    10211401    }
    1022     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1023         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     1402    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Unique Key", "64")) {
     1403        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    10241404        psFree(md);
    10251405        return false;
    … …  
    10381418}
    10391419
    1040 bool pzPendingImfileInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri)
     1420bool pzPendingImfileInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag)
    10411421{
    10421422    psMetadata *md = psMetadataAlloc();
    … …  
    10561436        return false;
    10571437    }
    1058     if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, bytes)) {
    1059         psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
    1060         psFree(md);
    1061         return false;
    1062     }
    1063     if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, md5sum)) {
    1064         psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
    1065         psFree(md);
    1066         return false;
    1067     }
    10681438    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) {
    10691439        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
    … …  
    10761446        return false;
    10771447    }
    1078     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1079         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     1448    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     1449        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    10801450        psFree(md);
    10811451        return false;
    … …  
    11041474bool pzPendingImfileInsertObject(psDB *dbh, pzPendingImfileRow *object)
    11051475{
    1106     return pzPendingImfileInsert(dbh, object->exp_id, object->camera, object->telescope, object->bytes, object->md5sum, object->class, object->class_id, object->uri);
     1476    return pzPendingImfileInsert(dbh, object->exp_id, object->camera, object->telescope, object->class, object->class_id, object->exp_tag);
    11071477}
    11081478
    … …  
    11921562        return false;
    11931563    }
    1194     if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, object->bytes)) {
    1195         psError(PS_ERR_UNKNOWN, false, "failed to add item bytes");
    1196         psFree(md);
    1197         return false;
    1198     }
    1199     if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, object->md5sum)) {
    1200         psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum");
    1201         psFree(md);
    1202         return false;
    1203     }
    12041564    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) {
    12051565        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
    … …  
    12121572        return false;
    12131573    }
    1214     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    1215         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     1574    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     1575        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    12161576        psFree(md);
    12171577        return false;
    … …  
    12411601        return false;
    12421602    }
    1243     psS32 bytes = psMetadataLookupS32(&status, md, "bytes");
    1244     if (!status) {
    1245         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bytes");
    1246         return false;
    1247     }
    1248     char* md5sum = psMetadataLookupPtr(&status, md, "md5sum");
    1249     if (!status) {
    1250         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item md5sum");
    1251         return false;
    1252     }
    12531603    char* class = psMetadataLookupPtr(&status, md, "class");
    12541604    if (!status) {
    … …  
    12611611        return false;
    12621612    }
    1263     char* uri = psMetadataLookupPtr(&status, md, "uri");
    1264     if (!status) {
    1265         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    1266         return false;
    1267     }
    1268 
    1269     return pzPendingImfileRowAlloc(exp_id, camera, telescope, bytes, md5sum, class, class_id, uri);
     1613    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     1614    if (!status) {
     1615        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     1616        return false;
     1617    }
     1618
     1619    return pzPendingImfileRowAlloc(exp_id, camera, telescope, class, class_id, exp_tag);
    12701620}
    12711621psArray *pzPendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    13621712    return true;
    13631713}
    1364 static void newExpRowFree(newExpRow *object);
    1365 
    1366 newExpRow *newExpRowAlloc(const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles)
    1367 {
    1368     newExpRow       *_object;
    1369 
    1370     _object = psAlloc(sizeof(newExpRow));
    1371     psMemSetDeallocator(_object, (psFreeFunc)newExpRowFree);
    1372 
    1373     _object->exp_tag = psStringCopy(exp_tag);
     1714static void pzDoneExpRowFree(pzDoneExpRow *object);
     1715
     1716pzDoneExpRow *pzDoneExpRowAlloc(const char *exp_id, const char *camera, const char *telescope)
     1717{
     1718    pzDoneExpRow    *_object;
     1719
     1720    _object = psAlloc(sizeof(pzDoneExpRow));
     1721    psMemSetDeallocator(_object, (psFreeFunc)pzDoneExpRowFree);
     1722
    13741723    _object->exp_id = psStringCopy(exp_id);
    13751724    _object->camera = psStringCopy(camera);
    13761725    _object->telescope = psStringCopy(telescope);
    1377     _object->exp_type = psStringCopy(exp_type);
    1378     _object->imfiles = imfiles;
    13791726
    13801727    return _object;
    13811728}
    13821729
    1383 static void newExpRowFree(newExpRow *object)
    1384 {
    1385     psFree(object->exp_tag);
     1730static void pzDoneExpRowFree(pzDoneExpRow *object)
     1731{
    13861732    psFree(object->exp_id);
    13871733    psFree(object->camera);
    13881734    psFree(object->telescope);
    1389     psFree(object->exp_type);
    1390 }
    1391 
    1392 bool newExpCreateTable(psDB *dbh)
     1735}
     1736
     1737bool pzDoneExpCreateTable(psDB *dbh)
    13931738{
    13941739    psMetadata *md = psMetadataAlloc();
    1395     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    1396         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    1397         psFree(md);
    1398         return false;
    1399     }
    1400     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Key", "64")) {
     1740    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) {
    14011741        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    14021742        psFree(md);
    14031743        return false;
    14041744    }
    1405     if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, "64")) {
     1745    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) {
    14061746        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    14071747        psFree(md);
    14081748        return false;
    14091749    }
    1410     if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, "64")) {
     1750    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) {
    14111751        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
    14121752        psFree(md);
    14131753        return false;
    14141754    }
    1415     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    1416         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    1417         psFree(md);
    1418         return false;
    1419     }
    1420     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) {
    1421         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    1422         psFree(md);
    1423         return false;
    1424     }
    1425 
    1426     bool status = psDBCreateTable(dbh, NEWEXP_TABLE_NAME, md);
     1755
     1756    bool status = psDBCreateTable(dbh, PZDONEEXP_TABLE_NAME, md);
    14271757
    14281758    psFree(md);
    … …  
    14311761}
    14321762
    1433 bool newExpDropTable(psDB *dbh)
    1434 {
    1435     return psDBDropTable(dbh, NEWEXP_TABLE_NAME);
    1436 }
    1437 
    1438 bool newExpInsert(psDB * dbh, const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles)
     1763bool pzDoneExpDropTable(psDB *dbh)
     1764{
     1765    return psDBDropTable(dbh, PZDONEEXP_TABLE_NAME);
     1766}
     1767
     1768bool pzDoneExpInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope)
    14391769{
    14401770    psMetadata *md = psMetadataAlloc();
    1441     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    1442         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    1443         psFree(md);
    1444         return false;
    1445     }
    14461771    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) {
    14471772        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    14591784        return false;
    14601785    }
    1461     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) {
    1462         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    1463         psFree(md);
    1464         return false;
    1465     }
    1466     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
    1467         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    1468         psFree(md);
    1469         return false;
    1470     }
    1471 
    1472     bool status = psDBInsertOneRow(dbh, NEWEXP_TABLE_NAME, md);
     1786
     1787    bool status = psDBInsertOneRow(dbh, PZDONEEXP_TABLE_NAME, md);
    14731788    psFree(md);
    14741789
    … …  
    14761791}
    14771792
    1478 long long newExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     1793long long pzDoneExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    14791794{
    14801795    long long       deleted = 0;
    14811796
    1482     long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, limit);
     1797    long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, limit);
    14831798    if (count < 0) {
    1484         psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp");
     1799        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp");
    14851800        return count;
    14861801
    … …  
    14901805    return deleted;
    14911806}
    1492 bool newExpInsertObject(psDB *dbh, newExpRow *object)
    1493 {
    1494     return newExpInsert(dbh, object->exp_tag, object->exp_id, object->camera, object->telescope, object->exp_type, object->imfiles);
    1495 }
    1496 
    1497 bool newExpInsertObjects(psDB *dbh, psArray *objects)
     1807bool pzDoneExpInsertObject(psDB *dbh, pzDoneExpRow *object)
     1808{
     1809    return pzDoneExpInsert(dbh, object->exp_id, object->camera, object->telescope);
     1810}
     1811
     1812bool pzDoneExpInsertObjects(psDB *dbh, psArray *objects)
    14981813{
    14991814    for (long i = 0; i < psArrayLength(objects); i++) {
    1500         if (!newExpInsertObject(dbh, objects->data[i])) {
     1815        if (!pzDoneExpInsertObject(dbh, objects->data[i])) {
    15011816            return false;
    15021817        }
    … …  
    15061821}
    15071822
    1508 bool newExpInsertFits(psDB *dbh, const psFits *fits)
     1823bool pzDoneExpInsertFits(psDB *dbh, const psFits *fits)
    15091824{
    15101825    psArray         *rowSet;
    15111826
    1512     // move to (the first?) extension named  NEWEXP_TABLE_NAME
    1513     if (!psFitsMoveExtName(fits, NEWEXP_TABLE_NAME)) {
    1514         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", NEWEXP_TABLE_NAME);
     1827    // move to (the first?) extension named  PZDONEEXP_TABLE_NAME
     1828    if (!psFitsMoveExtName(fits, PZDONEEXP_TABLE_NAME)) {
     1829        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZDONEEXP_TABLE_NAME);
    15151830        return false;
    15161831    }
    … …  
    15301845    }
    15311846
     1847    if (!psDBInsertRows(dbh, PZDONEEXP_TABLE_NAME, rowSet)) {
     1848        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     1849        psFree(rowSet);
     1850        return false;
     1851    }
     1852
     1853    psFree(rowSet);
     1854
     1855    return true;
     1856}
     1857
     1858bool pzDoneExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     1859{
     1860    psArray         *rowSet;
     1861
     1862    rowSet = psDBSelectRows(dbh, PZDONEEXP_TABLE_NAME, where, limit);
     1863    if (!rowSet) {
     1864        return false;
     1865    }
     1866
     1867    // output to fits
     1868    if (!psFitsWriteTable(fits, NULL, rowSet, PZDONEEXP_TABLE_NAME)) {
     1869        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     1870        psFree(rowSet);
     1871        return false;
     1872    }
     1873
     1874    psFree(rowSet);
     1875
     1876    return true;
     1877}
     1878
     1879psMetadata *pzDoneExpMetadataFromObject(const pzDoneExpRow *object)
     1880{
     1881    psMetadata *md = psMetadataAlloc();
     1882    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, object->exp_id)) {
     1883        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1884        psFree(md);
     1885        return false;
     1886    }
     1887    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) {
     1888        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     1889        psFree(md);
     1890        return false;
     1891    }
     1892    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) {
     1893        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     1894        psFree(md);
     1895        return false;
     1896    }
     1897
     1898
     1899    return md;
     1900}
     1901
     1902pzDoneExpRow *pzDoneExpObjectFromMetadata(psMetadata *md)
     1903{
     1904
     1905bool status = false;
     1906    char* exp_id = psMetadataLookupPtr(&status, md, "exp_id");
     1907    if (!status) {
     1908        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
     1909        return false;
     1910    }
     1911    char* camera = psMetadataLookupPtr(&status, md, "camera");
     1912    if (!status) {
     1913        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
     1914        return false;
     1915    }
     1916    char* telescope = psMetadataLookupPtr(&status, md, "telescope");
     1917    if (!status) {
     1918        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
     1919        return false;
     1920    }
     1921
     1922    return pzDoneExpRowAlloc(exp_id, camera, telescope);
     1923}
     1924psArray *pzDoneExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     1925{
     1926    psArray         *rowSet;
     1927    psArray         *returnSet;
     1928    psU64           i;
     1929
     1930    rowSet = psDBSelectRows(dbh, PZDONEEXP_TABLE_NAME, where, limit);
     1931    if (!rowSet) {
     1932        return NULL;
     1933    }
     1934
     1935    // convert psMetadata rows to row objects
     1936
     1937    returnSet = psArrayAllocEmpty(rowSet->n);
     1938
     1939    for (i = 0; i < rowSet->n; i++) {
     1940        pzDoneExpRow *object = pzDoneExpObjectFromMetadata(rowSet->data[i]);
     1941        psArrayAdd(returnSet, 0, object);
     1942        psFree(object);
     1943    }
     1944
     1945    psFree(rowSet);
     1946
     1947    return returnSet;
     1948}
     1949bool pzDoneExpDeleteObject(psDB *dbh, const pzDoneExpRow *object)
     1950{
     1951    psMetadata *where = pzDoneExpMetadataFromObject(object);
     1952    long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, 0);
     1953    psFree(where)
     1954    if (count < 0) {
     1955        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp");
     1956        return false;
     1957    }
     1958    if (count > 1) {
     1959        // XXX should this be a psAbort() instead?  It is possible that
     1960        // having an object match multiple rows was by design.
     1961        psError(PS_ERR_UNKNOWN, true, "pzDoneExpRow object matched more then one row.  Check your database schema");
     1962        return false;
     1963    }
     1964
     1965    return true;
     1966}
     1967long long pzDoneExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     1968{
     1969    long long       deleted = 0;
     1970
     1971    for (long long i = 0; i < objects->n; i++) {
     1972        pzDoneExpRow *object = objects->data[i];
     1973        psMetadata *where = pzDoneExpMetadataFromObject(object);
     1974        long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, limit);
     1975        psFree(where)
     1976        if (count < 0) {
     1977            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp");
     1978            return count;
     1979        }
     1980
     1981        deleted += count;
     1982    }
     1983
     1984    return deleted;
     1985}
     1986bool pzDoneExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     1987{
     1988    PS_ASSERT_PTR_NON_NULL(objects, false);
     1989
     1990    psMetadata *output = psMetadataAlloc();
     1991    for (long i = 0; i < psArrayLength(objects); i++) {
     1992        psMetadata *md = pzDoneExpMetadataFromObject(objects->data[i]);
     1993        if (!psMetadataAddMetadata(
     1994            output,
     1995            PS_LIST_TAIL,
     1996            PZDONEEXP_TABLE_NAME,
     1997            PS_META_DUPLICATE_OK,
     1998            NULL,
     1999            md
     2000        )) {
     2001            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     2002            psFree(md);
     2003            psFree(output);
     2004            return false;
     2005        }
     2006        psFree(md);
     2007    }
     2008
     2009    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     2010        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     2011        psFree(output);
     2012    }
     2013    psFree(output);
     2014
     2015    return true;
     2016}
     2017static void pzDoneImfileRowFree(pzDoneImfileRow *object);
     2018
     2019pzDoneImfileRow *pzDoneImfileRowAlloc(const char *exp_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag, const char *uri)
     2020{
     2021    pzDoneImfileRow *_object;
     2022
     2023    _object = psAlloc(sizeof(pzDoneImfileRow));
     2024    psMemSetDeallocator(_object, (psFreeFunc)pzDoneImfileRowFree);
     2025
     2026    _object->exp_id = psStringCopy(exp_id);
     2027    _object->camera = psStringCopy(camera);
     2028    _object->telescope = psStringCopy(telescope);
     2029    _object->class = psStringCopy(class);
     2030    _object->class_id = psStringCopy(class_id);
     2031    _object->exp_tag = psStringCopy(exp_tag);
     2032    _object->uri = psStringCopy(uri);
     2033
     2034    return _object;
     2035}
     2036
     2037static void pzDoneImfileRowFree(pzDoneImfileRow *object)
     2038{
     2039    psFree(object->exp_id);
     2040    psFree(object->camera);
     2041    psFree(object->telescope);
     2042    psFree(object->class);
     2043    psFree(object->class_id);
     2044    psFree(object->exp_tag);
     2045    psFree(object->uri);
     2046}
     2047
     2048bool pzDoneImfileCreateTable(psDB *dbh)
     2049{
     2050    psMetadata *md = psMetadataAlloc();
     2051    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) {
     2052        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     2053        psFree(md);
     2054        return false;
     2055    }
     2056    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) {
     2057        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     2058        psFree(md);
     2059        return false;
     2060    }
     2061    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) {
     2062        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     2063        psFree(md);
     2064        return false;
     2065    }
     2066    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) {
     2067        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     2068        psFree(md);
     2069        return false;
     2070    }
     2071    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     2072        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     2073        psFree(md);
     2074        return false;
     2075    }
     2076    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Unique Key", "64")) {
     2077        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     2078        psFree(md);
     2079        return false;
     2080    }
     2081    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     2082        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     2083        psFree(md);
     2084        return false;
     2085    }
     2086
     2087    bool status = psDBCreateTable(dbh, PZDONEIMFILE_TABLE_NAME, md);
     2088
     2089    psFree(md);
     2090
     2091    return status;
     2092}
     2093
     2094bool pzDoneImfileDropTable(psDB *dbh)
     2095{
     2096    return psDBDropTable(dbh, PZDONEIMFILE_TABLE_NAME);
     2097}
     2098
     2099bool pzDoneImfileInsert(psDB * dbh, const char *exp_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag, const char *uri)
     2100{
     2101    psMetadata *md = psMetadataAlloc();
     2102    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) {
     2103        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     2104        psFree(md);
     2105        return false;
     2106    }
     2107    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) {
     2108        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     2109        psFree(md);
     2110        return false;
     2111    }
     2112    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) {
     2113        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     2114        psFree(md);
     2115        return false;
     2116    }
     2117    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) {
     2118        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     2119        psFree(md);
     2120        return false;
     2121    }
     2122    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
     2123        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     2124        psFree(md);
     2125        return false;
     2126    }
     2127    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     2128        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     2129        psFree(md);
     2130        return false;
     2131    }
     2132    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
     2133        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     2134        psFree(md);
     2135        return false;
     2136    }
     2137
     2138    bool status = psDBInsertOneRow(dbh, PZDONEIMFILE_TABLE_NAME, md);
     2139    psFree(md);
     2140
     2141    return status;
     2142}
     2143
     2144long long pzDoneImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     2145{
     2146    long long       deleted = 0;
     2147
     2148    long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit);
     2149    if (count < 0) {
     2150        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile");
     2151        return count;
     2152
     2153        deleted += count;
     2154    }
     2155
     2156    return deleted;
     2157}
     2158bool pzDoneImfileInsertObject(psDB *dbh, pzDoneImfileRow *object)
     2159{
     2160    return pzDoneImfileInsert(dbh, object->exp_id, object->camera, object->telescope, object->class, object->class_id, object->exp_tag, object->uri);
     2161}
     2162
     2163bool pzDoneImfileInsertObjects(psDB *dbh, psArray *objects)
     2164{
     2165    for (long i = 0; i < psArrayLength(objects); i++) {
     2166        if (!pzDoneImfileInsertObject(dbh, objects->data[i])) {
     2167            return false;
     2168        }
     2169    }
     2170
     2171    return true;
     2172}
     2173
     2174bool pzDoneImfileInsertFits(psDB *dbh, const psFits *fits)
     2175{
     2176    psArray         *rowSet;
     2177
     2178    // move to (the first?) extension named  PZDONEIMFILE_TABLE_NAME
     2179    if (!psFitsMoveExtName(fits, PZDONEIMFILE_TABLE_NAME)) {
     2180        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZDONEIMFILE_TABLE_NAME);
     2181        return false;
     2182    }
     2183
     2184    // check HDU type
     2185    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     2186        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     2187        return false;
     2188    }
     2189
     2190    // read fits table
     2191    rowSet = psFitsReadTable(fits);
     2192    if (!rowSet) {
     2193        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     2194        psFree(rowSet);
     2195        return false;
     2196    }
     2197
     2198    if (!psDBInsertRows(dbh, PZDONEIMFILE_TABLE_NAME, rowSet)) {
     2199        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     2200        psFree(rowSet);
     2201        return false;
     2202    }
     2203
     2204    psFree(rowSet);
     2205
     2206    return true;
     2207}
     2208
     2209bool pzDoneImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     2210{
     2211    psArray         *rowSet;
     2212
     2213    rowSet = psDBSelectRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit);
     2214    if (!rowSet) {
     2215        return false;
     2216    }
     2217
     2218    // output to fits
     2219    if (!psFitsWriteTable(fits, NULL, rowSet, PZDONEIMFILE_TABLE_NAME)) {
     2220        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     2221        psFree(rowSet);
     2222        return false;
     2223    }
     2224
     2225    psFree(rowSet);
     2226
     2227    return true;
     2228}
     2229
     2230psMetadata *pzDoneImfileMetadataFromObject(const pzDoneImfileRow *object)
     2231{
     2232    psMetadata *md = psMetadataAlloc();
     2233    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, object->exp_id)) {
     2234        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     2235        psFree(md);
     2236        return false;
     2237    }
     2238    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) {
     2239        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     2240        psFree(md);
     2241        return false;
     2242    }
     2243    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) {
     2244        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     2245        psFree(md);
     2246        return false;
     2247    }
     2248    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) {
     2249        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
     2250        psFree(md);
     2251        return false;
     2252    }
     2253    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
     2254        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     2255        psFree(md);
     2256        return false;
     2257    }
     2258    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     2259        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     2260        psFree(md);
     2261        return false;
     2262    }
     2263    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
     2264        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     2265        psFree(md);
     2266        return false;
     2267    }
     2268
     2269
     2270    return md;
     2271}
     2272
     2273pzDoneImfileRow *pzDoneImfileObjectFromMetadata(psMetadata *md)
     2274{
     2275
     2276bool status = false;
     2277    char* exp_id = psMetadataLookupPtr(&status, md, "exp_id");
     2278    if (!status) {
     2279        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
     2280        return false;
     2281    }
     2282    char* camera = psMetadataLookupPtr(&status, md, "camera");
     2283    if (!status) {
     2284        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
     2285        return false;
     2286    }
     2287    char* telescope = psMetadataLookupPtr(&status, md, "telescope");
     2288    if (!status) {
     2289        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
     2290        return false;
     2291    }
     2292    char* class = psMetadataLookupPtr(&status, md, "class");
     2293    if (!status) {
     2294        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class");
     2295        return false;
     2296    }
     2297    char* class_id = psMetadataLookupPtr(&status, md, "class_id");
     2298    if (!status) {
     2299        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
     2300        return false;
     2301    }
     2302    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     2303    if (!status) {
     2304        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     2305        return false;
     2306    }
     2307    char* uri = psMetadataLookupPtr(&status, md, "uri");
     2308    if (!status) {
     2309        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     2310        return false;
     2311    }
     2312
     2313    return pzDoneImfileRowAlloc(exp_id, camera, telescope, class, class_id, exp_tag, uri);
     2314}
     2315psArray *pzDoneImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     2316{
     2317    psArray         *rowSet;
     2318    psArray         *returnSet;
     2319    psU64           i;
     2320
     2321    rowSet = psDBSelectRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit);
     2322    if (!rowSet) {
     2323        return NULL;
     2324    }
     2325
     2326    // convert psMetadata rows to row objects
     2327
     2328    returnSet = psArrayAllocEmpty(rowSet->n);
     2329
     2330    for (i = 0; i < rowSet->n; i++) {
     2331        pzDoneImfileRow *object = pzDoneImfileObjectFromMetadata(rowSet->data[i]);
     2332        psArrayAdd(returnSet, 0, object);
     2333        psFree(object);
     2334    }
     2335
     2336    psFree(rowSet);
     2337
     2338    return returnSet;
     2339}
     2340bool pzDoneImfileDeleteObject(psDB *dbh, const pzDoneImfileRow *object)
     2341{
     2342    psMetadata *where = pzDoneImfileMetadataFromObject(object);
     2343    long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, 0);
     2344    psFree(where)
     2345    if (count < 0) {
     2346        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile");
     2347        return false;
     2348    }
     2349    if (count > 1) {
     2350        // XXX should this be a psAbort() instead?  It is possible that
     2351        // having an object match multiple rows was by design.
     2352        psError(PS_ERR_UNKNOWN, true, "pzDoneImfileRow object matched more then one row.  Check your database schema");
     2353        return false;
     2354    }
     2355
     2356    return true;
     2357}
     2358long long pzDoneImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     2359{
     2360    long long       deleted = 0;
     2361
     2362    for (long long i = 0; i < objects->n; i++) {
     2363        pzDoneImfileRow *object = objects->data[i];
     2364        psMetadata *where = pzDoneImfileMetadataFromObject(object);
     2365        long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit);
     2366        psFree(where)
     2367        if (count < 0) {
     2368            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile");
     2369            return count;
     2370        }
     2371
     2372        deleted += count;
     2373    }
     2374
     2375    return deleted;
     2376}
     2377bool pzDoneImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     2378{
     2379    PS_ASSERT_PTR_NON_NULL(objects, false);
     2380
     2381    psMetadata *output = psMetadataAlloc();
     2382    for (long i = 0; i < psArrayLength(objects); i++) {
     2383        psMetadata *md = pzDoneImfileMetadataFromObject(objects->data[i]);
     2384        if (!psMetadataAddMetadata(
     2385            output,
     2386            PS_LIST_TAIL,
     2387            PZDONEIMFILE_TABLE_NAME,
     2388            PS_META_DUPLICATE_OK,
     2389            NULL,
     2390            md
     2391        )) {
     2392            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     2393            psFree(md);
     2394            psFree(output);
     2395            return false;
     2396        }
     2397        psFree(md);
     2398    }
     2399
     2400    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     2401        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     2402        psFree(output);
     2403    }
     2404    psFree(output);
     2405
     2406    return true;
     2407}
     2408static void newExpRowFree(newExpRow *object);
     2409
     2410newExpRow *newExpRowAlloc(psU64 exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles)
     2411{
     2412    newExpRow       *_object;
     2413
     2414    _object = psAlloc(sizeof(newExpRow));
     2415    psMemSetDeallocator(_object, (psFreeFunc)newExpRowFree);
     2416
     2417    _object->exp_tag = exp_tag;
     2418    _object->exp_id = psStringCopy(exp_id);
     2419    _object->camera = psStringCopy(camera);
     2420    _object->telescope = psStringCopy(telescope);
     2421    _object->dateobs = psTimeCopy(dateobs);
     2422    _object->exp_type = psStringCopy(exp_type);
     2423    _object->imfiles = imfiles;
     2424
     2425    return _object;
     2426}
     2427
     2428static void newExpRowFree(newExpRow *object)
     2429{
     2430    psFree(object->exp_id);
     2431    psFree(object->camera);
     2432    psFree(object->telescope);
     2433    psFree(object->dateobs);
     2434    psFree(object->exp_type);
     2435}
     2436
     2437bool newExpCreateTable(psDB *dbh)
     2438{
     2439    psMetadata *md = psMetadataAlloc();
     2440    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_U64, "Primary Key AUTO_INCREMENT", 0)) {
     2441        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     2442        psFree(md);
     2443        return false;
     2444    }
     2445    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Key", "64")) {
     2446        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     2447        psFree(md);
     2448        return false;
     2449    }
     2450    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Key", "64")) {
     2451        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     2452        psFree(md);
     2453        return false;
     2454    }
     2455    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Key", "64")) {
     2456        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     2457        psFree(md);
     2458        return false;
     2459    }
     2460    psTime* dateobs = psTimeFromISO("", PS_TIME_UTC);
     2461    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
     2462        psFree(dateobs);
     2463        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
     2464        psFree(md);
     2465        return false;
     2466    }
     2467    psFree(dateobs);
     2468    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
     2469        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
     2470        psFree(md);
     2471        return false;
     2472    }
     2473    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) {
     2474        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
     2475        psFree(md);
     2476        return false;
     2477    }
     2478
     2479    bool status = psDBCreateTable(dbh, NEWEXP_TABLE_NAME, md);
     2480
     2481    psFree(md);
     2482
     2483    return status;
     2484}
     2485
     2486bool newExpDropTable(psDB *dbh)
     2487{
     2488    return psDBDropTable(dbh, NEWEXP_TABLE_NAME);
     2489}
     2490
     2491bool newExpInsert(psDB * dbh, psU64 exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles)
     2492{
     2493    psMetadata *md = psMetadataAlloc();
     2494    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_U64, NULL, exp_tag)) {
     2495        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     2496        psFree(md);
     2497        return false;
     2498    }
     2499    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) {
     2500        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     2501        psFree(md);
     2502        return false;
     2503    }
     2504    if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) {
     2505        psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
     2506        psFree(md);
     2507        return false;
     2508    }
     2509    if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) {
     2510        psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
     2511        psFree(md);
     2512        return false;
     2513    }
     2514    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
     2515        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
     2516        psFree(md);
     2517        return false;
     2518    }
     2519    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) {
     2520        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
     2521        psFree(md);
     2522        return false;
     2523    }
     2524    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
     2525        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
     2526        psFree(md);
     2527        return false;
     2528    }
     2529
     2530    bool status = psDBInsertOneRow(dbh, NEWEXP_TABLE_NAME, md);
     2531    psFree(md);
     2532
     2533    return status;
     2534}
     2535
     2536long long newExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     2537{
     2538    long long       deleted = 0;
     2539
     2540    long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, limit);
     2541    if (count < 0) {
     2542        psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp");
     2543        return count;
     2544
     2545        deleted += count;
     2546    }
     2547
     2548    return deleted;
     2549}
     2550bool newExpInsertObject(psDB *dbh, newExpRow *object)
     2551{
     2552    return newExpInsert(dbh, object->exp_tag, object->exp_id, object->camera, object->telescope, object->dateobs, object->exp_type, object->imfiles);
     2553}
     2554
     2555bool newExpInsertObjects(psDB *dbh, psArray *objects)
     2556{
     2557    for (long i = 0; i < psArrayLength(objects); i++) {
     2558        if (!newExpInsertObject(dbh, objects->data[i])) {
     2559            return false;
     2560        }
     2561    }
     2562
     2563    return true;
     2564}
     2565
     2566bool newExpInsertFits(psDB *dbh, const psFits *fits)
     2567{
     2568    psArray         *rowSet;
     2569
     2570    // move to (the first?) extension named  NEWEXP_TABLE_NAME
     2571    if (!psFitsMoveExtName(fits, NEWEXP_TABLE_NAME)) {
     2572        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", NEWEXP_TABLE_NAME);
     2573        return false;
     2574    }
     2575
     2576    // check HDU type
     2577    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     2578        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     2579        return false;
     2580    }
     2581
     2582    // read fits table
     2583    rowSet = psFitsReadTable(fits);
     2584    if (!rowSet) {
     2585        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     2586        psFree(rowSet);
     2587        return false;
     2588    }
     2589
    15322590    if (!psDBInsertRows(dbh, NEWEXP_TABLE_NAME, rowSet)) {
    15332591        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    … …  
    15652623{
    15662624    psMetadata *md = psMetadataAlloc();
    1567     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     2625    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_U64, NULL, object->exp_tag)) {
    15682626        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    15692627        psFree(md);
    … …  
    15852643        return false;
    15862644    }
     2645    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) {
     2646        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
     2647        psFree(md);
     2648        return false;
     2649    }
    15872650    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) {
    15882651        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    … …  
    16042667
    16052668bool status = false;
    1606     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     2669    psU64 exp_tag = psMetadataLookupU64(&status, md, "exp_tag");
    16072670    if (!status) {
    16082671        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    … …  
    16242687        return false;
    16252688    }
     2689    psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs");
     2690    if (!status) {
     2691        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs");
     2692        return false;
     2693    }
    16262694    char* exp_type = psMetadataLookupPtr(&status, md, "exp_type");
    16272695    if (!status) {
    … …  
    16352703    }
    16362704
    1637     return newExpRowAlloc(exp_tag, exp_id, camera, telescope, exp_type, imfiles);
     2705    return newExpRowAlloc(exp_tag, exp_id, camera, telescope, dateobs, exp_type, imfiles);
    16382706}
    16392707psArray *newExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    17632831        return false;
    17642832    }
    1765     if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, "64")) {
     2833    if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) {
    17662834        psError(PS_ERR_UNKNOWN, false, "failed to add item class");
    17672835        psFree(md);

  • trunk/ippdb/src/ippdb.h

    r9970 r10060  
    134134    char            *camera;
    135135    char            *telescope;
    136     psTime*         time;
     136    psTime*         dateobs;
    137137    char            *exp_type;
    138138    char            *uri;
     139    psS32           imfiles;
    139140} summitExpRow;
    140141
    … …  
    148149    const char      *camera,
    149150    const char      *telescope,
    150     psTime*         time,
     151    psTime*         dateobs,
    151152    const char      *exp_type,
    152     const char      *uri
     153    const char      *uri,
     154    psS32           imfiles
    153155);
    154156
    … …  
    183185    const char      *camera,
    184186    const char      *telescope,
    185     psTime*         time,
     187    psTime*         dateobs,
    186188    const char      *exp_type,
    187     const char      *uri
     189    const char      *uri,
     190    psS32           imfiles
    188191);
    189192
    … …  
    322325    bool            mdcf                ///< format as mdconfig or simple
    323326);
    324 /** pzPendingExpRow data structure
    325  *
    326  * Structure for representing a single row of pzPendingExp table data.
    327  */
    328 
    329 typedef struct {
    330     char            *exp_id;
    331     char            *camera;
    332     char            *telescope;
    333     char            *exp_type;
    334     psS32           imfiles;
    335 } pzPendingExpRow;
    336 
    337 /** Creates a new pzPendingExpRow object
    338  *
    339  *  @return A new pzPendingExpRow object or NULL on failure.
    340  */
    341 
    342 pzPendingExpRow *pzPendingExpRowAlloc(
    343     const char      *exp_id,
    344     const char      *camera,
    345     const char      *telescope,
    346     const char      *exp_type,
    347     psS32           imfiles
    348 );
    349 
    350 /** Creates a new pzPendingExp table
    351  *
    352  * @return true on success
    353  */
    354 
    355 bool pzPendingExpCreateTable(
    356     psDB            *dbh                ///< Database handle
    357 );
    358 
    359 /** Deletes a pzPendingExp table
    360  *
    361  * @return true on success
    362  */
    363 
    364 bool pzPendingExpDropTable(
    365     psDB            *dbh                ///< Database handle
    366 );
    367 
    368 /** Insert a single row into a table
    369  *
    370  * This function constructs and inserts a single row based on it's parameters.
    371  *
    372  * @return true on success
    373  */
    374 
    375 bool pzPendingExpInsert(
    376     psDB            *dbh,               ///< Database handle
    377     const char      *exp_id,
    378     const char      *camera,
    379     const char      *telescope,
    380     const char      *exp_type,
    381     psS32           imfiles
    382 );
    383 
    384 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    385  *
    386  * @return A The number of rows removed or a negative value on error
    387  */
    388 
    389 long long pzPendingExpDelete(
    390     psDB            *dbh,               ///< Database handle
    391     const psMetadata *where,            ///< Row match criteria
    392     unsigned long long limit            ///< Maximum number of elements to delete
    393 );
    394 
    395 /** Insert a single pzPendingExpRow object into a table
    396  *
    397  * This function constructs and inserts a single row based on it's parameters.
    398  *
    399  * @return true on success
    400  */
    401 
    402 bool pzPendingExpInsertObject(
    403     psDB            *dbh,               ///< Database handle
    404     pzPendingExpRow *object             ///< pzPendingExpRow object
    405 );
    406 
    407 /** Insert an array of pzPendingExpRow object into a table
    408  *
    409  * This function constructs and inserts multiple rows based on it's parameters.
    410  *
    411  * @return true on success
    412  */
    413 
    414 bool pzPendingExpInsertObjects(
    415     psDB            *dbh,               ///< Database handle
    416     psArray         *objects            ///< array of pzPendingExpRow objects
    417 );
    418 
    419 /** Insert data from a binary FITS table pzPendingExpRow into the database
    420  *
    421  * This function expects a psFits object with a FITS table as the first
    422  * extension.  The table must have at least one row of data in it, that is of
    423  * the appropriate format (number of columns and their type).  All other
    424  * extensions are ignored.
    425  *
    426  * @return true on success
    427  */
    428 
    429 bool pzPendingExpInsertFits(
    430     psDB            *dbh,               ///< Database handle
    431     const psFits    *fits               ///< psFits object
    432 );
    433 
    434 /** Selects up to limit from the database and returns them in a binary FITS table
    435  *
    436  * This function assumes an empty psFits object and will create a FITS table
    437  * as the first extension.
    438  *
    439  *  See psDBSelectRows() for documentation on the format of where.
    440  *
    441  * @return true on success
    442  */
    443 
    444 bool pzPendingExpSelectRowsFits(
    445     psDB            *dbh,               ///< Database handle
    446     psFits          *fits,              ///< psFits object
    447     const psMetadata *where,            ///< Row match criteria
    448     unsigned long long limit            ///< Maximum number of elements to return
    449 );
    450 
    451 /** Convert a pzPendingExpRow into an equivalent psMetadata
    452  *
    453  * @return A psMetadata pointer or NULL on error
    454  */
    455 
    456 psMetadata *pzPendingExpMetadataFromObject(
    457     const pzPendingExpRow *object             ///< fooRow to convert into a psMetadata
    458 );
    459 
    460 /** Convert a psMetadata into an equivalent fooRow
    461  *
    462  * @return A pzPendingExpRow pointer or NULL on error
    463  */
    464 
    465 pzPendingExpRow *pzPendingExpObjectFromMetadata(
    466     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    467 );
    468 /** Selects up to limit rows from the database and returns as pzPendingExpRow objects in a psArray
    469  *
    470  *  See psDBSelectRows() for documentation on the format of where.
    471  *
    472  * @return A psArray pointer or NULL on error
    473  */
    474 
    475 psArray *pzPendingExpSelectRowObjects(
    476     psDB            *dbh,               ///< Database handle
    477     const psMetadata *where,            ///< Row match criteria
    478     unsigned long long limit            ///< Maximum number of elements to return
    479 );
    480 /** Deletes a row from the database coresponding to an pzPendingExp
    481  *
    482  *  Note that a 'where' search psMetadata is constructed from each object and
    483  *  used to find rows to delete.
    484  *
    485  * @return A The number of rows removed or a negative value on error
    486  */
    487 
    488 bool pzPendingExpDeleteObject(
    489     psDB            *dbh,               ///< Database handle
    490     const pzPendingExpRow *object    ///< Object to delete
    491 );
    492 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    493  *
    494  *  Note that a 'where' search psMetadata is constructed from each object and
    495  *  used to find rows to delete.
    496  *
    497  * @return A The number of rows removed or a negative value on error
    498  */
    499 
    500 long long pzPendingExpDeleteRowObjects(
    501     psDB            *dbh,               ///< Database handle
    502     const psArray   *objects,           ///< Array of objects to delete
    503     unsigned long long limit            ///< Maximum number of elements to delete
    504 );
    505 /** Formats and prints an array of pzPendingExpRow objects
    506  *
    507  * When mdcf is set the formated output is in psMetadataConfig
    508  * format, otherwise it is in a simple tabular format.
    509  *
    510  * @return true on success
    511  */
    512 
    513 bool pzPendingExpPrintObjects(
    514     FILE            *stream,            ///< a stream
    515     psArray         *objects,           ///< An array of pzPendingExpRow objects
    516     bool            mdcf                ///< format as mdconfig or simple
    517 );
    518 /** pzPendingImfileRow data structure
    519  *
    520  * Structure for representing a single row of pzPendingImfile table data.
     327/** summitImfileRow data structure
     328 *
     329 * Structure for representing a single row of summitImfile table data.
    521330 */
    522331
    … …  
    530339    char            *class_id;
    531340    char            *uri;
    532 } pzPendingImfileRow;
    533 
    534 /** Creates a new pzPendingImfileRow object
    535  *
    536  *  @return A new pzPendingImfileRow object or NULL on failure.
    537  */
    538 
    539 pzPendingImfileRow *pzPendingImfileRowAlloc(
     341} summitImfileRow;
     342
     343/** Creates a new summitImfileRow object
     344 *
     345 *  @return A new summitImfileRow object or NULL on failure.
     346 */
     347
     348summitImfileRow *summitImfileRowAlloc(
    540349    const char      *exp_id,
    541350    const char      *camera,
    … …  
    548357);
    549358
    550 /** Creates a new pzPendingImfile table
    551  *
    552  * @return true on success
    553  */
    554 
    555 bool pzPendingImfileCreateTable(
     359/** Creates a new summitImfile table
     360 *
     361 * @return true on success
     362 */
     363
     364bool summitImfileCreateTable(
    556365    psDB            *dbh                ///< Database handle
    557366);
    558367
    559 /** Deletes a pzPendingImfile table
    560  *
    561  * @return true on success
    562  */
    563 
    564 bool pzPendingImfileDropTable(
     368/** Deletes a summitImfile table
     369 *
     370 * @return true on success
     371 */
     372
     373bool summitImfileDropTable(
    565374    psDB            *dbh                ///< Database handle
    566375);
    … …  
    573382 */
    574383
    575 bool pzPendingImfileInsert(
     384bool summitImfileInsert(
    576385    psDB            *dbh,               ///< Database handle
    577386    const char      *exp_id,
    … …  
    590399 */
    591400
    592 long long pzPendingImfileDelete(
     401long long summitImfileDelete(
    593402    psDB            *dbh,               ///< Database handle
    594403    const psMetadata *where,            ///< Row match criteria
    … …  
    596405);
    597406
    598 /** Insert a single pzPendingImfileRow object into a table
     407/** Insert a single summitImfileRow object into a table
    599408 *
    600409 * This function constructs and inserts a single row based on it's parameters.
    … …  
    603412 */
    604413
    605 bool pzPendingImfileInsertObject(
    606     psDB            *dbh,               ///< Database handle
    607     pzPendingImfileRow *object             ///< pzPendingImfileRow object
    608 );
    609 
    610 /** Insert an array of pzPendingImfileRow object into a table
     414bool summitImfileInsertObject(
     415    psDB            *dbh,               ///< Database handle
     416    summitImfileRow *object             ///< summitImfileRow object
     417);
     418
     419/** Insert an array of summitImfileRow object into a table
    611420 *
    612421 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    615424 */
    616425
    617 bool pzPendingImfileInsertObjects(
    618     psDB            *dbh,               ///< Database handle
    619     psArray         *objects            ///< array of pzPendingImfileRow objects
    620 );
    621 
    622 /** Insert data from a binary FITS table pzPendingImfileRow into the database
     426bool summitImfileInsertObjects(
     427    psDB            *dbh,               ///< Database handle
     428    psArray         *objects            ///< array of summitImfileRow objects
     429);
     430
     431/** Insert data from a binary FITS table summitImfileRow into the database
    623432 *
    624433 * This function expects a psFits object with a FITS table as the first
    … …  
    630439 */
    631440
     441bool summitImfileInsertFits(
     442    psDB            *dbh,               ///< Database handle
     443    const psFits    *fits               ///< psFits object
     444);
     445
     446/** Selects up to limit from the database and returns them in a binary FITS table
     447 *
     448 * This function assumes an empty psFits object and will create a FITS table
     449 * as the first extension.
     450 *
     451 *  See psDBSelectRows() for documentation on the format of where.
     452 *
     453 * @return true on success
     454 */
     455
     456bool summitImfileSelectRowsFits(
     457    psDB            *dbh,               ///< Database handle
     458    psFits          *fits,              ///< psFits object
     459    const psMetadata *where,            ///< Row match criteria
     460    unsigned long long limit            ///< Maximum number of elements to return
     461);
     462
     463/** Convert a summitImfileRow into an equivalent psMetadata
     464 *
     465 * @return A psMetadata pointer or NULL on error
     466 */
     467
     468psMetadata *summitImfileMetadataFromObject(
     469    const summitImfileRow *object             ///< fooRow to convert into a psMetadata
     470);
     471
     472/** Convert a psMetadata into an equivalent fooRow
     473 *
     474 * @return A summitImfileRow pointer or NULL on error
     475 */
     476
     477summitImfileRow *summitImfileObjectFromMetadata(
     478    psMetadata      *md                 ///< psMetadata to convert into a fooRow
     479);
     480/** Selects up to limit rows from the database and returns as summitImfileRow objects in a psArray
     481 *
     482 *  See psDBSelectRows() for documentation on the format of where.
     483 *
     484 * @return A psArray pointer or NULL on error
     485 */
     486
     487psArray *summitImfileSelectRowObjects(
     488    psDB            *dbh,               ///< Database handle
     489    const psMetadata *where,            ///< Row match criteria
     490    unsigned long long limit            ///< Maximum number of elements to return
     491);
     492/** Deletes a row from the database coresponding to an summitImfile
     493 *
     494 *  Note that a 'where' search psMetadata is constructed from each object and
     495 *  used to find rows to delete.
     496 *
     497 * @return A The number of rows removed or a negative value on error
     498 */
     499
     500bool summitImfileDeleteObject(
     501    psDB            *dbh,               ///< Database handle
     502    const summitImfileRow *object    ///< Object to delete
     503);
     504/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     505 *
     506 *  Note that a 'where' search psMetadata is constructed from each object and
     507 *  used to find rows to delete.
     508 *
     509 * @return A The number of rows removed or a negative value on error
     510 */
     511
     512long long summitImfileDeleteRowObjects(
     513    psDB            *dbh,               ///< Database handle
     514    const psArray   *objects,           ///< Array of objects to delete
     515    unsigned long long limit            ///< Maximum number of elements to delete
     516);
     517/** Formats and prints an array of summitImfileRow objects
     518 *
     519 * When mdcf is set the formated output is in psMetadataConfig
     520 * format, otherwise it is in a simple tabular format.
     521 *
     522 * @return true on success
     523 */
     524
     525bool summitImfilePrintObjects(
     526    FILE            *stream,            ///< a stream
     527    psArray         *objects,           ///< An array of summitImfileRow objects
     528    bool            mdcf                ///< format as mdconfig or simple
     529);
     530/** pzPendingExpRow data structure
     531 *
     532 * Structure for representing a single row of pzPendingExp table data.
     533 */
     534
     535typedef struct {
     536    char            *exp_id;
     537    char            *camera;
     538    char            *telescope;
     539} pzPendingExpRow;
     540
     541/** Creates a new pzPendingExpRow object
     542 *
     543 *  @return A new pzPendingExpRow object or NULL on failure.
     544 */
     545
     546pzPendingExpRow *pzPendingExpRowAlloc(
     547    const char      *exp_id,
     548    const char      *camera,
     549    const char      *telescope
     550);
     551
     552/** Creates a new pzPendingExp table
     553 *
     554 * @return true on success
     555 */
     556
     557bool pzPendingExpCreateTable(
     558    psDB            *dbh                ///< Database handle
     559);
     560
     561/** Deletes a pzPendingExp table
     562 *
     563 * @return true on success
     564 */
     565
     566bool pzPendingExpDropTable(
     567    psDB            *dbh                ///< Database handle
     568);
     569
     570/** Insert a single row into a table
     571 *
     572 * This function constructs and inserts a single row based on it's parameters.
     573 *
     574 * @return true on success
     575 */
     576
     577bool pzPendingExpInsert(
     578    psDB            *dbh,               ///< Database handle
     579    const char      *exp_id,
     580    const char      *camera,
     581    const char      *telescope
     582);
     583
     584/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     585 *
     586 * @return A The number of rows removed or a negative value on error
     587 */
     588
     589long long pzPendingExpDelete(
     590    psDB            *dbh,               ///< Database handle
     591    const psMetadata *where,            ///< Row match criteria
     592    unsigned long long limit            ///< Maximum number of elements to delete
     593);
     594
     595/** Insert a single pzPendingExpRow object into a table
     596 *
     597 * This function constructs and inserts a single row based on it's parameters.
     598 *
     599 * @return true on success
     600 */
     601
     602bool pzPendingExpInsertObject(
     603    psDB            *dbh,               ///< Database handle
     604    pzPendingExpRow *object             ///< pzPendingExpRow object
     605);
     606
     607/** Insert an array of pzPendingExpRow object into a table
     608 *
     609 * This function constructs and inserts multiple rows based on it's parameters.
     610 *
     611 * @return true on success
     612 */
     613
     614bool pzPendingExpInsertObjects(
     615    psDB            *dbh,               ///< Database handle
     616    psArray         *objects            ///< array of pzPendingExpRow objects
     617);
     618
     619/** Insert data from a binary FITS table pzPendingExpRow into the database
     620 *
     621 * This function expects a psFits object with a FITS table as the first
     622 * extension.  The table must have at least one row of data in it, that is of
     623 * the appropriate format (number of columns and their type).  All other
     624 * extensions are ignored.
     625 *
     626 * @return true on success
     627 */
     628
     629bool pzPendingExpInsertFits(
     630    psDB            *dbh,               ///< Database handle
     631    const psFits    *fits               ///< psFits object
     632);
     633
     634/** Selects up to limit from the database and returns them in a binary FITS table
     635 *
     636 * This function assumes an empty psFits object and will create a FITS table
     637 * as the first extension.
     638 *
     639 *  See psDBSelectRows() for documentation on the format of where.
     640 *
     641 * @return true on success
     642 */
     643
     644bool pzPendingExpSelectRowsFits(
     645    psDB            *dbh,               ///< Database handle
     646    psFits          *fits,              ///< psFits object
     647    const psMetadata *where,            ///< Row match criteria
     648    unsigned long long limit            ///< Maximum number of elements to return
     649);
     650
     651/** Convert a pzPendingExpRow into an equivalent psMetadata
     652 *
     653 * @return A psMetadata pointer or NULL on error
     654 */
     655
     656psMetadata *pzPendingExpMetadataFromObject(
     657    const pzPendingExpRow *object             ///< fooRow to convert into a psMetadata
     658);
     659
     660/** Convert a psMetadata into an equivalent fooRow
     661 *
     662 * @return A pzPendingExpRow pointer or NULL on error
     663 */
     664
     665pzPendingExpRow *pzPendingExpObjectFromMetadata(
     666    psMetadata      *md                 ///< psMetadata to convert into a fooRow
     667);
     668/** Selects up to limit rows from the database and returns as pzPendingExpRow objects in a psArray
     669 *
     670 *  See psDBSelectRows() for documentation on the format of where.
     671 *
     672 * @return A psArray pointer or NULL on error
     673 */
     674
     675psArray *pzPendingExpSelectRowObjects(
     676    psDB            *dbh,               ///< Database handle
     677    const psMetadata *where,            ///< Row match criteria
     678    unsigned long long limit            ///< Maximum number of elements to return
     679);
     680/** Deletes a row from the database coresponding to an pzPendingExp
     681 *
     682 *  Note that a 'where' search psMetadata is constructed from each object and
     683 *  used to find rows to delete.
     684 *
     685 * @return A The number of rows removed or a negative value on error
     686 */
     687
     688bool pzPendingExpDeleteObject(
     689    psDB            *dbh,               ///< Database handle
     690    const pzPendingExpRow *object    ///< Object to delete
     691);
     692/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     693 *
     694 *  Note that a 'where' search psMetadata is constructed from each object and
     695 *  used to find rows to delete.
     696 *
     697 * @return A The number of rows removed or a negative value on error
     698 */
     699
     700long long pzPendingExpDeleteRowObjects(
     701    psDB            *dbh,               ///< Database handle
     702    const psArray   *objects,           ///< Array of objects to delete
     703    unsigned long long limit            ///< Maximum number of elements to delete
     704);
     705/** Formats and prints an array of pzPendingExpRow objects
     706 *
     707 * When mdcf is set the formated output is in psMetadataConfig
     708 * format, otherwise it is in a simple tabular format.
     709 *
     710 * @return true on success
     711 */
     712
     713bool pzPendingExpPrintObjects(
     714    FILE            *stream,            ///< a stream
     715    psArray         *objects,           ///< An array of pzPendingExpRow objects
     716    bool            mdcf                ///< format as mdconfig or simple
     717);
     718/** pzPendingImfileRow data structure
     719 *
     720 * Structure for representing a single row of pzPendingImfile table data.
     721 */
     722
     723typedef struct {
     724    char            *exp_id;
     725    char            *camera;
     726    char            *telescope;
     727    char            *class;
     728    char            *class_id;
     729    char            *exp_tag;
     730} pzPendingImfileRow;
     731
     732/** Creates a new pzPendingImfileRow object
     733 *
     734 *  @return A new pzPendingImfileRow object or NULL on failure.
     735 */
     736
     737pzPendingImfileRow *pzPendingImfileRowAlloc(
     738    const char      *exp_id,
     739    const char      *camera,
     740    const char      *telescope,
     741    const char      *class,
     742    const char      *class_id,
     743    const char      *exp_tag
     744);
     745
     746/** Creates a new pzPendingImfile table
     747 *
     748 * @return true on success
     749 */
     750
     751bool pzPendingImfileCreateTable(
     752    psDB            *dbh                ///< Database handle
     753);
     754
     755/** Deletes a pzPendingImfile table
     756 *
     757 * @return true on success
     758 */
     759
     760bool pzPendingImfileDropTable(
     761    psDB            *dbh                ///< Database handle
     762);
     763
     764/** Insert a single row into a table
     765 *
     766 * This function constructs and inserts a single row based on it's parameters.
     767 *
     768 * @return true on success
     769 */
     770
     771bool pzPendingImfileInsert(
     772    psDB            *dbh,               ///< Database handle
     773    const char      *exp_id,
     774    const char      *camera,
     775    const char      *telescope,
     776    const char      *class,
     777    const char      *class_id,
     778    const char      *exp_tag
     779);
     780
     781/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     782 *
     783 * @return A The number of rows removed or a negative value on error
     784 */
     785
     786long long pzPendingImfileDelete(
     787    psDB            *dbh,               ///< Database handle
     788    const psMetadata *where,            ///< Row match criteria
     789    unsigned long long limit            ///< Maximum number of elements to delete
     790);
     791
     792/** Insert a single pzPendingImfileRow object into a table
     793 *
     794 * This function constructs and inserts a single row based on it's parameters.
     795 *
     796 * @return true on success
     797 */
     798
     799bool pzPendingImfileInsertObject(
     800    psDB            *dbh,               ///< Database handle
     801    pzPendingImfileRow *object             ///< pzPendingImfileRow object
     802);
     803
     804/** Insert an array of pzPendingImfileRow object into a table
     805 *
     806 * This function constructs and inserts multiple rows based on it's parameters.
     807 *
     808 * @return true on success
     809 */
     810
     811bool pzPendingImfileInsertObjects(
     812    psDB            *dbh,               ///< Database handle
     813    psArray         *objects            ///< array of pzPendingImfileRow objects
     814);
     815
     816/** Insert data from a binary FITS table pzPendingImfileRow into the database
     817 *
     818 * This function expects a psFits object with a FITS table as the first
     819 * extension.  The table must have at least one row of data in it, that is of
     820 * the appropriate format (number of columns and their type).  All other
     821 * extensions are ignored.
     822 *
     823 * @return true on success
     824 */
     825
    632826bool pzPendingImfileInsertFits(
    633827    psDB            *dbh,               ///< Database handle
    … …  
    719913    bool            mdcf                ///< format as mdconfig or simple
    720914);
    721 /** newExpRow data structure
    722  *
    723  * Structure for representing a single row of newExp table data.
     915/** pzDoneExpRow data structure
     916 *
     917 * Structure for representing a single row of pzDoneExp table data.
    724918 */
    725919
    726920typedef struct {
    727     char            *exp_tag;
    728921    char            *exp_id;
    729922    char            *camera;
    730923    char            *telescope;
     924} pzDoneExpRow;
     925
     926/** Creates a new pzDoneExpRow object
     927 *
     928 *  @return A new pzDoneExpRow object or NULL on failure.
     929 */
     930
     931pzDoneExpRow *pzDoneExpRowAlloc(
     932    const char      *exp_id,
     933    const char      *camera,
     934    const char      *telescope
     935);
     936
     937/** Creates a new pzDoneExp table
     938 *
     939 * @return true on success
     940 */
     941
     942bool pzDoneExpCreateTable(
     943    psDB            *dbh                ///< Database handle
     944);
     945
     946/** Deletes a pzDoneExp table
     947 *
     948 * @return true on success
     949 */
     950
     951bool pzDoneExpDropTable(
     952    psDB            *dbh                ///< Database handle
     953);
     954
     955/** Insert a single row into a table
     956 *
     957 * This function constructs and inserts a single row based on it's parameters.
     958 *
     959 * @return true on success
     960 */
     961
     962bool pzDoneExpInsert(
     963    psDB            *dbh,               ///< Database handle
     964    const char      *exp_id,
     965    const char      *camera,
     966    const char      *telescope
     967);
     968
     969/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     970 *
     971 * @return A The number of rows removed or a negative value on error
     972 */
     973
     974long long pzDoneExpDelete(
     975    psDB            *dbh,               ///< Database handle
     976    const psMetadata *where,            ///< Row match criteria
     977    unsigned long long limit            ///< Maximum number of elements to delete
     978);
     979
     980/** Insert a single pzDoneExpRow object into a table
     981 *
     982 * This function constructs and inserts a single row based on it's parameters.
     983 *
     984 * @return true on success
     985 */
     986
     987bool pzDoneExpInsertObject(
     988    psDB            *dbh,               ///< Database handle
     989    pzDoneExpRow    *object             ///< pzDoneExpRow object
     990);
     991
     992/** Insert an array of pzDoneExpRow object into a table
     993 *
     994 * This function constructs and inserts multiple rows based on it's parameters.
     995 *
     996 * @return true on success
     997 */
     998
     999bool pzDoneExpInsertObjects(
     1000    psDB            *dbh,               ///< Database handle
     1001    psArray         *objects            ///< array of pzDoneExpRow objects
     1002);
     1003
     1004/** Insert data from a binary FITS table pzDoneExpRow into the database
     1005 *
     1006 * This function expects a psFits object with a FITS table as the first
     1007 * extension.  The table must have at least one row of data in it, that is of
     1008 * the appropriate format (number of columns and their type).  All other
     1009 * extensions are ignored.
     1010 *
     1011 * @return true on success
     1012 */
     1013
     1014bool pzDoneExpInsertFits(
     1015    psDB            *dbh,               ///< Database handle
     1016    const psFits    *fits               ///< psFits object
     1017);
     1018
     1019/** Selects up to limit from the database and returns them in a binary FITS table
     1020 *
     1021 * This function assumes an empty psFits object and will create a FITS table
     1022 * as the first extension.
     1023 *
     1024 *  See psDBSelectRows() for documentation on the format of where.
     1025 *
     1026 * @return true on success
     1027 */
     1028
     1029bool pzDoneExpSelectRowsFits(
     1030    psDB            *dbh,               ///< Database handle
     1031    psFits          *fits,              ///< psFits object
     1032    const psMetadata *where,            ///< Row match criteria
     1033    unsigned long long limit            ///< Maximum number of elements to return
     1034);
     1035
     1036/** Convert a pzDoneExpRow into an equivalent psMetadata
     1037 *
     1038 * @return A psMetadata pointer or NULL on error
     1039 */
     1040
     1041psMetadata *pzDoneExpMetadataFromObject(
     1042    const pzDoneExpRow *object             ///< fooRow to convert into a psMetadata
     1043);
     1044
     1045/** Convert a psMetadata into an equivalent fooRow
     1046 *
     1047 * @return A pzDoneExpRow pointer or NULL on error
     1048 */
     1049
     1050pzDoneExpRow *pzDoneExpObjectFromMetadata(
     1051    psMetadata      *md                 ///< psMetadata to convert into a fooRow
     1052);
     1053/** Selects up to limit rows from the database and returns as pzDoneExpRow objects in a psArray
     1054 *
     1055 *  See psDBSelectRows() for documentation on the format of where.
     1056 *
     1057 * @return A psArray pointer or NULL on error
     1058 */
     1059
     1060psArray *pzDoneExpSelectRowObjects(
     1061    psDB            *dbh,               ///< Database handle
     1062    const psMetadata *where,            ///< Row match criteria
     1063    unsigned long long limit            ///< Maximum number of elements to return
     1064);
     1065/** Deletes a row from the database coresponding to an pzDoneExp
     1066 *
     1067 *  Note that a 'where' search psMetadata is constructed from each object and
     1068 *  used to find rows to delete.
     1069 *
     1070 * @return A The number of rows removed or a negative value on error
     1071 */
     1072
     1073bool pzDoneExpDeleteObject(
     1074    psDB            *dbh,               ///< Database handle
     1075    const pzDoneExpRow *object    ///< Object to delete
     1076);
     1077/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     1078 *
     1079 *  Note that a 'where' search psMetadata is constructed from each object and
     1080 *  used to find rows to delete.
     1081 *
     1082 * @return A The number of rows removed or a negative value on error
     1083 */
     1084
     1085long long pzDoneExpDeleteRowObjects(
     1086    psDB            *dbh,               ///< Database handle
     1087    const psArray   *objects,           ///< Array of objects to delete
     1088    unsigned long long limit            ///< Maximum number of elements to delete
     1089);
     1090/** Formats and prints an array of pzDoneExpRow objects
     1091 *
     1092 * When mdcf is set the formated output is in psMetadataConfig
     1093 * format, otherwise it is in a simple tabular format.
     1094 *
     1095 * @return true on success
     1096 */
     1097
     1098bool pzDoneExpPrintObjects(
     1099    FILE            *stream,            ///< a stream
     1100    psArray         *objects,           ///< An array of pzDoneExpRow objects
     1101    bool            mdcf                ///< format as mdconfig or simple
     1102);
     1103/** pzDoneImfileRow data structure
     1104 *
     1105 * Structure for representing a single row of pzDoneImfile table data.
     1106 */
     1107
     1108typedef struct {
     1109    char            *exp_id;
     1110    char            *camera;
     1111    char            *telescope;
     1112    char            *class;
     1113    char            *class_id;
     1114    char            *exp_tag;
     1115    char            *uri;
     1116} pzDoneImfileRow;
     1117
     1118/** Creates a new pzDoneImfileRow object
     1119 *
     1120 *  @return A new pzDoneImfileRow object or NULL on failure.
     1121 */
     1122
     1123pzDoneImfileRow *pzDoneImfileRowAlloc(
     1124    const char      *exp_id,
     1125    const char      *camera,
     1126    const char      *telescope,
     1127    const char      *class,
     1128    const char      *class_id,
     1129    const char      *exp_tag,
     1130    const char      *uri
     1131);
     1132
     1133/** Creates a new pzDoneImfile table
     1134 *
     1135 * @return true on success
     1136 */
     1137
     1138bool pzDoneImfileCreateTable(
     1139    psDB            *dbh                ///< Database handle
     1140);
     1141
     1142/** Deletes a pzDoneImfile table
     1143 *
     1144 * @return true on success
     1145 */
     1146
     1147bool pzDoneImfileDropTable(
     1148    psDB            *dbh                ///< Database handle
     1149);
     1150
     1151/** Insert a single row into a table
     1152 *
     1153 * This function constructs and inserts a single row based on it's parameters.
     1154 *
     1155 * @return true on success
     1156 */
     1157
     1158bool pzDoneImfileInsert(
     1159    psDB            *dbh,               ///< Database handle
     1160    const char      *exp_id,
     1161    const char      *camera,
     1162    const char      *telescope,
     1163    const char      *class,
     1164    const char      *class_id,
     1165    const char      *exp_tag,
     1166    const char      *uri
     1167);
     1168
     1169/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     1170 *
     1171 * @return A The number of rows removed or a negative value on error
     1172 */
     1173
     1174long long pzDoneImfileDelete(
     1175    psDB            *dbh,               ///< Database handle
     1176    const psMetadata *where,            ///< Row match criteria
     1177    unsigned long long limit            ///< Maximum number of elements to delete
     1178);
     1179
     1180/** Insert a single pzDoneImfileRow object into a table
     1181 *
     1182 * This function constructs and inserts a single row based on it's parameters.
     1183 *
     1184 * @return true on success
     1185 */
     1186
     1187bool pzDoneImfileInsertObject(
     1188    psDB            *dbh,               ///< Database handle
     1189    pzDoneImfileRow *object             ///< pzDoneImfileRow object
     1190);
     1191
     1192/** Insert an array of pzDoneImfileRow object into a table
     1193 *
     1194 * This function constructs and inserts multiple rows based on it's parameters.
     1195 *
     1196 * @return true on success
     1197 */
     1198
     1199bool pzDoneImfileInsertObjects(
     1200    psDB            *dbh,               ///< Database handle
     1201    psArray         *objects            ///< array of pzDoneImfileRow objects
     1202);
     1203
     1204/** Insert data from a binary FITS table pzDoneImfileRow into the database
     1205 *
     1206 * This function expects a psFits object with a FITS table as the first
     1207 * extension.  The table must have at least one row of data in it, that is of
     1208 * the appropriate format (number of columns and their type).  All other
     1209 * extensions are ignored.
     1210 *
     1211 * @return true on success
     1212 */
     1213
     1214bool pzDoneImfileInsertFits(
     1215    psDB            *dbh,               ///< Database handle
     1216    const psFits    *fits               ///< psFits object
     1217);
     1218
     1219/** Selects up to limit from the database and returns them in a binary FITS table
     1220 *
     1221 * This function assumes an empty psFits object and will create a FITS table
     1222 * as the first extension.
     1223 *
     1224 *  See psDBSelectRows() for documentation on the format of where.
     1225 *
     1226 * @return true on success
     1227 */
     1228
     1229bool pzDoneImfileSelectRowsFits(
     1230    psDB            *dbh,               ///< Database handle
     1231    psFits          *fits,              ///< psFits object
     1232    const psMetadata *where,            ///< Row match criteria
     1233    unsigned long long limit            ///< Maximum number of elements to return
     1234);
     1235
     1236/** Convert a pzDoneImfileRow into an equivalent psMetadata
     1237 *
     1238 * @return A psMetadata pointer or NULL on error
     1239 */
     1240
     1241psMetadata *pzDoneImfileMetadataFromObject(
     1242    const pzDoneImfileRow *object             ///< fooRow to convert into a psMetadata
     1243);
     1244
     1245/** Convert a psMetadata into an equivalent fooRow
     1246 *
     1247 * @return A pzDoneImfileRow pointer or NULL on error
     1248 */
     1249
     1250pzDoneImfileRow *pzDoneImfileObjectFromMetadata(
     1251    psMetadata      *md                 ///< psMetadata to convert into a fooRow
     1252);
     1253/** Selects up to limit rows from the database and returns as pzDoneImfileRow objects in a psArray
     1254 *
     1255 *  See psDBSelectRows() for documentation on the format of where.
     1256 *
     1257 * @return A psArray pointer or NULL on error
     1258 */
     1259
     1260psArray *pzDoneImfileSelectRowObjects(
     1261    psDB            *dbh,               ///< Database handle
     1262    const psMetadata *where,            ///< Row match criteria
     1263    unsigned long long limit            ///< Maximum number of elements to return
     1264);
     1265/** Deletes a row from the database coresponding to an pzDoneImfile
     1266 *
     1267 *  Note that a 'where' search psMetadata is constructed from each object and
     1268 *  used to find rows to delete.
     1269 *
     1270 * @return A The number of rows removed or a negative value on error
     1271 */
     1272
     1273bool pzDoneImfileDeleteObject(
     1274    psDB            *dbh,               ///< Database handle
     1275    const pzDoneImfileRow *object    ///< Object to delete
     1276);
     1277/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
     1278 *
     1279 *  Note that a 'where' search psMetadata is constructed from each object and
     1280 *  used to find rows to delete.
     1281 *
     1282 * @return A The number of rows removed or a negative value on error
     1283 */
     1284
     1285long long pzDoneImfileDeleteRowObjects(
     1286    psDB            *dbh,               ///< Database handle
     1287    const psArray   *objects,           ///< Array of objects to delete
     1288    unsigned long long limit            ///< Maximum number of elements to delete
     1289);
     1290/** Formats and prints an array of pzDoneImfileRow objects
     1291 *
     1292 * When mdcf is set the formated output is in psMetadataConfig
     1293 * format, otherwise it is in a simple tabular format.
     1294 *
     1295 * @return true on success
     1296 */
     1297
     1298bool pzDoneImfilePrintObjects(
     1299    FILE            *stream,            ///< a stream
     1300    psArray         *objects,           ///< An array of pzDoneImfileRow objects
     1301    bool            mdcf                ///< format as mdconfig or simple
     1302);
     1303/** newExpRow data structure
     1304 *
     1305 * Structure for representing a single row of newExp table data.
     1306 */
     1307
     1308typedef struct {
     1309    psU64           exp_tag;
     1310    char            *exp_id;
     1311    char            *camera;
     1312    char            *telescope;
     1313    psTime*         dateobs;
    7311314    char            *exp_type;
    7321315    psS32           imfiles;
    … …  
    7391322
    7401323newExpRow *newExpRowAlloc(
    741     const char      *exp_tag,
     1324    psU64           exp_tag,
    7421325    const char      *exp_id,
    7431326    const char      *camera,
    7441327    const char      *telescope,
     1328    psTime*         dateobs,
    7451329    const char      *exp_type,
    7461330    psS32           imfiles
    … …  
    7741358bool newExpInsert(
    7751359    psDB            *dbh,               ///< Database handle
    776     const char      *exp_tag,
     1360    psU64           exp_tag,
    7771361    const char      *exp_id,
    7781362    const char      *camera,
    7791363    const char      *telescope,
     1364    psTime*         dateobs,
    7801365    const char      *exp_type,
    7811366    psS32           imfiles

  • trunk/ippdb/tests/alloc.c

    r9970 r10060  
    1111        summitExpRow    *object;
    1212
    13         object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string"    );
     13        object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32    );
    1414
    1515        if (!object) {
    … …  
    4040            exit(EXIT_FAILURE);
    4141        }
     42        if (!object->imfiles == -32) {
     43            psFree(object);
     44            exit(EXIT_FAILURE);
     45        }
     46
     47        psFree(object);
     48    }
     49
     50    {
     51        summitImfileRow *object;
     52
     53        object = summitImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"    );
     54
     55        if (!object) {
     56            exit(EXIT_FAILURE);
     57        }
     58
     59        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     60            psFree(object);
     61            exit(EXIT_FAILURE);
     62        }
     63        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     64            psFree(object);
     65            exit(EXIT_FAILURE);
     66        }
     67        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     68            psFree(object);
     69            exit(EXIT_FAILURE);
     70        }
     71        if (!object->bytes == -32) {
     72            psFree(object);
     73            exit(EXIT_FAILURE);
     74        }
     75        if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
     76            psFree(object);
     77            exit(EXIT_FAILURE);
     78        }
     79        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     80            psFree(object);
     81            exit(EXIT_FAILURE);
     82        }
     83        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     84            psFree(object);
     85            exit(EXIT_FAILURE);
     86        }
     87        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     88            psFree(object);
     89            exit(EXIT_FAILURE);
     90        }
    4291
    4392        psFree(object);
    … …  
    4796        pzPendingExpRow *object;
    4897
    49         object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32    );
     98        object = pzPendingExpRowAlloc("a string", "a string", "a string"    );
    5099
    51100        if (!object) {
    … …  
    65114            exit(EXIT_FAILURE);
    66115        }
    67         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    68             psFree(object);
    69             exit(EXIT_FAILURE);
    70         }
    71         if (!object->imfiles == -32) {
    72             psFree(object);
    73             exit(EXIT_FAILURE);
    74         }
    75116
    76117        psFree(object);
    … …  
    80121        pzPendingImfileRow *object;
    81122
    82         object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"    );
     123        object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string"    );
    83124
    84125        if (!object) {
    … …  
    98139            exit(EXIT_FAILURE);
    99140        }
    100         if (!object->bytes == -32) {
    101             psFree(object);
    102             exit(EXIT_FAILURE);
    103         }
    104         if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
    105             psFree(object);
    106             exit(EXIT_FAILURE);
    107         }
    108141        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    109142            psFree(object);
    … …  
    114147            exit(EXIT_FAILURE);
    115148        }
     149        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     150            psFree(object);
     151            exit(EXIT_FAILURE);
     152        }
     153
     154        psFree(object);
     155    }
     156
     157    {
     158        pzDoneExpRow    *object;
     159
     160        object = pzDoneExpRowAlloc("a string", "a string", "a string"    );
     161
     162        if (!object) {
     163            exit(EXIT_FAILURE);
     164        }
     165
     166        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     167            psFree(object);
     168            exit(EXIT_FAILURE);
     169        }
     170        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     171            psFree(object);
     172            exit(EXIT_FAILURE);
     173        }
     174        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     175            psFree(object);
     176            exit(EXIT_FAILURE);
     177        }
     178
     179        psFree(object);
     180    }
     181
     182    {
     183        pzDoneImfileRow *object;
     184
     185        object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", "a string"    );
     186
     187        if (!object) {
     188            exit(EXIT_FAILURE);
     189        }
     190
     191        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     192            psFree(object);
     193            exit(EXIT_FAILURE);
     194        }
     195        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     196            psFree(object);
     197            exit(EXIT_FAILURE);
     198        }
     199        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     200            psFree(object);
     201            exit(EXIT_FAILURE);
     202        }
     203        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     204            psFree(object);
     205            exit(EXIT_FAILURE);
     206        }
     207        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     208            psFree(object);
     209            exit(EXIT_FAILURE);
     210        }
     211        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     212            psFree(object);
     213            exit(EXIT_FAILURE);
     214        }
    116215        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    117216            psFree(object);
    … …  
    125224        newExpRow       *object;
    126225
    127         object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32    );
    128 
    129         if (!object) {
    130             exit(EXIT_FAILURE);
    131         }
    132 
    133         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     226        object = newExpRowAlloc(64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32    );
     227
     228        if (!object) {
     229            exit(EXIT_FAILURE);
     230        }
     231
    134232            psFree(object);
    135233            exit(EXIT_FAILURE);
    … …  
    144242        }
    145243        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     244            psFree(object);
     245            exit(EXIT_FAILURE);
     246        }
    146247            psFree(object);
    147248            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/createtable.c

    r9788 r10060  
    2828        }
    2929
     30        if(!summitImfileCreateTable(dbh)) {
     31            exit(EXIT_FAILURE);
     32        }
     33
     34        psDBCleanup(dbh);
     35    }
     36
     37    {
     38        psDB            *dbh;
     39
     40        dbh = psDBInit("localhost", "test", NULL, "test");
     41        if (!dbh) {
     42            exit(EXIT_FAILURE);
     43        }
     44
    3045        if(!pzPendingExpCreateTable(dbh)) {
    3146            exit(EXIT_FAILURE);
    … …  
    4459
    4560        if(!pzPendingImfileCreateTable(dbh)) {
     61            exit(EXIT_FAILURE);
     62        }
     63
     64        psDBCleanup(dbh);
     65    }
     66
     67    {
     68        psDB            *dbh;
     69
     70        dbh = psDBInit("localhost", "test", NULL, "test");
     71        if (!dbh) {
     72            exit(EXIT_FAILURE);
     73        }
     74
     75        if(!pzDoneExpCreateTable(dbh)) {
     76            exit(EXIT_FAILURE);
     77        }
     78
     79        psDBCleanup(dbh);
     80    }
     81
     82    {
     83        psDB            *dbh;
     84
     85        dbh = psDBInit("localhost", "test", NULL, "test");
     86        if (!dbh) {
     87            exit(EXIT_FAILURE);
     88        }
     89
     90        if(!pzDoneImfileCreateTable(dbh)) {
    4691            exit(EXIT_FAILURE);
    4792        }

  • trunk/ippdb/tests/dbcleanup.c

    r9788 r10060  
    1212
    1313    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp");
     14    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitImfile");
    1415    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingExp");
    1516    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingImfile");
     17    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneExp");
     18    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneImfile");
    1619    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newExp");
    1720    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newImfile");

  • trunk/ippdb/tests/dbsetup.c

    r9788 r10060  
    1616    summitExpCreateTable(dbh);
    1717
     18    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitImfile");
     19    summitImfileCreateTable(dbh);
     20
    1821    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingExp");
    1922    pzPendingExpCreateTable(dbh);
    … …  
    2124    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingImfile");
    2225    pzPendingImfileCreateTable(dbh);
     26
     27    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneExp");
     28    pzDoneExpCreateTable(dbh);
     29
     30    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneImfile");
     31    pzDoneImfileCreateTable(dbh);
    2332
    2433    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newExp");

  • trunk/ippdb/tests/droptable.c

    r9788 r10060  
    2828        }
    2929
     30        if (!summitImfileDropTable(dbh)) {
     31            exit(EXIT_FAILURE);
     32        }
     33
     34        psDBCleanup(dbh);
     35    }
     36
     37    {
     38        psDB            *dbh;
     39
     40        dbh = psDBInit("localhost", "test", NULL, "test");
     41        if (!dbh) {
     42            exit(EXIT_FAILURE);
     43        }
     44
    3045        if (!pzPendingExpDropTable(dbh)) {
    3146            exit(EXIT_FAILURE);
    … …  
    4459
    4560        if (!pzPendingImfileDropTable(dbh)) {
     61            exit(EXIT_FAILURE);
     62        }
     63
     64        psDBCleanup(dbh);
     65    }
     66
     67    {
     68        psDB            *dbh;
     69
     70        dbh = psDBInit("localhost", "test", NULL, "test");
     71        if (!dbh) {
     72            exit(EXIT_FAILURE);
     73        }
     74
     75        if (!pzDoneExpDropTable(dbh)) {
     76            exit(EXIT_FAILURE);
     77        }
     78
     79        psDBCleanup(dbh);
     80    }
     81
     82    {
     83        psDB            *dbh;
     84
     85        dbh = psDBInit("localhost", "test", NULL, "test");
     86        if (!dbh) {
     87            exit(EXIT_FAILURE);
     88        }
     89
     90        if (!pzDoneImfileDropTable(dbh)) {
    4691            exit(EXIT_FAILURE);
    4792        }

  • trunk/ippdb/tests/insert.c

    r9970 r10060  
    1313        }
    1414
    15         if (!summitExpInsert(dbh, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string")) {
    16             exit(EXIT_FAILURE);
    17         }
    18 
    19         psDBCleanup(dbh);
    20     }
    21 
    22     {
    23         psDB            *dbh;
    24 
    25         dbh = psDBInit("localhost", "test", NULL, "test");
    26         if (!dbh) {
    27             exit(EXIT_FAILURE);
    28         }
    29 
    30         if (!pzPendingExpInsert(dbh, "a string", "a string", "a string", "a string", -32)) {
    31             exit(EXIT_FAILURE);
    32         }
    33 
    34         psDBCleanup(dbh);
    35     }
    36 
    37     {
    38         psDB            *dbh;
    39 
    40         dbh = psDBInit("localhost", "test", NULL, "test");
    41         if (!dbh) {
    42             exit(EXIT_FAILURE);
    43         }
    44 
    45         if (!pzPendingImfileInsert(dbh, "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string")) {
    46             exit(EXIT_FAILURE);
    47         }
    48 
    49         psDBCleanup(dbh);
    50     }
    51 
    52     {
    53         psDB            *dbh;
    54 
    55         dbh = psDBInit("localhost", "test", NULL, "test");
    56         if (!dbh) {
    57             exit(EXIT_FAILURE);
    58         }
    59 
    60         if (!newExpInsert(dbh, "a string", "a string", "a string", "a string", "a string", -32)) {
     15        if (!summitExpInsert(dbh, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32)) {
     16            exit(EXIT_FAILURE);
     17        }
     18
     19        psDBCleanup(dbh);
     20    }
     21
     22    {
     23        psDB            *dbh;
     24
     25        dbh = psDBInit("localhost", "test", NULL, "test");
     26        if (!dbh) {
     27            exit(EXIT_FAILURE);
     28        }
     29
     30        if (!summitImfileInsert(dbh, "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string")) {
     31            exit(EXIT_FAILURE);
     32        }
     33
     34        psDBCleanup(dbh);
     35    }
     36
     37    {
     38        psDB            *dbh;
     39
     40        dbh = psDBInit("localhost", "test", NULL, "test");
     41        if (!dbh) {
     42            exit(EXIT_FAILURE);
     43        }
     44
     45        if (!pzPendingExpInsert(dbh, "a string", "a string", "a string")) {
     46            exit(EXIT_FAILURE);
     47        }
     48
     49        psDBCleanup(dbh);
     50    }
     51
     52    {
     53        psDB            *dbh;
     54
     55        dbh = psDBInit("localhost", "test", NULL, "test");
     56        if (!dbh) {
     57            exit(EXIT_FAILURE);
     58        }
     59
     60        if (!pzPendingImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string")) {
     61            exit(EXIT_FAILURE);
     62        }
     63
     64        psDBCleanup(dbh);
     65    }
     66
     67    {
     68        psDB            *dbh;
     69
     70        dbh = psDBInit("localhost", "test", NULL, "test");
     71        if (!dbh) {
     72            exit(EXIT_FAILURE);
     73        }
     74
     75        if (!pzDoneExpInsert(dbh, "a string", "a string", "a string")) {
     76            exit(EXIT_FAILURE);
     77        }
     78
     79        psDBCleanup(dbh);
     80    }
     81
     82    {
     83        psDB            *dbh;
     84
     85        dbh = psDBInit("localhost", "test", NULL, "test");
     86        if (!dbh) {
     87            exit(EXIT_FAILURE);
     88        }
     89
     90        if (!pzDoneImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", "a string")) {
     91            exit(EXIT_FAILURE);
     92        }
     93
     94        psDBCleanup(dbh);
     95    }
     96
     97    {
     98        psDB            *dbh;
     99
     100        dbh = psDBInit("localhost", "test", NULL, "test");
     101        if (!dbh) {
     102            exit(EXIT_FAILURE);
     103        }
     104
     105        if (!newExpInsert(dbh, 64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32)) {
    61106            exit(EXIT_FAILURE);
    62107        }

  • trunk/ippdb/tests/insertfits.c

    r9788 r10060  
    5050        }
    5151
     52        if (!summitImfileInsertFits(dbh, fits)) {
     53            exit(EXIT_FAILURE);
     54        }
     55
     56        if (!psFitsClose(fits)) {
     57            exit(EXIT_FAILURE);
     58        }
     59
     60        psDBCleanup(dbh);
     61    }
     62
     63    {
     64        psDB            *dbh;
     65        psFits          *fits;
     66
     67        dbh = psDBInit("localhost", "test", NULL, "test");
     68        if (!dbh) {
     69            exit(EXIT_FAILURE);
     70        }
     71
     72        // open a temp
     73        fits = psFitsOpen(TMP_FILENAME, "r");
     74        if (!fits) {
     75            exit(EXIT_FAILURE);
     76        }
     77
    5278        if (!pzPendingExpInsertFits(dbh, fits)) {
    5379            exit(EXIT_FAILURE);
    … …  
    77103
    78104        if (!pzPendingImfileInsertFits(dbh, fits)) {
     105            exit(EXIT_FAILURE);
     106        }
     107
     108        if (!psFitsClose(fits)) {
     109            exit(EXIT_FAILURE);
     110        }
     111
     112        psDBCleanup(dbh);
     113    }
     114
     115    {
     116        psDB            *dbh;
     117        psFits          *fits;
     118
     119        dbh = psDBInit("localhost", "test", NULL, "test");
     120        if (!dbh) {
     121            exit(EXIT_FAILURE);
     122        }
     123
     124        // open a temp
     125        fits = psFitsOpen(TMP_FILENAME, "r");
     126        if (!fits) {
     127            exit(EXIT_FAILURE);
     128        }
     129
     130        if (!pzDoneExpInsertFits(dbh, fits)) {
     131            exit(EXIT_FAILURE);
     132        }
     133
     134        if (!psFitsClose(fits)) {
     135            exit(EXIT_FAILURE);
     136        }
     137
     138        psDBCleanup(dbh);
     139    }
     140
     141    {
     142        psDB            *dbh;
     143        psFits          *fits;
     144
     145        dbh = psDBInit("localhost", "test", NULL, "test");
     146        if (!dbh) {
     147            exit(EXIT_FAILURE);
     148        }
     149
     150        // open a temp
     151        fits = psFitsOpen(TMP_FILENAME, "r");
     152        if (!fits) {
     153            exit(EXIT_FAILURE);
     154        }
     155
     156        if (!pzDoneImfileInsertFits(dbh, fits)) {
    79157            exit(EXIT_FAILURE);
    80158        }

  • trunk/ippdb/tests/insertobject.c

    r9970 r10060  
    1414        }
    1515
    16         object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
     16        object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32);
    1717        if (!object) {
    1818            exit(EXIT_FAILURE);
    … …  
    2929    {
    3030        psDB            *dbh;
     31        summitImfileRow *object;
     32
     33        dbh = psDBInit("localhost", "test", NULL, "test");
     34        if (!dbh) {
     35            exit(EXIT_FAILURE);
     36        }
     37
     38        object = summitImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
     39        if (!object) {
     40            exit(EXIT_FAILURE);
     41        }
     42
     43        if (!summitImfileInsertObject(dbh, object)) {
     44            exit(EXIT_FAILURE);
     45        }
     46
     47        psFree(object);
     48        psDBCleanup(dbh);
     49    }
     50
     51    {
     52        psDB            *dbh;
    3153        pzPendingExpRow *object;
    3254
    … …  
    3658        }
    3759
    38         object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32);
     60        object = pzPendingExpRowAlloc("a string", "a string", "a string");
    3961        if (!object) {
    4062            exit(EXIT_FAILURE);
    … …  
    5880        }
    5981
    60         object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
     82        object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string");
    6183        if (!object) {
    6284            exit(EXIT_FAILURE);
    … …  
    7395    {
    7496        psDB            *dbh;
     97        pzDoneExpRow    *object;
     98
     99        dbh = psDBInit("localhost", "test", NULL, "test");
     100        if (!dbh) {
     101            exit(EXIT_FAILURE);
     102        }
     103
     104        object = pzDoneExpRowAlloc("a string", "a string", "a string");
     105        if (!object) {
     106            exit(EXIT_FAILURE);
     107        }
     108
     109        if (!pzDoneExpInsertObject(dbh, object)) {
     110            exit(EXIT_FAILURE);
     111        }
     112
     113        psFree(object);
     114        psDBCleanup(dbh);
     115    }
     116
     117    {
     118        psDB            *dbh;
     119        pzDoneImfileRow *object;
     120
     121        dbh = psDBInit("localhost", "test", NULL, "test");
     122        if (!dbh) {
     123            exit(EXIT_FAILURE);
     124        }
     125
     126        object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", "a string");
     127        if (!object) {
     128            exit(EXIT_FAILURE);
     129        }
     130
     131        if (!pzDoneImfileInsertObject(dbh, object)) {
     132            exit(EXIT_FAILURE);
     133        }
     134
     135        psFree(object);
     136        psDBCleanup(dbh);
     137    }
     138
     139    {
     140        psDB            *dbh;
    75141        newExpRow       *object;
    76142
    … …  
    80146        }
    81147
    82         object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32);
     148        object = newExpRowAlloc(64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32);
    83149        if (!object) {
    84150            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/metadatafromobject.c

    r9970 r10060  
    1313        bool            status;
    1414
    15         object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string");
     15        object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32);
    1616        if (!object) {
    1717            exit(EXIT_FAILURE);
    … …  
    4848            exit(EXIT_FAILURE);
    4949        }
     50        if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
     51            psFree(md);
     52            exit(EXIT_FAILURE);
     53        }
     54
     55        psFree(md);
     56    }
     57
     58    {
     59        psMetadata      *md;
     60        summitImfileRow *object;
     61        bool            status;
     62
     63        object = summitImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
     64        if (!object) {
     65            exit(EXIT_FAILURE);
     66        }
     67
     68        md = summitImfileMetadataFromObject(object);
     69        if (!md) {
     70            exit(EXIT_FAILURE);
     71        }
     72
     73        psFree(object);
     74
     75        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     76            psFree(md);
     77            exit(EXIT_FAILURE);
     78        }
     79        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     80            psFree(md);
     81            exit(EXIT_FAILURE);
     82        }
     83        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     84            psFree(md);
     85            exit(EXIT_FAILURE);
     86        }
     87        if (!psMetadataLookupS32(&status, md, "bytes") == -32) {
     88            psFree(md);
     89            exit(EXIT_FAILURE);
     90        }
     91        if (strncmp(psMetadataLookupPtr(&status, md, "md5sum"), "a string", MAX_STRING_LENGTH)) {
     92            psFree(md);
     93            exit(EXIT_FAILURE);
     94        }
     95        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     96            psFree(md);
     97            exit(EXIT_FAILURE);
     98        }
     99        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     100            psFree(md);
     101            exit(EXIT_FAILURE);
     102        }
     103        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
     104            psFree(md);
     105            exit(EXIT_FAILURE);
     106        }
    50107
    51108        psFree(md);
    … …  
    57114        bool            status;
    58115
    59         object = pzPendingExpRowAlloc("a string", "a string", "a string", "a string", -32);
     116        object = pzPendingExpRowAlloc("a string", "a string", "a string");
    60117        if (!object) {
    61118            exit(EXIT_FAILURE);
    … …  
    81138            exit(EXIT_FAILURE);
    82139        }
    83         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    84             psFree(md);
    85             exit(EXIT_FAILURE);
    86         }
    87         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    88             psFree(md);
    89             exit(EXIT_FAILURE);
    90         }
    91140
    92141        psFree(md);
    … …  
    98147        bool            status;
    99148
    100         object = pzPendingImfileRowAlloc("a string", "a string", "a string", -32, "a string", "a string", "a string", "a string");
     149        object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string");
    101150        if (!object) {
    102151            exit(EXIT_FAILURE);
    … …  
    122171            exit(EXIT_FAILURE);
    123172        }
    124         if (!psMetadataLookupS32(&status, md, "bytes") == -32) {
    125             psFree(md);
    126             exit(EXIT_FAILURE);
    127         }
    128         if (strncmp(psMetadataLookupPtr(&status, md, "md5sum"), "a string", MAX_STRING_LENGTH)) {
    129             psFree(md);
    130             exit(EXIT_FAILURE);
    131         }
    132173        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
    133174            psFree(md);
    … …  
    138179            exit(EXIT_FAILURE);
    139180        }
     181        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     182            psFree(md);
     183            exit(EXIT_FAILURE);
     184        }
     185
     186        psFree(md);
     187    }
     188
     189    {
     190        psMetadata      *md;
     191        pzDoneExpRow    *object;
     192        bool            status;
     193
     194        object = pzDoneExpRowAlloc("a string", "a string", "a string");
     195        if (!object) {
     196            exit(EXIT_FAILURE);
     197        }
     198
     199        md = pzDoneExpMetadataFromObject(object);
     200        if (!md) {
     201            exit(EXIT_FAILURE);
     202        }
     203
     204        psFree(object);
     205
     206        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     207            psFree(md);
     208            exit(EXIT_FAILURE);
     209        }
     210        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     211            psFree(md);
     212            exit(EXIT_FAILURE);
     213        }
     214        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     215            psFree(md);
     216            exit(EXIT_FAILURE);
     217        }
     218
     219        psFree(md);
     220    }
     221
     222    {
     223        psMetadata      *md;
     224        pzDoneImfileRow *object;
     225        bool            status;
     226
     227        object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", "a string");
     228        if (!object) {
     229            exit(EXIT_FAILURE);
     230        }
     231
     232        md = pzDoneImfileMetadataFromObject(object);
     233        if (!md) {
     234            exit(EXIT_FAILURE);
     235        }
     236
     237        psFree(object);
     238
     239        if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "a string", MAX_STRING_LENGTH)) {
     240            psFree(md);
     241            exit(EXIT_FAILURE);
     242        }
     243        if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
     244            psFree(md);
     245            exit(EXIT_FAILURE);
     246        }
     247        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     248            psFree(md);
     249            exit(EXIT_FAILURE);
     250        }
     251        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     252            psFree(md);
     253            exit(EXIT_FAILURE);
     254        }
     255        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     256            psFree(md);
     257            exit(EXIT_FAILURE);
     258        }
     259        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     260            psFree(md);
     261            exit(EXIT_FAILURE);
     262        }
    140263        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    141264            psFree(md);
    … …  
    151274        bool            status;
    152275
    153         object = newExpRowAlloc("a string", "a string", "a string", "a string", "a string", -32);
     276        object = newExpRowAlloc(64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32);
    154277        if (!object) {
    155278            exit(EXIT_FAILURE);
    … …  
    163286        psFree(object);
    164287
    165         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    166288            psFree(md);
    167289            exit(EXIT_FAILURE);
    … …  
    176298        }
    177299        if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     300            psFree(md);
     301            exit(EXIT_FAILURE);
     302        }
    178303            psFree(md);
    179304            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r9970 r10060  
    3636            exit(EXIT_FAILURE);
    3737        }
     38        if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
     39            psFree(md);
     40            exit(EXIT_FAILURE);
     41        }
    3842
    3943        object = summitExpObjectFromMetadata(md);
    … …  
    6872            exit(EXIT_FAILURE);
    6973        }
     74        if (!object->imfiles == -32) {
     75            psFree(object);
     76            exit(EXIT_FAILURE);
     77        }
     78
     79        psFree(object);
     80    }
     81
     82    {
     83        psMetadata      *md;
     84        summitImfileRow *object;
     85
     86        md = psMetadataAlloc();
     87        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     88            psFree(md);
     89            exit(EXIT_FAILURE);
     90        }
     91        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     92            psFree(md);
     93            exit(EXIT_FAILURE);
     94        }
     95        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     96            psFree(md);
     97            exit(EXIT_FAILURE);
     98        }
     99        if (!psMetadataAddS32(md, PS_LIST_TAIL, "bytes", 0, NULL, -32)) {
     100            psFree(md);
     101            exit(EXIT_FAILURE);
     102        }
     103        if (!psMetadataAddStr(md, PS_LIST_TAIL, "md5sum", 0, NULL, "a string")) {
     104            psFree(md);
     105            exit(EXIT_FAILURE);
     106        }
     107        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     108            psFree(md);
     109            exit(EXIT_FAILURE);
     110        }
     111        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     112            psFree(md);
     113            exit(EXIT_FAILURE);
     114        }
     115        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     116            psFree(md);
     117            exit(EXIT_FAILURE);
     118        }
     119
     120        object = summitImfileObjectFromMetadata(md);
     121        if (!object) {
     122            psFree(md);
     123            exit(EXIT_FAILURE);
     124        }
     125
     126        psFree(md);
     127
     128        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     129            psFree(object);
     130            exit(EXIT_FAILURE);
     131        }
     132        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     133            psFree(object);
     134            exit(EXIT_FAILURE);
     135        }
     136        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     137            psFree(object);
     138            exit(EXIT_FAILURE);
     139        }
     140        if (!object->bytes == -32) {
     141            psFree(object);
     142            exit(EXIT_FAILURE);
     143        }
     144        if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
     145            psFree(object);
     146            exit(EXIT_FAILURE);
     147        }
     148        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     149            psFree(object);
     150            exit(EXIT_FAILURE);
     151        }
     152        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     153            psFree(object);
     154            exit(EXIT_FAILURE);
     155        }
     156        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     157            psFree(object);
     158            exit(EXIT_FAILURE);
     159        }
    70160
    71161        psFree(object);
    … …  
    89179            exit(EXIT_FAILURE);
    90180        }
     181
     182        object = pzPendingExpObjectFromMetadata(md);
     183        if (!object) {
     184            psFree(md);
     185            exit(EXIT_FAILURE);
     186        }
     187
     188        psFree(md);
     189
     190        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     191            psFree(object);
     192            exit(EXIT_FAILURE);
     193        }
     194        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     195            psFree(object);
     196            exit(EXIT_FAILURE);
     197        }
     198        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     199            psFree(object);
     200            exit(EXIT_FAILURE);
     201        }
     202
     203        psFree(object);
     204    }
     205
     206    {
     207        psMetadata      *md;
     208        pzPendingImfileRow *object;
     209
     210        md = psMetadataAlloc();
     211        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     212            psFree(md);
     213            exit(EXIT_FAILURE);
     214        }
     215        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     216            psFree(md);
     217            exit(EXIT_FAILURE);
     218        }
     219        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     220            psFree(md);
     221            exit(EXIT_FAILURE);
     222        }
     223        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     224            psFree(md);
     225            exit(EXIT_FAILURE);
     226        }
     227        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     228            psFree(md);
     229            exit(EXIT_FAILURE);
     230        }
     231        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     232            psFree(md);
     233            exit(EXIT_FAILURE);
     234        }
     235
     236        object = pzPendingImfileObjectFromMetadata(md);
     237        if (!object) {
     238            psFree(md);
     239            exit(EXIT_FAILURE);
     240        }
     241
     242        psFree(md);
     243
     244        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     245            psFree(object);
     246            exit(EXIT_FAILURE);
     247        }
     248        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     249            psFree(object);
     250            exit(EXIT_FAILURE);
     251        }
     252        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     253            psFree(object);
     254            exit(EXIT_FAILURE);
     255        }
     256        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     257            psFree(object);
     258            exit(EXIT_FAILURE);
     259        }
     260        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     261            psFree(object);
     262            exit(EXIT_FAILURE);
     263        }
     264        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     265            psFree(object);
     266            exit(EXIT_FAILURE);
     267        }
     268
     269        psFree(object);
     270    }
     271
     272    {
     273        psMetadata      *md;
     274        pzDoneExpRow    *object;
     275
     276        md = psMetadataAlloc();
     277        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     278            psFree(md);
     279            exit(EXIT_FAILURE);
     280        }
     281        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     282            psFree(md);
     283            exit(EXIT_FAILURE);
     284        }
     285        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     286            psFree(md);
     287            exit(EXIT_FAILURE);
     288        }
     289
     290        object = pzDoneExpObjectFromMetadata(md);
     291        if (!object) {
     292            psFree(md);
     293            exit(EXIT_FAILURE);
     294        }
     295
     296        psFree(md);
     297
     298        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     299            psFree(object);
     300            exit(EXIT_FAILURE);
     301        }
     302        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     303            psFree(object);
     304            exit(EXIT_FAILURE);
     305        }
     306        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     307            psFree(object);
     308            exit(EXIT_FAILURE);
     309        }
     310
     311        psFree(object);
     312    }
     313
     314    {
     315        psMetadata      *md;
     316        pzDoneImfileRow *object;
     317
     318        md = psMetadataAlloc();
     319        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     320            psFree(md);
     321            exit(EXIT_FAILURE);
     322        }
     323        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     324            psFree(md);
     325            exit(EXIT_FAILURE);
     326        }
     327        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     328            psFree(md);
     329            exit(EXIT_FAILURE);
     330        }
     331        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     332            psFree(md);
     333            exit(EXIT_FAILURE);
     334        }
     335        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     336            psFree(md);
     337            exit(EXIT_FAILURE);
     338        }
     339        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     340            psFree(md);
     341            exit(EXIT_FAILURE);
     342        }
     343        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     344            psFree(md);
     345            exit(EXIT_FAILURE);
     346        }
     347
     348        object = pzDoneImfileObjectFromMetadata(md);
     349        if (!object) {
     350            psFree(md);
     351            exit(EXIT_FAILURE);
     352        }
     353
     354        psFree(md);
     355
     356        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
     357            psFree(object);
     358            exit(EXIT_FAILURE);
     359        }
     360        if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
     361            psFree(object);
     362            exit(EXIT_FAILURE);
     363        }
     364        if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     365            psFree(object);
     366            exit(EXIT_FAILURE);
     367        }
     368        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     369            psFree(object);
     370            exit(EXIT_FAILURE);
     371        }
     372        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     373            psFree(object);
     374            exit(EXIT_FAILURE);
     375        }
     376        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     377            psFree(object);
     378            exit(EXIT_FAILURE);
     379        }
     380        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
     381            psFree(object);
     382            exit(EXIT_FAILURE);
     383        }
     384
     385        psFree(object);
     386    }
     387
     388    {
     389        psMetadata      *md;
     390        newExpRow       *object;
     391
     392        md = psMetadataAlloc();
     393            psFree(md);
     394            exit(EXIT_FAILURE);
     395        }
     396        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
     397            psFree(md);
     398            exit(EXIT_FAILURE);
     399        }
     400        if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
     401            psFree(md);
     402            exit(EXIT_FAILURE);
     403        }
     404        if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     405            psFree(md);
     406            exit(EXIT_FAILURE);
     407        }
     408            psFree(md);
     409            exit(EXIT_FAILURE);
     410        }
    91411        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    92412            psFree(md);
    … …  
    98418        }
    99419
    100         object = pzPendingExpObjectFromMetadata(md);
    101         if (!object) {
    102             psFree(md);
    103             exit(EXIT_FAILURE);
    104         }
    105 
    106         psFree(md);
    107 
     420        object = newExpObjectFromMetadata(md);
     421        if (!object) {
     422            psFree(md);
     423            exit(EXIT_FAILURE);
     424        }
     425
     426        psFree(md);
     427
     428            psFree(object);
     429            exit(EXIT_FAILURE);
     430        }
    108431        if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    109432            psFree(object);
    … …  
    118441            exit(EXIT_FAILURE);
    119442        }
    120         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    121             psFree(object);
    122             exit(EXIT_FAILURE);
    123         }
    124         if (!object->imfiles == -32) {
    125             psFree(object);
    126             exit(EXIT_FAILURE);
    127         }
    128 
    129         psFree(object);
    130     }
    131 
    132     {
    133         psMetadata      *md;
    134         pzPendingImfileRow *object;
    135 
    136         md = psMetadataAlloc();
    137         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    138             psFree(md);
    139             exit(EXIT_FAILURE);
    140         }
    141         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    142             psFree(md);
    143             exit(EXIT_FAILURE);
    144         }
    145         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    146             psFree(md);
    147             exit(EXIT_FAILURE);
    148         }
    149         if (!psMetadataAddS32(md, PS_LIST_TAIL, "bytes", 0, NULL, -32)) {
    150             psFree(md);
    151             exit(EXIT_FAILURE);
    152         }
    153         if (!psMetadataAddStr(md, PS_LIST_TAIL, "md5sum", 0, NULL, "a string")) {
    154             psFree(md);
    155             exit(EXIT_FAILURE);
    156         }
    157         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
    158             psFree(md);
    159             exit(EXIT_FAILURE);
    160         }
    161         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    162             psFree(md);
    163             exit(EXIT_FAILURE);
    164         }
    165         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    166             psFree(md);
    167             exit(EXIT_FAILURE);
    168         }
    169 
    170         object = pzPendingImfileObjectFromMetadata(md);
    171         if (!object) {
    172             psFree(md);
    173             exit(EXIT_FAILURE);
    174         }
    175 
    176         psFree(md);
    177 
    178         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    179             psFree(object);
    180             exit(EXIT_FAILURE);
    181         }
    182         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    183             psFree(object);
    184             exit(EXIT_FAILURE);
    185         }
    186         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    187             psFree(object);
    188             exit(EXIT_FAILURE);
    189         }
    190         if (!object->bytes == -32) {
    191             psFree(object);
    192             exit(EXIT_FAILURE);
    193         }
    194         if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) {
    195             psFree(object);
    196             exit(EXIT_FAILURE);
    197         }
    198         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    199             psFree(object);
    200             exit(EXIT_FAILURE);
    201         }
    202         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    203             psFree(object);
    204             exit(EXIT_FAILURE);
    205         }
    206         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    207             psFree(object);
    208             exit(EXIT_FAILURE);
    209         }
    210 
    211         psFree(object);
    212     }
    213 
    214     {
    215         psMetadata      *md;
    216         newExpRow       *object;
    217 
    218         md = psMetadataAlloc();
    219         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    220             psFree(md);
    221             exit(EXIT_FAILURE);
    222         }
    223         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, "a string")) {
    224             psFree(md);
    225             exit(EXIT_FAILURE);
    226         }
    227         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    228             psFree(md);
    229             exit(EXIT_FAILURE);
    230         }
    231         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
    232             psFree(md);
    233             exit(EXIT_FAILURE);
    234         }
    235         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    236             psFree(md);
    237             exit(EXIT_FAILURE);
    238         }
    239         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    240             psFree(md);
    241             exit(EXIT_FAILURE);
    242         }
    243 
    244         object = newExpObjectFromMetadata(md);
    245         if (!object) {
    246             psFree(md);
    247             exit(EXIT_FAILURE);
    248         }
    249 
    250         psFree(md);
    251 
    252         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    253             psFree(object);
    254             exit(EXIT_FAILURE);
    255         }
    256         if (strncmp(object->exp_id, "a string", MAX_STRING_LENGTH)) {
    257             psFree(object);
    258             exit(EXIT_FAILURE);
    259         }
    260         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    261             psFree(object);
    262             exit(EXIT_FAILURE);
    263         }
    264         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
    265443            psFree(object);
    266444            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/selectrowsfits.c

    r9788 r10060  
    4343        }
    4444
     45        if (!summitImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     46            exit(EXIT_FAILURE);
     47        }
     48
     49        psFree(fits);
     50        psDBCleanup(dbh);
     51    }
     52
     53    {
     54        psDB            *dbh;
     55        psFits          *fits;
     56
     57        dbh = psDBInit("localhost", "test", NULL, "test");
     58        if (!dbh) {
     59            exit(EXIT_FAILURE);
     60        }
     61
     62        fits = psFitsOpen(TMP_FILENAME, "w");
     63        if (!fits) {
     64            exit(EXIT_FAILURE);
     65        }
     66
    4567        if (!pzPendingExpSelectRowsFits(dbh, fits, NULL, 1)) {
    4668            exit(EXIT_FAILURE);
    … …  
    6688
    6789        if (!pzPendingImfileSelectRowsFits(dbh, fits, NULL, 1)) {
     90            exit(EXIT_FAILURE);
     91        }
     92
     93        psFree(fits);
     94        psDBCleanup(dbh);
     95    }
     96
     97    {
     98        psDB            *dbh;
     99        psFits          *fits;
     100
     101        dbh = psDBInit("localhost", "test", NULL, "test");
     102        if (!dbh) {
     103            exit(EXIT_FAILURE);
     104        }
     105
     106        fits = psFitsOpen(TMP_FILENAME, "w");
     107        if (!fits) {
     108            exit(EXIT_FAILURE);
     109        }
     110
     111        if (!pzDoneExpSelectRowsFits(dbh, fits, NULL, 1)) {
     112            exit(EXIT_FAILURE);
     113        }
     114
     115        psFree(fits);
     116        psDBCleanup(dbh);
     117    }
     118
     119    {
     120        psDB            *dbh;
     121        psFits          *fits;
     122
     123        dbh = psDBInit("localhost", "test", NULL, "test");
     124        if (!dbh) {
     125            exit(EXIT_FAILURE);
     126        }
     127
     128        fits = psFitsOpen(TMP_FILENAME, "w");
     129        if (!fits) {
     130            exit(EXIT_FAILURE);
     131        }
     132
     133        if (!pzDoneImfileSelectRowsFits(dbh, fits, NULL, 1)) {
    68134            exit(EXIT_FAILURE);
    69135        }
Note: See TracChangeset for help on using the changeset viewer.