IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11720


Ignore:
Timestamp:
Feb 8, 2007, 3:18:04 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.3

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/config.md

    r11715 r11720  
    22    pkg_name        STR     ippdb
    33    pkg_namespace   STR     ippdb
    4     pkg_version     STR     1.1.2
     4    pkg_version     STR     1.1.3
    55END

  • trunk/dbconfig/p4.md

    r11715 r11720  
    1 # $Id: p4.md,v 1.9 2007-02-09 00:07:38 jhoblitt Exp $
     1# $Id: p4.md,v 1.10 2007-02-09 01:17:50 jhoblitt Exp $
    22
    33#
    … …  
    1111p4Run METADATA
    1212    p4a_id      S32         0       # Primary Key AUTO_INCREMENT
     13    mode        STR         64      # Key
    1314    state       STR         64      # Key
    14     mode        STR         64      # Key
    1515    workdir     STR         255
    16     magic       BOOL        f       # Primary Key
     16    registered  TAI         NULL
    1717END
    1818
    … …  
    2727    p3_version  S32         0       # Primary Key
    2828# if magic is T then look for the exp_tag in the magic output tables
     29    magiced     BOOL        f       # Primary Key
    2930END
    3031

  • trunk/ippdb/Makefile.am

    r11679 r11720  
    4141    $(top_builddir)/docs/man/man3/detResidExpRow.3 \
    4242    $(top_builddir)/docs/man/man3/detRunSummaryRow.3 \
    43     $(top_builddir)/docs/man/man3/p4aRunRow.3 \
    44     $(top_builddir)/docs/man/man3/p4aInputExpRow.3 \
    45     $(top_builddir)/docs/man/man3/p4aScfileRow.3 \
    46     $(top_builddir)/docs/man/man3/p4bRunRow.3 \
    47     $(top_builddir)/docs/man/man3/p4bInputScfileRow.3 \
    48     $(top_builddir)/docs/man/man3/p4bDiffScfileRow.3 \
    49     $(top_builddir)/docs/man/man3/p4cRunRow.3 \
    50     $(top_builddir)/docs/man/man3/p4cInputExpRow.3 \
     43    $(top_builddir)/docs/man/man3/p4RunRow.3 \
     44    $(top_builddir)/docs/man/man3/p4InputExpRow.3 \
     45    $(top_builddir)/docs/man/man3/p4ScfileRow.3 \
     46    $(top_builddir)/docs/man/man3/p4InputScfileRow.3 \
     47    $(top_builddir)/docs/man/man3/p4DiffScfileRow.3 \
    5148    $(top_builddir)/docs/man/man3/p4MagicMaskImfileRow.3 \
    5249    $(top_builddir)/docs/man/man3/skyCellRow.3 \
    … …  
    5451
    5552
    56 docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4aRunRow.3 docs/man/man3/p4aInputExpRow.3 docs/man/man3/p4aScfileRow.3 docs/man/man3/p4bRunRow.3 docs/man/man3/p4bInputScfileRow.3 docs/man/man3/p4bDiffScfileRow.3 docs/man/man3/p4cRunRow.3 docs/man/man3/p4cInputExpRow.3 docs/man/man3/p4MagicMaskImfileRow.3 docs/man/man3/skyCellRow.3 docs/man/man3/skyCellMapRow.3:
     53docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4RunRow.3 docs/man/man3/p4InputExpRow.3 docs/man/man3/p4ScfileRow.3 docs/man/man3/p4InputScfileRow.3 docs/man/man3/p4DiffScfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3 docs/man/man3/skyCellRow.3 docs/man/man3/skyCellMapRow.3:
    5754        $(DOXYGEN)
    5855

  • trunk/ippdb/configure.ac

    r11679 r11720  
    11dnl
    2 dnl This file was generated by glueforge 0.36
     2dnl This file was generated by glueforge 1.00
    33dnl
    44dnl Do NOT directly edit this file.
    … …  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [1.1.1], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [1.1.3], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • trunk/ippdb/src/ippdb.c

    r11679 r11720  
    2020/*
    2121 *
    22  * This file was generated by glueforge 0.36
     22 * This file was generated by glueforge 1.00
    2323 *
    2424 * Do NOT directly edit this file.
    … …  
    6262#define DETRESIDEXP_TABLE_NAME "detResidExp"
    6363#define DETRUNSUMMARY_TABLE_NAME "detRunSummary"
    64 #define P4ARUN_TABLE_NAME "p4aRun"
    65 #define P4AINPUTEXP_TABLE_NAME "p4aInputExp"
    66 #define P4ASCFILE_TABLE_NAME "p4aScfile"
    67 #define P4BRUN_TABLE_NAME "p4bRun"
    68 #define P4BINPUTSCFILE_TABLE_NAME "p4bInputScfile"
    69 #define P4BDIFFSCFILE_TABLE_NAME "p4bDiffScfile"
    70 #define P4CRUN_TABLE_NAME "p4cRun"
    71 #define P4CINPUTEXP_TABLE_NAME "p4cInputExp"
     64#define P4RUN_TABLE_NAME "p4Run"
     65#define P4INPUTEXP_TABLE_NAME "p4InputExp"
     66#define P4SCFILE_TABLE_NAME "p4Scfile"
     67#define P4INPUTSCFILE_TABLE_NAME "p4InputScfile"
     68#define P4DIFFSCFILE_TABLE_NAME "p4DiffScfile"
    7269#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
    7370#define SKYCELL_TABLE_NAME "skyCell"
    … …  
    1346313460    return true;
    1346413461}
    13465 static void p4aRunRowFree(p4aRunRow *object);
    13466 
    13467 p4aRunRow *p4aRunRowAlloc(psS32 p4a_id, const char *state, const char *workdir, bool magic)
    13468 {
    13469     p4aRunRow       *_object;
    13470 
    13471     _object = psAlloc(sizeof(p4aRunRow));
    13472     psMemSetDeallocator(_object, (psFreeFunc)p4aRunRowFree);
     13462static void p4RunRowFree(p4RunRow *object);
     13463
     13464p4RunRow *p4RunRowAlloc(psS32 p4a_id, const char *mode, const char *state, const char *workdir, psTime* registered)
     13465{
     13466    p4RunRow        *_object;
     13467
     13468    _object = psAlloc(sizeof(p4RunRow));
     13469    psMemSetDeallocator(_object, (psFreeFunc)p4RunRowFree);
    1347313470
    1347413471    _object->p4a_id = p4a_id;
     13472    _object->mode = psStringCopy(mode);
    1347513473    _object->state = psStringCopy(state);
    1347613474    _object->workdir = psStringCopy(workdir);
    13477     _object->magic = magic;
     13475    _object->registered = psTimeCopy(registered);
    1347813476
    1347913477    return _object;
    1348013478}
    1348113479
    13482 static void p4aRunRowFree(p4aRunRow *object)
    13483 {
     13480static void p4RunRowFree(p4RunRow *object)
     13481{
     13482    psFree(object->mode);
    1348413483    psFree(object->state);
    1348513484    psFree(object->workdir);
    13486 }
    13487 
    13488 bool p4aRunCreateTable(psDB *dbh)
     13485    psFree(object->registered);
     13486}
     13487
     13488bool p4RunCreateTable(psDB *dbh)
    1348913489{
    1349013490    psMetadata *md = psMetadataAlloc();
    … …  
    1349413494        return false;
    1349513495    }
     13496    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, "Key", "64")) {
     13497        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
     13498        psFree(md);
     13499        return false;
     13500    }
    1349613501    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
    1349713502        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    … …  
    1350413509        return false;
    1350513510    }
    13506     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
    13507         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    13508         psFree(md);
    13509         return false;
    13510     }
    13511 
    13512     bool status = psDBCreateTable(dbh, P4ARUN_TABLE_NAME, md);
     13511    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) {
     13512        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
     13513        psFree(md);
     13514        return false;
     13515    }
     13516
     13517    bool status = psDBCreateTable(dbh, P4RUN_TABLE_NAME, md);
    1351313518
    1351413519    psFree(md);
    … …  
    1351713522}
    1351813523
    13519 bool p4aRunDropTable(psDB *dbh)
    13520 {
    13521     return psDBDropTable(dbh, P4ARUN_TABLE_NAME);
    13522 }
    13523 
    13524 bool p4aRunInsert(psDB * dbh, psS32 p4a_id, const char *state, const char *workdir, bool magic)
     13524bool p4RunDropTable(psDB *dbh)
     13525{
     13526    return psDBDropTable(dbh, P4RUN_TABLE_NAME);
     13527}
     13528
     13529bool p4RunInsert(psDB * dbh, psS32 p4a_id, const char *mode, const char *state, const char *workdir, psTime* registered)
    1352513530{
    1352613531    psMetadata *md = psMetadataAlloc();
    … …  
    1353013535        return false;
    1353113536    }
     13537    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, mode)) {
     13538        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
     13539        psFree(md);
     13540        return false;
     13541    }
    1353213542    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
    1353313543        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    … …  
    1354013550        return false;
    1354113551    }
    13542     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
    13543         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    13544         psFree(md);
    13545         return false;
    13546     }
    13547 
    13548     bool status = psDBInsertOneRow(dbh, P4ARUN_TABLE_NAME, md);
     13552    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
     13553        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
     13554        psFree(md);
     13555        return false;
     13556    }
     13557
     13558    bool status = psDBInsertOneRow(dbh, P4RUN_TABLE_NAME, md);
    1354913559    psFree(md);
    1355013560
    … …  
    1355213562}
    1355313563
    13554 long long p4aRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13564long long p4RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1355513565{
    1355613566    long long       deleted = 0;
    1355713567
    13558     long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
     13568    long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
    1355913569    if (count < 0) {
    13560         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
     13570        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
    1356113571        return count;
    1356213572
    … …  
    1356613576    return deleted;
    1356713577}
    13568 bool p4aRunInsertObject(psDB *dbh, p4aRunRow *object)
    13569 {
    13570     return p4aRunInsert(dbh, object->p4a_id, object->state, object->workdir, object->magic);
    13571 }
    13572 
    13573 bool p4aRunInsertObjects(psDB *dbh, psArray *objects)
     13578bool p4RunInsertObject(psDB *dbh, p4RunRow *object)
     13579{
     13580    return p4RunInsert(dbh, object->p4a_id, object->mode, object->state, object->workdir, object->registered);
     13581}
     13582
     13583bool p4RunInsertObjects(psDB *dbh, psArray *objects)
    1357413584{
    1357513585    for (long i = 0; i < psArrayLength(objects); i++) {
    13576         if (!p4aRunInsertObject(dbh, objects->data[i])) {
     13586        if (!p4RunInsertObject(dbh, objects->data[i])) {
    1357713587            return false;
    1357813588        }
    … …  
    1358213592}
    1358313593
    13584 bool p4aRunInsertFits(psDB *dbh, const psFits *fits)
     13594bool p4RunInsertFits(psDB *dbh, const psFits *fits)
    1358513595{
    1358613596    psArray         *rowSet;
    1358713597
    13588     // move to (the first?) extension named  P4ARUN_TABLE_NAME
    13589     if (!psFitsMoveExtName(fits, P4ARUN_TABLE_NAME)) {
    13590         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ARUN_TABLE_NAME);
     13598    // move to (the first?) extension named  P4RUN_TABLE_NAME
     13599    if (!psFitsMoveExtName(fits, P4RUN_TABLE_NAME)) {
     13600        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4RUN_TABLE_NAME);
    1359113601        return false;
    1359213602    }
    … …  
    1360613616    }
    1360713617
    13608     if (!psDBInsertRows(dbh, P4ARUN_TABLE_NAME, rowSet)) {
     13618    if (!psDBInsertRows(dbh, P4RUN_TABLE_NAME, rowSet)) {
    1360913619        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1361013620        psFree(rowSet);
    … …  
    1361713627}
    1361813628
    13619 bool p4aRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13629bool p4RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1362013630{
    1362113631    psArray         *rowSet;
    1362213632
    13623     rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
     13633    rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
    1362413634    if (!rowSet) {
    1362513635        return false;
    … …  
    1362713637
    1362813638    // output to fits
    13629     if (!psFitsWriteTable(fits, NULL, rowSet, P4ARUN_TABLE_NAME)) {
     13639    if (!psFitsWriteTable(fits, NULL, rowSet, P4RUN_TABLE_NAME)) {
    1363013640        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1363113641        psFree(rowSet);
    … …  
    1363813648}
    1363913649
    13640 psMetadata *p4aRunMetadataFromObject(const p4aRunRow *object)
     13650psMetadata *p4RunMetadataFromObject(const p4RunRow *object)
    1364113651{
    1364213652    psMetadata *md = psMetadataAlloc();
    … …  
    1364613656        return false;
    1364713657    }
     13658    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, object->mode)) {
     13659        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
     13660        psFree(md);
     13661        return false;
     13662    }
    1364813663    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
    1364913664        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    … …  
    1365613671        return false;
    1365713672    }
    13658     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
    13659         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     13673    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) {
     13674        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
    1366013675        psFree(md);
    1366113676        return false;
    … …  
    1366613681}
    1366713682
    13668 p4aRunRow *p4aRunObjectFromMetadata(psMetadata *md)
     13683p4RunRow *p4RunObjectFromMetadata(psMetadata *md)
    1366913684{
    1367013685
    … …  
    1367513690        return false;
    1367613691    }
     13692    char* mode = psMetadataLookupPtr(&status, md, "mode");
     13693    if (!status) {
     13694        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item mode");
     13695        return false;
     13696    }
    1367713697    char* state = psMetadataLookupPtr(&status, md, "state");
    1367813698    if (!status) {
    … …  
    1368513705        return false;
    1368613706    }
    13687     bool magic = psMetadataLookupBool(&status, md, "magic");
    13688     if (!status) {
    13689         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
    13690         return false;
    13691     }
    13692 
    13693     return p4aRunRowAlloc(p4a_id, state, workdir, magic);
    13694 }
    13695 psArray *p4aRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13707    psTime* registered = psMetadataLookupPtr(&status, md, "registered");
     13708    if (!status) {
     13709        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered");
     13710        return false;
     13711    }
     13712
     13713    return p4RunRowAlloc(p4a_id, mode, state, workdir, registered);
     13714}
     13715psArray *p4RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1369613716{
    1369713717    psArray         *rowSet;
    … …  
    1369913719    psU64           i;
    1370013720
    13701     rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
     13721    rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
    1370213722    if (!rowSet) {
    1370313723        return NULL;
    … …  
    1370913729
    1371013730    for (i = 0; i < rowSet->n; i++) {
    13711         p4aRunRow *object = p4aRunObjectFromMetadata(rowSet->data[i]);
     13731        p4RunRow *object = p4RunObjectFromMetadata(rowSet->data[i]);
    1371213732        psArrayAdd(returnSet, 0, object);
    1371313733        psFree(object);
    … …  
    1371813738    return returnSet;
    1371913739}
    13720 bool p4aRunDeleteObject(psDB *dbh, const p4aRunRow *object)
    13721 {
    13722     psMetadata *where = p4aRunMetadataFromObject(object);
    13723     long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, 0);
     13740bool p4RunDeleteObject(psDB *dbh, const p4RunRow *object)
     13741{
     13742    psMetadata *where = p4RunMetadataFromObject(object);
     13743    long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, 0);
    1372413744    psFree(where);
    1372513745    if (count < 0) {
    13726         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
     13746        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
    1372713747        return false;
    1372813748    }
    … …  
    1373013750        // XXX should this be a psAbort() instead?  It is possible that
    1373113751        // having an object match multiple rows was by design.
    13732         psError(PS_ERR_UNKNOWN, true, "p4aRunRow object matched more then one row.  Check your database schema");
    13733         return false;
    13734     }
    13735 
    13736     return true;
    13737 }
    13738 long long p4aRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     13752        psError(PS_ERR_UNKNOWN, true, "p4RunRow object matched more then one row.  Check your database schema");
     13753        return false;
     13754    }
     13755
     13756    return true;
     13757}
     13758long long p4RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1373913759{
    1374013760    long long       deleted = 0;
    1374113761
    1374213762    for (long long i = 0; i < objects->n; i++) {
    13743         p4aRunRow *object = objects->data[i];
    13744         psMetadata *where = p4aRunMetadataFromObject(object);
    13745         long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
     13763        p4RunRow *object = objects->data[i];
     13764        psMetadata *where = p4RunMetadataFromObject(object);
     13765        long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
    1374613766        psFree(where);
    1374713767        if (count < 0) {
    13748             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
     13768            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
    1374913769            return count;
    1375013770        }
    … …  
    1375513775    return deleted;
    1375613776}
    13757 bool p4aRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     13777bool p4RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1375813778{
    1375913779    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1376113781    psMetadata *output = psMetadataAlloc();
    1376213782    for (long i = 0; i < psArrayLength(objects); i++) {
    13763         psMetadata *md = p4aRunMetadataFromObject(objects->data[i]);
     13783        psMetadata *md = p4RunMetadataFromObject(objects->data[i]);
    1376413784        if (!psMetadataAddMetadata(
    1376513785            output,
    1376613786            PS_LIST_TAIL,
    13767             P4ARUN_TABLE_NAME,
     13787            P4RUN_TABLE_NAME,
    1376813788            PS_META_DUPLICATE_OK,
    1376913789            NULL,
    … …  
    1378613806    return true;
    1378713807}
    13788 bool p4aRunPrintObject(FILE *stream, p4aRunRow *object, bool mdcf)
     13808bool p4RunPrintObject(FILE *stream, p4RunRow *object, bool mdcf)
    1378913809{
    1379013810    PS_ASSERT_PTR_NON_NULL(object, false);
    1379113811
    13792     psMetadata *md = p4aRunMetadataFromObject(object);
     13812    psMetadata *md = p4RunMetadataFromObject(object);
    1379313813
    1379413814    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1380113821    return true;
    1380213822}
    13803 static void p4aInputExpRowFree(p4aInputExpRow *object);
    13804 
    13805 p4aInputExpRow *p4aInputExpRowAlloc(psS32 p4a_id, const char *exp_tag, psS32 p3_version)
    13806 {
    13807     p4aInputExpRow  *_object;
    13808 
    13809     _object = psAlloc(sizeof(p4aInputExpRow));
    13810     psMemSetDeallocator(_object, (psFreeFunc)p4aInputExpRowFree);
     13823static void p4InputExpRowFree(p4InputExpRow *object);
     13824
     13825p4InputExpRow *p4InputExpRowAlloc(psS32 p4a_id, const char *exp_tag, psS32 p3_version, bool magiced)
     13826{
     13827    p4InputExpRow   *_object;
     13828
     13829    _object = psAlloc(sizeof(p4InputExpRow));
     13830    psMemSetDeallocator(_object, (psFreeFunc)p4InputExpRowFree);
    1381113831
    1381213832    _object->p4a_id = p4a_id;
    1381313833    _object->exp_tag = psStringCopy(exp_tag);
    1381413834    _object->p3_version = p3_version;
     13835    _object->magiced = magiced;
    1381513836
    1381613837    return _object;
    1381713838}
    1381813839
    13819 static void p4aInputExpRowFree(p4aInputExpRow *object)
     13840static void p4InputExpRowFree(p4InputExpRow *object)
    1382013841{
    1382113842    psFree(object->exp_tag);
    1382213843}
    1382313844
    13824 bool p4aInputExpCreateTable(psDB *dbh)
     13845bool p4InputExpCreateTable(psDB *dbh)
    1382513846{
    1382613847    psMetadata *md = psMetadataAlloc();
    … …  
    1384013861        return false;
    1384113862    }
    13842 
    13843     bool status = psDBCreateTable(dbh, P4AINPUTEXP_TABLE_NAME, md);
     13863    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, "Primary Key", 0)) {
     13864        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
     13865        psFree(md);
     13866        return false;
     13867    }
     13868
     13869    bool status = psDBCreateTable(dbh, P4INPUTEXP_TABLE_NAME, md);
    1384413870
    1384513871    psFree(md);
    … …  
    1384813874}
    1384913875
    13850 bool p4aInputExpDropTable(psDB *dbh)
    13851 {
    13852     return psDBDropTable(dbh, P4AINPUTEXP_TABLE_NAME);
    13853 }
    13854 
    13855 bool p4aInputExpInsert(psDB * dbh, psS32 p4a_id, const char *exp_tag, psS32 p3_version)
     13876bool p4InputExpDropTable(psDB *dbh)
     13877{
     13878    return psDBDropTable(dbh, P4INPUTEXP_TABLE_NAME);
     13879}
     13880
     13881bool p4InputExpInsert(psDB * dbh, psS32 p4a_id, const char *exp_tag, psS32 p3_version, bool magiced)
    1385613882{
    1385713883    psMetadata *md = psMetadataAlloc();
    … …  
    1387113897        return false;
    1387213898    }
    13873 
    13874     bool status = psDBInsertOneRow(dbh, P4AINPUTEXP_TABLE_NAME, md);
     13899    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, magiced)) {
     13900        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
     13901        psFree(md);
     13902        return false;
     13903    }
     13904
     13905    bool status = psDBInsertOneRow(dbh, P4INPUTEXP_TABLE_NAME, md);
    1387513906    psFree(md);
    1387613907
    … …  
    1387813909}
    1387913910
    13880 long long p4aInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13911long long p4InputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1388113912{
    1388213913    long long       deleted = 0;
    1388313914
    13884     long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
     13915    long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
    1388513916    if (count < 0) {
    13886         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
     13917        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
    1388713918        return count;
    1388813919
    … …  
    1389213923    return deleted;
    1389313924}
    13894 bool p4aInputExpInsertObject(psDB *dbh, p4aInputExpRow *object)
    13895 {
    13896     return p4aInputExpInsert(dbh, object->p4a_id, object->exp_tag, object->p3_version);
    13897 }
    13898 
    13899 bool p4aInputExpInsertObjects(psDB *dbh, psArray *objects)
     13925bool p4InputExpInsertObject(psDB *dbh, p4InputExpRow *object)
     13926{
     13927    return p4InputExpInsert(dbh, object->p4a_id, object->exp_tag, object->p3_version, object->magiced);
     13928}
     13929
     13930bool p4InputExpInsertObjects(psDB *dbh, psArray *objects)
    1390013931{
    1390113932    for (long i = 0; i < psArrayLength(objects); i++) {
    13902         if (!p4aInputExpInsertObject(dbh, objects->data[i])) {
     13933        if (!p4InputExpInsertObject(dbh, objects->data[i])) {
    1390313934            return false;
    1390413935        }
    … …  
    1390813939}
    1390913940
    13910 bool p4aInputExpInsertFits(psDB *dbh, const psFits *fits)
     13941bool p4InputExpInsertFits(psDB *dbh, const psFits *fits)
    1391113942{
    1391213943    psArray         *rowSet;
    1391313944
    13914     // move to (the first?) extension named  P4AINPUTEXP_TABLE_NAME
    13915     if (!psFitsMoveExtName(fits, P4AINPUTEXP_TABLE_NAME)) {
    13916         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4AINPUTEXP_TABLE_NAME);
     13945    // move to (the first?) extension named  P4INPUTEXP_TABLE_NAME
     13946    if (!psFitsMoveExtName(fits, P4INPUTEXP_TABLE_NAME)) {
     13947        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTEXP_TABLE_NAME);
    1391713948        return false;
    1391813949    }
    … …  
    1393213963    }
    1393313964
    13934     if (!psDBInsertRows(dbh, P4AINPUTEXP_TABLE_NAME, rowSet)) {
     13965    if (!psDBInsertRows(dbh, P4INPUTEXP_TABLE_NAME, rowSet)) {
    1393513966        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1393613967        psFree(rowSet);
    … …  
    1394313974}
    1394413975
    13945 bool p4aInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13976bool p4InputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1394613977{
    1394713978    psArray         *rowSet;
    1394813979
    13949     rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
     13980    rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
    1395013981    if (!rowSet) {
    1395113982        return false;
    … …  
    1395313984
    1395413985    // output to fits
    13955     if (!psFitsWriteTable(fits, NULL, rowSet, P4AINPUTEXP_TABLE_NAME)) {
     13986    if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTEXP_TABLE_NAME)) {
    1395613987        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1395713988        psFree(rowSet);
    … …  
    1396413995}
    1396513996
    13966 psMetadata *p4aInputExpMetadataFromObject(const p4aInputExpRow *object)
     13997psMetadata *p4InputExpMetadataFromObject(const p4InputExpRow *object)
    1396713998{
    1396813999    psMetadata *md = psMetadataAlloc();
    … …  
    1398214013        return false;
    1398314014    }
     14015    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, object->magiced)) {
     14016        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
     14017        psFree(md);
     14018        return false;
     14019    }
    1398414020
    1398514021
    … …  
    1398714023}
    1398814024
    13989 p4aInputExpRow *p4aInputExpObjectFromMetadata(psMetadata *md)
     14025p4InputExpRow *p4InputExpObjectFromMetadata(psMetadata *md)
    1399014026{
    1399114027
    … …  
    1400614042        return false;
    1400714043    }
    14008 
    14009     return p4aInputExpRowAlloc(p4a_id, exp_tag, p3_version);
    14010 }
    14011 psArray *p4aInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14044    bool magiced = psMetadataLookupBool(&status, md, "magiced");
     14045    if (!status) {
     14046        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magiced");
     14047        return false;
     14048    }
     14049
     14050    return p4InputExpRowAlloc(p4a_id, exp_tag, p3_version, magiced);
     14051}
     14052psArray *p4InputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1401214053{
    1401314054    psArray         *rowSet;
    … …  
    1401514056    psU64           i;
    1401614057
    14017     rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
     14058    rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
    1401814059    if (!rowSet) {
    1401914060        return NULL;
    … …  
    1402514066
    1402614067    for (i = 0; i < rowSet->n; i++) {
    14027         p4aInputExpRow *object = p4aInputExpObjectFromMetadata(rowSet->data[i]);
     14068        p4InputExpRow *object = p4InputExpObjectFromMetadata(rowSet->data[i]);
    1402814069        psArrayAdd(returnSet, 0, object);
    1402914070        psFree(object);
    … …  
    1403414075    return returnSet;
    1403514076}
    14036 bool p4aInputExpDeleteObject(psDB *dbh, const p4aInputExpRow *object)
    14037 {
    14038     psMetadata *where = p4aInputExpMetadataFromObject(object);
    14039     long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, 0);
     14077bool p4InputExpDeleteObject(psDB *dbh, const p4InputExpRow *object)
     14078{
     14079    psMetadata *where = p4InputExpMetadataFromObject(object);
     14080    long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, 0);
    1404014081    psFree(where);
    1404114082    if (count < 0) {
    14042         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
     14083        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
    1404314084        return false;
    1404414085    }
    … …  
    1404614087        // XXX should this be a psAbort() instead?  It is possible that
    1404714088        // having an object match multiple rows was by design.
    14048         psError(PS_ERR_UNKNOWN, true, "p4aInputExpRow object matched more then one row.  Check your database schema");
    14049         return false;
    14050     }
    14051 
    14052     return true;
    14053 }
    14054 long long p4aInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14089        psError(PS_ERR_UNKNOWN, true, "p4InputExpRow object matched more then one row.  Check your database schema");
     14090        return false;
     14091    }
     14092
     14093    return true;
     14094}
     14095long long p4InputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1405514096{
    1405614097    long long       deleted = 0;
    1405714098
    1405814099    for (long long i = 0; i < objects->n; i++) {
    14059         p4aInputExpRow *object = objects->data[i];
    14060         psMetadata *where = p4aInputExpMetadataFromObject(object);
    14061         long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
     14100        p4InputExpRow *object = objects->data[i];
     14101        psMetadata *where = p4InputExpMetadataFromObject(object);
     14102        long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
    1406214103        psFree(where);
    1406314104        if (count < 0) {
    14064             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
     14105            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
    1406514106            return count;
    1406614107        }
    … …  
    1407114112    return deleted;
    1407214113}
    14073 bool p4aInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14114bool p4InputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1407414115{
    1407514116    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1407714118    psMetadata *output = psMetadataAlloc();
    1407814119    for (long i = 0; i < psArrayLength(objects); i++) {
    14079         psMetadata *md = p4aInputExpMetadataFromObject(objects->data[i]);
     14120        psMetadata *md = p4InputExpMetadataFromObject(objects->data[i]);
    1408014121        if (!psMetadataAddMetadata(
    1408114122            output,
    1408214123            PS_LIST_TAIL,
    14083             P4AINPUTEXP_TABLE_NAME,
     14124            P4INPUTEXP_TABLE_NAME,
    1408414125            PS_META_DUPLICATE_OK,
    1408514126            NULL,
    … …  
    1410214143    return true;
    1410314144}
    14104 bool p4aInputExpPrintObject(FILE *stream, p4aInputExpRow *object, bool mdcf)
     14145bool p4InputExpPrintObject(FILE *stream, p4InputExpRow *object, bool mdcf)
    1410514146{
    1410614147    PS_ASSERT_PTR_NON_NULL(object, false);
    1410714148
    14108     psMetadata *md = p4aInputExpMetadataFromObject(object);
     14149    psMetadata *md = p4InputExpMetadataFromObject(object);
    1410914150
    1411014151    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1411714158    return true;
    1411814159}
    14119 static void p4aScfileRowFree(p4aScfileRow *object);
    14120 
    14121 p4aScfileRow *p4aScfileRowAlloc(psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    14122 {
    14123     p4aScfileRow    *_object;
    14124 
    14125     _object = psAlloc(sizeof(p4aScfileRow));
    14126     psMemSetDeallocator(_object, (psFreeFunc)p4aScfileRowFree);
     14160static void p4ScfileRowFree(p4ScfileRow *object);
     14161
     14162p4ScfileRow *p4ScfileRowAlloc(psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14163{
     14164    p4ScfileRow     *_object;
     14165
     14166    _object = psAlloc(sizeof(p4ScfileRow));
     14167    psMemSetDeallocator(_object, (psFreeFunc)p4ScfileRowFree);
    1412714168
    1412814169    _object->p4a_id = p4a_id;
    … …  
    1413814179}
    1413914180
    14140 static void p4aScfileRowFree(p4aScfileRow *object)
     14181static void p4ScfileRowFree(p4ScfileRow *object)
    1414114182{
    1414214183    psFree(object->skycell_id);
    … …  
    1414614187}
    1414714188
    14148 bool p4aScfileCreateTable(psDB *dbh)
     14189bool p4ScfileCreateTable(psDB *dbh)
    1414914190{
    1415014191    psMetadata *md = psMetadataAlloc();
    … …  
    1419014231    }
    1419114232
    14192     bool status = psDBCreateTable(dbh, P4ASCFILE_TABLE_NAME, md);
     14233    bool status = psDBCreateTable(dbh, P4SCFILE_TABLE_NAME, md);
    1419314234
    1419414235    psFree(md);
    … …  
    1419714238}
    1419814239
    14199 bool p4aScfileDropTable(psDB *dbh)
    14200 {
    14201     return psDBDropTable(dbh, P4ASCFILE_TABLE_NAME);
    14202 }
    14203 
    14204 bool p4aScfileInsert(psDB * dbh, psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14240bool p4ScfileDropTable(psDB *dbh)
     14241{
     14242    return psDBDropTable(dbh, P4SCFILE_TABLE_NAME);
     14243}
     14244
     14245bool p4ScfileInsert(psDB * dbh, psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1420514246{
    1420614247    psMetadata *md = psMetadataAlloc();
    … …  
    1424614287    }
    1424714288
    14248     bool status = psDBInsertOneRow(dbh, P4ASCFILE_TABLE_NAME, md);
     14289    bool status = psDBInsertOneRow(dbh, P4SCFILE_TABLE_NAME, md);
    1424914290    psFree(md);
    1425014291
    … …  
    1425214293}
    1425314294
    14254 long long p4aScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14295long long p4ScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1425514296{
    1425614297    long long       deleted = 0;
    1425714298
    14258     long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
     14299    long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
    1425914300    if (count < 0) {
    14260         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
     14301        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
    1426114302        return count;
    1426214303
    … …  
    1426614307    return deleted;
    1426714308}
    14268 bool p4aScfileInsertObject(psDB *dbh, p4aScfileRow *object)
    14269 {
    14270     return p4aScfileInsert(dbh, object->p4a_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
    14271 }
    14272 
    14273 bool p4aScfileInsertObjects(psDB *dbh, psArray *objects)
     14309bool p4ScfileInsertObject(psDB *dbh, p4ScfileRow *object)
     14310{
     14311    return p4ScfileInsert(dbh, object->p4a_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
     14312}
     14313
     14314bool p4ScfileInsertObjects(psDB *dbh, psArray *objects)
    1427414315{
    1427514316    for (long i = 0; i < psArrayLength(objects); i++) {
    14276         if (!p4aScfileInsertObject(dbh, objects->data[i])) {
     14317        if (!p4ScfileInsertObject(dbh, objects->data[i])) {
    1427714318            return false;
    1427814319        }
    … …  
    1428214323}
    1428314324
    14284 bool p4aScfileInsertFits(psDB *dbh, const psFits *fits)
     14325bool p4ScfileInsertFits(psDB *dbh, const psFits *fits)
    1428514326{
    1428614327    psArray         *rowSet;
    1428714328
    14288     // move to (the first?) extension named  P4ASCFILE_TABLE_NAME
    14289     if (!psFitsMoveExtName(fits, P4ASCFILE_TABLE_NAME)) {
    14290         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ASCFILE_TABLE_NAME);
     14329    // move to (the first?) extension named  P4SCFILE_TABLE_NAME
     14330    if (!psFitsMoveExtName(fits, P4SCFILE_TABLE_NAME)) {
     14331        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4SCFILE_TABLE_NAME);
    1429114332        return false;
    1429214333    }
    … …  
    1430614347    }
    1430714348
    14308     if (!psDBInsertRows(dbh, P4ASCFILE_TABLE_NAME, rowSet)) {
     14349    if (!psDBInsertRows(dbh, P4SCFILE_TABLE_NAME, rowSet)) {
    1430914350        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1431014351        psFree(rowSet);
    … …  
    1431714358}
    1431814359
    14319 bool p4aScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14360bool p4ScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1432014361{
    1432114362    psArray         *rowSet;
    1432214363
    14323     rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
     14364    rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
    1432414365    if (!rowSet) {
    1432514366        return false;
    … …  
    1432714368
    1432814369    // output to fits
    14329     if (!psFitsWriteTable(fits, NULL, rowSet, P4ASCFILE_TABLE_NAME)) {
     14370    if (!psFitsWriteTable(fits, NULL, rowSet, P4SCFILE_TABLE_NAME)) {
    1433014371        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1433114372        psFree(rowSet);
    … …  
    1433814379}
    1433914380
    14340 psMetadata *p4aScfileMetadataFromObject(const p4aScfileRow *object)
     14381psMetadata *p4ScfileMetadataFromObject(const p4ScfileRow *object)
    1434114382{
    1434214383    psMetadata *md = psMetadataAlloc();
    … …  
    1438614427}
    1438714428
    14388 p4aScfileRow *p4aScfileObjectFromMetadata(psMetadata *md)
     14429p4ScfileRow *p4ScfileObjectFromMetadata(psMetadata *md)
    1438914430{
    1439014431
    … …  
    1443114472    }
    1443214473
    14433     return p4aScfileRowAlloc(p4a_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
    14434 }
    14435 psArray *p4aScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14474    return p4ScfileRowAlloc(p4a_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
     14475}
     14476psArray *p4ScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1443614477{
    1443714478    psArray         *rowSet;
    … …  
    1443914480    psU64           i;
    1444014481
    14441     rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
     14482    rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
    1444214483    if (!rowSet) {
    1444314484        return NULL;
    … …  
    1444914490
    1445014491    for (i = 0; i < rowSet->n; i++) {
    14451         p4aScfileRow *object = p4aScfileObjectFromMetadata(rowSet->data[i]);
     14492        p4ScfileRow *object = p4ScfileObjectFromMetadata(rowSet->data[i]);
    1445214493        psArrayAdd(returnSet, 0, object);
    1445314494        psFree(object);
    … …  
    1445814499    return returnSet;
    1445914500}
    14460 bool p4aScfileDeleteObject(psDB *dbh, const p4aScfileRow *object)
    14461 {
    14462     psMetadata *where = p4aScfileMetadataFromObject(object);
    14463     long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, 0);
     14501bool p4ScfileDeleteObject(psDB *dbh, const p4ScfileRow *object)
     14502{
     14503    psMetadata *where = p4ScfileMetadataFromObject(object);
     14504    long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, 0);
    1446414505    psFree(where);
    1446514506    if (count < 0) {
    14466         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
     14507        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
    1446714508        return false;
    1446814509    }
    … …  
    1447014511        // XXX should this be a psAbort() instead?  It is possible that
    1447114512        // having an object match multiple rows was by design.
    14472         psError(PS_ERR_UNKNOWN, true, "p4aScfileRow object matched more then one row.  Check your database schema");
    14473         return false;
    14474     }
    14475 
    14476     return true;
    14477 }
    14478 long long p4aScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14513        psError(PS_ERR_UNKNOWN, true, "p4ScfileRow object matched more then one row.  Check your database schema");
     14514        return false;
     14515    }
     14516
     14517    return true;
     14518}
     14519long long p4ScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1447914520{
    1448014521    long long       deleted = 0;
    1448114522
    1448214523    for (long long i = 0; i < objects->n; i++) {
    14483         p4aScfileRow *object = objects->data[i];
    14484         psMetadata *where = p4aScfileMetadataFromObject(object);
    14485         long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
     14524        p4ScfileRow *object = objects->data[i];
     14525        psMetadata *where = p4ScfileMetadataFromObject(object);
     14526        long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
    1448614527        psFree(where);
    1448714528        if (count < 0) {
    14488             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
     14529            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
    1448914530            return count;
    1449014531        }
    … …  
    1449514536    return deleted;
    1449614537}
    14497 bool p4aScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14538bool p4ScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1449814539{
    1449914540    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1450114542    psMetadata *output = psMetadataAlloc();
    1450214543    for (long i = 0; i < psArrayLength(objects); i++) {
    14503         psMetadata *md = p4aScfileMetadataFromObject(objects->data[i]);
     14544        psMetadata *md = p4ScfileMetadataFromObject(objects->data[i]);
    1450414545        if (!psMetadataAddMetadata(
    1450514546            output,
    1450614547            PS_LIST_TAIL,
    14507             P4ASCFILE_TABLE_NAME,
     14548            P4SCFILE_TABLE_NAME,
    1450814549            PS_META_DUPLICATE_OK,
    1450914550            NULL,
    … …  
    1452614567    return true;
    1452714568}
    14528 bool p4aScfilePrintObject(FILE *stream, p4aScfileRow *object, bool mdcf)
     14569bool p4ScfilePrintObject(FILE *stream, p4ScfileRow *object, bool mdcf)
    1452914570{
    1453014571    PS_ASSERT_PTR_NON_NULL(object, false);
    1453114572
    14532     psMetadata *md = p4aScfileMetadataFromObject(object);
     14573    psMetadata *md = p4ScfileMetadataFromObject(object);
    1453314574
    1453414575    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1454114582    return true;
    1454214583}
    14543 static void p4bRunRowFree(p4bRunRow *object);
    14544 
    14545 p4bRunRow *p4bRunRowAlloc(psS32 p4b_id, const char *state, const char *workdir, bool magic)
    14546 {
    14547     p4bRunRow      *_object;
    14548 
    14549     _object = psAlloc(sizeof(p4bRunRow));
    14550     psMemSetDeallocator(_object, (psFreeFunc)p4bRunRowFree);
     14584static void p4InputScfileRowFree(p4InputScfileRow *object);
     14585
     14586p4InputScfileRow *p4InputScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
     14587{
     14588    p4InputScfileRow *_object;
     14589
     14590    _object = psAlloc(sizeof(p4InputScfileRow));
     14591    psMemSetDeallocator(_object, (psFreeFunc)p4InputScfileRowFree);
    1455114592
    1455214593    _object->p4b_id = p4b_id;
    14553     _object->state = psStringCopy(state);
    14554     _object->workdir = psStringCopy(workdir);
    14555     _object->magic = magic;
     14594    _object->skycell_id = psStringCopy(skycell_id);
     14595    _object->tess_id = psStringCopy(tess_id);
     14596    _object->exp_tag = psStringCopy(exp_tag);
     14597    _object->p3_version = p3_version;
     14598    _object->kind = psStringCopy(kind);
    1455614599
    1455714600    return _object;
    1455814601}
    1455914602
    14560 static void p4bRunRowFree(p4bRunRow *object)
    14561 {
    14562     psFree(object->state);
    14563     psFree(object->workdir);
    14564 }
    14565 
    14566 bool p4bRunCreateTable(psDB *dbh)
     14603static void p4InputScfileRowFree(p4InputScfileRow *object)
     14604{
     14605    psFree(object->skycell_id);
     14606    psFree(object->tess_id);
     14607    psFree(object->exp_tag);
     14608    psFree(object->kind);
     14609}
     14610
     14611bool p4InputScfileCreateTable(psDB *dbh)
    1456714612{
    1456814613    psMetadata *md = psMetadataAlloc();
    14569     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     14614    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
    1457014615        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
    1457114616        psFree(md);
    1457214617        return false;
    1457314618    }
    14574     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
    14575         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    14576         psFree(md);
    14577         return false;
    14578     }
    14579     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
    14580         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    14581         psFree(md);
    14582         return false;
    14583     }
    14584     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
    14585         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    14586         psFree(md);
    14587         return false;
    14588     }
    14589 
    14590     bool status = psDBCreateTable(dbh, P4BRUN_TABLE_NAME, md);
     14619    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     14620        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14621        psFree(md);
     14622        return false;
     14623    }
     14624    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     14625        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     14626        psFree(md);
     14627        return false;
     14628    }
     14629    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
     14630        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     14631        psFree(md);
     14632        return false;
     14633    }
     14634    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
     14635        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14636        psFree(md);
     14637        return false;
     14638    }
     14639    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) {
     14640        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
     14641        psFree(md);
     14642        return false;
     14643    }
     14644
     14645    bool status = psDBCreateTable(dbh, P4INPUTSCFILE_TABLE_NAME, md);
    1459114646
    1459214647    psFree(md);
    … …  
    1459514650}
    1459614651
    14597 bool p4bRunDropTable(psDB *dbh)
    14598 {
    14599     return psDBDropTable(dbh, P4BRUN_TABLE_NAME);
    14600 }
    14601 
    14602 bool p4bRunInsert(psDB * dbh, psS32 p4b_id, const char *state, const char *workdir, bool magic)
     14652bool p4InputScfileDropTable(psDB *dbh)
     14653{
     14654    return psDBDropTable(dbh, P4INPUTSCFILE_TABLE_NAME);
     14655}
     14656
     14657bool p4InputScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
    1460314658{
    1460414659    psMetadata *md = psMetadataAlloc();
    … …  
    1460814663        return false;
    1460914664    }
    14610     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
    14611         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    14612         psFree(md);
    14613         return false;
    14614     }
    14615     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
    14616         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    14617         psFree(md);
    14618         return false;
    14619     }
    14620     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
    14621         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    14622         psFree(md);
    14623         return false;
    14624     }
    14625 
    14626     bool status = psDBInsertOneRow(dbh, P4BRUN_TABLE_NAME, md);
     14665    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     14666        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14667        psFree(md);
     14668        return false;
     14669    }
     14670    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     14671        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     14672        psFree(md);
     14673        return false;
     14674    }
     14675    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     14676        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     14677        psFree(md);
     14678        return false;
     14679    }
     14680    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
     14681        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14682        psFree(md);
     14683        return false;
     14684    }
     14685    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) {
     14686        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
     14687        psFree(md);
     14688        return false;
     14689    }
     14690
     14691    bool status = psDBInsertOneRow(dbh, P4INPUTSCFILE_TABLE_NAME, md);
    1462714692    psFree(md);
    1462814693
    … …  
    1463014695}
    1463114696
    14632 long long p4bRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14697long long p4InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1463314698{
    1463414699    long long       deleted = 0;
    1463514700
    14636     long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
     14701    long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
    1463714702    if (count < 0) {
    14638         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
     14703        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
    1463914704        return count;
    1464014705
    … …  
    1464414709    return deleted;
    1464514710}
    14646 bool p4bRunInsertObject(psDB *dbh, p4bRunRow *object)
    14647 {
    14648     return p4bRunInsert(dbh, object->p4b_id, object->state, object->workdir, object->magic);
    14649 }
    14650 
    14651 bool p4bRunInsertObjects(psDB *dbh, psArray *objects)
     14711bool p4InputScfileInsertObject(psDB *dbh, p4InputScfileRow *object)
     14712{
     14713    return p4InputScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind);
     14714}
     14715
     14716bool p4InputScfileInsertObjects(psDB *dbh, psArray *objects)
    1465214717{
    1465314718    for (long i = 0; i < psArrayLength(objects); i++) {
    14654         if (!p4bRunInsertObject(dbh, objects->data[i])) {
     14719        if (!p4InputScfileInsertObject(dbh, objects->data[i])) {
    1465514720            return false;
    1465614721        }
    … …  
    1466014725}
    1466114726
    14662 bool p4bRunInsertFits(psDB *dbh, const psFits *fits)
     14727bool p4InputScfileInsertFits(psDB *dbh, const psFits *fits)
    1466314728{
    1466414729    psArray         *rowSet;
    1466514730
    14666     // move to (the first?) extension named  P4BRUN_TABLE_NAME
    14667     if (!psFitsMoveExtName(fits, P4BRUN_TABLE_NAME)) {
    14668         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BRUN_TABLE_NAME);
     14731    // move to (the first?) extension named  P4INPUTSCFILE_TABLE_NAME
     14732    if (!psFitsMoveExtName(fits, P4INPUTSCFILE_TABLE_NAME)) {
     14733        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTSCFILE_TABLE_NAME);
    1466914734        return false;
    1467014735    }
    … …  
    1468414749    }
    1468514750
    14686     if (!psDBInsertRows(dbh, P4BRUN_TABLE_NAME, rowSet)) {
     14751    if (!psDBInsertRows(dbh, P4INPUTSCFILE_TABLE_NAME, rowSet)) {
    1468714752        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1468814753        psFree(rowSet);
    … …  
    1469514760}
    1469614761
    14697 bool p4bRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14762bool p4InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1469814763{
    1469914764    psArray         *rowSet;
    1470014765
    14701     rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
     14766    rowSet = psDBSelectRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
    1470214767    if (!rowSet) {
    1470314768        return false;
    … …  
    1470514770
    1470614771    // output to fits
    14707     if (!psFitsWriteTable(fits, NULL, rowSet, P4BRUN_TABLE_NAME)) {
     14772    if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTSCFILE_TABLE_NAME)) {
    1470814773        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1470914774        psFree(rowSet);
    … …  
    1471614781}
    1471714782
    14718 psMetadata *p4bRunMetadataFromObject(const p4bRunRow *object)
     14783psMetadata *p4InputScfileMetadataFromObject(const p4InputScfileRow *object)
    1471914784{
    1472014785    psMetadata *md = psMetadataAlloc();
    … …  
    1472414789        return false;
    1472514790    }
    14726     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
    14727         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    14728         psFree(md);
    14729         return false;
    14730     }
    14731     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
    14732         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    14733         psFree(md);
    14734         return false;
    14735     }
    14736     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
    14737         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     14791    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     14792        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14793        psFree(md);
     14794        return false;
     14795    }
     14796    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     14797        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     14798        psFree(md);
     14799        return false;
     14800    }
     14801    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     14802        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     14803        psFree(md);
     14804        return false;
     14805    }
     14806    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
     14807        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14808        psFree(md);
     14809        return false;
     14810    }
     14811    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) {
     14812        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
    1473814813        psFree(md);
    1473914814        return false;
    … …  
    1474414819}
    1474514820
    14746 p4bRunRow *p4bRunObjectFromMetadata(psMetadata *md)
     14821p4InputScfileRow *p4InputScfileObjectFromMetadata(psMetadata *md)
    1474714822{
    1474814823
    … …  
    1475314828        return false;
    1475414829    }
    14755     char* state = psMetadataLookupPtr(&status, md, "state");
    14756     if (!status) {
    14757         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
    14758         return false;
    14759     }
    14760     char* workdir = psMetadataLookupPtr(&status, md, "workdir");
    14761     if (!status) {
    14762         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
    14763         return false;
    14764     }
    14765     bool magic = psMetadataLookupBool(&status, md, "magic");
    14766     if (!status) {
    14767         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
    14768         return false;
    14769     }
    14770 
    14771     return p4bRunRowAlloc(p4b_id, state, workdir, magic);
    14772 }
    14773 psArray *p4bRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14830    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     14831    if (!status) {
     14832        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     14833        return false;
     14834    }
     14835    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     14836    if (!status) {
     14837        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     14838        return false;
     14839    }
     14840    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     14841    if (!status) {
     14842        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     14843        return false;
     14844    }
     14845    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
     14846    if (!status) {
     14847        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     14848        return false;
     14849    }
     14850    char* kind = psMetadataLookupPtr(&status, md, "kind");
     14851    if (!status) {
     14852        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind");
     14853        return false;
     14854    }
     14855
     14856    return p4InputScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, kind);
     14857}
     14858psArray *p4InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1477414859{
    1477514860    psArray         *rowSet;
    … …  
    1477714862    psU64           i;
    1477814863
    14779     rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
     14864    rowSet = psDBSelectRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
    1478014865    if (!rowSet) {
    1478114866        return NULL;
    … …  
    1478714872
    1478814873    for (i = 0; i < rowSet->n; i++) {
    14789         p4bRunRow *object = p4bRunObjectFromMetadata(rowSet->data[i]);
     14874        p4InputScfileRow *object = p4InputScfileObjectFromMetadata(rowSet->data[i]);
    1479014875        psArrayAdd(returnSet, 0, object);
    1479114876        psFree(object);
    … …  
    1479614881    return returnSet;
    1479714882}
    14798 bool p4bRunDeleteObject(psDB *dbh, const p4bRunRow *object)
    14799 {
    14800     psMetadata *where = p4bRunMetadataFromObject(object);
    14801     long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, 0);
     14883bool p4InputScfileDeleteObject(psDB *dbh, const p4InputScfileRow *object)
     14884{
     14885    psMetadata *where = p4InputScfileMetadataFromObject(object);
     14886    long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, 0);
    1480214887    psFree(where);
    1480314888    if (count < 0) {
    14804         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
     14889        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
    1480514890        return false;
    1480614891    }
    … …  
    1480814893        // XXX should this be a psAbort() instead?  It is possible that
    1480914894        // having an object match multiple rows was by design.
    14810         psError(PS_ERR_UNKNOWN, true, "p4bRunRow object matched more then one row.  Check your database schema");
    14811         return false;
    14812     }
    14813 
    14814     return true;
    14815 }
    14816 long long p4bRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14895        psError(PS_ERR_UNKNOWN, true, "p4InputScfileRow object matched more then one row.  Check your database schema");
     14896        return false;
     14897    }
     14898
     14899    return true;
     14900}
     14901long long p4InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1481714902{
    1481814903    long long       deleted = 0;
    1481914904
    1482014905    for (long long i = 0; i < objects->n; i++) {
    14821         p4bRunRow *object = objects->data[i];
    14822         psMetadata *where = p4bRunMetadataFromObject(object);
    14823         long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
     14906        p4InputScfileRow *object = objects->data[i];
     14907        psMetadata *where = p4InputScfileMetadataFromObject(object);
     14908        long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
    1482414909        psFree(where);
    1482514910        if (count < 0) {
    14826             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
     14911            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
    1482714912            return count;
    1482814913        }
    … …  
    1483314918    return deleted;
    1483414919}
    14835 bool p4bRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14920bool p4InputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1483614921{
    1483714922    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1483914924    psMetadata *output = psMetadataAlloc();
    1484014925    for (long i = 0; i < psArrayLength(objects); i++) {
    14841         psMetadata *md = p4bRunMetadataFromObject(objects->data[i]);
     14926        psMetadata *md = p4InputScfileMetadataFromObject(objects->data[i]);
    1484214927        if (!psMetadataAddMetadata(
    1484314928            output,
    1484414929            PS_LIST_TAIL,
    14845             P4BRUN_TABLE_NAME,
     14930            P4INPUTSCFILE_TABLE_NAME,
    1484614931            PS_META_DUPLICATE_OK,
    1484714932            NULL,
    … …  
    1486414949    return true;
    1486514950}
    14866 bool p4bRunPrintObject(FILE *stream, p4bRunRow *object, bool mdcf)
     14951bool p4InputScfilePrintObject(FILE *stream, p4InputScfileRow *object, bool mdcf)
    1486714952{
    1486814953    PS_ASSERT_PTR_NON_NULL(object, false);
    1486914954
    14870     psMetadata *md = p4bRunMetadataFromObject(object);
     14955    psMetadata *md = p4InputScfileMetadataFromObject(object);
    1487114956
    1487214957    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1487914964    return true;
    1488014965}
    14881 static void p4bInputScfileRowFree(p4bInputScfileRow *object);
    14882 
    14883 p4bInputScfileRow *p4bInputScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
    14884 {
    14885     p4bInputScfileRow *_object;
    14886 
    14887     _object = psAlloc(sizeof(p4bInputScfileRow));
    14888     psMemSetDeallocator(_object, (psFreeFunc)p4bInputScfileRowFree);
     14966static void p4DiffScfileRowFree(p4DiffScfileRow *object);
     14967
     14968p4DiffScfileRow *p4DiffScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14969{
     14970    p4DiffScfileRow *_object;
     14971
     14972    _object = psAlloc(sizeof(p4DiffScfileRow));
     14973    psMemSetDeallocator(_object, (psFreeFunc)p4DiffScfileRowFree);
    1488914974
    1489014975    _object->p4b_id = p4b_id;
    … …  
    1489314978    _object->exp_tag = psStringCopy(exp_tag);
    1489414979    _object->p3_version = p3_version;
    14895     _object->kind = psStringCopy(kind);
     14980    _object->uri = psStringCopy(uri);
     14981    _object->bg = bg;
     14982    _object->bg_mean_stdev = bg_mean_stdev;
    1489614983
    1489714984    return _object;
    1489814985}
    1489914986
    14900 static void p4bInputScfileRowFree(p4bInputScfileRow *object)
     14987static void p4DiffScfileRowFree(p4DiffScfileRow *object)
    1490114988{
    1490214989    psFree(object->skycell_id);
    1490314990    psFree(object->tess_id);
    1490414991    psFree(object->exp_tag);
    14905     psFree(object->kind);
    14906 }
    14907 
    14908 bool p4bInputScfileCreateTable(psDB *dbh)
     14992    psFree(object->uri);
     14993}
     14994
     14995bool p4DiffScfileCreateTable(psDB *dbh)
    1490914996{
    1491014997    psMetadata *md = psMetadataAlloc();
    … …  
    1493415021        return false;
    1493515022    }
    14936     if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) {
    14937         psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
    14938         psFree(md);
    14939         return false;
    14940     }
    14941 
    14942     bool status = psDBCreateTable(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
     15023    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     15024        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     15025        psFree(md);
     15026        return false;
     15027    }
     15028    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
     15029        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15030        psFree(md);
     15031        return false;
     15032    }
     15033    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
     15034        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     15035        psFree(md);
     15036        return false;
     15037    }
     15038
     15039    bool status = psDBCreateTable(dbh, P4DIFFSCFILE_TABLE_NAME, md);
    1494315040
    1494415041    psFree(md);
    … …  
    1494715044}
    1494815045
    14949 bool p4bInputScfileDropTable(psDB *dbh)
    14950 {
    14951     return psDBDropTable(dbh, P4BINPUTSCFILE_TABLE_NAME);
    14952 }
    14953 
    14954 bool p4bInputScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
     15046bool p4DiffScfileDropTable(psDB *dbh)
     15047{
     15048    return psDBDropTable(dbh, P4DIFFSCFILE_TABLE_NAME);
     15049}
     15050
     15051bool p4DiffScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1495515052{
    1495615053    psMetadata *md = psMetadataAlloc();
    … …  
    1498015077        return false;
    1498115078    }
    14982     if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) {
    14983         psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
    14984         psFree(md);
    14985         return false;
    14986     }
    14987 
    14988     bool status = psDBInsertOneRow(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
     15079    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
     15080        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     15081        psFree(md);
     15082        return false;
     15083    }
     15084    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
     15085        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15086        psFree(md);
     15087        return false;
     15088    }
     15089    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
     15090        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     15091        psFree(md);
     15092        return false;
     15093    }
     15094
     15095    bool status = psDBInsertOneRow(dbh, P4DIFFSCFILE_TABLE_NAME, md);
    1498915096    psFree(md);
    1499015097
    … …  
    1499215099}
    1499315100
    14994 long long p4bInputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15101long long p4DiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1499515102{
    1499615103    long long       deleted = 0;
    1499715104
    14998     long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
     15105    long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
    1499915106    if (count < 0) {
    15000         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
     15107        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
    1500115108        return count;
    1500215109
    … …  
    1500615113    return deleted;
    1500715114}
    15008 bool p4bInputScfileInsertObject(psDB *dbh, p4bInputScfileRow *object)
    15009 {
    15010     return p4bInputScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind);
    15011 }
    15012 
    15013 bool p4bInputScfileInsertObjects(psDB *dbh, psArray *objects)
     15115bool p4DiffScfileInsertObject(psDB *dbh, p4DiffScfileRow *object)
     15116{
     15117    return p4DiffScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
     15118}
     15119
     15120bool p4DiffScfileInsertObjects(psDB *dbh, psArray *objects)
    1501415121{
    1501515122    for (long i = 0; i < psArrayLength(objects); i++) {
    15016         if (!p4bInputScfileInsertObject(dbh, objects->data[i])) {
     15123        if (!p4DiffScfileInsertObject(dbh, objects->data[i])) {
    1501715124            return false;
    1501815125        }
    … …  
    1502215129}
    1502315130
    15024 bool p4bInputScfileInsertFits(psDB *dbh, const psFits *fits)
     15131bool p4DiffScfileInsertFits(psDB *dbh, const psFits *fits)
    1502515132{
    1502615133    psArray         *rowSet;
    1502715134
    15028     // move to (the first?) extension named  P4BINPUTSCFILE_TABLE_NAME
    15029     if (!psFitsMoveExtName(fits, P4BINPUTSCFILE_TABLE_NAME)) {
    15030         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BINPUTSCFILE_TABLE_NAME);
     15135    // move to (the first?) extension named  P4DIFFSCFILE_TABLE_NAME
     15136    if (!psFitsMoveExtName(fits, P4DIFFSCFILE_TABLE_NAME)) {
     15137        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFSCFILE_TABLE_NAME);
    1503115138        return false;
    1503215139    }
    … …  
    1504615153    }
    1504715154
    15048     if (!psDBInsertRows(dbh, P4BINPUTSCFILE_TABLE_NAME, rowSet)) {
     15155    if (!psDBInsertRows(dbh, P4DIFFSCFILE_TABLE_NAME, rowSet)) {
    1504915156        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1505015157        psFree(rowSet);
    … …  
    1505715164}
    1505815165
    15059 bool p4bInputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15166bool p4DiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1506015167{
    1506115168    psArray         *rowSet;
    1506215169
    15063     rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
     15170    rowSet = psDBSelectRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
    1506415171    if (!rowSet) {
    1506515172        return false;
    … …  
    1506715174
    1506815175    // output to fits
    15069     if (!psFitsWriteTable(fits, NULL, rowSet, P4BINPUTSCFILE_TABLE_NAME)) {
     15176    if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFSCFILE_TABLE_NAME)) {
    1507015177        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1507115178        psFree(rowSet);
    … …  
    1507815185}
    1507915186
    15080 psMetadata *p4bInputScfileMetadataFromObject(const p4bInputScfileRow *object)
     15187psMetadata *p4DiffScfileMetadataFromObject(const p4DiffScfileRow *object)
    1508115188{
    1508215189    psMetadata *md = psMetadataAlloc();
    … …  
    1510615213        return false;
    1510715214    }
    15108     if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) {
    15109         psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
     15215    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
     15216        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     15217        psFree(md);
     15218        return false;
     15219    }
     15220    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
     15221        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15222        psFree(md);
     15223        return false;
     15224    }
     15225    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
     15226        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    1511015227        psFree(md);
    1511115228        return false;
    … …  
    1511615233}
    1511715234
    15118 p4bInputScfileRow *p4bInputScfileObjectFromMetadata(psMetadata *md)
     15235p4DiffScfileRow *p4DiffScfileObjectFromMetadata(psMetadata *md)
    1511915236{
    1512015237
    … …  
    1514515262        return false;
    1514615263    }
    15147     char* kind = psMetadataLookupPtr(&status, md, "kind");
    15148     if (!status) {
    15149         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind");
    15150         return false;
    15151     }
    15152 
    15153     return p4bInputScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, kind);
    15154 }
    15155 psArray *p4bInputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15264    char* uri = psMetadataLookupPtr(&status, md, "uri");
     15265    if (!status) {
     15266        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     15267        return false;
     15268    }
     15269    psF64 bg = psMetadataLookupF64(&status, md, "bg");
     15270    if (!status) {
     15271        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
     15272        return false;
     15273    }
     15274    psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     15275    if (!status) {
     15276        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
     15277        return false;
     15278    }
     15279
     15280    return p4DiffScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
     15281}
     15282psArray *p4DiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1515615283{
    1515715284    psArray         *rowSet;
    … …  
    1515915286    psU64           i;
    1516015287
    15161     rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
     15288    rowSet = psDBSelectRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
    1516215289    if (!rowSet) {
    1516315290        return NULL;
    … …  
    1516915296
    1517015297    for (i = 0; i < rowSet->n; i++) {
    15171         p4bInputScfileRow *object = p4bInputScfileObjectFromMetadata(rowSet->data[i]);
     15298        p4DiffScfileRow *object = p4DiffScfileObjectFromMetadata(rowSet->data[i]);
    1517215299        psArrayAdd(returnSet, 0, object);
    1517315300        psFree(object);
    … …  
    1517815305    return returnSet;
    1517915306}
    15180 bool p4bInputScfileDeleteObject(psDB *dbh, const p4bInputScfileRow *object)
    15181 {
    15182     psMetadata *where = p4bInputScfileMetadataFromObject(object);
    15183     long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, 0);
     15307bool p4DiffScfileDeleteObject(psDB *dbh, const p4DiffScfileRow *object)
     15308{
     15309    psMetadata *where = p4DiffScfileMetadataFromObject(object);
     15310    long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, 0);
    1518415311    psFree(where);
    1518515312    if (count < 0) {
    15186         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
     15313        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
    1518715314        return false;
    1518815315    }
    … …  
    1519015317        // XXX should this be a psAbort() instead?  It is possible that
    1519115318        // having an object match multiple rows was by design.
    15192         psError(PS_ERR_UNKNOWN, true, "p4bInputScfileRow object matched more then one row.  Check your database schema");
    15193         return false;
    15194     }
    15195 
    15196     return true;
    15197 }
    15198 long long p4bInputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15319        psError(PS_ERR_UNKNOWN, true, "p4DiffScfileRow object matched more then one row.  Check your database schema");
     15320        return false;
     15321    }
     15322
     15323    return true;
     15324}
     15325long long p4DiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1519915326{
    1520015327    long long       deleted = 0;
    1520115328
    1520215329    for (long long i = 0; i < objects->n; i++) {
    15203         p4bInputScfileRow *object = objects->data[i];
    15204         psMetadata *where = p4bInputScfileMetadataFromObject(object);
    15205         long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
     15330        p4DiffScfileRow *object = objects->data[i];
     15331        psMetadata *where = p4DiffScfileMetadataFromObject(object);
     15332        long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
    1520615333        psFree(where);
    1520715334        if (count < 0) {
    15208             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
     15335            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
    1520915336            return count;
    1521015337        }
    … …  
    1521515342    return deleted;
    1521615343}
    15217 bool p4bInputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15344bool p4DiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1521815345{
    1521915346    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1522115348    psMetadata *output = psMetadataAlloc();
    1522215349    for (long i = 0; i < psArrayLength(objects); i++) {
    15223         psMetadata *md = p4bInputScfileMetadataFromObject(objects->data[i]);
     15350        psMetadata *md = p4DiffScfileMetadataFromObject(objects->data[i]);
    1522415351        if (!psMetadataAddMetadata(
    1522515352            output,
    1522615353            PS_LIST_TAIL,
    15227             P4BINPUTSCFILE_TABLE_NAME,
     15354            P4DIFFSCFILE_TABLE_NAME,
    1522815355            PS_META_DUPLICATE_OK,
    1522915356            NULL,
    … …  
    1524615373    return true;
    1524715374}
    15248 bool p4bInputScfilePrintObject(FILE *stream, p4bInputScfileRow *object, bool mdcf)
     15375bool p4DiffScfilePrintObject(FILE *stream, p4DiffScfileRow *object, bool mdcf)
    1524915376{
    1525015377    PS_ASSERT_PTR_NON_NULL(object, false);
    1525115378
    15252     psMetadata *md = p4bInputScfileMetadataFromObject(object);
    15253 
    15254     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    15255         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    15256         psFree(md);
    15257     }
    15258 
    15259     psFree(md);
    15260 
    15261     return true;
    15262 }
    15263 static void p4bDiffScfileRowFree(p4bDiffScfileRow *object);
    15264 
    15265 p4bDiffScfileRow *p4bDiffScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    15266 {
    15267     p4bDiffScfileRow *_object;
    15268 
    15269     _object = psAlloc(sizeof(p4bDiffScfileRow));
    15270     psMemSetDeallocator(_object, (psFreeFunc)p4bDiffScfileRowFree);
    15271 
    15272     _object->p4b_id = p4b_id;
    15273     _object->skycell_id = psStringCopy(skycell_id);
    15274     _object->tess_id = psStringCopy(tess_id);
    15275     _object->exp_tag = psStringCopy(exp_tag);
    15276     _object->p3_version = p3_version;
    15277     _object->uri = psStringCopy(uri);
    15278     _object->bg = bg;
    15279     _object->bg_mean_stdev = bg_mean_stdev;
    15280 
    15281     return _object;
    15282 }
    15283 
    15284 static void p4bDiffScfileRowFree(p4bDiffScfileRow *object)
    15285 {
    15286     psFree(object->skycell_id);
    15287     psFree(object->tess_id);
    15288     psFree(object->exp_tag);
    15289     psFree(object->uri);
    15290 }
    15291 
    15292 bool p4bDiffScfileCreateTable(psDB *dbh)
    15293 {
    15294     psMetadata *md = psMetadataAlloc();
    15295     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
    15296         psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
    15297         psFree(md);
    15298         return false;
    15299     }
    15300     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
    15301         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    15302         psFree(md);
    15303         return false;
    15304     }
    15305     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
    15306         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    15307         psFree(md);
    15308         return false;
    15309     }
    15310     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    15311         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    15312         psFree(md);
    15313         return false;
    15314     }
    15315     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
    15316         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    15317         psFree(md);
    15318         return false;
    15319     }
    15320     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    15321         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15322         psFree(md);
    15323         return false;
    15324     }
    15325     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
    15326         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    15327         psFree(md);
    15328         return false;
    15329     }
    15330     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
    15331         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    15332         psFree(md);
    15333         return false;
    15334     }
    15335 
    15336     bool status = psDBCreateTable(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
    15337 
    15338     psFree(md);
    15339 
    15340     return status;
    15341 }
    15342 
    15343 bool p4bDiffScfileDropTable(psDB *dbh)
    15344 {
    15345     return psDBDropTable(dbh, P4BDIFFSCFILE_TABLE_NAME);
    15346 }
    15347 
    15348 bool p4bDiffScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    15349 {
    15350     psMetadata *md = psMetadataAlloc();
    15351     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, p4b_id)) {
    15352         psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
    15353         psFree(md);
    15354         return false;
    15355     }
    15356     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
    15357         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    15358         psFree(md);
    15359         return false;
    15360     }
    15361     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    15362         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    15363         psFree(md);
    15364         return false;
    15365     }
    15366     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    15367         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    15368         psFree(md);
    15369         return false;
    15370     }
    15371     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    15372         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    15373         psFree(md);
    15374         return false;
    15375     }
    15376     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    15377         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15378         psFree(md);
    15379         return false;
    15380     }
    15381     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
    15382         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    15383         psFree(md);
    15384         return false;
    15385     }
    15386     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
    15387         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    15388         psFree(md);
    15389         return false;
    15390     }
    15391 
    15392     bool status = psDBInsertOneRow(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
    15393     psFree(md);
    15394 
    15395     return status;
    15396 }
    15397 
    15398 long long p4bDiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    15399 {
    15400     long long       deleted = 0;
    15401 
    15402     long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
    15403     if (count < 0) {
    15404         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
    15405         return count;
    15406 
    15407         deleted += count;
    15408     }
    15409 
    15410     return deleted;
    15411 }
    15412 bool p4bDiffScfileInsertObject(psDB *dbh, p4bDiffScfileRow *object)
    15413 {
    15414     return p4bDiffScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
    15415 }
    15416 
    15417 bool p4bDiffScfileInsertObjects(psDB *dbh, psArray *objects)
    15418 {
    15419     for (long i = 0; i < psArrayLength(objects); i++) {
    15420         if (!p4bDiffScfileInsertObject(dbh, objects->data[i])) {
    15421             return false;
    15422         }
    15423     }
    15424 
    15425     return true;
    15426 }
    15427 
    15428 bool p4bDiffScfileInsertFits(psDB *dbh, const psFits *fits)
    15429 {
    15430     psArray         *rowSet;
    15431 
    15432     // move to (the first?) extension named  P4BDIFFSCFILE_TABLE_NAME
    15433     if (!psFitsMoveExtName(fits, P4BDIFFSCFILE_TABLE_NAME)) {
    15434         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BDIFFSCFILE_TABLE_NAME);
    15435         return false;
    15436     }
    15437 
    15438     // check HDU type
    15439     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    15440         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    15441         return false;
    15442     }
    15443 
    15444     // read fits table
    15445     rowSet = psFitsReadTable(fits);
    15446     if (!rowSet) {
    15447         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    15448         psFree(rowSet);
    15449         return false;
    15450     }
    15451 
    15452     if (!psDBInsertRows(dbh, P4BDIFFSCFILE_TABLE_NAME, rowSet)) {
    15453         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    15454         psFree(rowSet);
    15455         return false;
    15456     }
    15457 
    15458     psFree(rowSet);
    15459 
    15460     return true;
    15461 }
    15462 
    15463 bool p4bDiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    15464 {
    15465     psArray         *rowSet;
    15466 
    15467     rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
    15468     if (!rowSet) {
    15469         return false;
    15470     }
    15471 
    15472     // output to fits
    15473     if (!psFitsWriteTable(fits, NULL, rowSet, P4BDIFFSCFILE_TABLE_NAME)) {
    15474         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    15475         psFree(rowSet);
    15476         return false;
    15477     }
    15478 
    15479     psFree(rowSet);
    15480 
    15481     return true;
    15482 }
    15483 
    15484 psMetadata *p4bDiffScfileMetadataFromObject(const p4bDiffScfileRow *object)
    15485 {
    15486     psMetadata *md = psMetadataAlloc();
    15487     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, object->p4b_id)) {
    15488         psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
    15489         psFree(md);
    15490         return false;
    15491     }
    15492     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
    15493         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    15494         psFree(md);
    15495         return false;
    15496     }
    15497     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
    15498         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    15499         psFree(md);
    15500         return false;
    15501     }
    15502     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    15503         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    15504         psFree(md);
    15505         return false;
    15506     }
    15507     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    15508         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    15509         psFree(md);
    15510         return false;
    15511     }
    15512     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    15513         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15514         psFree(md);
    15515         return false;
    15516     }
    15517     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
    15518         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    15519         psFree(md);
    15520         return false;
    15521     }
    15522     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
    15523         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    15524         psFree(md);
    15525         return false;
    15526     }
    15527 
    15528 
    15529     return md;
    15530 }
    15531 
    15532 p4bDiffScfileRow *p4bDiffScfileObjectFromMetadata(psMetadata *md)
    15533 {
    15534 
    15535 bool status = false;
    15536     psS32 p4b_id = psMetadataLookupS32(&status, md, "p4b_id");
    15537     if (!status) {
    15538         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4b_id");
    15539         return false;
    15540     }
    15541     char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
    15542     if (!status) {
    15543         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
    15544         return false;
    15545     }
    15546     char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
    15547     if (!status) {
    15548         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    15549         return false;
    15550     }
    15551     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    15552     if (!status) {
    15553         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    15554         return false;
    15555     }
    15556     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    15557     if (!status) {
    15558         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    15559         return false;
    15560     }
    15561     char* uri = psMetadataLookupPtr(&status, md, "uri");
    15562     if (!status) {
    15563         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    15564         return false;
    15565     }
    15566     psF64 bg = psMetadataLookupF64(&status, md, "bg");
    15567     if (!status) {
    15568         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    15569         return false;
    15570     }
    15571     psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
    15572     if (!status) {
    15573         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    15574         return false;
    15575     }
    15576 
    15577     return p4bDiffScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
    15578 }
    15579 psArray *p4bDiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    15580 {
    15581     psArray         *rowSet;
    15582     psArray         *returnSet;
    15583     psU64           i;
    15584 
    15585     rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
    15586     if (!rowSet) {
    15587         return NULL;
    15588     }
    15589 
    15590     // convert psMetadata rows to row objects
    15591 
    15592     returnSet = psArrayAllocEmpty(rowSet->n);
    15593 
    15594     for (i = 0; i < rowSet->n; i++) {
    15595         p4bDiffScfileRow *object = p4bDiffScfileObjectFromMetadata(rowSet->data[i]);
    15596         psArrayAdd(returnSet, 0, object);
    15597         psFree(object);
    15598     }
    15599 
    15600     psFree(rowSet);
    15601 
    15602     return returnSet;
    15603 }
    15604 bool p4bDiffScfileDeleteObject(psDB *dbh, const p4bDiffScfileRow *object)
    15605 {
    15606     psMetadata *where = p4bDiffScfileMetadataFromObject(object);
    15607     long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, 0);
    15608     psFree(where);
    15609     if (count < 0) {
    15610         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
    15611         return false;
    15612     }
    15613     if (count > 1) {
    15614         // XXX should this be a psAbort() instead?  It is possible that
    15615         // having an object match multiple rows was by design.
    15616         psError(PS_ERR_UNKNOWN, true, "p4bDiffScfileRow object matched more then one row.  Check your database schema");
    15617         return false;
    15618     }
    15619 
    15620     return true;
    15621 }
    15622 long long p4bDiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    15623 {
    15624     long long       deleted = 0;
    15625 
    15626     for (long long i = 0; i < objects->n; i++) {
    15627         p4bDiffScfileRow *object = objects->data[i];
    15628         psMetadata *where = p4bDiffScfileMetadataFromObject(object);
    15629         long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
    15630         psFree(where);
    15631         if (count < 0) {
    15632             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
    15633             return count;
    15634         }
    15635 
    15636         deleted += count;
    15637     }
    15638 
    15639     return deleted;
    15640 }
    15641 bool p4bDiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    15642 {
    15643     PS_ASSERT_PTR_NON_NULL(objects, false);
    15644 
    15645     psMetadata *output = psMetadataAlloc();
    15646     for (long i = 0; i < psArrayLength(objects); i++) {
    15647         psMetadata *md = p4bDiffScfileMetadataFromObject(objects->data[i]);
    15648         if (!psMetadataAddMetadata(
    15649             output,
    15650             PS_LIST_TAIL,
    15651             P4BDIFFSCFILE_TABLE_NAME,
    15652             PS_META_DUPLICATE_OK,
    15653             NULL,
    15654             md
    15655         )) {
    15656             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    15657             psFree(md);
    15658             psFree(output);
    15659             return false;
    15660         }
    15661         psFree(md);
    15662     }
    15663 
    15664     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    15665         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    15666         psFree(output);
    15667     }
    15668     psFree(output);
    15669 
    15670     return true;
    15671 }
    15672 bool p4bDiffScfilePrintObject(FILE *stream, p4bDiffScfileRow *object, bool mdcf)
    15673 {
    15674     PS_ASSERT_PTR_NON_NULL(object, false);
    15675 
    15676     psMetadata *md = p4bDiffScfileMetadataFromObject(object);
    15677 
    15678     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    15679         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    15680         psFree(md);
    15681     }
    15682 
    15683     psFree(md);
    15684 
    15685     return true;
    15686 }
    15687 static void p4cRunRowFree(p4cRunRow *object);
    15688 
    15689 p4cRunRow *p4cRunRowAlloc(psS32 p4c_id, const char *state, const char *workdir, bool magic)
    15690 {
    15691     p4cRunRow       *_object;
    15692 
    15693     _object = psAlloc(sizeof(p4cRunRow));
    15694     psMemSetDeallocator(_object, (psFreeFunc)p4cRunRowFree);
    15695 
    15696     _object->p4c_id = p4c_id;
    15697     _object->state = psStringCopy(state);
    15698     _object->workdir = psStringCopy(workdir);
    15699     _object->magic = magic;
    15700 
    15701     return _object;
    15702 }
    15703 
    15704 static void p4cRunRowFree(p4cRunRow *object)
    15705 {
    15706     psFree(object->state);
    15707     psFree(object->workdir);
    15708 }
    15709 
    15710 bool p4cRunCreateTable(psDB *dbh)
    15711 {
    15712     psMetadata *md = psMetadataAlloc();
    15713     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
    15714         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    15715         psFree(md);
    15716         return false;
    15717     }
    15718     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
    15719         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    15720         psFree(md);
    15721         return false;
    15722     }
    15723     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
    15724         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    15725         psFree(md);
    15726         return false;
    15727     }
    15728     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
    15729         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    15730         psFree(md);
    15731         return false;
    15732     }
    15733 
    15734     bool status = psDBCreateTable(dbh, P4CRUN_TABLE_NAME, md);
    15735 
    15736     psFree(md);
    15737 
    15738     return status;
    15739 }
    15740 
    15741 bool p4cRunDropTable(psDB *dbh)
    15742 {
    15743     return psDBDropTable(dbh, P4CRUN_TABLE_NAME);
    15744 }
    15745 
    15746 bool p4cRunInsert(psDB * dbh, psS32 p4c_id, const char *state, const char *workdir, bool magic)
    15747 {
    15748     psMetadata *md = psMetadataAlloc();
    15749     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
    15750         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    15751         psFree(md);
    15752         return false;
    15753     }
    15754     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
    15755         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    15756         psFree(md);
    15757         return false;
    15758     }
    15759     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
    15760         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    15761         psFree(md);
    15762         return false;
    15763     }
    15764     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
    15765         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    15766         psFree(md);
    15767         return false;
    15768     }
    15769 
    15770     bool status = psDBInsertOneRow(dbh, P4CRUN_TABLE_NAME, md);
    15771     psFree(md);
    15772 
    15773     return status;
    15774 }
    15775 
    15776 long long p4cRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    15777 {
    15778     long long       deleted = 0;
    15779 
    15780     long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
    15781     if (count < 0) {
    15782         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
    15783         return count;
    15784 
    15785         deleted += count;
    15786     }
    15787 
    15788     return deleted;
    15789 }
    15790 bool p4cRunInsertObject(psDB *dbh, p4cRunRow *object)
    15791 {
    15792     return p4cRunInsert(dbh, object->p4c_id, object->state, object->workdir, object->magic);
    15793 }
    15794 
    15795 bool p4cRunInsertObjects(psDB *dbh, psArray *objects)
    15796 {
    15797     for (long i = 0; i < psArrayLength(objects); i++) {
    15798         if (!p4cRunInsertObject(dbh, objects->data[i])) {
    15799             return false;
    15800         }
    15801     }
    15802 
    15803     return true;
    15804 }
    15805 
    15806 bool p4cRunInsertFits(psDB *dbh, const psFits *fits)
    15807 {
    15808     psArray         *rowSet;
    15809 
    15810     // move to (the first?) extension named  P4CRUN_TABLE_NAME
    15811     if (!psFitsMoveExtName(fits, P4CRUN_TABLE_NAME)) {
    15812         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CRUN_TABLE_NAME);
    15813         return false;
    15814     }
    15815 
    15816     // check HDU type
    15817     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    15818         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    15819         return false;
    15820     }
    15821 
    15822     // read fits table
    15823     rowSet = psFitsReadTable(fits);
    15824     if (!rowSet) {
    15825         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    15826         psFree(rowSet);
    15827         return false;
    15828     }
    15829 
    15830     if (!psDBInsertRows(dbh, P4CRUN_TABLE_NAME, rowSet)) {
    15831         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    15832         psFree(rowSet);
    15833         return false;
    15834     }
    15835 
    15836     psFree(rowSet);
    15837 
    15838     return true;
    15839 }
    15840 
    15841 bool p4cRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    15842 {
    15843     psArray         *rowSet;
    15844 
    15845     rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
    15846     if (!rowSet) {
    15847         return false;
    15848     }
    15849 
    15850     // output to fits
    15851     if (!psFitsWriteTable(fits, NULL, rowSet, P4CRUN_TABLE_NAME)) {
    15852         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    15853         psFree(rowSet);
    15854         return false;
    15855     }
    15856 
    15857     psFree(rowSet);
    15858 
    15859     return true;
    15860 }
    15861 
    15862 psMetadata *p4cRunMetadataFromObject(const p4cRunRow *object)
    15863 {
    15864     psMetadata *md = psMetadataAlloc();
    15865     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
    15866         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    15867         psFree(md);
    15868         return false;
    15869     }
    15870     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
    15871         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    15872         psFree(md);
    15873         return false;
    15874     }
    15875     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
    15876         psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
    15877         psFree(md);
    15878         return false;
    15879     }
    15880     if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
    15881         psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    15882         psFree(md);
    15883         return false;
    15884     }
    15885 
    15886 
    15887     return md;
    15888 }
    15889 
    15890 p4cRunRow *p4cRunObjectFromMetadata(psMetadata *md)
    15891 {
    15892 
    15893 bool status = false;
    15894     psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
    15895     if (!status) {
    15896         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
    15897         return false;
    15898     }
    15899     char* state = psMetadataLookupPtr(&status, md, "state");
    15900     if (!status) {
    15901         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
    15902         return false;
    15903     }
    15904     char* workdir = psMetadataLookupPtr(&status, md, "workdir");
    15905     if (!status) {
    15906         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
    15907         return false;
    15908     }
    15909     bool magic = psMetadataLookupBool(&status, md, "magic");
    15910     if (!status) {
    15911         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
    15912         return false;
    15913     }
    15914 
    15915     return p4cRunRowAlloc(p4c_id, state, workdir, magic);
    15916 }
    15917 psArray *p4cRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    15918 {
    15919     psArray         *rowSet;
    15920     psArray         *returnSet;
    15921     psU64           i;
    15922 
    15923     rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
    15924     if (!rowSet) {
    15925         return NULL;
    15926     }
    15927 
    15928     // convert psMetadata rows to row objects
    15929 
    15930     returnSet = psArrayAllocEmpty(rowSet->n);
    15931 
    15932     for (i = 0; i < rowSet->n; i++) {
    15933         p4cRunRow *object = p4cRunObjectFromMetadata(rowSet->data[i]);
    15934         psArrayAdd(returnSet, 0, object);
    15935         psFree(object);
    15936     }
    15937 
    15938     psFree(rowSet);
    15939 
    15940     return returnSet;
    15941 }
    15942 bool p4cRunDeleteObject(psDB *dbh, const p4cRunRow *object)
    15943 {
    15944     psMetadata *where = p4cRunMetadataFromObject(object);
    15945     long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, 0);
    15946     psFree(where);
    15947     if (count < 0) {
    15948         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
    15949         return false;
    15950     }
    15951     if (count > 1) {
    15952         // XXX should this be a psAbort() instead?  It is possible that
    15953         // having an object match multiple rows was by design.
    15954         psError(PS_ERR_UNKNOWN, true, "p4cRunRow object matched more then one row.  Check your database schema");
    15955         return false;
    15956     }
    15957 
    15958     return true;
    15959 }
    15960 long long p4cRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    15961 {
    15962     long long       deleted = 0;
    15963 
    15964     for (long long i = 0; i < objects->n; i++) {
    15965         p4cRunRow *object = objects->data[i];
    15966         psMetadata *where = p4cRunMetadataFromObject(object);
    15967         long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
    15968         psFree(where);
    15969         if (count < 0) {
    15970             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
    15971             return count;
    15972         }
    15973 
    15974         deleted += count;
    15975     }
    15976 
    15977     return deleted;
    15978 }
    15979 bool p4cRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    15980 {
    15981     PS_ASSERT_PTR_NON_NULL(objects, false);
    15982 
    15983     psMetadata *output = psMetadataAlloc();
    15984     for (long i = 0; i < psArrayLength(objects); i++) {
    15985         psMetadata *md = p4cRunMetadataFromObject(objects->data[i]);
    15986         if (!psMetadataAddMetadata(
    15987             output,
    15988             PS_LIST_TAIL,
    15989             P4CRUN_TABLE_NAME,
    15990             PS_META_DUPLICATE_OK,
    15991             NULL,
    15992             md
    15993         )) {
    15994             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    15995             psFree(md);
    15996             psFree(output);
    15997             return false;
    15998         }
    15999         psFree(md);
    16000     }
    16001 
    16002     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    16003         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    16004         psFree(output);
    16005     }
    16006     psFree(output);
    16007 
    16008     return true;
    16009 }
    16010 bool p4cRunPrintObject(FILE *stream, p4cRunRow *object, bool mdcf)
    16011 {
    16012     PS_ASSERT_PTR_NON_NULL(object, false);
    16013 
    16014     psMetadata *md = p4cRunMetadataFromObject(object);
    16015 
    16016     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    16017         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    16018         psFree(md);
    16019     }
    16020 
    16021     psFree(md);
    16022 
    16023     return true;
    16024 }
    16025 static void p4cInputExpRowFree(p4cInputExpRow *object);
    16026 
    16027 p4cInputExpRow *p4cInputExpRowAlloc(psS32 p4c_id, const char *exp_tag, psS32 p3_version)
    16028 {
    16029     p4cInputExpRow  *_object;
    16030 
    16031     _object = psAlloc(sizeof(p4cInputExpRow));
    16032     psMemSetDeallocator(_object, (psFreeFunc)p4cInputExpRowFree);
    16033 
    16034     _object->p4c_id = p4c_id;
    16035     _object->exp_tag = psStringCopy(exp_tag);
    16036     _object->p3_version = p3_version;
    16037 
    16038     return _object;
    16039 }
    16040 
    16041 static void p4cInputExpRowFree(p4cInputExpRow *object)
    16042 {
    16043     psFree(object->exp_tag);
    16044 }
    16045 
    16046 bool p4cInputExpCreateTable(psDB *dbh)
    16047 {
    16048     psMetadata *md = psMetadataAlloc();
    16049     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key", 0)) {
    16050         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    16051         psFree(md);
    16052         return false;
    16053     }
    16054     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    16055         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    16056         psFree(md);
    16057         return false;
    16058     }
    16059     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
    16060         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    16061         psFree(md);
    16062         return false;
    16063     }
    16064 
    16065     bool status = psDBCreateTable(dbh, P4CINPUTEXP_TABLE_NAME, md);
    16066 
    16067     psFree(md);
    16068 
    16069     return status;
    16070 }
    16071 
    16072 bool p4cInputExpDropTable(psDB *dbh)
    16073 {
    16074     return psDBDropTable(dbh, P4CINPUTEXP_TABLE_NAME);
    16075 }
    16076 
    16077 bool p4cInputExpInsert(psDB * dbh, psS32 p4c_id, const char *exp_tag, psS32 p3_version)
    16078 {
    16079     psMetadata *md = psMetadataAlloc();
    16080     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
    16081         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    16082         psFree(md);
    16083         return false;
    16084     }
    16085     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    16086         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    16087         psFree(md);
    16088         return false;
    16089     }
    16090     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    16091         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    16092         psFree(md);
    16093         return false;
    16094     }
    16095 
    16096     bool status = psDBInsertOneRow(dbh, P4CINPUTEXP_TABLE_NAME, md);
    16097     psFree(md);
    16098 
    16099     return status;
    16100 }
    16101 
    16102 long long p4cInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    16103 {
    16104     long long       deleted = 0;
    16105 
    16106     long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
    16107     if (count < 0) {
    16108         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
    16109         return count;
    16110 
    16111         deleted += count;
    16112     }
    16113 
    16114     return deleted;
    16115 }
    16116 bool p4cInputExpInsertObject(psDB *dbh, p4cInputExpRow *object)
    16117 {
    16118     return p4cInputExpInsert(dbh, object->p4c_id, object->exp_tag, object->p3_version);
    16119 }
    16120 
    16121 bool p4cInputExpInsertObjects(psDB *dbh, psArray *objects)
    16122 {
    16123     for (long i = 0; i < psArrayLength(objects); i++) {
    16124         if (!p4cInputExpInsertObject(dbh, objects->data[i])) {
    16125             return false;
    16126         }
    16127     }
    16128 
    16129     return true;
    16130 }
    16131 
    16132 bool p4cInputExpInsertFits(psDB *dbh, const psFits *fits)
    16133 {
    16134     psArray         *rowSet;
    16135 
    16136     // move to (the first?) extension named  P4CINPUTEXP_TABLE_NAME
    16137     if (!psFitsMoveExtName(fits, P4CINPUTEXP_TABLE_NAME)) {
    16138         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CINPUTEXP_TABLE_NAME);
    16139         return false;
    16140     }
    16141 
    16142     // check HDU type
    16143     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    16144         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    16145         return false;
    16146     }
    16147 
    16148     // read fits table
    16149     rowSet = psFitsReadTable(fits);
    16150     if (!rowSet) {
    16151         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    16152         psFree(rowSet);
    16153         return false;
    16154     }
    16155 
    16156     if (!psDBInsertRows(dbh, P4CINPUTEXP_TABLE_NAME, rowSet)) {
    16157         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    16158         psFree(rowSet);
    16159         return false;
    16160     }
    16161 
    16162     psFree(rowSet);
    16163 
    16164     return true;
    16165 }
    16166 
    16167 bool p4cInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    16168 {
    16169     psArray         *rowSet;
    16170 
    16171     rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
    16172     if (!rowSet) {
    16173         return false;
    16174     }
    16175 
    16176     // output to fits
    16177     if (!psFitsWriteTable(fits, NULL, rowSet, P4CINPUTEXP_TABLE_NAME)) {
    16178         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    16179         psFree(rowSet);
    16180         return false;
    16181     }
    16182 
    16183     psFree(rowSet);
    16184 
    16185     return true;
    16186 }
    16187 
    16188 psMetadata *p4cInputExpMetadataFromObject(const p4cInputExpRow *object)
    16189 {
    16190     psMetadata *md = psMetadataAlloc();
    16191     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
    16192         psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    16193         psFree(md);
    16194         return false;
    16195     }
    16196     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    16197         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    16198         psFree(md);
    16199         return false;
    16200     }
    16201     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    16202         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    16203         psFree(md);
    16204         return false;
    16205     }
    16206 
    16207 
    16208     return md;
    16209 }
    16210 
    16211 p4cInputExpRow *p4cInputExpObjectFromMetadata(psMetadata *md)
    16212 {
    16213 
    16214 bool status = false;
    16215     psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
    16216     if (!status) {
    16217         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
    16218         return false;
    16219     }
    16220     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    16221     if (!status) {
    16222         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    16223         return false;
    16224     }
    16225     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    16226     if (!status) {
    16227         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    16228         return false;
    16229     }
    16230 
    16231     return p4cInputExpRowAlloc(p4c_id, exp_tag, p3_version);
    16232 }
    16233 psArray *p4cInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    16234 {
    16235     psArray         *rowSet;
    16236     psArray         *returnSet;
    16237     psU64           i;
    16238 
    16239     rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
    16240     if (!rowSet) {
    16241         return NULL;
    16242     }
    16243 
    16244     // convert psMetadata rows to row objects
    16245 
    16246     returnSet = psArrayAllocEmpty(rowSet->n);
    16247 
    16248     for (i = 0; i < rowSet->n; i++) {
    16249         p4cInputExpRow *object = p4cInputExpObjectFromMetadata(rowSet->data[i]);
    16250         psArrayAdd(returnSet, 0, object);
    16251         psFree(object);
    16252     }
    16253 
    16254     psFree(rowSet);
    16255 
    16256     return returnSet;
    16257 }
    16258 bool p4cInputExpDeleteObject(psDB *dbh, const p4cInputExpRow *object)
    16259 {
    16260     psMetadata *where = p4cInputExpMetadataFromObject(object);
    16261     long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, 0);
    16262     psFree(where);
    16263     if (count < 0) {
    16264         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
    16265         return false;
    16266     }
    16267     if (count > 1) {
    16268         // XXX should this be a psAbort() instead?  It is possible that
    16269         // having an object match multiple rows was by design.
    16270         psError(PS_ERR_UNKNOWN, true, "p4cInputExpRow object matched more then one row.  Check your database schema");
    16271         return false;
    16272     }
    16273 
    16274     return true;
    16275 }
    16276 long long p4cInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    16277 {
    16278     long long       deleted = 0;
    16279 
    16280     for (long long i = 0; i < objects->n; i++) {
    16281         p4cInputExpRow *object = objects->data[i];
    16282         psMetadata *where = p4cInputExpMetadataFromObject(object);
    16283         long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
    16284         psFree(where);
    16285         if (count < 0) {
    16286             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
    16287             return count;
    16288         }
    16289 
    16290         deleted += count;
    16291     }
    16292 
    16293     return deleted;
    16294 }
    16295 bool p4cInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    16296 {
    16297     PS_ASSERT_PTR_NON_NULL(objects, false);
    16298 
    16299     psMetadata *output = psMetadataAlloc();
    16300     for (long i = 0; i < psArrayLength(objects); i++) {
    16301         psMetadata *md = p4cInputExpMetadataFromObject(objects->data[i]);
    16302         if (!psMetadataAddMetadata(
    16303             output,
    16304             PS_LIST_TAIL,
    16305             P4CINPUTEXP_TABLE_NAME,
    16306             PS_META_DUPLICATE_OK,
    16307             NULL,
    16308             md
    16309         )) {
    16310             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    16311             psFree(md);
    16312             psFree(output);
    16313             return false;
    16314         }
    16315         psFree(md);
    16316     }
    16317 
    16318     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    16319         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    16320         psFree(output);
    16321     }
    16322     psFree(output);
    16323 
    16324     return true;
    16325 }
    16326 bool p4cInputExpPrintObject(FILE *stream, p4cInputExpRow *object, bool mdcf)
    16327 {
    16328     PS_ASSERT_PTR_NON_NULL(object, false);
    16329 
    16330     psMetadata *md = p4cInputExpMetadataFromObject(object);
     15379    psMetadata *md = p4DiffScfileMetadataFromObject(object);
    1633115380
    1633215381    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {

  • trunk/ippdb/src/ippdb.h

    r11679 r11720  
    2020/*
    2121 *
    22  * This file was generated by glueforge 0.36
     22 * This file was generated by glueforge 1.00
    2323 *
    2424 * Do NOT directly edit this file.
    … …  
    68306830    bool            mdcf                ///< format as mdconfig or simple
    68316831);
    6832 /** p4aRunRow data structure
    6833  *
    6834  * Structure for representing a single row of p4aRun table data.
     6832/** p4RunRow data structure
     6833 *
     6834 * Structure for representing a single row of p4Run table data.
    68356835 */
    68366836
    68376837typedef struct {
    68386838    psS32           p4a_id;
     6839    char            *mode;
    68396840    char            *state;
    68406841    char            *workdir;
    6841     bool            magic;
    6842 } p4aRunRow;
    6843 
    6844 /** Creates a new p4aRunRow object
    6845  *
    6846  *  @return A new p4aRunRow object or NULL on failure.
    6847  */
    6848 
    6849 p4aRunRow *p4aRunRowAlloc(
     6842    psTime*         registered;
     6843} p4RunRow;
     6844
     6845/** Creates a new p4RunRow object
     6846 *
     6847 *  @return A new p4RunRow object or NULL on failure.
     6848 */
     6849
     6850p4RunRow *p4RunRowAlloc(
    68506851    psS32           p4a_id,
     6852    const char      *mode,
    68516853    const char      *state,
    68526854    const char      *workdir,
    6853     bool            magic
    6854 );
    6855 
    6856 /** Creates a new p4aRun table
    6857  *
    6858  * @return true on success
    6859  */
    6860 
    6861 bool p4aRunCreateTable(
     6855    psTime*         registered
     6856);
     6857
     6858/** Creates a new p4Run table
     6859 *
     6860 * @return true on success
     6861 */
     6862
     6863bool p4RunCreateTable(
    68626864    psDB            *dbh                ///< Database handle
    68636865);
    68646866
    6865 /** Deletes a p4aRun table
    6866  *
    6867  * @return true on success
    6868  */
    6869 
    6870 bool p4aRunDropTable(
     6867/** Deletes a p4Run table
     6868 *
     6869 * @return true on success
     6870 */
     6871
     6872bool p4RunDropTable(
    68716873    psDB            *dbh                ///< Database handle
    68726874);
    … …  
    68796881 */
    68806882
    6881 bool p4aRunInsert(
     6883bool p4RunInsert(
    68826884    psDB            *dbh,               ///< Database handle
    68836885    psS32           p4a_id,
     6886    const char      *mode,
    68846887    const char      *state,
    68856888    const char      *workdir,
    6886     bool            magic
     6889    psTime*         registered
    68876890);
    68886891
    … …  
    68926895 */
    68936896
    6894 long long p4aRunDelete(
     6897long long p4RunDelete(
    68956898    psDB            *dbh,               ///< Database handle
    68966899    const psMetadata *where,            ///< Row match criteria
    … …  
    68986901);
    68996902
    6900 /** Insert a single p4aRunRow object into a table
     6903/** Insert a single p4RunRow object into a table
    69016904 *
    69026905 * This function constructs and inserts a single row based on it's parameters.
    … …  
    69056908 */
    69066909
    6907 bool p4aRunInsertObject(
    6908     psDB            *dbh,               ///< Database handle
    6909     p4aRunRow       *object             ///< p4aRunRow object
    6910 );
    6911 
    6912 /** Insert an array of p4aRunRow object into a table
     6910bool p4RunInsertObject(
     6911    psDB            *dbh,               ///< Database handle
     6912    p4RunRow        *object             ///< p4RunRow object
     6913);
     6914
     6915/** Insert an array of p4RunRow object into a table
    69136916 *
    69146917 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    69176920 */
    69186921
    6919 bool p4aRunInsertObjects(
    6920     psDB            *dbh,               ///< Database handle
    6921     psArray         *objects            ///< array of p4aRunRow objects
    6922 );
    6923 
    6924 /** Insert data from a binary FITS table p4aRunRow into the database
     6922bool p4RunInsertObjects(
     6923    psDB            *dbh,               ///< Database handle
     6924    psArray         *objects            ///< array of p4RunRow objects
     6925);
     6926
     6927/** Insert data from a binary FITS table p4RunRow into the database
    69256928 *
    69266929 * This function expects a psFits object with a FITS table as the first
    … …  
    69326935 */
    69336936
    6934 bool p4aRunInsertFits(
     6937bool p4RunInsertFits(
    69356938    psDB            *dbh,               ///< Database handle
    69366939    const psFits    *fits               ///< psFits object
    … …  
    69476950 */
    69486951
    6949 bool p4aRunSelectRowsFits(
     6952bool p4RunSelectRowsFits(
    69506953    psDB            *dbh,               ///< Database handle
    69516954    psFits          *fits,              ///< psFits object
    … …  
    69546957);
    69556958
    6956 /** Convert a p4aRunRow into an equivalent psMetadata
     6959/** Convert a p4RunRow into an equivalent psMetadata
    69576960 *
    69586961 * @return A psMetadata pointer or NULL on error
    69596962 */
    69606963
    6961 psMetadata *p4aRunMetadataFromObject(
    6962     const p4aRunRow *object             ///< fooRow to convert into a psMetadata
     6964psMetadata *p4RunMetadataFromObject(
     6965    const p4RunRow *object             ///< fooRow to convert into a psMetadata
    69636966);
    69646967
    69656968/** Convert a psMetadata into an equivalent fooRow
    69666969 *
    6967  * @return A p4aRunRow pointer or NULL on error
    6968  */
    6969 
    6970 p4aRunRow *p4aRunObjectFromMetadata(
     6970 * @return A p4RunRow pointer or NULL on error
     6971 */
     6972
     6973p4RunRow *p4RunObjectFromMetadata(
    69716974    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    69726975);
    6973 /** Selects up to limit rows from the database and returns as p4aRunRow objects in a psArray
     6976/** Selects up to limit rows from the database and returns as p4RunRow objects in a psArray
    69746977 *
    69756978 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    69786981 */
    69796982
    6980 psArray *p4aRunSelectRowObjects(
     6983psArray *p4RunSelectRowObjects(
    69816984    psDB            *dbh,               ///< Database handle
    69826985    const psMetadata *where,            ///< Row match criteria
    69836986    unsigned long long limit            ///< Maximum number of elements to return
    69846987);
    6985 /** Deletes a row from the database coresponding to an p4aRun
     6988/** Deletes a row from the database coresponding to an p4Run
    69866989 *
    69876990 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    69916994 */
    69926995
    6993 bool p4aRunDeleteObject(
    6994     psDB            *dbh,               ///< Database handle
    6995     const p4aRunRow *object    ///< Object to delete
     6996bool p4RunDeleteObject(
     6997    psDB            *dbh,               ///< Database handle
     6998    const p4RunRow *object    ///< Object to delete
    69966999);
    69977000/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    70037006 */
    70047007
    7005 long long p4aRunDeleteRowObjects(
     7008long long p4RunDeleteRowObjects(
    70067009    psDB            *dbh,               ///< Database handle
    70077010    const psArray   *objects,           ///< Array of objects to delete
    70087011    unsigned long long limit            ///< Maximum number of elements to delete
    70097012);
    7010 /** Formats and prints an array of p4aRunRow objects
     7013/** Formats and prints an array of p4RunRow objects
    70117014 *
    70127015 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    70167019 */
    70177020
    7018 bool p4aRunPrintObjects(
     7021bool p4RunPrintObjects(
    70197022    FILE            *stream,            ///< a stream
    7020     psArray         *objects,           ///< An array of p4aRunRow objects
     7023    psArray         *objects,           ///< An array of p4RunRow objects
    70217024    bool            mdcf                ///< format as mdconfig or simple
    70227025);
    7023 /** Formats and prints an p4aRunRow object
     7026/** Formats and prints an p4RunRow object
    70247027 *
    70257028 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    70297032 */
    70307033
    7031 bool p4aRunPrintObject(
     7034bool p4RunPrintObject(
    70327035    FILE            *stream,            ///< a stream
    7033     p4aRunRow *object,    ///< an p4aRunRow object
     7036    p4RunRow *object,    ///< an p4RunRow object
    70347037    bool            mdcf                ///< format as mdconfig or simple
    70357038);
    7036 /** p4aInputExpRow data structure
    7037  *
    7038  * Structure for representing a single row of p4aInputExp table data.
     7039/** p4InputExpRow data structure
     7040 *
     7041 * Structure for representing a single row of p4InputExp table data.
    70397042 */
    70407043
    … …  
    70437046    char            *exp_tag;
    70447047    psS32           p3_version;
    7045 } p4aInputExpRow;
    7046 
    7047 /** Creates a new p4aInputExpRow object
    7048  *
    7049  *  @return A new p4aInputExpRow object or NULL on failure.
    7050  */
    7051 
    7052 p4aInputExpRow *p4aInputExpRowAlloc(
     7048    bool            magiced;
     7049} p4InputExpRow;
     7050
     7051/** Creates a new p4InputExpRow object
     7052 *
     7053 *  @return A new p4InputExpRow object or NULL on failure.
     7054 */
     7055
     7056p4InputExpRow *p4InputExpRowAlloc(
    70537057    psS32           p4a_id,
    70547058    const char      *exp_tag,
    7055     psS32           p3_version
    7056 );
    7057 
    7058 /** Creates a new p4aInputExp table
    7059  *
    7060  * @return true on success
    7061  */
    7062 
    7063 bool p4aInputExpCreateTable(
     7059    psS32           p3_version,
     7060    bool            magiced
     7061);
     7062
     7063/** Creates a new p4InputExp table
     7064 *
     7065 * @return true on success
     7066 */
     7067
     7068bool p4InputExpCreateTable(
    70647069    psDB            *dbh                ///< Database handle
    70657070);
    70667071
    7067 /** Deletes a p4aInputExp table
    7068  *
    7069  * @return true on success
    7070  */
    7071 
    7072 bool p4aInputExpDropTable(
     7072/** Deletes a p4InputExp table
     7073 *
     7074 * @return true on success
     7075 */
     7076
     7077bool p4InputExpDropTable(
    70737078    psDB            *dbh                ///< Database handle
    70747079);
    … …  
    70817086 */
    70827087
    7083 bool p4aInputExpInsert(
     7088bool p4InputExpInsert(
    70847089    psDB            *dbh,               ///< Database handle
    70857090    psS32           p4a_id,
    70867091    const char      *exp_tag,
    7087     psS32           p3_version
     7092    psS32           p3_version,
     7093    bool            magiced
    70887094);
    70897095
    … …  
    70937099 */
    70947100
    7095 long long p4aInputExpDelete(
     7101long long p4InputExpDelete(
    70967102    psDB            *dbh,               ///< Database handle
    70977103    const psMetadata *where,            ///< Row match criteria
    … …  
    70997105);
    71007106
    7101 /** Insert a single p4aInputExpRow object into a table
     7107/** Insert a single p4InputExpRow object into a table
    71027108 *
    71037109 * This function constructs and inserts a single row based on it's parameters.
    … …  
    71067112 */
    71077113
    7108 bool p4aInputExpInsertObject(
    7109     psDB            *dbh,               ///< Database handle
    7110     p4aInputExpRow  *object             ///< p4aInputExpRow object
    7111 );
    7112 
    7113 /** Insert an array of p4aInputExpRow object into a table
     7114bool p4InputExpInsertObject(
     7115    psDB            *dbh,               ///< Database handle
     7116    p4InputExpRow   *object             ///< p4InputExpRow object
     7117);
     7118
     7119/** Insert an array of p4InputExpRow object into a table
    71147120 *
    71157121 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    71187124 */
    71197125
    7120 bool p4aInputExpInsertObjects(
    7121     psDB            *dbh,               ///< Database handle
    7122     psArray         *objects            ///< array of p4aInputExpRow objects
    7123 );
    7124 
    7125 /** Insert data from a binary FITS table p4aInputExpRow into the database
     7126bool p4InputExpInsertObjects(
     7127    psDB            *dbh,               ///< Database handle
     7128    psArray         *objects            ///< array of p4InputExpRow objects
     7129);
     7130
     7131/** Insert data from a binary FITS table p4InputExpRow into the database
    71267132 *
    71277133 * This function expects a psFits object with a FITS table as the first
    … …  
    71337139 */
    71347140
    7135 bool p4aInputExpInsertFits(
     7141bool p4InputExpInsertFits(
    71367142    psDB            *dbh,               ///< Database handle
    71377143    const psFits    *fits               ///< psFits object
    … …  
    71487154 */
    71497155
    7150 bool p4aInputExpSelectRowsFits(
     7156bool p4InputExpSelectRowsFits(
    71517157    psDB            *dbh,               ///< Database handle
    71527158    psFits          *fits,              ///< psFits object
    … …  
    71557161);
    71567162
    7157 /** Convert a p4aInputExpRow into an equivalent psMetadata
     7163/** Convert a p4InputExpRow into an equivalent psMetadata
    71587164 *
    71597165 * @return A psMetadata pointer or NULL on error
    71607166 */
    71617167
    7162 psMetadata *p4aInputExpMetadataFromObject(
    7163     const p4aInputExpRow *object             ///< fooRow to convert into a psMetadata
     7168psMetadata *p4InputExpMetadataFromObject(
     7169    const p4InputExpRow *object             ///< fooRow to convert into a psMetadata
    71647170);
    71657171
    71667172/** Convert a psMetadata into an equivalent fooRow
    71677173 *
    7168  * @return A p4aInputExpRow pointer or NULL on error
    7169  */
    7170 
    7171 p4aInputExpRow *p4aInputExpObjectFromMetadata(
     7174 * @return A p4InputExpRow pointer or NULL on error
     7175 */
     7176
     7177p4InputExpRow *p4InputExpObjectFromMetadata(
    71727178    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    71737179);
    7174 /** Selects up to limit rows from the database and returns as p4aInputExpRow objects in a psArray
     7180/** Selects up to limit rows from the database and returns as p4InputExpRow objects in a psArray
    71757181 *
    71767182 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    71797185 */
    71807186
    7181 psArray *p4aInputExpSelectRowObjects(
     7187psArray *p4InputExpSelectRowObjects(
    71827188    psDB            *dbh,               ///< Database handle
    71837189    const psMetadata *where,            ///< Row match criteria
    71847190    unsigned long long limit            ///< Maximum number of elements to return
    71857191);
    7186 /** Deletes a row from the database coresponding to an p4aInputExp
     7192/** Deletes a row from the database coresponding to an p4InputExp
    71877193 *
    71887194 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    71927198 */
    71937199
    7194 bool p4aInputExpDeleteObject(
    7195     psDB            *dbh,               ///< Database handle
    7196     const p4aInputExpRow *object    ///< Object to delete
     7200bool p4InputExpDeleteObject(
     7201    psDB            *dbh,               ///< Database handle
     7202    const p4InputExpRow *object    ///< Object to delete
    71977203);
    71987204/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    72047210 */
    72057211
    7206 long long p4aInputExpDeleteRowObjects(
     7212long long p4InputExpDeleteRowObjects(
    72077213    psDB            *dbh,               ///< Database handle
    72087214    const psArray   *objects,           ///< Array of objects to delete
    72097215    unsigned long long limit            ///< Maximum number of elements to delete
    72107216);
    7211 /** Formats and prints an array of p4aInputExpRow objects
     7217/** Formats and prints an array of p4InputExpRow objects
    72127218 *
    72137219 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    72177223 */
    72187224
    7219 bool p4aInputExpPrintObjects(
     7225bool p4InputExpPrintObjects(
    72207226    FILE            *stream,            ///< a stream
    7221     psArray         *objects,           ///< An array of p4aInputExpRow objects
     7227    psArray         *objects,           ///< An array of p4InputExpRow objects
    72227228    bool            mdcf                ///< format as mdconfig or simple
    72237229);
    7224 /** Formats and prints an p4aInputExpRow object
     7230/** Formats and prints an p4InputExpRow object
    72257231 *
    72267232 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    72307236 */
    72317237
    7232 bool p4aInputExpPrintObject(
     7238bool p4InputExpPrintObject(
    72337239    FILE            *stream,            ///< a stream
    7234     p4aInputExpRow *object,    ///< an p4aInputExpRow object
     7240    p4InputExpRow *object,    ///< an p4InputExpRow object
    72357241    bool            mdcf                ///< format as mdconfig or simple
    72367242);
    7237 /** p4aScfileRow data structure
    7238  *
    7239  * Structure for representing a single row of p4aScfile table data.
     7243/** p4ScfileRow data structure
     7244 *
     7245 * Structure for representing a single row of p4Scfile table data.
    72407246 */
    72417247
    … …  
    72497255    psF64           bg;
    72507256    psF64           bg_mean_stdev;
    7251 } p4aScfileRow;
    7252 
    7253 /** Creates a new p4aScfileRow object
    7254  *
    7255  *  @return A new p4aScfileRow object or NULL on failure.
    7256  */
    7257 
    7258 p4aScfileRow *p4aScfileRowAlloc(
     7257} p4ScfileRow;
     7258
     7259/** Creates a new p4ScfileRow object
     7260 *
     7261 *  @return A new p4ScfileRow object or NULL on failure.
     7262 */
     7263
     7264p4ScfileRow *p4ScfileRowAlloc(
    72597265    psS32           p4a_id,
    72607266    const char      *skycell_id,
    … …  
    72677273);
    72687274
    7269 /** Creates a new p4aScfile table
    7270  *
    7271  * @return true on success
    7272  */
    7273 
    7274 bool p4aScfileCreateTable(
     7275/** Creates a new p4Scfile table
     7276 *
     7277 * @return true on success
     7278 */
     7279
     7280bool p4ScfileCreateTable(
    72757281    psDB            *dbh                ///< Database handle
    72767282);
    72777283
    7278 /** Deletes a p4aScfile table
    7279  *
    7280  * @return true on success
    7281  */
    7282 
    7283 bool p4aScfileDropTable(
     7284/** Deletes a p4Scfile table
     7285 *
     7286 * @return true on success
     7287 */
     7288
     7289bool p4ScfileDropTable(
    72847290    psDB            *dbh                ///< Database handle
    72857291);
    … …  
    72927298 */
    72937299
    7294 bool p4aScfileInsert(
     7300bool p4ScfileInsert(
    72957301    psDB            *dbh,               ///< Database handle
    72967302    psS32           p4a_id,
    … …  
    73097315 */
    73107316
    7311 long long p4aScfileDelete(
     7317long long p4ScfileDelete(
    73127318    psDB            *dbh,               ///< Database handle
    73137319    const psMetadata *where,            ///< Row match criteria
    … …  
    73157321);
    73167322
    7317 /** Insert a single p4aScfileRow object into a table
     7323/** Insert a single p4ScfileRow object into a table
    73187324 *
    73197325 * This function constructs and inserts a single row based on it's parameters.
    … …  
    73227328 */
    73237329
    7324 bool p4aScfileInsertObject(
    7325     psDB            *dbh,               ///< Database handle
    7326     p4aScfileRow    *object             ///< p4aScfileRow object
    7327 );
    7328 
    7329 /** Insert an array of p4aScfileRow object into a table
     7330bool p4ScfileInsertObject(
     7331    psDB            *dbh,               ///< Database handle
     7332    p4ScfileRow     *object             ///< p4ScfileRow object
     7333);
     7334
     7335/** Insert an array of p4ScfileRow object into a table
    73307336 *
    73317337 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    73347340 */
    73357341
    7336 bool p4aScfileInsertObjects(
    7337     psDB            *dbh,               ///< Database handle
    7338     psArray         *objects            ///< array of p4aScfileRow objects
    7339 );
    7340 
    7341 /** Insert data from a binary FITS table p4aScfileRow into the database
     7342bool p4ScfileInsertObjects(
     7343    psDB            *dbh,               ///< Database handle
     7344    psArray         *objects            ///< array of p4ScfileRow objects
     7345);
     7346
     7347/** Insert data from a binary FITS table p4ScfileRow into the database
    73427348 *
    73437349 * This function expects a psFits object with a FITS table as the first
    … …  
    73497355 */
    73507356
    7351 bool p4aScfileInsertFits(
     7357bool p4ScfileInsertFits(
    73527358    psDB            *dbh,               ///< Database handle
    73537359    const psFits    *fits               ///< psFits object
    … …  
    73647370 */
    73657371
    7366 bool p4aScfileSelectRowsFits(
     7372bool p4ScfileSelectRowsFits(
    73677373    psDB            *dbh,               ///< Database handle
    73687374    psFits          *fits,              ///< psFits object
    … …  
    73717377);
    73727378
    7373 /** Convert a p4aScfileRow into an equivalent psMetadata
     7379/** Convert a p4ScfileRow into an equivalent psMetadata
    73747380 *
    73757381 * @return A psMetadata pointer or NULL on error
    73767382 */
    73777383
    7378 psMetadata *p4aScfileMetadataFromObject(
    7379     const p4aScfileRow *object             ///< fooRow to convert into a psMetadata
     7384psMetadata *p4ScfileMetadataFromObject(
     7385    const p4ScfileRow *object             ///< fooRow to convert into a psMetadata
    73807386);
    73817387
    73827388/** Convert a psMetadata into an equivalent fooRow
    73837389 *
    7384  * @return A p4aScfileRow pointer or NULL on error
    7385  */
    7386 
    7387 p4aScfileRow *p4aScfileObjectFromMetadata(
     7390 * @return A p4ScfileRow pointer or NULL on error
     7391 */
     7392
     7393p4ScfileRow *p4ScfileObjectFromMetadata(
    73887394    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    73897395);
    7390 /** Selects up to limit rows from the database and returns as p4aScfileRow objects in a psArray
     7396/** Selects up to limit rows from the database and returns as p4ScfileRow objects in a psArray
    73917397 *
    73927398 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    73957401 */
    73967402
    7397 psArray *p4aScfileSelectRowObjects(
     7403psArray *p4ScfileSelectRowObjects(
    73987404    psDB            *dbh,               ///< Database handle
    73997405    const psMetadata *where,            ///< Row match criteria
    74007406    unsigned long long limit            ///< Maximum number of elements to return
    74017407);
    7402 /** Deletes a row from the database coresponding to an p4aScfile
     7408/** Deletes a row from the database coresponding to an p4Scfile
    74037409 *
    74047410 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    74087414 */
    74097415
    7410 bool p4aScfileDeleteObject(
    7411     psDB            *dbh,               ///< Database handle
    7412     const p4aScfileRow *object    ///< Object to delete
     7416bool p4ScfileDeleteObject(
     7417    psDB            *dbh,               ///< Database handle
     7418    const p4ScfileRow *object    ///< Object to delete
    74137419);
    74147420/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    74207426 */
    74217427
    7422 long long p4aScfileDeleteRowObjects(
     7428long long p4ScfileDeleteRowObjects(
    74237429    psDB            *dbh,               ///< Database handle
    74247430    const psArray   *objects,           ///< Array of objects to delete
    74257431    unsigned long long limit            ///< Maximum number of elements to delete
    74267432);
    7427 /** Formats and prints an array of p4aScfileRow objects
     7433/** Formats and prints an array of p4ScfileRow objects
    74287434 *
    74297435 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    74337439 */
    74347440
    7435 bool p4aScfilePrintObjects(
     7441bool p4ScfilePrintObjects(
    74367442    FILE            *stream,            ///< a stream
    7437     psArray         *objects,           ///< An array of p4aScfileRow objects
     7443    psArray         *objects,           ///< An array of p4ScfileRow objects
    74387444    bool            mdcf                ///< format as mdconfig or simple
    74397445);
    7440 /** Formats and prints an p4aScfileRow object
     7446/** Formats and prints an p4ScfileRow object
    74417447 *
    74427448 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    74467452 */
    74477453
    7448 bool p4aScfilePrintObject(
     7454bool p4ScfilePrintObject(
    74497455    FILE            *stream,            ///< a stream
    7450     p4aScfileRow *object,    ///< an p4aScfileRow object
     7456    p4ScfileRow *object,    ///< an p4ScfileRow object
    74517457    bool            mdcf                ///< format as mdconfig or simple
    74527458);
    7453 /** p4bRunRow data structure
    7454  *
    7455  * Structure for representing a single row of p4bRun table data.
    7456  */
    7457 
    7458 typedef struct {
    7459     psS32           p4b_id;
    7460     char            *state;
    7461     char            *workdir;
    7462     bool            magic;
    7463 } p4bRunRow;
    7464 
    7465 /** Creates a new p4bRunRow object
    7466  *
    7467  *  @return A new p4bRunRow object or NULL on failure.
    7468  */
    7469 
    7470 p4bRunRow *p4bRunRowAlloc(
    7471     psS32           p4b_id,
    7472     const char      *state,
    7473     const char      *workdir,
    7474     bool            magic
    7475 );
    7476 
    7477 /** Creates a new p4bRun table
    7478  *
    7479  * @return true on success
    7480  */
    7481 
    7482 bool p4bRunCreateTable(
    7483     psDB            *dbh                ///< Database handle
    7484 );
    7485 
    7486 /** Deletes a p4bRun table
    7487  *
    7488  * @return true on success
    7489  */
    7490 
    7491 bool p4bRunDropTable(
    7492     psDB            *dbh                ///< Database handle
    7493 );
    7494 
    7495 /** Insert a single row into a table
    7496  *
    7497  * This function constructs and inserts a single row based on it's parameters.
    7498  *
    7499  * @return true on success
    7500  */
    7501 
    7502 bool p4bRunInsert(
    7503     psDB            *dbh,               ///< Database handle
    7504     psS32           p4b_id,
    7505     const char      *state,
    7506     const char      *workdir,
    7507     bool            magic
    7508 );
    7509 
    7510 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    7511  *
    7512  * @return A The number of rows removed or a negative value on error
    7513  */
    7514 
    7515 long long p4bRunDelete(
    7516     psDB            *dbh,               ///< Database handle
    7517     const psMetadata *where,            ///< Row match criteria
    7518     unsigned long long limit            ///< Maximum number of elements to delete
    7519 );
    7520 
    7521 /** Insert a single p4bRunRow object into a table
    7522  *
    7523  * This function constructs and inserts a single row based on it's parameters.
    7524  *
    7525  * @return true on success
    7526  */
    7527 
    7528 bool p4bRunInsertObject(
    7529     psDB            *dbh,               ///< Database handle
    7530     p4bRunRow       *object             ///< p4bRunRow object
    7531 );
    7532 
    7533 /** Insert an array of p4bRunRow object into a table
    7534  *
    7535  * This function constructs and inserts multiple rows based on it's parameters.
    7536  *
    7537  * @return true on success
    7538  */
    7539 
    7540 bool p4bRunInsertObjects(
    7541     psDB            *dbh,               ///< Database handle
    7542     psArray         *objects            ///< array of p4bRunRow objects
    7543 );
    7544 
    7545 /** Insert data from a binary FITS table p4bRunRow into the database
    7546  *
    7547  * This function expects a psFits object with a FITS table as the first
    7548  * extension.  The table must have at least one row of data in it, that is of
    7549  * the appropriate format (number of columns and their type).  All other
    7550  * extensions are ignored.
    7551  *
    7552  * @return true on success
    7553  */
    7554 
    7555 bool p4bRunInsertFits(
    7556     psDB            *dbh,               ///< Database handle
    7557     const psFits    *fits               ///< psFits object
    7558 );
    7559 
    7560 /** Selects up to limit from the database and returns them in a binary FITS table
    7561  *
    7562  * This function assumes an empty psFits object and will create a FITS table
    7563  * as the first extension.
    7564  *
    7565  *  See psDBSelectRows() for documentation on the format of where.
    7566  *
    7567  * @return true on success
    7568  */
    7569 
    7570 bool p4bRunSelectRowsFits(
    7571     psDB            *dbh,               ///< Database handle
    7572     psFits          *fits,              ///< psFits object
    7573     const psMetadata *where,            ///< Row match criteria
    7574     unsigned long long limit            ///< Maximum number of elements to return
    7575 );
    7576 
    7577 /** Convert a p4bRunRow into an equivalent psMetadata
    7578  *
    7579  * @return A psMetadata pointer or NULL on error
    7580  */
    7581 
    7582 psMetadata *p4bRunMetadataFromObject(
    7583     const p4bRunRow *object             ///< fooRow to convert into a psMetadata
    7584 );
    7585 
    7586 /** Convert a psMetadata into an equivalent fooRow
    7587  *
    7588  * @return A p4bRunRow pointer or NULL on error
    7589  */
    7590 
    7591 p4bRunRow *p4bRunObjectFromMetadata(
    7592     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    7593 );
    7594 /** Selects up to limit rows from the database and returns as p4bRunRow objects in a psArray
    7595  *
    7596  *  See psDBSelectRows() for documentation on the format of where.
    7597  *
    7598  * @return A psArray pointer or NULL on error
    7599  */
    7600 
    7601 psArray *p4bRunSelectRowObjects(
    7602     psDB            *dbh,               ///< Database handle
    7603     const psMetadata *where,            ///< Row match criteria
    7604     unsigned long long limit            ///< Maximum number of elements to return
    7605 );
    7606 /** Deletes a row from the database coresponding to an p4bRun
    7607  *
    7608  *  Note that a 'where' search psMetadata is constructed from each object and
    7609  *  used to find rows to delete.
    7610  *
    7611  * @return A The number of rows removed or a negative value on error
    7612  */
    7613 
    7614 bool p4bRunDeleteObject(
    7615     psDB            *dbh,               ///< Database handle
    7616     const p4bRunRow *object    ///< Object to delete
    7617 );
    7618 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    7619  *
    7620  *  Note that a 'where' search psMetadata is constructed from each object and
    7621  *  used to find rows to delete.
    7622  *
    7623  * @return A The number of rows removed or a negative value on error
    7624  */
    7625 
    7626 long long p4bRunDeleteRowObjects(
    7627     psDB            *dbh,               ///< Database handle
    7628     const psArray   *objects,           ///< Array of objects to delete
    7629     unsigned long long limit            ///< Maximum number of elements to delete
    7630 );
    7631 /** Formats and prints an array of p4bRunRow objects
    7632  *
    7633  * When mdcf is set the formated output is in psMetadataConfig
    7634  * format, otherwise it is in a simple tabular format.
    7635  *
    7636  * @return true on success
    7637  */
    7638 
    7639 bool p4bRunPrintObjects(
    7640     FILE            *stream,            ///< a stream
    7641     psArray         *objects,           ///< An array of p4bRunRow objects
    7642     bool            mdcf                ///< format as mdconfig or simple
    7643 );
    7644 /** Formats and prints an p4bRunRow object
    7645  *
    7646  * When mdcf is set the formated output is in psMetadataConfig
    7647  * format, otherwise it is in a simple tabular format.
    7648  *
    7649  * @return true on success
    7650  */
    7651 
    7652 bool p4bRunPrintObject(
    7653     FILE            *stream,            ///< a stream
    7654     p4bRunRow *object,    ///< an p4bRunRow object
    7655     bool            mdcf                ///< format as mdconfig or simple
    7656 );
    7657 /** p4bInputScfileRow data structure
    7658  *
    7659  * Structure for representing a single row of p4bInputScfile table data.
     7459/** p4InputScfileRow data structure
     7460 *
     7461 * Structure for representing a single row of p4InputScfile table data.
    76607462 */
    76617463
    … …  
    76677469    psS32           p3_version;
    76687470    char            *kind;
    7669 } p4bInputScfileRow;
    7670 
    7671 /** Creates a new p4bInputScfileRow object
    7672  *
    7673  *  @return A new p4bInputScfileRow object or NULL on failure.
    7674  */
    7675 
    7676 p4bInputScfileRow *p4bInputScfileRowAlloc(
     7471} p4InputScfileRow;
     7472
     7473/** Creates a new p4InputScfileRow object
     7474 *
     7475 *  @return A new p4InputScfileRow object or NULL on failure.
     7476 */
     7477
     7478p4InputScfileRow *p4InputScfileRowAlloc(
    76777479    psS32           p4b_id,
    76787480    const char      *skycell_id,
    … …  
    76837485);
    76847486
    7685 /** Creates a new p4bInputScfile table
    7686  *
    7687  * @return true on success
    7688  */
    7689 
    7690 bool p4bInputScfileCreateTable(
     7487/** Creates a new p4InputScfile table
     7488 *
     7489 * @return true on success
     7490 */
     7491
     7492bool p4InputScfileCreateTable(
    76917493    psDB            *dbh                ///< Database handle
    76927494);
    76937495
    7694 /** Deletes a p4bInputScfile table
    7695  *
    7696  * @return true on success
    7697  */
    7698 
    7699 bool p4bInputScfileDropTable(
     7496/** Deletes a p4InputScfile table
     7497 *
     7498 * @return true on success
     7499 */
     7500
     7501bool p4InputScfileDropTable(
    77007502    psDB            *dbh                ///< Database handle
    77017503);
    … …  
    77087510 */
    77097511
    7710 bool p4bInputScfileInsert(
     7512bool p4InputScfileInsert(
    77117513    psDB            *dbh,               ///< Database handle
    77127514    psS32           p4b_id,
    … …  
    77237525 */
    77247526
    7725 long long p4bInputScfileDelete(
     7527long long p4InputScfileDelete(
    77267528    psDB            *dbh,               ///< Database handle
    77277529    const psMetadata *where,            ///< Row match criteria
    … …  
    77297531);
    77307532
    7731 /** Insert a single p4bInputScfileRow object into a table
     7533/** Insert a single p4InputScfileRow object into a table
    77327534 *
    77337535 * This function constructs and inserts a single row based on it's parameters.
    … …  
    77367538 */
    77377539
    7738 bool p4bInputScfileInsertObject(
    7739     psDB            *dbh,               ///< Database handle
    7740     p4bInputScfileRow *object             ///< p4bInputScfileRow object
    7741 );
    7742 
    7743 /** Insert an array of p4bInputScfileRow object into a table
     7540bool p4InputScfileInsertObject(
     7541    psDB            *dbh,               ///< Database handle
     7542    p4InputScfileRow *object             ///< p4InputScfileRow object
     7543);
     7544
     7545/** Insert an array of p4InputScfileRow object into a table
    77447546 *
    77457547 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    77487550 */
    77497551
    7750 bool p4bInputScfileInsertObjects(
    7751     psDB            *dbh,               ///< Database handle
    7752     psArray         *objects            ///< array of p4bInputScfileRow objects
    7753 );
    7754 
    7755 /** Insert data from a binary FITS table p4bInputScfileRow into the database
     7552bool p4InputScfileInsertObjects(
     7553    psDB            *dbh,               ///< Database handle
     7554    psArray         *objects            ///< array of p4InputScfileRow objects
     7555);
     7556
     7557/** Insert data from a binary FITS table p4InputScfileRow into the database
    77567558 *
    77577559 * This function expects a psFits object with a FITS table as the first
    … …  
    77637565 */
    77647566
    7765 bool p4bInputScfileInsertFits(
     7567bool p4InputScfileInsertFits(
    77667568    psDB            *dbh,               ///< Database handle
    77677569    const psFits    *fits               ///< psFits object
    … …  
    77787580 */
    77797581
    7780 bool p4bInputScfileSelectRowsFits(
     7582bool p4InputScfileSelectRowsFits(
    77817583    psDB            *dbh,               ///< Database handle
    77827584    psFits          *fits,              ///< psFits object
    … …  
    77857587);
    77867588
    7787 /** Convert a p4bInputScfileRow into an equivalent psMetadata
     7589/** Convert a p4InputScfileRow into an equivalent psMetadata
    77887590 *
    77897591 * @return A psMetadata pointer or NULL on error
    77907592 */
    77917593
    7792 psMetadata *p4bInputScfileMetadataFromObject(
    7793     const p4bInputScfileRow *object             ///< fooRow to convert into a psMetadata
     7594psMetadata *p4InputScfileMetadataFromObject(
     7595    const p4InputScfileRow *object             ///< fooRow to convert into a psMetadata
    77947596);
    77957597
    77967598/** Convert a psMetadata into an equivalent fooRow
    77977599 *
    7798  * @return A p4bInputScfileRow pointer or NULL on error
    7799  */
    7800 
    7801 p4bInputScfileRow *p4bInputScfileObjectFromMetadata(
     7600 * @return A p4InputScfileRow pointer or NULL on error
     7601 */
     7602
     7603p4InputScfileRow *p4InputScfileObjectFromMetadata(
    78027604    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    78037605);
    7804 /** Selects up to limit rows from the database and returns as p4bInputScfileRow objects in a psArray
     7606/** Selects up to limit rows from the database and returns as p4InputScfileRow objects in a psArray
    78057607 *
    78067608 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    78097611 */
    78107612
    7811 psArray *p4bInputScfileSelectRowObjects(
     7613psArray *p4InputScfileSelectRowObjects(
    78127614    psDB            *dbh,               ///< Database handle
    78137615    const psMetadata *where,            ///< Row match criteria
    78147616    unsigned long long limit            ///< Maximum number of elements to return
    78157617);
    7816 /** Deletes a row from the database coresponding to an p4bInputScfile
     7618/** Deletes a row from the database coresponding to an p4InputScfile
    78177619 *
    78187620 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    78227624 */
    78237625
    7824 bool p4bInputScfileDeleteObject(
    7825     psDB            *dbh,               ///< Database handle
    7826     const p4bInputScfileRow *object    ///< Object to delete
     7626bool p4InputScfileDeleteObject(
     7627    psDB            *dbh,               ///< Database handle
     7628    const p4InputScfileRow *object    ///< Object to delete
    78277629);
    78287630/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    78347636 */
    78357637
    7836 long long p4bInputScfileDeleteRowObjects(
     7638long long p4InputScfileDeleteRowObjects(
    78377639    psDB            *dbh,               ///< Database handle
    78387640    const psArray   *objects,           ///< Array of objects to delete
    78397641    unsigned long long limit            ///< Maximum number of elements to delete
    78407642);
    7841 /** Formats and prints an array of p4bInputScfileRow objects
     7643/** Formats and prints an array of p4InputScfileRow objects
    78427644 *
    78437645 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    78477649 */
    78487650
    7849 bool p4bInputScfilePrintObjects(
     7651bool p4InputScfilePrintObjects(
    78507652    FILE            *stream,            ///< a stream
    7851     psArray         *objects,           ///< An array of p4bInputScfileRow objects
     7653    psArray         *objects,           ///< An array of p4InputScfileRow objects
    78527654    bool            mdcf                ///< format as mdconfig or simple
    78537655);
    7854 /** Formats and prints an p4bInputScfileRow object
     7656/** Formats and prints an p4InputScfileRow object
    78557657 *
    78567658 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    78607662 */
    78617663
    7862 bool p4bInputScfilePrintObject(
     7664bool p4InputScfilePrintObject(
    78637665    FILE            *stream,            ///< a stream
    7864     p4bInputScfileRow *object,    ///< an p4bInputScfileRow object
     7666    p4InputScfileRow *object,    ///< an p4InputScfileRow object
    78657667    bool            mdcf                ///< format as mdconfig or simple
    78667668);
    7867 /** p4bDiffScfileRow data structure
    7868  *
    7869  * Structure for representing a single row of p4bDiffScfile table data.
     7669/** p4DiffScfileRow data structure
     7670 *
     7671 * Structure for representing a single row of p4DiffScfile table data.
    78707672 */
    78717673
    … …  
    78797681    psF64           bg;
    78807682    psF64           bg_mean_stdev;
    7881 } p4bDiffScfileRow;
    7882 
    7883 /** Creates a new p4bDiffScfileRow object
    7884  *
    7885  *  @return A new p4bDiffScfileRow object or NULL on failure.
    7886  */
    7887 
    7888 p4bDiffScfileRow *p4bDiffScfileRowAlloc(
     7683} p4DiffScfileRow;
     7684
     7685/** Creates a new p4DiffScfileRow object
     7686 *
     7687 *  @return A new p4DiffScfileRow object or NULL on failure.
     7688 */
     7689
     7690p4DiffScfileRow *p4DiffScfileRowAlloc(
    78897691    psS32           p4b_id,
    78907692    const char      *skycell_id,
    … …  
    78977699);
    78987700
    7899 /** Creates a new p4bDiffScfile table
    7900  *
    7901  * @return true on success
    7902  */
    7903 
    7904 bool p4bDiffScfileCreateTable(
     7701/** Creates a new p4DiffScfile table
     7702 *
     7703 * @return true on success
     7704 */
     7705
     7706bool p4DiffScfileCreateTable(
    79057707    psDB            *dbh                ///< Database handle
    79067708);
    79077709
    7908 /** Deletes a p4bDiffScfile table
    7909  *
    7910  * @return true on success
    7911  */
    7912 
    7913 bool p4bDiffScfileDropTable(
     7710/** Deletes a p4DiffScfile table
     7711 *
     7712 * @return true on success
     7713 */
     7714
     7715bool p4DiffScfileDropTable(
    79147716    psDB            *dbh                ///< Database handle
    79157717);
    … …  
    79227724 */
    79237725
    7924 bool p4bDiffScfileInsert(
     7726bool p4DiffScfileInsert(
    79257727    psDB            *dbh,               ///< Database handle
    79267728    psS32           p4b_id,
    … …  
    79397741 */
    79407742
    7941 long long p4bDiffScfileDelete(
     7743long long p4DiffScfileDelete(
    79427744    psDB            *dbh,               ///< Database handle
    79437745    const psMetadata *where,            ///< Row match criteria
    … …  
    79457747);
    79467748
    7947 /** Insert a single p4bDiffScfileRow object into a table
     7749/** Insert a single p4DiffScfileRow object into a table
    79487750 *
    79497751 * This function constructs and inserts a single row based on it's parameters.
    … …  
    79527754 */
    79537755
    7954 bool p4bDiffScfileInsertObject(
    7955     psDB            *dbh,               ///< Database handle
    7956     p4bDiffScfileRow *object             ///< p4bDiffScfileRow object
    7957 );
    7958 
    7959 /** Insert an array of p4bDiffScfileRow object into a table
     7756bool p4DiffScfileInsertObject(
     7757    psDB            *dbh,               ///< Database handle
     7758    p4DiffScfileRow *object             ///< p4DiffScfileRow object
     7759);
     7760
     7761/** Insert an array of p4DiffScfileRow object into a table
    79607762 *
    79617763 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    79647766 */
    79657767
    7966 bool p4bDiffScfileInsertObjects(
    7967     psDB            *dbh,               ///< Database handle
    7968     psArray         *objects            ///< array of p4bDiffScfileRow objects
    7969 );
    7970 
    7971 /** Insert data from a binary FITS table p4bDiffScfileRow into the database
     7768bool p4DiffScfileInsertObjects(
     7769    psDB            *dbh,               ///< Database handle
     7770    psArray         *objects            ///< array of p4DiffScfileRow objects
     7771);
     7772
     7773/** Insert data from a binary FITS table p4DiffScfileRow into the database
    79727774 *
    79737775 * This function expects a psFits object with a FITS table as the first
    … …  
    79797781 */
    79807782
    7981 bool p4bDiffScfileInsertFits(
     7783bool p4DiffScfileInsertFits(
    79827784    psDB            *dbh,               ///< Database handle
    79837785    const psFits    *fits               ///< psFits object
    … …  
    79947796 */
    79957797
    7996 bool p4bDiffScfileSelectRowsFits(
     7798bool p4DiffScfileSelectRowsFits(
    79977799    psDB            *dbh,               ///< Database handle
    79987800    psFits          *fits,              ///< psFits object
    … …  
    80017803);
    80027804
    8003 /** Convert a p4bDiffScfileRow into an equivalent psMetadata
     7805/** Convert a p4DiffScfileRow into an equivalent psMetadata
    80047806 *
    80057807 * @return A psMetadata pointer or NULL on error
    80067808 */
    80077809
    8008 psMetadata *p4bDiffScfileMetadataFromObject(
    8009     const p4bDiffScfileRow *object             ///< fooRow to convert into a psMetadata
     7810psMetadata *p4DiffScfileMetadataFromObject(
     7811    const p4DiffScfileRow *object             ///< fooRow to convert into a psMetadata
    80107812);
    80117813
    80127814/** Convert a psMetadata into an equivalent fooRow
    80137815 *
    8014  * @return A p4bDiffScfileRow pointer or NULL on error
    8015  */
    8016 
    8017 p4bDiffScfileRow *p4bDiffScfileObjectFromMetadata(
     7816 * @return A p4DiffScfileRow pointer or NULL on error
     7817 */
     7818
     7819p4DiffScfileRow *p4DiffScfileObjectFromMetadata(
    80187820    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    80197821);
    8020 /** Selects up to limit rows from the database and returns as p4bDiffScfileRow objects in a psArray
     7822/** Selects up to limit rows from the database and returns as p4DiffScfileRow objects in a psArray
    80217823 *
    80227824 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    80257827 */
    80267828
    8027 psArray *p4bDiffScfileSelectRowObjects(
     7829psArray *p4DiffScfileSelectRowObjects(
    80287830    psDB            *dbh,               ///< Database handle
    80297831    const psMetadata *where,            ///< Row match criteria
    80307832    unsigned long long limit            ///< Maximum number of elements to return
    80317833);
    8032 /** Deletes a row from the database coresponding to an p4bDiffScfile
     7834/** Deletes a row from the database coresponding to an p4DiffScfile
    80337835 *
    80347836 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    80387840 */
    80397841
    8040 bool p4bDiffScfileDeleteObject(
    8041     psDB            *dbh,               ///< Database handle
    8042     const p4bDiffScfileRow *object    ///< Object to delete
     7842bool p4DiffScfileDeleteObject(
     7843    psDB            *dbh,               ///< Database handle
     7844    const p4DiffScfileRow *object    ///< Object to delete
    80437845);
    80447846/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    80507852 */
    80517853
    8052 long long p4bDiffScfileDeleteRowObjects(
     7854long long p4DiffScfileDeleteRowObjects(
    80537855    psDB            *dbh,               ///< Database handle
    80547856    const psArray   *objects,           ///< Array of objects to delete
    80557857    unsigned long long limit            ///< Maximum number of elements to delete
    80567858);
    8057 /** Formats and prints an array of p4bDiffScfileRow objects
     7859/** Formats and prints an array of p4DiffScfileRow objects
    80587860 *
    80597861 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    80637865 */
    80647866
    8065 bool p4bDiffScfilePrintObjects(
     7867bool p4DiffScfilePrintObjects(
    80667868    FILE            *stream,            ///< a stream
    8067     psArray         *objects,           ///< An array of p4bDiffScfileRow objects
     7869    psArray         *objects,           ///< An array of p4DiffScfileRow objects
    80687870    bool            mdcf                ///< format as mdconfig or simple
    80697871);
    8070 /** Formats and prints an p4bDiffScfileRow object
     7872/** Formats and prints an p4DiffScfileRow object
    80717873 *
    80727874 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    80767878 */
    80777879
    8078 bool p4bDiffScfilePrintObject(
     7880bool p4DiffScfilePrintObject(
    80797881    FILE            *stream,            ///< a stream
    8080     p4bDiffScfileRow *object,    ///< an p4bDiffScfileRow object
    8081     bool            mdcf                ///< format as mdconfig or simple
    8082 );
    8083 /** p4cRunRow data structure
    8084  *
    8085  * Structure for representing a single row of p4cRun table data.
    8086  */
    8087 
    8088 typedef struct {
    8089     psS32           p4c_id;
    8090     char            *state;
    8091     char            *workdir;
    8092     bool            magic;
    8093 } p4cRunRow;
    8094 
    8095 /** Creates a new p4cRunRow object
    8096  *
    8097  *  @return A new p4cRunRow object or NULL on failure.
    8098  */
    8099 
    8100 p4cRunRow *p4cRunRowAlloc(
    8101     psS32           p4c_id,
    8102     const char      *state,
    8103     const char      *workdir,
    8104     bool            magic
    8105 );
    8106 
    8107 /** Creates a new p4cRun table
    8108  *
    8109  * @return true on success
    8110  */
    8111 
    8112 bool p4cRunCreateTable(
    8113     psDB            *dbh                ///< Database handle
    8114 );
    8115 
    8116 /** Deletes a p4cRun table
    8117  *
    8118  * @return true on success
    8119  */
    8120 
    8121 bool p4cRunDropTable(
    8122     psDB            *dbh                ///< Database handle
    8123 );
    8124 
    8125 /** Insert a single row into a table
    8126  *
    8127  * This function constructs and inserts a single row based on it's parameters.
    8128  *
    8129  * @return true on success
    8130  */
    8131 
    8132 bool p4cRunInsert(
    8133     psDB            *dbh,               ///< Database handle
    8134     psS32           p4c_id,
    8135     const char      *state,
    8136     const char      *workdir,
    8137     bool            magic
    8138 );
    8139 
    8140 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    8141  *
    8142  * @return A The number of rows removed or a negative value on error
    8143  */
    8144 
    8145 long long p4cRunDelete(
    8146     psDB            *dbh,               ///< Database handle
    8147     const psMetadata *where,            ///< Row match criteria
    8148     unsigned long long limit            ///< Maximum number of elements to delete
    8149 );
    8150 
    8151 /** Insert a single p4cRunRow object into a table
    8152  *
    8153  * This function constructs and inserts a single row based on it's parameters.
    8154  *
    8155  * @return true on success
    8156  */
    8157 
    8158 bool p4cRunInsertObject(
    8159     psDB            *dbh,               ///< Database handle
    8160     p4cRunRow       *object             ///< p4cRunRow object
    8161 );
    8162 
    8163 /** Insert an array of p4cRunRow object into a table
    8164  *
    8165  * This function constructs and inserts multiple rows based on it's parameters.
    8166  *
    8167  * @return true on success
    8168  */
    8169 
    8170 bool p4cRunInsertObjects(
    8171     psDB            *dbh,               ///< Database handle
    8172     psArray         *objects            ///< array of p4cRunRow objects
    8173 );
    8174 
    8175 /** Insert data from a binary FITS table p4cRunRow into the database
    8176  *
    8177  * This function expects a psFits object with a FITS table as the first
    8178  * extension.  The table must have at least one row of data in it, that is of
    8179  * the appropriate format (number of columns and their type).  All other
    8180  * extensions are ignored.
    8181  *
    8182  * @return true on success
    8183  */
    8184 
    8185 bool p4cRunInsertFits(
    8186     psDB            *dbh,               ///< Database handle
    8187     const psFits    *fits               ///< psFits object
    8188 );
    8189 
    8190 /** Selects up to limit from the database and returns them in a binary FITS table
    8191  *
    8192  * This function assumes an empty psFits object and will create a FITS table
    8193  * as the first extension.
    8194  *
    8195  *  See psDBSelectRows() for documentation on the format of where.
    8196  *
    8197  * @return true on success
    8198  */
    8199 
    8200 bool p4cRunSelectRowsFits(
    8201     psDB            *dbh,               ///< Database handle
    8202     psFits          *fits,              ///< psFits object
    8203     const psMetadata *where,            ///< Row match criteria
    8204     unsigned long long limit            ///< Maximum number of elements to return
    8205 );
    8206 
    8207 /** Convert a p4cRunRow into an equivalent psMetadata
    8208  *
    8209  * @return A psMetadata pointer or NULL on error
    8210  */
    8211 
    8212 psMetadata *p4cRunMetadataFromObject(
    8213     const p4cRunRow *object             ///< fooRow to convert into a psMetadata
    8214 );
    8215 
    8216 /** Convert a psMetadata into an equivalent fooRow
    8217  *
    8218  * @return A p4cRunRow pointer or NULL on error
    8219  */
    8220 
    8221 p4cRunRow *p4cRunObjectFromMetadata(
    8222     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    8223 );
    8224 /** Selects up to limit rows from the database and returns as p4cRunRow objects in a psArray
    8225  *
    8226  *  See psDBSelectRows() for documentation on the format of where.
    8227  *
    8228  * @return A psArray pointer or NULL on error
    8229  */
    8230 
    8231 psArray *p4cRunSelectRowObjects(
    8232     psDB            *dbh,               ///< Database handle
    8233     const psMetadata *where,            ///< Row match criteria
    8234     unsigned long long limit            ///< Maximum number of elements to return
    8235 );
    8236 /** Deletes a row from the database coresponding to an p4cRun
    8237  *
    8238  *  Note that a 'where' search psMetadata is constructed from each object and
    8239  *  used to find rows to delete.
    8240  *
    8241  * @return A The number of rows removed or a negative value on error
    8242  */
    8243 
    8244 bool p4cRunDeleteObject(
    8245     psDB            *dbh,               ///< Database handle
    8246     const p4cRunRow *object    ///< Object to delete
    8247 );
    8248 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    8249  *
    8250  *  Note that a 'where' search psMetadata is constructed from each object and
    8251  *  used to find rows to delete.
    8252  *
    8253  * @return A The number of rows removed or a negative value on error
    8254  */
    8255 
    8256 long long p4cRunDeleteRowObjects(
    8257     psDB            *dbh,               ///< Database handle
    8258     const psArray   *objects,           ///< Array of objects to delete
    8259     unsigned long long limit            ///< Maximum number of elements to delete
    8260 );
    8261 /** Formats and prints an array of p4cRunRow objects
    8262  *
    8263  * When mdcf is set the formated output is in psMetadataConfig
    8264  * format, otherwise it is in a simple tabular format.
    8265  *
    8266  * @return true on success
    8267  */
    8268 
    8269 bool p4cRunPrintObjects(
    8270     FILE            *stream,            ///< a stream
    8271     psArray         *objects,           ///< An array of p4cRunRow objects
    8272     bool            mdcf                ///< format as mdconfig or simple
    8273 );
    8274 /** Formats and prints an p4cRunRow object
    8275  *
    8276  * When mdcf is set the formated output is in psMetadataConfig
    8277  * format, otherwise it is in a simple tabular format.
    8278  *
    8279  * @return true on success
    8280  */
    8281 
    8282 bool p4cRunPrintObject(
    8283     FILE            *stream,            ///< a stream
    8284     p4cRunRow *object,    ///< an p4cRunRow object
    8285     bool            mdcf                ///< format as mdconfig or simple
    8286 );
    8287 /** p4cInputExpRow data structure
    8288  *
    8289  * Structure for representing a single row of p4cInputExp table data.
    8290  */
    8291 
    8292 typedef struct {
    8293     psS32           p4c_id;
    8294     char            *exp_tag;
    8295     psS32           p3_version;
    8296 } p4cInputExpRow;
    8297 
    8298 /** Creates a new p4cInputExpRow object
    8299  *
    8300  *  @return A new p4cInputExpRow object or NULL on failure.
    8301  */
    8302 
    8303 p4cInputExpRow *p4cInputExpRowAlloc(
    8304     psS32           p4c_id,
    8305     const char      *exp_tag,
    8306     psS32           p3_version
    8307 );
    8308 
    8309 /** Creates a new p4cInputExp table
    8310  *
    8311  * @return true on success
    8312  */
    8313 
    8314 bool p4cInputExpCreateTable(
    8315     psDB            *dbh                ///< Database handle
    8316 );
    8317 
    8318 /** Deletes a p4cInputExp table
    8319  *
    8320  * @return true on success
    8321  */
    8322 
    8323 bool p4cInputExpDropTable(
    8324     psDB            *dbh                ///< Database handle
    8325 );
    8326 
    8327 /** Insert a single row into a table
    8328  *
    8329  * This function constructs and inserts a single row based on it's parameters.
    8330  *
    8331  * @return true on success
    8332  */
    8333 
    8334 bool p4cInputExpInsert(
    8335     psDB            *dbh,               ///< Database handle
    8336     psS32           p4c_id,
    8337     const char      *exp_tag,
    8338     psS32           p3_version
    8339 );
    8340 
    8341 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    8342  *
    8343  * @return A The number of rows removed or a negative value on error
    8344  */
    8345 
    8346 long long p4cInputExpDelete(
    8347     psDB            *dbh,               ///< Database handle
    8348     const psMetadata *where,            ///< Row match criteria
    8349     unsigned long long limit            ///< Maximum number of elements to delete
    8350 );
    8351 
    8352 /** Insert a single p4cInputExpRow object into a table
    8353  *
    8354  * This function constructs and inserts a single row based on it's parameters.
    8355  *
    8356  * @return true on success
    8357  */
    8358 
    8359 bool p4cInputExpInsertObject(
    8360     psDB            *dbh,               ///< Database handle
    8361     p4cInputExpRow  *object             ///< p4cInputExpRow object
    8362 );
    8363 
    8364 /** Insert an array of p4cInputExpRow object into a table
    8365  *
    8366  * This function constructs and inserts multiple rows based on it's parameters.
    8367  *
    8368  * @return true on success
    8369  */
    8370 
    8371 bool p4cInputExpInsertObjects(
    8372     psDB            *dbh,               ///< Database handle
    8373     psArray         *objects            ///< array of p4cInputExpRow objects
    8374 );
    8375 
    8376 /** Insert data from a binary FITS table p4cInputExpRow into the database
    8377  *
    8378  * This function expects a psFits object with a FITS table as the first
    8379  * extension.  The table must have at least one row of data in it, that is of
    8380  * the appropriate format (number of columns and their type).  All other
    8381  * extensions are ignored.
    8382  *
    8383  * @return true on success
    8384  */
    8385 
    8386 bool p4cInputExpInsertFits(
    8387     psDB            *dbh,               ///< Database handle
    8388     const psFits    *fits               ///< psFits object
    8389 );
    8390 
    8391 /** Selects up to limit from the database and returns them in a binary FITS table
    8392  *
    8393  * This function assumes an empty psFits object and will create a FITS table
    8394  * as the first extension.
    8395  *
    8396  *  See psDBSelectRows() for documentation on the format of where.
    8397  *
    8398  * @return true on success
    8399  */
    8400 
    8401 bool p4cInputExpSelectRowsFits(
    8402     psDB            *dbh,               ///< Database handle
    8403     psFits          *fits,              ///< psFits object
    8404     const psMetadata *where,            ///< Row match criteria
    8405     unsigned long long limit            ///< Maximum number of elements to return
    8406 );
    8407 
    8408 /** Convert a p4cInputExpRow into an equivalent psMetadata
    8409  *
    8410  * @return A psMetadata pointer or NULL on error
    8411  */
    8412 
    8413 psMetadata *p4cInputExpMetadataFromObject(
    8414     const p4cInputExpRow *object             ///< fooRow to convert into a psMetadata
    8415 );
    8416 
    8417 /** Convert a psMetadata into an equivalent fooRow
    8418  *
    8419  * @return A p4cInputExpRow pointer or NULL on error
    8420  */
    8421 
    8422 p4cInputExpRow *p4cInputExpObjectFromMetadata(
    8423     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    8424 );
    8425 /** Selects up to limit rows from the database and returns as p4cInputExpRow objects in a psArray
    8426  *
    8427  *  See psDBSelectRows() for documentation on the format of where.
    8428  *
    8429  * @return A psArray pointer or NULL on error
    8430  */
    8431 
    8432 psArray *p4cInputExpSelectRowObjects(
    8433     psDB            *dbh,               ///< Database handle
    8434     const psMetadata *where,            ///< Row match criteria
    8435     unsigned long long limit            ///< Maximum number of elements to return
    8436 );
    8437 /** Deletes a row from the database coresponding to an p4cInputExp
    8438  *
    8439  *  Note that a 'where' search psMetadata is constructed from each object and
    8440  *  used to find rows to delete.
    8441  *
    8442  * @return A The number of rows removed or a negative value on error
    8443  */
    8444 
    8445 bool p4cInputExpDeleteObject(
    8446     psDB            *dbh,               ///< Database handle
    8447     const p4cInputExpRow *object    ///< Object to delete
    8448 );
    8449 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    8450  *
    8451  *  Note that a 'where' search psMetadata is constructed from each object and
    8452  *  used to find rows to delete.
    8453  *
    8454  * @return A The number of rows removed or a negative value on error
    8455  */
    8456 
    8457 long long p4cInputExpDeleteRowObjects(
    8458     psDB            *dbh,               ///< Database handle
    8459     const psArray   *objects,           ///< Array of objects to delete
    8460     unsigned long long limit            ///< Maximum number of elements to delete
    8461 );
    8462 /** Formats and prints an array of p4cInputExpRow objects
    8463  *
    8464  * When mdcf is set the formated output is in psMetadataConfig
    8465  * format, otherwise it is in a simple tabular format.
    8466  *
    8467  * @return true on success
    8468  */
    8469 
    8470 bool p4cInputExpPrintObjects(
    8471     FILE            *stream,            ///< a stream
    8472     psArray         *objects,           ///< An array of p4cInputExpRow objects
    8473     bool            mdcf                ///< format as mdconfig or simple
    8474 );
    8475 /** Formats and prints an p4cInputExpRow object
    8476  *
    8477  * When mdcf is set the formated output is in psMetadataConfig
    8478  * format, otherwise it is in a simple tabular format.
    8479  *
    8480  * @return true on success
    8481  */
    8482 
    8483 bool p4cInputExpPrintObject(
    8484     FILE            *stream,            ///< a stream
    8485     p4cInputExpRow *object,    ///< an p4cInputExpRow object
     7882    p4DiffScfileRow *object,    ///< an p4DiffScfileRow object
    84867883    bool            mdcf                ///< format as mdconfig or simple
    84877884);

  • trunk/ippdb/tests/alloc.c

    r11679 r11720  
    14081408
    14091409    {
    1410         p4aRunRow       *object;
    1411 
    1412         object = p4aRunRowAlloc(-32, "a string", "a string", true    );
     1410        p4RunRow        *object;
     1411
     1412        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "0001-01-01T00:00:00Z"    );
    14131413
    14141414        if (!object) {
    … …  
    14201420            exit(EXIT_FAILURE);
    14211421        }
     1422        if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) {
     1423            psFree(object);
     1424            exit(EXIT_FAILURE);
     1425        }
    14221426        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    14231427            psFree(object);
    … …  
    14281432            exit(EXIT_FAILURE);
    14291433        }
    1430         if (!object->magic == true) {
    1431             psFree(object);
    1432             exit(EXIT_FAILURE);
    1433         }
    1434 
    1435         psFree(object);
    1436     }
    1437 
    1438     {
    1439         p4aInputExpRow  *object;
    1440 
    1441         object = p4aInputExpRowAlloc(-32, "a string", -32    );
     1434            psFree(object);
     1435            exit(EXIT_FAILURE);
     1436        }
     1437
     1438        psFree(object);
     1439    }
     1440
     1441    {
     1442        p4InputExpRow   *object;
     1443
     1444        object = p4InputExpRowAlloc(-32, "a string", -32, true    );
    14421445
    14431446        if (!object) {
    … …  
    14571460            exit(EXIT_FAILURE);
    14581461        }
    1459 
    1460         psFree(object);
    1461     }
    1462 
    1463     {
    1464         p4aScfileRow    *object;
    1465 
    1466         object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
     1462        if (!object->magiced == true) {
     1463            psFree(object);
     1464            exit(EXIT_FAILURE);
     1465        }
     1466
     1467        psFree(object);
     1468    }
     1469
     1470    {
     1471        p4ScfileRow     *object;
     1472
     1473        object = p4ScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
    14671474
    14681475        if (!object) {
    … …  
    15071514
    15081515    {
    1509         p4bRunRow      *object;
    1510 
    1511         object = p4bRunRowAlloc(-32, "a string", "a string", true    );
     1516        p4InputScfileRow *object;
     1517
     1518        object = p4InputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string"    );
    15121519
    15131520        if (!object) {
    … …  
    15191526            exit(EXIT_FAILURE);
    15201527        }
    1521         if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    1522             psFree(object);
    1523             exit(EXIT_FAILURE);
    1524         }
    1525         if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
    1526             psFree(object);
    1527             exit(EXIT_FAILURE);
    1528         }
    1529         if (!object->magic == true) {
    1530             psFree(object);
    1531             exit(EXIT_FAILURE);
    1532         }
    1533 
    1534         psFree(object);
    1535     }
    1536 
    1537     {
    1538         p4bInputScfileRow *object;
    1539 
    1540         object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string"    );
     1528        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     1529            psFree(object);
     1530            exit(EXIT_FAILURE);
     1531        }
     1532        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     1533            psFree(object);
     1534            exit(EXIT_FAILURE);
     1535        }
     1536        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     1537            psFree(object);
     1538            exit(EXIT_FAILURE);
     1539        }
     1540        if (!object->p3_version == -32) {
     1541            psFree(object);
     1542            exit(EXIT_FAILURE);
     1543        }
     1544        if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
     1545            psFree(object);
     1546            exit(EXIT_FAILURE);
     1547        }
     1548
     1549        psFree(object);
     1550    }
     1551
     1552    {
     1553        p4DiffScfileRow *object;
     1554
     1555        object = p4DiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
    15411556
    15421557        if (!object) {
    … …  
    15641579            exit(EXIT_FAILURE);
    15651580        }
    1566         if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
    1567             psFree(object);
    1568             exit(EXIT_FAILURE);
    1569         }
    1570 
    1571         psFree(object);
    1572     }
    1573 
    1574     {
    1575         p4bDiffScfileRow *object;
    1576 
    1577         object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64    );
    1578 
    1579         if (!object) {
    1580             exit(EXIT_FAILURE);
    1581         }
    1582 
    1583         if (!object->p4b_id == -32) {
    1584             psFree(object);
    1585             exit(EXIT_FAILURE);
    1586         }
    1587         if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
    1588             psFree(object);
    1589             exit(EXIT_FAILURE);
    1590         }
    1591         if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
    1592             psFree(object);
    1593             exit(EXIT_FAILURE);
    1594         }
    1595         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1596             psFree(object);
    1597             exit(EXIT_FAILURE);
    1598         }
    1599         if (!object->p3_version == -32) {
    1600             psFree(object);
    1601             exit(EXIT_FAILURE);
    1602         }
    16031581        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    16041582            psFree(object);
    … …  
    16101588        }
    16111589        if (!object->bg_mean_stdev == 64.64) {
    1612             psFree(object);
    1613             exit(EXIT_FAILURE);
    1614         }
    1615 
    1616         psFree(object);
    1617     }
    1618 
    1619     {
    1620         p4cRunRow       *object;
    1621 
    1622         object = p4cRunRowAlloc(-32, "a string", "a string", true    );
    1623 
    1624         if (!object) {
    1625             exit(EXIT_FAILURE);
    1626         }
    1627 
    1628         if (!object->p4c_id == -32) {
    1629             psFree(object);
    1630             exit(EXIT_FAILURE);
    1631         }
    1632         if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    1633             psFree(object);
    1634             exit(EXIT_FAILURE);
    1635         }
    1636         if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
    1637             psFree(object);
    1638             exit(EXIT_FAILURE);
    1639         }
    1640         if (!object->magic == true) {
    1641             psFree(object);
    1642             exit(EXIT_FAILURE);
    1643         }
    1644 
    1645         psFree(object);
    1646     }
    1647 
    1648     {
    1649         p4cInputExpRow  *object;
    1650 
    1651         object = p4cInputExpRowAlloc(-32, "a string", -32    );
    1652 
    1653         if (!object) {
    1654             exit(EXIT_FAILURE);
    1655         }
    1656 
    1657         if (!object->p4c_id == -32) {
    1658             psFree(object);
    1659             exit(EXIT_FAILURE);
    1660         }
    1661         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    1662             psFree(object);
    1663             exit(EXIT_FAILURE);
    1664         }
    1665         if (!object->p3_version == -32) {
    16661590            psFree(object);
    16671591            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/createtable.c

    r11679 r11720  
    478478        }
    479479
    480         if(!p4aRunCreateTable(dbh)) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if(!p4aInputExpCreateTable(dbh)) {
    496             exit(EXIT_FAILURE);
    497         }
    498 
    499         psDBCleanup(dbh);
    500     }
    501 
    502     {
    503         psDB            *dbh;
    504 
    505         dbh = psDBInit("localhost", "test", NULL, "test");
    506         if (!dbh) {
    507             exit(EXIT_FAILURE);
    508         }
    509 
    510         if(!p4aScfileCreateTable(dbh)) {
    511             exit(EXIT_FAILURE);
    512         }
    513 
    514         psDBCleanup(dbh);
    515     }
    516 
    517     {
    518         psDB            *dbh;
    519 
    520         dbh = psDBInit("localhost", "test", NULL, "test");
    521         if (!dbh) {
    522             exit(EXIT_FAILURE);
    523         }
    524 
    525         if(!p4bRunCreateTable(dbh)) {
    526             exit(EXIT_FAILURE);
    527         }
    528 
    529         psDBCleanup(dbh);
    530     }
    531 
    532     {
    533         psDB            *dbh;
    534 
    535         dbh = psDBInit("localhost", "test", NULL, "test");
    536         if (!dbh) {
    537             exit(EXIT_FAILURE);
    538         }
    539 
    540         if(!p4bInputScfileCreateTable(dbh)) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if(!p4bDiffScfileCreateTable(dbh)) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if(!p4cRunCreateTable(dbh)) {
    571             exit(EXIT_FAILURE);
    572         }
    573 
    574         psDBCleanup(dbh);
    575     }
    576 
    577     {
    578         psDB            *dbh;
    579 
    580         dbh = psDBInit("localhost", "test", NULL, "test");
    581         if (!dbh) {
    582             exit(EXIT_FAILURE);
    583         }
    584 
    585         if(!p4cInputExpCreateTable(dbh)) {
     480        if(!p4RunCreateTable(dbh)) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if(!p4InputExpCreateTable(dbh)) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if(!p4ScfileCreateTable(dbh)) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if(!p4InputScfileCreateTable(dbh)) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if(!p4DiffScfileCreateTable(dbh)) {
    586541            exit(EXIT_FAILURE);
    587542        }

  • trunk/ippdb/tests/dbcleanup.c

    r11679 r11720  
    4242    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidExp");
    4343    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary");
    44     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aRun");
    45     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aInputExp");
    46     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aScfile");
    47     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bRun");
    48     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bInputScfile");
    49     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bDiffScfile");
    50     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cRun");
    51     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cInputExp");
     44    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
     45    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputExp");
     46    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Scfile");
     47    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputScfile");
     48    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffScfile");
    5249    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");
    5350    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS skyCell");

  • trunk/ippdb/tests/dbsetup.c

    r11679 r11720  
    106106    detRunSummaryCreateTable(dbh);
    107107
    108     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aRun");
    109     p4aRunCreateTable(dbh);
     108    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Run");
     109    p4RunCreateTable(dbh);
    110110
    111     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aInputExp");
    112     p4aInputExpCreateTable(dbh);
     111    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputExp");
     112    p4InputExpCreateTable(dbh);
    113113
    114     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4aScfile");
    115     p4aScfileCreateTable(dbh);
     114    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4Scfile");
     115    p4ScfileCreateTable(dbh);
    116116
    117     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bRun");
    118     p4bRunCreateTable(dbh);
     117    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputScfile");
     118    p4InputScfileCreateTable(dbh);
    119119
    120     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bInputScfile");
    121     p4bInputScfileCreateTable(dbh);
    122 
    123     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4bDiffScfile");
    124     p4bDiffScfileCreateTable(dbh);
    125 
    126     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cRun");
    127     p4cRunCreateTable(dbh);
    128 
    129     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4cInputExp");
    130     p4cInputExpCreateTable(dbh);
     120    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffScfile");
     121    p4DiffScfileCreateTable(dbh);
    131122
    132123    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile");

  • trunk/ippdb/tests/droptable.c

    r11679 r11720  
    478478        }
    479479
    480         if (!p4aRunDropTable(dbh)) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if (!p4aInputExpDropTable(dbh)) {
    496             exit(EXIT_FAILURE);
    497         }
    498 
    499         psDBCleanup(dbh);
    500     }
    501 
    502     {
    503         psDB            *dbh;
    504 
    505         dbh = psDBInit("localhost", "test", NULL, "test");
    506         if (!dbh) {
    507             exit(EXIT_FAILURE);
    508         }
    509 
    510         if (!p4aScfileDropTable(dbh)) {
    511             exit(EXIT_FAILURE);
    512         }
    513 
    514         psDBCleanup(dbh);
    515     }
    516 
    517     {
    518         psDB            *dbh;
    519 
    520         dbh = psDBInit("localhost", "test", NULL, "test");
    521         if (!dbh) {
    522             exit(EXIT_FAILURE);
    523         }
    524 
    525         if (!p4bRunDropTable(dbh)) {
    526             exit(EXIT_FAILURE);
    527         }
    528 
    529         psDBCleanup(dbh);
    530     }
    531 
    532     {
    533         psDB            *dbh;
    534 
    535         dbh = psDBInit("localhost", "test", NULL, "test");
    536         if (!dbh) {
    537             exit(EXIT_FAILURE);
    538         }
    539 
    540         if (!p4bInputScfileDropTable(dbh)) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if (!p4bDiffScfileDropTable(dbh)) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if (!p4cRunDropTable(dbh)) {
    571             exit(EXIT_FAILURE);
    572         }
    573 
    574         psDBCleanup(dbh);
    575     }
    576 
    577     {
    578         psDB            *dbh;
    579 
    580         dbh = psDBInit("localhost", "test", NULL, "test");
    581         if (!dbh) {
    582             exit(EXIT_FAILURE);
    583         }
    584 
    585         if (!p4cInputExpDropTable(dbh)) {
     480        if (!p4RunDropTable(dbh)) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4InputExpDropTable(dbh)) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if (!p4ScfileDropTable(dbh)) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if (!p4InputScfileDropTable(dbh)) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if (!p4DiffScfileDropTable(dbh)) {
    586541            exit(EXIT_FAILURE);
    587542        }

  • trunk/ippdb/tests/insert.c

    r11679 r11720  
    478478        }
    479479
    480         if (!p4aRunInsert(dbh, -32, "a string", "a string", true)) {
    481             exit(EXIT_FAILURE);
    482         }
    483 
    484         psDBCleanup(dbh);
    485     }
    486 
    487     {
    488         psDB            *dbh;
    489 
    490         dbh = psDBInit("localhost", "test", NULL, "test");
    491         if (!dbh) {
    492             exit(EXIT_FAILURE);
    493         }
    494 
    495         if (!p4aInputExpInsert(dbh, -32, "a string", -32)) {
    496             exit(EXIT_FAILURE);
    497         }
    498 
    499         psDBCleanup(dbh);
    500     }
    501 
    502     {
    503         psDB            *dbh;
    504 
    505         dbh = psDBInit("localhost", "test", NULL, "test");
    506         if (!dbh) {
    507             exit(EXIT_FAILURE);
    508         }
    509 
    510         if (!p4aScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
    511             exit(EXIT_FAILURE);
    512         }
    513 
    514         psDBCleanup(dbh);
    515     }
    516 
    517     {
    518         psDB            *dbh;
    519 
    520         dbh = psDBInit("localhost", "test", NULL, "test");
    521         if (!dbh) {
    522             exit(EXIT_FAILURE);
    523         }
    524 
    525         if (!p4bRunInsert(dbh, -32, "a string", "a string", true)) {
    526             exit(EXIT_FAILURE);
    527         }
    528 
    529         psDBCleanup(dbh);
    530     }
    531 
    532     {
    533         psDB            *dbh;
    534 
    535         dbh = psDBInit("localhost", "test", NULL, "test");
    536         if (!dbh) {
    537             exit(EXIT_FAILURE);
    538         }
    539 
    540         if (!p4bInputScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string")) {
    541             exit(EXIT_FAILURE);
    542         }
    543 
    544         psDBCleanup(dbh);
    545     }
    546 
    547     {
    548         psDB            *dbh;
    549 
    550         dbh = psDBInit("localhost", "test", NULL, "test");
    551         if (!dbh) {
    552             exit(EXIT_FAILURE);
    553         }
    554 
    555         if (!p4bDiffScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
    556             exit(EXIT_FAILURE);
    557         }
    558 
    559         psDBCleanup(dbh);
    560     }
    561 
    562     {
    563         psDB            *dbh;
    564 
    565         dbh = psDBInit("localhost", "test", NULL, "test");
    566         if (!dbh) {
    567             exit(EXIT_FAILURE);
    568         }
    569 
    570         if (!p4cRunInsert(dbh, -32, "a string", "a string", true)) {
    571             exit(EXIT_FAILURE);
    572         }
    573 
    574         psDBCleanup(dbh);
    575     }
    576 
    577     {
    578         psDB            *dbh;
    579 
    580         dbh = psDBInit("localhost", "test", NULL, "test");
    581         if (!dbh) {
    582             exit(EXIT_FAILURE);
    583         }
    584 
    585         if (!p4cInputExpInsert(dbh, -32, "a string", -32)) {
     480        if (!p4RunInsert(dbh, -32, "a string", "a string", "a string", "0001-01-01T00:00:00Z")) {
     481            exit(EXIT_FAILURE);
     482        }
     483
     484        psDBCleanup(dbh);
     485    }
     486
     487    {
     488        psDB            *dbh;
     489
     490        dbh = psDBInit("localhost", "test", NULL, "test");
     491        if (!dbh) {
     492            exit(EXIT_FAILURE);
     493        }
     494
     495        if (!p4InputExpInsert(dbh, -32, "a string", -32, true)) {
     496            exit(EXIT_FAILURE);
     497        }
     498
     499        psDBCleanup(dbh);
     500    }
     501
     502    {
     503        psDB            *dbh;
     504
     505        dbh = psDBInit("localhost", "test", NULL, "test");
     506        if (!dbh) {
     507            exit(EXIT_FAILURE);
     508        }
     509
     510        if (!p4ScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
     511            exit(EXIT_FAILURE);
     512        }
     513
     514        psDBCleanup(dbh);
     515    }
     516
     517    {
     518        psDB            *dbh;
     519
     520        dbh = psDBInit("localhost", "test", NULL, "test");
     521        if (!dbh) {
     522            exit(EXIT_FAILURE);
     523        }
     524
     525        if (!p4InputScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string")) {
     526            exit(EXIT_FAILURE);
     527        }
     528
     529        psDBCleanup(dbh);
     530    }
     531
     532    {
     533        psDB            *dbh;
     534
     535        dbh = psDBInit("localhost", "test", NULL, "test");
     536        if (!dbh) {
     537            exit(EXIT_FAILURE);
     538        }
     539
     540        if (!p4DiffScfileInsert(dbh, -32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64)) {
    586541            exit(EXIT_FAILURE);
    587542        }

  • trunk/ippdb/tests/insertfits.c

    r11679 r11720  
    830830        }
    831831
    832         if (!p4aRunInsertFits(dbh, fits)) {
    833             exit(EXIT_FAILURE);
    834         }
    835 
    836         if (!psFitsClose(fits)) {
    837             exit(EXIT_FAILURE);
    838         }
    839 
    840         psDBCleanup(dbh);
    841     }
    842 
    843     {
    844         psDB            *dbh;
    845         psFits          *fits;
    846 
    847         dbh = psDBInit("localhost", "test", NULL, "test");
    848         if (!dbh) {
    849             exit(EXIT_FAILURE);
    850         }
    851 
    852         // open a temp
    853         fits = psFitsOpen(TMP_FILENAME, "r");
    854         if (!fits) {
    855             exit(EXIT_FAILURE);
    856         }
    857 
    858         if (!p4aInputExpInsertFits(dbh, fits)) {
    859             exit(EXIT_FAILURE);
    860         }
    861 
    862         if (!psFitsClose(fits)) {
    863             exit(EXIT_FAILURE);
    864         }
    865 
    866         psDBCleanup(dbh);
    867     }
    868 
    869     {
    870         psDB            *dbh;
    871         psFits          *fits;
    872 
    873         dbh = psDBInit("localhost", "test", NULL, "test");
    874         if (!dbh) {
    875             exit(EXIT_FAILURE);
    876         }
    877 
    878         // open a temp
    879         fits = psFitsOpen(TMP_FILENAME, "r");
    880         if (!fits) {
    881             exit(EXIT_FAILURE);
    882         }
    883 
    884         if (!p4aScfileInsertFits(dbh, fits)) {
    885             exit(EXIT_FAILURE);
    886         }
    887 
    888         if (!psFitsClose(fits)) {
    889             exit(EXIT_FAILURE);
    890         }
    891 
    892         psDBCleanup(dbh);
    893     }
    894 
    895     {
    896         psDB            *dbh;
    897         psFits          *fits;
    898 
    899         dbh = psDBInit("localhost", "test", NULL, "test");
    900         if (!dbh) {
    901             exit(EXIT_FAILURE);
    902         }
    903 
    904         // open a temp
    905         fits = psFitsOpen(TMP_FILENAME, "r");
    906         if (!fits) {
    907             exit(EXIT_FAILURE);
    908         }
    909 
    910         if (!p4bRunInsertFits(dbh, fits)) {
    911             exit(EXIT_FAILURE);
    912         }
    913 
    914         if (!psFitsClose(fits)) {
    915             exit(EXIT_FAILURE);
    916         }
    917 
    918         psDBCleanup(dbh);
    919     }
    920 
    921     {
    922         psDB            *dbh;
    923         psFits          *fits;
    924 
    925         dbh = psDBInit("localhost", "test", NULL, "test");
    926         if (!dbh) {
    927             exit(EXIT_FAILURE);
    928         }
    929 
    930         // open a temp
    931         fits = psFitsOpen(TMP_FILENAME, "r");
    932         if (!fits) {
    933             exit(EXIT_FAILURE);
    934         }
    935 
    936         if (!p4bInputScfileInsertFits(dbh, fits)) {
    937             exit(EXIT_FAILURE);
    938         }
    939 
    940         if (!psFitsClose(fits)) {
    941             exit(EXIT_FAILURE);
    942         }
    943 
    944         psDBCleanup(dbh);
    945     }
    946 
    947     {
    948         psDB            *dbh;
    949         psFits          *fits;
    950 
    951         dbh = psDBInit("localhost", "test", NULL, "test");
    952         if (!dbh) {
    953             exit(EXIT_FAILURE);
    954         }
    955 
    956         // open a temp
    957         fits = psFitsOpen(TMP_FILENAME, "r");
    958         if (!fits) {
    959             exit(EXIT_FAILURE);
    960         }
    961 
    962         if (!p4bDiffScfileInsertFits(dbh, fits)) {
    963             exit(EXIT_FAILURE);
    964         }
    965 
    966         if (!psFitsClose(fits)) {
    967             exit(EXIT_FAILURE);
    968         }
    969 
    970         psDBCleanup(dbh);
    971     }
    972 
    973     {
    974         psDB            *dbh;
    975         psFits          *fits;
    976 
    977         dbh = psDBInit("localhost", "test", NULL, "test");
    978         if (!dbh) {
    979             exit(EXIT_FAILURE);
    980         }
    981 
    982         // open a temp
    983         fits = psFitsOpen(TMP_FILENAME, "r");
    984         if (!fits) {
    985             exit(EXIT_FAILURE);
    986         }
    987 
    988         if (!p4cRunInsertFits(dbh, fits)) {
    989             exit(EXIT_FAILURE);
    990         }
    991 
    992         if (!psFitsClose(fits)) {
    993             exit(EXIT_FAILURE);
    994         }
    995 
    996         psDBCleanup(dbh);
    997     }
    998 
    999     {
    1000         psDB            *dbh;
    1001         psFits          *fits;
    1002 
    1003         dbh = psDBInit("localhost", "test", NULL, "test");
    1004         if (!dbh) {
    1005             exit(EXIT_FAILURE);
    1006         }
    1007 
    1008         // open a temp
    1009         fits = psFitsOpen(TMP_FILENAME, "r");
    1010         if (!fits) {
    1011             exit(EXIT_FAILURE);
    1012         }
    1013 
    1014         if (!p4cInputExpInsertFits(dbh, fits)) {
     832        if (!p4RunInsertFits(dbh, fits)) {
     833            exit(EXIT_FAILURE);
     834        }
     835
     836        if (!psFitsClose(fits)) {
     837            exit(EXIT_FAILURE);
     838        }
     839
     840        psDBCleanup(dbh);
     841    }
     842
     843    {
     844        psDB            *dbh;
     845        psFits          *fits;
     846
     847        dbh = psDBInit("localhost", "test", NULL, "test");
     848        if (!dbh) {
     849            exit(EXIT_FAILURE);
     850        }
     851
     852        // open a temp
     853        fits = psFitsOpen(TMP_FILENAME, "r");
     854        if (!fits) {
     855            exit(EXIT_FAILURE);
     856        }
     857
     858        if (!p4InputExpInsertFits(dbh, fits)) {
     859            exit(EXIT_FAILURE);
     860        }
     861
     862        if (!psFitsClose(fits)) {
     863            exit(EXIT_FAILURE);
     864        }
     865
     866        psDBCleanup(dbh);
     867    }
     868
     869    {
     870        psDB            *dbh;
     871        psFits          *fits;
     872
     873        dbh = psDBInit("localhost", "test", NULL, "test");
     874        if (!dbh) {
     875            exit(EXIT_FAILURE);
     876        }
     877
     878        // open a temp
     879        fits = psFitsOpen(TMP_FILENAME, "r");
     880        if (!fits) {
     881            exit(EXIT_FAILURE);
     882        }
     883
     884        if (!p4ScfileInsertFits(dbh, fits)) {
     885            exit(EXIT_FAILURE);
     886        }
     887
     888        if (!psFitsClose(fits)) {
     889            exit(EXIT_FAILURE);
     890        }
     891
     892        psDBCleanup(dbh);
     893    }
     894
     895    {
     896        psDB            *dbh;
     897        psFits          *fits;
     898
     899        dbh = psDBInit("localhost", "test", NULL, "test");
     900        if (!dbh) {
     901            exit(EXIT_FAILURE);
     902        }
     903
     904        // open a temp
     905        fits = psFitsOpen(TMP_FILENAME, "r");
     906        if (!fits) {
     907            exit(EXIT_FAILURE);
     908        }
     909
     910        if (!p4InputScfileInsertFits(dbh, fits)) {
     911            exit(EXIT_FAILURE);
     912        }
     913
     914        if (!psFitsClose(fits)) {
     915            exit(EXIT_FAILURE);
     916        }
     917
     918        psDBCleanup(dbh);
     919    }
     920
     921    {
     922        psDB            *dbh;
     923        psFits          *fits;
     924
     925        dbh = psDBInit("localhost", "test", NULL, "test");
     926        if (!dbh) {
     927            exit(EXIT_FAILURE);
     928        }
     929
     930        // open a temp
     931        fits = psFitsOpen(TMP_FILENAME, "r");
     932        if (!fits) {
     933            exit(EXIT_FAILURE);
     934        }
     935
     936        if (!p4DiffScfileInsertFits(dbh, fits)) {
    1015937            exit(EXIT_FAILURE);
    1016938        }

  • trunk/ippdb/tests/insertobject.c

    r11679 r11720  
    689689    {
    690690        psDB            *dbh;
    691         p4aRunRow       *object;
    692 
    693         dbh = psDBInit("localhost", "test", NULL, "test");
    694         if (!dbh) {
    695             exit(EXIT_FAILURE);
    696         }
    697 
    698         object = p4aRunRowAlloc(-32, "a string", "a string", true);
    699         if (!object) {
    700             exit(EXIT_FAILURE);
    701         }
    702 
    703         if (!p4aRunInsertObject(dbh, object)) {
    704             exit(EXIT_FAILURE);
    705         }
    706 
    707         psFree(object);
    708         psDBCleanup(dbh);
    709     }
    710 
    711     {
    712         psDB            *dbh;
    713         p4aInputExpRow  *object;
    714 
    715         dbh = psDBInit("localhost", "test", NULL, "test");
    716         if (!dbh) {
    717             exit(EXIT_FAILURE);
    718         }
    719 
    720         object = p4aInputExpRowAlloc(-32, "a string", -32);
    721         if (!object) {
    722             exit(EXIT_FAILURE);
    723         }
    724 
    725         if (!p4aInputExpInsertObject(dbh, object)) {
    726             exit(EXIT_FAILURE);
    727         }
    728 
    729         psFree(object);
    730         psDBCleanup(dbh);
    731     }
    732 
    733     {
    734         psDB            *dbh;
    735         p4aScfileRow    *object;
    736 
    737         dbh = psDBInit("localhost", "test", NULL, "test");
    738         if (!dbh) {
    739             exit(EXIT_FAILURE);
    740         }
    741 
    742         object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
    743         if (!object) {
    744             exit(EXIT_FAILURE);
    745         }
    746 
    747         if (!p4aScfileInsertObject(dbh, object)) {
    748             exit(EXIT_FAILURE);
    749         }
    750 
    751         psFree(object);
    752         psDBCleanup(dbh);
    753     }
    754 
    755     {
    756         psDB            *dbh;
    757         p4bRunRow       *object;
    758 
    759         dbh = psDBInit("localhost", "test", NULL, "test");
    760         if (!dbh) {
    761             exit(EXIT_FAILURE);
    762         }
    763 
    764         object = p4bRunRowAlloc(-32, "a string", "a string", true);
    765         if (!object) {
    766             exit(EXIT_FAILURE);
    767         }
    768 
    769         if (!p4bRunInsertObject(dbh, object)) {
    770             exit(EXIT_FAILURE);
    771         }
    772 
    773         psFree(object);
    774         psDBCleanup(dbh);
    775     }
    776 
    777     {
    778         psDB            *dbh;
    779         p4bInputScfileRow *object;
    780 
    781         dbh = psDBInit("localhost", "test", NULL, "test");
    782         if (!dbh) {
    783             exit(EXIT_FAILURE);
    784         }
    785 
    786         object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
    787         if (!object) {
    788             exit(EXIT_FAILURE);
    789         }
    790 
    791         if (!p4bInputScfileInsertObject(dbh, object)) {
    792             exit(EXIT_FAILURE);
    793         }
    794 
    795         psFree(object);
    796         psDBCleanup(dbh);
    797     }
    798 
    799     {
    800         psDB            *dbh;
    801         p4bDiffScfileRow *object;
    802 
    803         dbh = psDBInit("localhost", "test", NULL, "test");
    804         if (!dbh) {
    805             exit(EXIT_FAILURE);
    806         }
    807 
    808         object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
    809         if (!object) {
    810             exit(EXIT_FAILURE);
    811         }
    812 
    813         if (!p4bDiffScfileInsertObject(dbh, object)) {
    814             exit(EXIT_FAILURE);
    815         }
    816 
    817         psFree(object);
    818         psDBCleanup(dbh);
    819     }
    820 
    821     {
    822         psDB            *dbh;
    823         p4cRunRow       *object;
    824 
    825         dbh = psDBInit("localhost", "test", NULL, "test");
    826         if (!dbh) {
    827             exit(EXIT_FAILURE);
    828         }
    829 
    830         object = p4cRunRowAlloc(-32, "a string", "a string", true);
    831         if (!object) {
    832             exit(EXIT_FAILURE);
    833         }
    834 
    835         if (!p4cRunInsertObject(dbh, object)) {
    836             exit(EXIT_FAILURE);
    837         }
    838 
    839         psFree(object);
    840         psDBCleanup(dbh);
    841     }
    842 
    843     {
    844         psDB            *dbh;
    845         p4cInputExpRow  *object;
    846 
    847         dbh = psDBInit("localhost", "test", NULL, "test");
    848         if (!dbh) {
    849             exit(EXIT_FAILURE);
    850         }
    851 
    852         object = p4cInputExpRowAlloc(-32, "a string", -32);
    853         if (!object) {
    854             exit(EXIT_FAILURE);
    855         }
    856 
    857         if (!p4cInputExpInsertObject(dbh, object)) {
     691        p4RunRow        *object;
     692
     693        dbh = psDBInit("localhost", "test", NULL, "test");
     694        if (!dbh) {
     695            exit(EXIT_FAILURE);
     696        }
     697
     698        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "0001-01-01T00:00:00Z");
     699        if (!object) {
     700            exit(EXIT_FAILURE);
     701        }
     702
     703        if (!p4RunInsertObject(dbh, object)) {
     704            exit(EXIT_FAILURE);
     705        }
     706
     707        psFree(object);
     708        psDBCleanup(dbh);
     709    }
     710
     711    {
     712        psDB            *dbh;
     713        p4InputExpRow   *object;
     714
     715        dbh = psDBInit("localhost", "test", NULL, "test");
     716        if (!dbh) {
     717            exit(EXIT_FAILURE);
     718        }
     719
     720        object = p4InputExpRowAlloc(-32, "a string", -32, true);
     721        if (!object) {
     722            exit(EXIT_FAILURE);
     723        }
     724
     725        if (!p4InputExpInsertObject(dbh, object)) {
     726            exit(EXIT_FAILURE);
     727        }
     728
     729        psFree(object);
     730        psDBCleanup(dbh);
     731    }
     732
     733    {
     734        psDB            *dbh;
     735        p4ScfileRow     *object;
     736
     737        dbh = psDBInit("localhost", "test", NULL, "test");
     738        if (!dbh) {
     739            exit(EXIT_FAILURE);
     740        }
     741
     742        object = p4ScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     743        if (!object) {
     744            exit(EXIT_FAILURE);
     745        }
     746
     747        if (!p4ScfileInsertObject(dbh, object)) {
     748            exit(EXIT_FAILURE);
     749        }
     750
     751        psFree(object);
     752        psDBCleanup(dbh);
     753    }
     754
     755    {
     756        psDB            *dbh;
     757        p4InputScfileRow *object;
     758
     759        dbh = psDBInit("localhost", "test", NULL, "test");
     760        if (!dbh) {
     761            exit(EXIT_FAILURE);
     762        }
     763
     764        object = p4InputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
     765        if (!object) {
     766            exit(EXIT_FAILURE);
     767        }
     768
     769        if (!p4InputScfileInsertObject(dbh, object)) {
     770            exit(EXIT_FAILURE);
     771        }
     772
     773        psFree(object);
     774        psDBCleanup(dbh);
     775    }
     776
     777    {
     778        psDB            *dbh;
     779        p4DiffScfileRow *object;
     780
     781        dbh = psDBInit("localhost", "test", NULL, "test");
     782        if (!dbh) {
     783            exit(EXIT_FAILURE);
     784        }
     785
     786        object = p4DiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     787        if (!object) {
     788            exit(EXIT_FAILURE);
     789        }
     790
     791        if (!p4DiffScfileInsertObject(dbh, object)) {
    858792            exit(EXIT_FAILURE);
    859793        }

  • trunk/ippdb/tests/metadatafromobject.c

    r11679 r11720  
    16431643    {
    16441644        psMetadata      *md;
    1645         p4aRunRow       *object;
    1646         bool            status;
    1647 
    1648         object = p4aRunRowAlloc(-32, "a string", "a string", true);
    1649         if (!object) {
    1650             exit(EXIT_FAILURE);
    1651         }
    1652 
    1653         md = p4aRunMetadataFromObject(object);
     1645        p4RunRow        *object;
     1646        bool            status;
     1647
     1648        object = p4RunRowAlloc(-32, "a string", "a string", "a string", "0001-01-01T00:00:00Z");
     1649        if (!object) {
     1650            exit(EXIT_FAILURE);
     1651        }
     1652
     1653        md = p4RunMetadataFromObject(object);
    16541654        if (!md) {
    16551655            exit(EXIT_FAILURE);
    … …  
    16621662            exit(EXIT_FAILURE);
    16631663        }
     1664        if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) {
     1665            psFree(md);
     1666            exit(EXIT_FAILURE);
     1667        }
    16641668        if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    16651669            psFree(md);
    … …  
    16701674            exit(EXIT_FAILURE);
    16711675        }
    1672         if (!psMetadataLookupBool(&status, md, "magic") == true) {
    1673             psFree(md);
    1674             exit(EXIT_FAILURE);
    1675         }
    1676 
    1677         psFree(md);
    1678     }
    1679 
    1680     {
    1681         psMetadata      *md;
    1682         p4aInputExpRow  *object;
    1683         bool            status;
    1684 
    1685         object = p4aInputExpRowAlloc(-32, "a string", -32);
    1686         if (!object) {
    1687             exit(EXIT_FAILURE);
    1688         }
    1689 
    1690         md = p4aInputExpMetadataFromObject(object);
     1676            psFree(md);
     1677            exit(EXIT_FAILURE);
     1678        }
     1679
     1680        psFree(md);
     1681    }
     1682
     1683    {
     1684        psMetadata      *md;
     1685        p4InputExpRow   *object;
     1686        bool            status;
     1687
     1688        object = p4InputExpRowAlloc(-32, "a string", -32, true);
     1689        if (!object) {
     1690            exit(EXIT_FAILURE);
     1691        }
     1692
     1693        md = p4InputExpMetadataFromObject(object);
    16911694        if (!md) {
    16921695            exit(EXIT_FAILURE);
    … …  
    17071710            exit(EXIT_FAILURE);
    17081711        }
    1709 
    1710         psFree(md);
    1711     }
    1712 
    1713     {
    1714         psMetadata      *md;
    1715         p4aScfileRow    *object;
    1716         bool            status;
    1717 
    1718         object = p4aScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
    1719         if (!object) {
    1720             exit(EXIT_FAILURE);
    1721         }
    1722 
    1723         md = p4aScfileMetadataFromObject(object);
     1712        if (!psMetadataLookupBool(&status, md, "magiced") == true) {
     1713            psFree(md);
     1714            exit(EXIT_FAILURE);
     1715        }
     1716
     1717        psFree(md);
     1718    }
     1719
     1720    {
     1721        psMetadata      *md;
     1722        p4ScfileRow     *object;
     1723        bool            status;
     1724
     1725        object = p4ScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     1726        if (!object) {
     1727            exit(EXIT_FAILURE);
     1728        }
     1729
     1730        md = p4ScfileMetadataFromObject(object);
    17241731        if (!md) {
    17251732            exit(EXIT_FAILURE);
    … …  
    17661773    {
    17671774        psMetadata      *md;
    1768         p4bRunRow      *object;
    1769         bool            status;
    1770 
    1771         object = p4bRunRowAlloc(-32, "a string", "a string", true);
    1772         if (!object) {
    1773             exit(EXIT_FAILURE);
    1774         }
    1775 
    1776         md = p4bRunMetadataFromObject(object);
     1775        p4InputScfileRow *object;
     1776        bool            status;
     1777
     1778        object = p4InputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
     1779        if (!object) {
     1780            exit(EXIT_FAILURE);
     1781        }
     1782
     1783        md = p4InputScfileMetadataFromObject(object);
    17771784        if (!md) {
    17781785            exit(EXIT_FAILURE);
    … …  
    17851792            exit(EXIT_FAILURE);
    17861793        }
    1787         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1788             psFree(md);
    1789             exit(EXIT_FAILURE);
    1790         }
    1791         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1792             psFree(md);
    1793             exit(EXIT_FAILURE);
    1794         }
    1795         if (!psMetadataLookupBool(&status, md, "magic") == true) {
    1796             psFree(md);
    1797             exit(EXIT_FAILURE);
    1798         }
    1799 
    1800         psFree(md);
    1801     }
    1802 
    1803     {
    1804         psMetadata      *md;
    1805         p4bInputScfileRow *object;
    1806         bool            status;
    1807 
    1808         object = p4bInputScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string");
    1809         if (!object) {
    1810             exit(EXIT_FAILURE);
    1811         }
    1812 
    1813         md = p4bInputScfileMetadataFromObject(object);
     1794        if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
     1795            psFree(md);
     1796            exit(EXIT_FAILURE);
     1797        }
     1798        if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
     1799            psFree(md);
     1800            exit(EXIT_FAILURE);
     1801        }
     1802        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     1803            psFree(md);
     1804            exit(EXIT_FAILURE);
     1805        }
     1806        if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
     1807            psFree(md);
     1808            exit(EXIT_FAILURE);
     1809        }
     1810        if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) {
     1811            psFree(md);
     1812            exit(EXIT_FAILURE);
     1813        }
     1814
     1815        psFree(md);
     1816    }
     1817
     1818    {
     1819        psMetadata      *md;
     1820        p4DiffScfileRow *object;
     1821        bool            status;
     1822
     1823        object = p4DiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
     1824        if (!object) {
     1825            exit(EXIT_FAILURE);
     1826        }
     1827
     1828        md = p4DiffScfileMetadataFromObject(object);
    18141829        if (!md) {
    18151830            exit(EXIT_FAILURE);
    … …  
    18381853            exit(EXIT_FAILURE);
    18391854        }
    1840         if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) {
    1841             psFree(md);
    1842             exit(EXIT_FAILURE);
    1843         }
    1844 
    1845         psFree(md);
    1846     }
    1847 
    1848     {
    1849         psMetadata      *md;
    1850         p4bDiffScfileRow *object;
    1851         bool            status;
    1852 
    1853         object = p4bDiffScfileRowAlloc(-32, "a string", "a string", "a string", -32, "a string", 64.64, 64.64);
    1854         if (!object) {
    1855             exit(EXIT_FAILURE);
    1856         }
    1857 
    1858         md = p4bDiffScfileMetadataFromObject(object);
    1859         if (!md) {
    1860             exit(EXIT_FAILURE);
    1861         }
    1862 
    1863         psFree(object);
    1864 
    1865         if (!psMetadataLookupS32(&status, md, "p4b_id") == -32) {
    1866             psFree(md);
    1867             exit(EXIT_FAILURE);
    1868         }
    1869         if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) {
    1870             psFree(md);
    1871             exit(EXIT_FAILURE);
    1872         }
    1873         if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) {
    1874             psFree(md);
    1875             exit(EXIT_FAILURE);
    1876         }
    1877         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    1878             psFree(md);
    1879             exit(EXIT_FAILURE);
    1880         }
    1881         if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
    1882             psFree(md);
    1883             exit(EXIT_FAILURE);
    1884         }
    18851855        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    18861856            psFree(md);
    … …  
    18921862        }
    18931863        if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    1894             psFree(md);
    1895             exit(EXIT_FAILURE);
    1896         }
    1897 
    1898         psFree(md);
    1899     }
    1900 
    1901     {
    1902         psMetadata      *md;
    1903         p4cRunRow       *object;
    1904         bool            status;
    1905 
    1906         object = p4cRunRowAlloc(-32, "a string", "a string", true);
    1907         if (!object) {
    1908             exit(EXIT_FAILURE);
    1909         }
    1910 
    1911         md = p4cRunMetadataFromObject(object);
    1912         if (!md) {
    1913             exit(EXIT_FAILURE);
    1914         }
    1915 
    1916         psFree(object);
    1917 
    1918         if (!psMetadataLookupS32(&status, md, "p4c_id") == -32) {
    1919             psFree(md);
    1920             exit(EXIT_FAILURE);
    1921         }
    1922         if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) {
    1923             psFree(md);
    1924             exit(EXIT_FAILURE);
    1925         }
    1926         if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) {
    1927             psFree(md);
    1928             exit(EXIT_FAILURE);
    1929         }
    1930         if (!psMetadataLookupBool(&status, md, "magic") == true) {
    1931             psFree(md);
    1932             exit(EXIT_FAILURE);
    1933         }
    1934 
    1935         psFree(md);
    1936     }
    1937 
    1938     {
    1939         psMetadata      *md;
    1940         p4cInputExpRow  *object;
    1941         bool            status;
    1942 
    1943         object = p4cInputExpRowAlloc(-32, "a string", -32);
    1944         if (!object) {
    1945             exit(EXIT_FAILURE);
    1946         }
    1947 
    1948         md = p4cInputExpMetadataFromObject(object);
    1949         if (!md) {
    1950             exit(EXIT_FAILURE);
    1951         }
    1952 
    1953         psFree(object);
    1954 
    1955         if (!psMetadataLookupS32(&status, md, "p4c_id") == -32) {
    1956             psFree(md);
    1957             exit(EXIT_FAILURE);
    1958         }
    1959         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    1960             psFree(md);
    1961             exit(EXIT_FAILURE);
    1962         }
    1963         if (!psMetadataLookupS32(&status, md, "p3_version") == -32) {
    19641864            psFree(md);
    19651865            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r11679 r11720  
    25322532    {
    25332533        psMetadata      *md;
    2534         p4aRunRow       *object;
     2534        p4RunRow        *object;
    25352535
    25362536        md = psMetadataAlloc();
    … …  
    25392539            exit(EXIT_FAILURE);
    25402540        }
     2541        if (!psMetadataAddStr(md, PS_LIST_TAIL, "mode", 0, NULL, "a string")) {
     2542            psFree(md);
     2543            exit(EXIT_FAILURE);
     2544        }
    25412545        if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
    25422546            psFree(md);
    … …  
    25472551            exit(EXIT_FAILURE);
    25482552        }
    2549         if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
    2550             psFree(md);
    2551             exit(EXIT_FAILURE);
    2552         }
    2553 
    2554         object = p4aRunObjectFromMetadata(md);
     2553            psFree(md);
     2554            exit(EXIT_FAILURE);
     2555        }
     2556
     2557        object = p4RunObjectFromMetadata(md);
    25552558        if (!object) {
    25562559            psFree(md);
    … …  
    25642567            exit(EXIT_FAILURE);
    25652568        }
     2569        if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) {
     2570            psFree(object);
     2571            exit(EXIT_FAILURE);
     2572        }
    25662573        if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    25672574            psFree(object);
    … …  
    25722579            exit(EXIT_FAILURE);
    25732580        }
    2574         if (!object->magic == true) {
    2575             psFree(object);
    2576             exit(EXIT_FAILURE);
    2577         }
    2578 
    2579         psFree(object);
    2580     }
    2581 
    2582     {
    2583         psMetadata      *md;
    2584         p4aInputExpRow  *object;
     2581            psFree(object);
     2582            exit(EXIT_FAILURE);
     2583        }
     2584
     2585        psFree(object);
     2586    }
     2587
     2588    {
     2589        psMetadata      *md;
     2590        p4InputExpRow   *object;
    25852591
    25862592        md = psMetadataAlloc();
    … …  
    25972603            exit(EXIT_FAILURE);
    25982604        }
    2599 
    2600         object = p4aInputExpObjectFromMetadata(md);
     2605        if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, true)) {
     2606            psFree(md);
     2607            exit(EXIT_FAILURE);
     2608        }
     2609
     2610        object = p4InputExpObjectFromMetadata(md);
    26012611        if (!object) {
    26022612            psFree(md);
    … …  
    26182628            exit(EXIT_FAILURE);
    26192629        }
    2620 
    2621         psFree(object);
    2622     }
    2623 
    2624     {
    2625         psMetadata      *md;
    2626         p4aScfileRow    *object;
     2630        if (!object->magiced == true) {
     2631            psFree(object);
     2632            exit(EXIT_FAILURE);
     2633        }
     2634
     2635        psFree(object);
     2636    }
     2637
     2638    {
     2639        psMetadata      *md;
     2640        p4ScfileRow     *object;
    26272641
    26282642        md = psMetadataAlloc();
    … …  
    26602674        }
    26612675
    2662         object = p4aScfileObjectFromMetadata(md);
     2676        object = p4ScfileObjectFromMetadata(md);
    26632677        if (!object) {
    26642678            psFree(md);
    … …  
    27062720    {
    27072721        psMetadata      *md;
    2708         p4bRunRow      *object;
     2722        p4InputScfileRow *object;
    27092723
    27102724        md = psMetadataAlloc();
    … …  
    27132727            exit(EXIT_FAILURE);
    27142728        }
    2715         if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
    2716             psFree(md);
    2717             exit(EXIT_FAILURE);
    2718         }
    2719         if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) {
    2720             psFree(md);
    2721             exit(EXIT_FAILURE);
    2722         }
    2723         if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
    2724             psFree(md);
    2725             exit(EXIT_FAILURE);
    2726         }
    2727 
    2728         object = p4bRunObjectFromMetadata(md);
     2729        if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
     2730            psFree(md);
     2731            exit(EXIT_FAILURE);
     2732        }
     2733        if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
     2734            psFree(md);
     2735            exit(EXIT_FAILURE);
     2736        }
     2737        if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
     2738            psFree(md);
     2739            exit(EXIT_FAILURE);
     2740        }
     2741        if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
     2742            psFree(md);
     2743            exit(EXIT_FAILURE);
     2744        }
     2745        if (!psMetadataAddStr(md, PS_LIST_TAIL, "kind", 0, NULL, "a string")) {
     2746            psFree(md);
     2747            exit(EXIT_FAILURE);
     2748        }
     2749
     2750        object = p4InputScfileObjectFromMetadata(md);
    27292751        if (!object) {
    27302752            psFree(md);
    … …  
    27382760            exit(EXIT_FAILURE);
    27392761        }
    2740         if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    2741             psFree(object);
    2742             exit(EXIT_FAILURE);
    2743         }
    2744         if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
    2745             psFree(object);
    2746             exit(EXIT_FAILURE);
    2747         }
    2748         if (!object->magic == true) {
    2749             psFree(object);
    2750             exit(EXIT_FAILURE);
    2751         }
    2752 
    2753         psFree(object);
    2754     }
    2755 
    2756     {
    2757         psMetadata      *md;
    2758         p4bInputScfileRow *object;
     2762        if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
     2763            psFree(object);
     2764            exit(EXIT_FAILURE);
     2765        }
     2766        if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
     2767            psFree(object);
     2768            exit(EXIT_FAILURE);
     2769        }
     2770        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     2771            psFree(object);
     2772            exit(EXIT_FAILURE);
     2773        }
     2774        if (!object->p3_version == -32) {
     2775            psFree(object);
     2776            exit(EXIT_FAILURE);
     2777        }
     2778        if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
     2779            psFree(object);
     2780            exit(EXIT_FAILURE);
     2781        }
     2782
     2783        psFree(object);
     2784    }
     2785
     2786    {
     2787        psMetadata      *md;
     2788        p4DiffScfileRow *object;
    27592789
    27602790        md = psMetadataAlloc();
    … …  
    27792809            exit(EXIT_FAILURE);
    27802810        }
    2781         if (!psMetadataAddStr(md, PS_LIST_TAIL, "kind", 0, NULL, "a string")) {
    2782             psFree(md);
    2783             exit(EXIT_FAILURE);
    2784         }
    2785 
    2786         object = p4bInputScfileObjectFromMetadata(md);
     2811        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
     2812            psFree(md);
     2813            exit(EXIT_FAILURE);
     2814        }
     2815        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
     2816            psFree(md);
     2817            exit(EXIT_FAILURE);
     2818        }
     2819        if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
     2820            psFree(md);
     2821            exit(EXIT_FAILURE);
     2822        }
     2823
     2824        object = p4DiffScfileObjectFromMetadata(md);
    27872825        if (!object) {
    27882826            psFree(md);
    … …  
    28122850            exit(EXIT_FAILURE);
    28132851        }
    2814         if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) {
    2815             psFree(object);
    2816             exit(EXIT_FAILURE);
    2817         }
    2818 
    2819         psFree(object);
    2820     }
    2821 
    2822     {
    2823         psMetadata      *md;
    2824         p4bDiffScfileRow *object;
    2825 
    2826         md = psMetadataAlloc();
    2827         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4b_id", 0, NULL, -32)) {
    2828             psFree(md);
    2829             exit(EXIT_FAILURE);
    2830         }
    2831         if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) {
    2832             psFree(md);
    2833             exit(EXIT_FAILURE);
    2834         }
    2835         if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) {
    2836             psFree(md);
    2837             exit(EXIT_FAILURE);
    2838         }
    2839         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    2840             psFree(md);
    2841             exit(EXIT_FAILURE);
    2842         }
    2843         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
    2844             psFree(md);
    2845             exit(EXIT_FAILURE);
    2846         }
    2847         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    2848             psFree(md);
    2849             exit(EXIT_FAILURE);
    2850         }
    2851         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    2852             psFree(md);
    2853             exit(EXIT_FAILURE);
    2854         }
    2855         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
    2856             psFree(md);
    2857             exit(EXIT_FAILURE);
    2858         }
    2859 
    2860         object = p4bDiffScfileObjectFromMetadata(md);
    2861         if (!object) {
    2862             psFree(md);
    2863             exit(EXIT_FAILURE);
    2864         }
    2865 
    2866         psFree(md);
    2867 
    2868         if (!object->p4b_id == -32) {
    2869             psFree(object);
    2870             exit(EXIT_FAILURE);
    2871         }
    2872         if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) {
    2873             psFree(object);
    2874             exit(EXIT_FAILURE);
    2875         }
    2876         if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) {
    2877             psFree(object);
    2878             exit(EXIT_FAILURE);
    2879         }
    2880         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    2881             psFree(object);
    2882             exit(EXIT_FAILURE);
    2883         }
    2884         if (!object->p3_version == -32) {
    2885             psFree(object);
    2886             exit(EXIT_FAILURE);
    2887         }
    28882852        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    28892853            psFree(object);
    … …  
    28952859        }
    28962860        if (!object->bg_mean_stdev == 64.64) {
    2897             psFree(object);
    2898             exit(EXIT_FAILURE);
    2899         }
    2900 
    2901         psFree(object);
    2902     }
    2903 
    2904     {
    2905         psMetadata      *md;
    2906         p4cRunRow       *object;
    2907 
    2908         md = psMetadataAlloc();
    2909         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4c_id", 0, NULL, -32)) {
    2910             psFree(md);
    2911             exit(EXIT_FAILURE);
    2912         }
    2913         if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) {
    2914             psFree(md);
    2915             exit(EXIT_FAILURE);
    2916         }
    2917         if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) {
    2918             psFree(md);
    2919             exit(EXIT_FAILURE);
    2920         }
    2921         if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, true)) {
    2922             psFree(md);
    2923             exit(EXIT_FAILURE);
    2924         }
    2925 
    2926         object = p4cRunObjectFromMetadata(md);
    2927         if (!object) {
    2928             psFree(md);
    2929             exit(EXIT_FAILURE);
    2930         }
    2931 
    2932         psFree(md);
    2933 
    2934         if (!object->p4c_id == -32) {
    2935             psFree(object);
    2936             exit(EXIT_FAILURE);
    2937         }
    2938         if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) {
    2939             psFree(object);
    2940             exit(EXIT_FAILURE);
    2941         }
    2942         if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) {
    2943             psFree(object);
    2944             exit(EXIT_FAILURE);
    2945         }
    2946         if (!object->magic == true) {
    2947             psFree(object);
    2948             exit(EXIT_FAILURE);
    2949         }
    2950 
    2951         psFree(object);
    2952     }
    2953 
    2954     {
    2955         psMetadata      *md;
    2956         p4cInputExpRow  *object;
    2957 
    2958         md = psMetadataAlloc();
    2959         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4c_id", 0, NULL, -32)) {
    2960             psFree(md);
    2961             exit(EXIT_FAILURE);
    2962         }
    2963         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    2964             psFree(md);
    2965             exit(EXIT_FAILURE);
    2966         }
    2967         if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) {
    2968             psFree(md);
    2969             exit(EXIT_FAILURE);
    2970         }
    2971 
    2972         object = p4cInputExpObjectFromMetadata(md);
    2973         if (!object) {
    2974             psFree(md);
    2975             exit(EXIT_FAILURE);
    2976         }
    2977 
    2978         psFree(md);
    2979 
    2980         if (!object->p4c_id == -32) {
    2981             psFree(object);
    2982             exit(EXIT_FAILURE);
    2983         }
    2984         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    2985             psFree(object);
    2986             exit(EXIT_FAILURE);
    2987         }
    2988         if (!object->p3_version == -32) {
    29892861            psFree(object);
    29902862            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/selectrowsfits.c

    r11679 r11720  
    703703        }
    704704
    705         if (!p4aRunSelectRowsFits(dbh, fits, NULL, 1)) {
    706             exit(EXIT_FAILURE);
    707         }
    708 
    709         psFree(fits);
    710         psDBCleanup(dbh);
    711     }
    712 
    713     {
    714         psDB            *dbh;
    715         psFits          *fits;
    716 
    717         dbh = psDBInit("localhost", "test", NULL, "test");
    718         if (!dbh) {
    719             exit(EXIT_FAILURE);
    720         }
    721 
    722         fits = psFitsOpen(TMP_FILENAME, "w");
    723         if (!fits) {
    724             exit(EXIT_FAILURE);
    725         }
    726 
    727         if (!p4aInputExpSelectRowsFits(dbh, fits, NULL, 1)) {
    728             exit(EXIT_FAILURE);
    729         }
    730 
    731         psFree(fits);
    732         psDBCleanup(dbh);
    733     }
    734 
    735     {
    736         psDB            *dbh;
    737         psFits          *fits;
    738 
    739         dbh = psDBInit("localhost", "test", NULL, "test");
    740         if (!dbh) {
    741             exit(EXIT_FAILURE);
    742         }
    743 
    744         fits = psFitsOpen(TMP_FILENAME, "w");
    745         if (!fits) {
    746             exit(EXIT_FAILURE);
    747         }
    748 
    749         if (!p4aScfileSelectRowsFits(dbh, fits, NULL, 1)) {
    750             exit(EXIT_FAILURE);
    751         }
    752 
    753         psFree(fits);
    754         psDBCleanup(dbh);
    755     }
    756 
    757     {
    758         psDB            *dbh;
    759         psFits          *fits;
    760 
    761         dbh = psDBInit("localhost", "test", NULL, "test");
    762         if (!dbh) {
    763             exit(EXIT_FAILURE);
    764         }
    765 
    766         fits = psFitsOpen(TMP_FILENAME, "w");
    767         if (!fits) {
    768             exit(EXIT_FAILURE);
    769         }
    770 
    771         if (!p4bRunSelectRowsFits(dbh, fits, NULL, 1)) {
    772             exit(EXIT_FAILURE);
    773         }
    774 
    775         psFree(fits);
    776         psDBCleanup(dbh);
    777     }
    778 
    779     {
    780         psDB            *dbh;
    781         psFits          *fits;
    782 
    783         dbh = psDBInit("localhost", "test", NULL, "test");
    784         if (!dbh) {
    785             exit(EXIT_FAILURE);
    786         }
    787 
    788         fits = psFitsOpen(TMP_FILENAME, "w");
    789         if (!fits) {
    790             exit(EXIT_FAILURE);
    791         }
    792 
    793         if (!p4bInputScfileSelectRowsFits(dbh, fits, NULL, 1)) {
    794             exit(EXIT_FAILURE);
    795         }
    796 
    797         psFree(fits);
    798         psDBCleanup(dbh);
    799     }
    800 
    801     {
    802         psDB            *dbh;
    803         psFits          *fits;
    804 
    805         dbh = psDBInit("localhost", "test", NULL, "test");
    806         if (!dbh) {
    807             exit(EXIT_FAILURE);
    808         }
    809 
    810         fits = psFitsOpen(TMP_FILENAME, "w");
    811         if (!fits) {
    812             exit(EXIT_FAILURE);
    813         }
    814 
    815         if (!p4bDiffScfileSelectRowsFits(dbh, fits, NULL, 1)) {
    816             exit(EXIT_FAILURE);
    817         }
    818 
    819         psFree(fits);
    820         psDBCleanup(dbh);
    821     }
    822 
    823     {
    824         psDB            *dbh;
    825         psFits          *fits;
    826 
    827         dbh = psDBInit("localhost", "test", NULL, "test");
    828         if (!dbh) {
    829             exit(EXIT_FAILURE);
    830         }
    831 
    832         fits = psFitsOpen(TMP_FILENAME, "w");
    833         if (!fits) {
    834             exit(EXIT_FAILURE);
    835         }
    836 
    837         if (!p4cRunSelectRowsFits(dbh, fits, NULL, 1)) {
    838             exit(EXIT_FAILURE);
    839         }
    840 
    841         psFree(fits);
    842         psDBCleanup(dbh);
    843     }
    844 
    845     {
    846         psDB            *dbh;
    847         psFits          *fits;
    848 
    849         dbh = psDBInit("localhost", "test", NULL, "test");
    850         if (!dbh) {
    851             exit(EXIT_FAILURE);
    852         }
    853 
    854         fits = psFitsOpen(TMP_FILENAME, "w");
    855         if (!fits) {
    856             exit(EXIT_FAILURE);
    857         }
    858 
    859         if (!p4cInputExpSelectRowsFits(dbh, fits, NULL, 1)) {
     705        if (!p4RunSelectRowsFits(dbh, fits, NULL, 1)) {
     706            exit(EXIT_FAILURE);
     707        }
     708
     709        psFree(fits);
     710        psDBCleanup(dbh);
     711    }
     712
     713    {
     714        psDB            *dbh;
     715        psFits          *fits;
     716
     717        dbh = psDBInit("localhost", "test", NULL, "test");
     718        if (!dbh) {
     719            exit(EXIT_FAILURE);
     720        }
     721
     722        fits = psFitsOpen(TMP_FILENAME, "w");
     723        if (!fits) {
     724            exit(EXIT_FAILURE);
     725        }
     726
     727        if (!p4InputExpSelectRowsFits(dbh, fits, NULL, 1)) {
     728            exit(EXIT_FAILURE);
     729        }
     730
     731        psFree(fits);
     732        psDBCleanup(dbh);
     733    }
     734
     735    {
     736        psDB            *dbh;
     737        psFits          *fits;
     738
     739        dbh = psDBInit("localhost", "test", NULL, "test");
     740        if (!dbh) {
     741            exit(EXIT_FAILURE);
     742        }
     743
     744        fits = psFitsOpen(TMP_FILENAME, "w");
     745        if (!fits) {
     746            exit(EXIT_FAILURE);
     747        }
     748
     749        if (!p4ScfileSelectRowsFits(dbh, fits, NULL, 1)) {
     750            exit(EXIT_FAILURE);
     751        }
     752
     753        psFree(fits);
     754        psDBCleanup(dbh);
     755    }
     756
     757    {
     758        psDB            *dbh;
     759        psFits          *fits;
     760
     761        dbh = psDBInit("localhost", "test", NULL, "test");
     762        if (!dbh) {
     763            exit(EXIT_FAILURE);
     764        }
     765
     766        fits = psFitsOpen(TMP_FILENAME, "w");
     767        if (!fits) {
     768            exit(EXIT_FAILURE);
     769        }
     770
     771        if (!p4InputScfileSelectRowsFits(dbh, fits, NULL, 1)) {
     772            exit(EXIT_FAILURE);
     773        }
     774
     775        psFree(fits);
     776        psDBCleanup(dbh);
     777    }
     778
     779    {
     780        psDB            *dbh;
     781        psFits          *fits;
     782
     783        dbh = psDBInit("localhost", "test", NULL, "test");
     784        if (!dbh) {
     785            exit(EXIT_FAILURE);
     786        }
     787
     788        fits = psFitsOpen(TMP_FILENAME, "w");
     789        if (!fits) {
     790            exit(EXIT_FAILURE);
     791        }
     792
     793        if (!p4DiffScfileSelectRowsFits(dbh, fits, NULL, 1)) {
    860794            exit(EXIT_FAILURE);
    861795        }
Note: See TracChangeset for help on using the changeset viewer.