IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 21, 2007, 4:29:12 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.10

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r11873 r11988  
    6565#define P4INPUTEXP_TABLE_NAME "p4InputExp"
    6666#define P4SKYCELLMAP_TABLE_NAME "p4SkyCellMap"
    67 #define P4SCFILE_TABLE_NAME "p4Scfile"
     67#define P4SKYFILE_TABLE_NAME "p4Skyfile"
    6868#define P5RUN_TABLE_NAME "p5Run"
    69 #define P5INPUTSCFILE_TABLE_NAME "p5InputScfile"
    70 #define P5DIFFSCFILE_TABLE_NAME "p5DiffScfile"
     69#define P5INPUTSKYFILE_TABLE_NAME "p5InputSkyfile"
     70#define P5DIFFSKYFILE_TABLE_NAME "p5DiffSkyfile"
    7171#define P6RUN_TABLE_NAME "p6Run"
    72 #define P6INPUTSCFILE_TABLE_NAME "p6InputScfile"
    73 #define P6SUMSCFILE_TABLE_NAME "p6SumScfile"
     72#define P6INPUTSKYFILE_TABLE_NAME "p6InputSkyfile"
     73#define P6SUMSKYFILE_TABLE_NAME "p6SumSkyfile"
    7474#define MAX_STRING_LENGTH 1024
    7575
    … …  
    1484614846    return true;
    1484714847}
    14848 static void p4ScfileRowFree(p4ScfileRow *object);
    14849 
    14850 p4ScfileRow *p4ScfileRowAlloc(psS32 p4_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)
    14851 {
    14852     p4ScfileRow     *_object;
    14853 
    14854     _object = psAlloc(sizeof(p4ScfileRow));
    14855     psMemSetDeallocator(_object, (psFreeFunc)p4ScfileRowFree);
     14848static void p4SkyfileRowFree(p4SkyfileRow *object);
     14849
     14850p4SkyfileRow *p4SkyfileRowAlloc(psS32 p4_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14851{
     14852    p4SkyfileRow    *_object;
     14853
     14854    _object = psAlloc(sizeof(p4SkyfileRow));
     14855    psMemSetDeallocator(_object, (psFreeFunc)p4SkyfileRowFree);
    1485614856
    1485714857    _object->p4_id = p4_id;
    1485814858    _object->skycell_id = psStringCopy(skycell_id);
    1485914859    _object->tess_id = psStringCopy(tess_id);
    14860     _object->exp_tag = psStringCopy(exp_tag);
    14861     _object->p3_version = p3_version;
    1486214860    _object->uri = psStringCopy(uri);
    1486314861    _object->bg = bg;
    … …  
    1486714865}
    1486814866
    14869 static void p4ScfileRowFree(p4ScfileRow *object)
     14867static void p4SkyfileRowFree(p4SkyfileRow *object)
    1487014868{
    1487114869    psFree(object->skycell_id);
    1487214870    psFree(object->tess_id);
    14873     psFree(object->exp_tag);
    1487414871    psFree(object->uri);
    1487514872}
    1487614873
    14877 bool p4ScfileCreateTable(psDB *dbh)
     14874bool p4SkyfileCreateTable(psDB *dbh)
    1487814875{
    1487914876    psMetadata *md = psMetadataAlloc();
    … …  
    1489314890        return false;
    1489414891    }
    14895     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Key", "64")) {
    14896         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14897         psFree(md);
    14898         return false;
    14899     }
    14900     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Key", 0)) {
    14901         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    14902         psFree(md);
    14903         return false;
    14904     }
    1490514892    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1490614893        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1491914906    }
    1492014907
    14921     bool status = psDBCreateTable(dbh, P4SCFILE_TABLE_NAME, md);
     14908    bool status = psDBCreateTable(dbh, P4SKYFILE_TABLE_NAME, md);
    1492214909
    1492314910    psFree(md);
    … …  
    1492614913}
    1492714914
    14928 bool p4ScfileDropTable(psDB *dbh)
    14929 {
    14930     return psDBDropTable(dbh, P4SCFILE_TABLE_NAME);
    14931 }
    14932 
    14933 bool p4ScfileInsert(psDB * dbh, psS32 p4_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)
     14915bool p4SkyfileDropTable(psDB *dbh)
     14916{
     14917    return psDBDropTable(dbh, P4SKYFILE_TABLE_NAME);
     14918}
     14919
     14920bool p4SkyfileInsert(psDB * dbh, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1493414921{
    1493514922    psMetadata *md = psMetadataAlloc();
    … …  
    1494914936        return false;
    1495014937    }
    14951     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    14952         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14953         psFree(md);
    14954         return false;
    14955     }
    14956     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    14957         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    14958         psFree(md);
    14959         return false;
    14960     }
    1496114938    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1496214939        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1497514952    }
    1497614953
    14977     bool status = psDBInsertOneRow(dbh, P4SCFILE_TABLE_NAME, md);
     14954    bool status = psDBInsertOneRow(dbh, P4SKYFILE_TABLE_NAME, md);
    1497814955    psFree(md);
    1497914956
    … …  
    1498114958}
    1498214959
    14983 long long p4ScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14960long long p4SkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1498414961{
    1498514962    long long       deleted = 0;
    1498614963
    14987     long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     14964    long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
    1498814965    if (count < 0) {
    14989         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
     14966        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
    1499014967        return count;
    1499114968
    … …  
    1499514972    return deleted;
    1499614973}
    14997 bool p4ScfileInsertObject(psDB *dbh, p4ScfileRow *object)
    14998 {
    14999     return p4ScfileInsert(dbh, object->p4_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
    15000 }
    15001 
    15002 bool p4ScfileInsertObjects(psDB *dbh, psArray *objects)
     14974bool p4SkyfileInsertObject(psDB *dbh, p4SkyfileRow *object)
     14975{
     14976    return p4SkyfileInsert(dbh, object->p4_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev);
     14977}
     14978
     14979bool p4SkyfileInsertObjects(psDB *dbh, psArray *objects)
    1500314980{
    1500414981    for (long i = 0; i < psArrayLength(objects); i++) {
    15005         if (!p4ScfileInsertObject(dbh, objects->data[i])) {
     14982        if (!p4SkyfileInsertObject(dbh, objects->data[i])) {
    1500614983            return false;
    1500714984        }
    … …  
    1501114988}
    1501214989
    15013 bool p4ScfileInsertFits(psDB *dbh, const psFits *fits)
     14990bool p4SkyfileInsertFits(psDB *dbh, const psFits *fits)
    1501414991{
    1501514992    psArray         *rowSet;
    1501614993
    15017     // move to (the first?) extension named  P4SCFILE_TABLE_NAME
    15018     if (!psFitsMoveExtName(fits, P4SCFILE_TABLE_NAME)) {
    15019         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4SCFILE_TABLE_NAME);
     14994    // move to (the first?) extension named  P4SKYFILE_TABLE_NAME
     14995    if (!psFitsMoveExtName(fits, P4SKYFILE_TABLE_NAME)) {
     14996        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4SKYFILE_TABLE_NAME);
    1502014997        return false;
    1502114998    }
    … …  
    1503515012    }
    1503615013
    15037     if (!psDBInsertRows(dbh, P4SCFILE_TABLE_NAME, rowSet)) {
     15014    if (!psDBInsertRows(dbh, P4SKYFILE_TABLE_NAME, rowSet)) {
    1503815015        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1503915016        psFree(rowSet);
    … …  
    1504615023}
    1504715024
    15048 bool p4ScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15025bool p4SkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1504915026{
    1505015027    psArray         *rowSet;
    1505115028
    15052     rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     15029    rowSet = psDBSelectRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
    1505315030    if (!rowSet) {
    1505415031        return false;
    … …  
    1505615033
    1505715034    // output to fits
    15058     if (!psFitsWriteTable(fits, NULL, rowSet, P4SCFILE_TABLE_NAME)) {
     15035    if (!psFitsWriteTable(fits, NULL, rowSet, P4SKYFILE_TABLE_NAME)) {
    1505915036        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1506015037        psFree(rowSet);
    … …  
    1506715044}
    1506815045
    15069 psMetadata *p4ScfileMetadataFromObject(const p4ScfileRow *object)
     15046psMetadata *p4SkyfileMetadataFromObject(const p4SkyfileRow *object)
    1507015047{
    1507115048    psMetadata *md = psMetadataAlloc();
    … …  
    1508515062        return false;
    1508615063    }
    15087     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    15088         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    15089         psFree(md);
    15090         return false;
    15091     }
    15092     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    15093         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    15094         psFree(md);
    15095         return false;
    15096     }
    1509715064    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    1509815065        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1511515082}
    1511615083
    15117 p4ScfileRow *p4ScfileObjectFromMetadata(psMetadata *md)
     15084p4SkyfileRow *p4SkyfileObjectFromMetadata(psMetadata *md)
    1511815085{
    1511915086
    … …  
    1513415101        return false;
    1513515102    }
    15136     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    15137     if (!status) {
    15138         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    15139         return false;
    15140     }
    15141     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    15142     if (!status) {
    15143         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    15144         return false;
    15145     }
    1514615103    char* uri = psMetadataLookupPtr(&status, md, "uri");
    1514715104    if (!status) {
    … …  
    1516015117    }
    1516115118
    15162     return p4ScfileRowAlloc(p4_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
    15163 }
    15164 psArray *p4ScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15119    return p4SkyfileRowAlloc(p4_id, skycell_id, tess_id, uri, bg, bg_mean_stdev);
     15120}
     15121psArray *p4SkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1516515122{
    1516615123    psArray         *rowSet;
    … …  
    1516815125    psU64           i;
    1516915126
    15170     rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     15127    rowSet = psDBSelectRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
    1517115128    if (!rowSet) {
    1517215129        return NULL;
    … …  
    1517815135
    1517915136    for (i = 0; i < rowSet->n; i++) {
    15180         p4ScfileRow *object = p4ScfileObjectFromMetadata(rowSet->data[i]);
     15137        p4SkyfileRow *object = p4SkyfileObjectFromMetadata(rowSet->data[i]);
    1518115138        psArrayAdd(returnSet, 0, object);
    1518215139        psFree(object);
    … …  
    1518715144    return returnSet;
    1518815145}
    15189 bool p4ScfileDeleteObject(psDB *dbh, const p4ScfileRow *object)
    15190 {
    15191     psMetadata *where = p4ScfileMetadataFromObject(object);
    15192     long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, 0);
     15146bool p4SkyfileDeleteObject(psDB *dbh, const p4SkyfileRow *object)
     15147{
     15148    psMetadata *where = p4SkyfileMetadataFromObject(object);
     15149    long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, 0);
    1519315150    psFree(where);
    1519415151    if (count < 0) {
    15195         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
     15152        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
    1519615153        return false;
    1519715154    }
    … …  
    1519915156        // XXX should this be a psAbort() instead?  It is possible that
    1520015157        // having an object match multiple rows was by design.
    15201         psError(PS_ERR_UNKNOWN, true, "p4ScfileRow object matched more then one row.  Check your database schema");
    15202         return false;
    15203     }
    15204 
    15205     return true;
    15206 }
    15207 long long p4ScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15158        psError(PS_ERR_UNKNOWN, true, "p4SkyfileRow object matched more then one row.  Check your database schema");
     15159        return false;
     15160    }
     15161
     15162    return true;
     15163}
     15164long long p4SkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1520815165{
    1520915166    long long       deleted = 0;
    1521015167
    1521115168    for (long long i = 0; i < objects->n; i++) {
    15212         p4ScfileRow *object = objects->data[i];
    15213         psMetadata *where = p4ScfileMetadataFromObject(object);
    15214         long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     15169        p4SkyfileRow *object = objects->data[i];
     15170        psMetadata *where = p4SkyfileMetadataFromObject(object);
     15171        long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
    1521515172        psFree(where);
    1521615173        if (count < 0) {
    15217             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
     15174            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
    1521815175            return count;
    1521915176        }
    … …  
    1522415181    return deleted;
    1522515182}
    15226 bool p4ScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15183bool p4SkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1522715184{
    1522815185    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1523015187    psMetadata *output = psMetadataAlloc();
    1523115188    for (long i = 0; i < psArrayLength(objects); i++) {
    15232         psMetadata *md = p4ScfileMetadataFromObject(objects->data[i]);
     15189        psMetadata *md = p4SkyfileMetadataFromObject(objects->data[i]);
    1523315190        if (!psMetadataAddMetadata(
    1523415191            output,
    1523515192            PS_LIST_TAIL,
    15236             P4SCFILE_TABLE_NAME,
     15193            P4SKYFILE_TABLE_NAME,
    1523715194            PS_META_DUPLICATE_OK,
    1523815195            NULL,
    … …  
    1525515212    return true;
    1525615213}
    15257 bool p4ScfilePrintObject(FILE *stream, p4ScfileRow *object, bool mdcf)
     15214bool p4SkyfilePrintObject(FILE *stream, p4SkyfileRow *object, bool mdcf)
    1525815215{
    1525915216    PS_ASSERT_PTR_NON_NULL(object, false);
    1526015217
    15261     psMetadata *md = p4ScfileMetadataFromObject(object);
     15218    psMetadata *md = p4SkyfileMetadataFromObject(object);
    1526215219
    1526315220    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1527215229static void p5RunRowFree(p5RunRow *object);
    1527315230
    15274 p5RunRow *p5RunRowAlloc(psS32 p5_id, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     15231p5RunRow *p5RunRowAlloc(psS32 p5_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1527515232{
    1527615233    p5RunRow        *_object;
    … …  
    1528415241    _object->dvodb = psStringCopy(dvodb);
    1528515242    _object->registered = psTimeCopy(registered);
     15243    _object->skycell_id = psStringCopy(skycell_id);
     15244    _object->tess_id = psStringCopy(tess_id);
    1528615245
    1528715246    return _object;
    … …  
    1529415253    psFree(object->dvodb);
    1529515254    psFree(object->registered);
     15255    psFree(object->skycell_id);
     15256    psFree(object->tess_id);
    1529615257}
    1529715258
    … …  
    1532415285        return false;
    1532515286    }
     15287    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Key", "64")) {
     15288        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15289        psFree(md);
     15290        return false;
     15291    }
     15292    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Key", "64")) {
     15293        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     15294        psFree(md);
     15295        return false;
     15296    }
    1532615297
    1532715298    bool status = psDBCreateTable(dbh, P5RUN_TABLE_NAME, md);
    … …  
    1533715308}
    1533815309
    15339 bool p5RunInsert(psDB * dbh, psS32 p5_id, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     15310bool p5RunInsert(psDB * dbh, psS32 p5_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1534015311{
    1534115312    psMetadata *md = psMetadataAlloc();
    … …  
    1536215333    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
    1536315334        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
     15335        psFree(md);
     15336        return false;
     15337    }
     15338    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     15339        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15340        psFree(md);
     15341        return false;
     15342    }
     15343    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     15344        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1536415345        psFree(md);
    1536515346        return false;
    … …  
    1538815369bool p5RunInsertObject(psDB *dbh, p5RunRow *object)
    1538915370{
    15390     return p5RunInsert(dbh, object->p5_id, object->state, object->workdir, object->dvodb, object->registered);
     15371    return p5RunInsert(dbh, object->p5_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
    1539115372}
    1539215373
    … …  
    1548615467        return false;
    1548715468    }
     15469    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     15470        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15471        psFree(md);
     15472        return false;
     15473    }
     15474    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     15475        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     15476        psFree(md);
     15477        return false;
     15478    }
    1548815479
    1548915480
    … …  
    1552015511        return false;
    1552115512    }
    15522 
    15523     return p5RunRowAlloc(p5_id, state, workdir, dvodb, registered);
     15513    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     15514    if (!status) {
     15515        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     15516        return false;
     15517    }
     15518    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     15519    if (!status) {
     15520        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     15521        return false;
     15522    }
     15523
     15524    return p5RunRowAlloc(p5_id, state, workdir, dvodb, registered, skycell_id, tess_id);
    1552415525}
    1552515526psArray *p5RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1563115632    return true;
    1563215633}
    15633 static void p5InputScfileRowFree(p5InputScfileRow *object);
    15634 
    15635 p5InputScfileRow *p5InputScfileRowAlloc(psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
    15636 {
    15637     p5InputScfileRow *_object;
    15638 
    15639     _object = psAlloc(sizeof(p5InputScfileRow));
    15640     psMemSetDeallocator(_object, (psFreeFunc)p5InputScfileRowFree);
     15634static void p5InputSkyfileRowFree(p5InputSkyfileRow *object);
     15635
     15636p5InputSkyfileRow *p5InputSkyfileRowAlloc(psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15637{
     15638    p5InputSkyfileRow *_object;
     15639
     15640    _object = psAlloc(sizeof(p5InputSkyfileRow));
     15641    psMemSetDeallocator(_object, (psFreeFunc)p5InputSkyfileRowFree);
    1564115642
    1564215643    _object->p5_id = p5_id;
    … …  
    1565015651}
    1565115652
    15652 static void p5InputScfileRowFree(p5InputScfileRow *object)
     15653static void p5InputSkyfileRowFree(p5InputSkyfileRow *object)
    1565315654{
    1565415655    psFree(object->skycell_id);
    … …  
    1565715658}
    1565815659
    15659 bool p5InputScfileCreateTable(psDB *dbh)
     15660bool p5InputSkyfileCreateTable(psDB *dbh)
    1566015661{
    1566115662    psMetadata *md = psMetadataAlloc();
    … …  
    1569115692    }
    1569215693
    15693     bool status = psDBCreateTable(dbh, P5INPUTSCFILE_TABLE_NAME, md);
     15694    bool status = psDBCreateTable(dbh, P5INPUTSKYFILE_TABLE_NAME, md);
    1569415695
    1569515696    psFree(md);
    … …  
    1569815699}
    1569915700
    15700 bool p5InputScfileDropTable(psDB *dbh)
    15701 {
    15702     return psDBDropTable(dbh, P5INPUTSCFILE_TABLE_NAME);
    15703 }
    15704 
    15705 bool p5InputScfileInsert(psDB * dbh, psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15701bool p5InputSkyfileDropTable(psDB *dbh)
     15702{
     15703    return psDBDropTable(dbh, P5INPUTSKYFILE_TABLE_NAME);
     15704}
     15705
     15706bool p5InputSkyfileInsert(psDB * dbh, psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
    1570615707{
    1570715708    psMetadata *md = psMetadataAlloc();
    … …  
    1573715738    }
    1573815739
    15739     bool status = psDBInsertOneRow(dbh, P5INPUTSCFILE_TABLE_NAME, md);
     15740    bool status = psDBInsertOneRow(dbh, P5INPUTSKYFILE_TABLE_NAME, md);
    1574015741    psFree(md);
    1574115742
    … …  
    1574315744}
    1574415745
    15745 long long p5InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15746long long p5InputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1574615747{
    1574715748    long long       deleted = 0;
    1574815749
    15749     long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit);
     15750    long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
    1575015751    if (count < 0) {
    15751         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile");
     15752        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
    1575215753        return count;
    1575315754
    … …  
    1575715758    return deleted;
    1575815759}
    15759 bool p5InputScfileInsertObject(psDB *dbh, p5InputScfileRow *object)
    15760 {
    15761     return p5InputScfileInsert(dbh, object->p5_id, object->p4_id, object->skycell_id, object->tess_id, object->kind, object->template);
    15762 }
    15763 
    15764 bool p5InputScfileInsertObjects(psDB *dbh, psArray *objects)
     15760bool p5InputSkyfileInsertObject(psDB *dbh, p5InputSkyfileRow *object)
     15761{
     15762    return p5InputSkyfileInsert(dbh, object->p5_id, object->p4_id, object->skycell_id, object->tess_id, object->kind, object->template);
     15763}
     15764
     15765bool p5InputSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1576515766{
    1576615767    for (long i = 0; i < psArrayLength(objects); i++) {
    15767         if (!p5InputScfileInsertObject(dbh, objects->data[i])) {
     15768        if (!p5InputSkyfileInsertObject(dbh, objects->data[i])) {
    1576815769            return false;
    1576915770        }
    … …  
    1577315774}
    1577415775
    15775 bool p5InputScfileInsertFits(psDB *dbh, const psFits *fits)
     15776bool p5InputSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1577615777{
    1577715778    psArray         *rowSet;
    1577815779
    15779     // move to (the first?) extension named  P5INPUTSCFILE_TABLE_NAME
    15780     if (!psFitsMoveExtName(fits, P5INPUTSCFILE_TABLE_NAME)) {
    15781         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5INPUTSCFILE_TABLE_NAME);
     15780    // move to (the first?) extension named  P5INPUTSKYFILE_TABLE_NAME
     15781    if (!psFitsMoveExtName(fits, P5INPUTSKYFILE_TABLE_NAME)) {
     15782        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5INPUTSKYFILE_TABLE_NAME);
    1578215783        return false;
    1578315784    }
    … …  
    1579715798    }
    1579815799
    15799     if (!psDBInsertRows(dbh, P5INPUTSCFILE_TABLE_NAME, rowSet)) {
     15800    if (!psDBInsertRows(dbh, P5INPUTSKYFILE_TABLE_NAME, rowSet)) {
    1580015801        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1580115802        psFree(rowSet);
    … …  
    1580815809}
    1580915810
    15810 bool p5InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15811bool p5InputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1581115812{
    1581215813    psArray         *rowSet;
    1581315814
    15814     rowSet = psDBSelectRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit);
     15815    rowSet = psDBSelectRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
    1581515816    if (!rowSet) {
    1581615817        return false;
    … …  
    1581815819
    1581915820    // output to fits
    15820     if (!psFitsWriteTable(fits, NULL, rowSet, P5INPUTSCFILE_TABLE_NAME)) {
     15821    if (!psFitsWriteTable(fits, NULL, rowSet, P5INPUTSKYFILE_TABLE_NAME)) {
    1582115822        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1582215823        psFree(rowSet);
    … …  
    1582915830}
    1583015831
    15831 psMetadata *p5InputScfileMetadataFromObject(const p5InputScfileRow *object)
     15832psMetadata *p5InputSkyfileMetadataFromObject(const p5InputSkyfileRow *object)
    1583215833{
    1583315834    psMetadata *md = psMetadataAlloc();
    … …  
    1586715868}
    1586815869
    15869 p5InputScfileRow *p5InputScfileObjectFromMetadata(psMetadata *md)
     15870p5InputSkyfileRow *p5InputSkyfileObjectFromMetadata(psMetadata *md)
    1587015871{
    1587115872
    … …  
    1590215903    }
    1590315904
    15904     return p5InputScfileRowAlloc(p5_id, p4_id, skycell_id, tess_id, kind, template);
    15905 }
    15906 psArray *p5InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15905    return p5InputSkyfileRowAlloc(p5_id, p4_id, skycell_id, tess_id, kind, template);
     15906}
     15907psArray *p5InputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1590715908{
    1590815909    psArray         *rowSet;
    … …  
    1591015911    psU64           i;
    1591115912
    15912     rowSet = psDBSelectRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit);
     15913    rowSet = psDBSelectRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
    1591315914    if (!rowSet) {
    1591415915        return NULL;
    … …  
    1592015921
    1592115922    for (i = 0; i < rowSet->n; i++) {
    15922         p5InputScfileRow *object = p5InputScfileObjectFromMetadata(rowSet->data[i]);
     15923        p5InputSkyfileRow *object = p5InputSkyfileObjectFromMetadata(rowSet->data[i]);
    1592315924        psArrayAdd(returnSet, 0, object);
    1592415925        psFree(object);
    … …  
    1592915930    return returnSet;
    1593015931}
    15931 bool p5InputScfileDeleteObject(psDB *dbh, const p5InputScfileRow *object)
    15932 {
    15933     psMetadata *where = p5InputScfileMetadataFromObject(object);
    15934     long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, 0);
     15932bool p5InputSkyfileDeleteObject(psDB *dbh, const p5InputSkyfileRow *object)
     15933{
     15934    psMetadata *where = p5InputSkyfileMetadataFromObject(object);
     15935    long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, 0);
    1593515936    psFree(where);
    1593615937    if (count < 0) {
    15937         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile");
     15938        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
    1593815939        return false;
    1593915940    }
    … …  
    1594115942        // XXX should this be a psAbort() instead?  It is possible that
    1594215943        // having an object match multiple rows was by design.
    15943         psError(PS_ERR_UNKNOWN, true, "p5InputScfileRow object matched more then one row.  Check your database schema");
    15944         return false;
    15945     }
    15946 
    15947     return true;
    15948 }
    15949 long long p5InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15944        psError(PS_ERR_UNKNOWN, true, "p5InputSkyfileRow object matched more then one row.  Check your database schema");
     15945        return false;
     15946    }
     15947
     15948    return true;
     15949}
     15950long long p5InputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1595015951{
    1595115952    long long       deleted = 0;
    1595215953
    1595315954    for (long long i = 0; i < objects->n; i++) {
    15954         p5InputScfileRow *object = objects->data[i];
    15955         psMetadata *where = p5InputScfileMetadataFromObject(object);
    15956         long long count = psDBDeleteRows(dbh, P5INPUTSCFILE_TABLE_NAME, where, limit);
     15955        p5InputSkyfileRow *object = objects->data[i];
     15956        psMetadata *where = p5InputSkyfileMetadataFromObject(object);
     15957        long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
    1595715958        psFree(where);
    1595815959        if (count < 0) {
    15959             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputScfile");
     15960            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
    1596015961            return count;
    1596115962        }
    … …  
    1596615967    return deleted;
    1596715968}
    15968 bool p5InputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15969bool p5InputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1596915970{
    1597015971    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1597215973    psMetadata *output = psMetadataAlloc();
    1597315974    for (long i = 0; i < psArrayLength(objects); i++) {
    15974         psMetadata *md = p5InputScfileMetadataFromObject(objects->data[i]);
     15975        psMetadata *md = p5InputSkyfileMetadataFromObject(objects->data[i]);
    1597515976        if (!psMetadataAddMetadata(
    1597615977            output,
    1597715978            PS_LIST_TAIL,
    15978             P5INPUTSCFILE_TABLE_NAME,
     15979            P5INPUTSKYFILE_TABLE_NAME,
    1597915980            PS_META_DUPLICATE_OK,
    1598015981            NULL,
    … …  
    1599715998    return true;
    1599815999}
    15999 bool p5InputScfilePrintObject(FILE *stream, p5InputScfileRow *object, bool mdcf)
     16000bool p5InputSkyfilePrintObject(FILE *stream, p5InputSkyfileRow *object, bool mdcf)
    1600016001{
    1600116002    PS_ASSERT_PTR_NON_NULL(object, false);
    1600216003
    16003     psMetadata *md = p5InputScfileMetadataFromObject(object);
     16004    psMetadata *md = p5InputSkyfileMetadataFromObject(object);
    1600416005
    1600516006    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1601216013    return true;
    1601316014}
    16014 static void p5DiffScfileRowFree(p5DiffScfileRow *object);
    16015 
    16016 p5DiffScfileRow *p5DiffScfileRowAlloc(psS32 p5_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    16017 {
    16018     p5DiffScfileRow *_object;
    16019 
    16020     _object = psAlloc(sizeof(p5DiffScfileRow));
    16021     psMemSetDeallocator(_object, (psFreeFunc)p5DiffScfileRowFree);
     16015static void p5DiffSkyfileRowFree(p5DiffSkyfileRow *object);
     16016
     16017p5DiffSkyfileRow *p5DiffSkyfileRowAlloc(psS32 p5_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     16018{
     16019    p5DiffSkyfileRow *_object;
     16020
     16021    _object = psAlloc(sizeof(p5DiffSkyfileRow));
     16022    psMemSetDeallocator(_object, (psFreeFunc)p5DiffSkyfileRowFree);
    1602216023
    1602316024    _object->p5_id = p5_id;
    16024     _object->skycell_id = psStringCopy(skycell_id);
    16025     _object->tess_id = psStringCopy(tess_id);
    1602616025    _object->uri = psStringCopy(uri);
    1602716026    _object->bg = bg;
    … …  
    1603116030}
    1603216031
    16033 static void p5DiffScfileRowFree(p5DiffScfileRow *object)
    16034 {
    16035     psFree(object->skycell_id);
    16036     psFree(object->tess_id);
     16032static void p5DiffSkyfileRowFree(p5DiffSkyfileRow *object)
     16033{
    1603716034    psFree(object->uri);
    1603816035}
    1603916036
    16040 bool p5DiffScfileCreateTable(psDB *dbh)
     16037bool p5DiffSkyfileCreateTable(psDB *dbh)
    1604116038{
    1604216039    psMetadata *md = psMetadataAlloc();
    … …  
    1604616043        return false;
    1604716044    }
    16048     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
    16049         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16050         psFree(md);
    16051         return false;
    16052     }
    16053     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
    16054         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16055         psFree(md);
    16056         return false;
    16057     }
    1605816045    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1605916046        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1607216059    }
    1607316060
    16074     bool status = psDBCreateTable(dbh, P5DIFFSCFILE_TABLE_NAME, md);
     16061    bool status = psDBCreateTable(dbh, P5DIFFSKYFILE_TABLE_NAME, md);
    1607516062
    1607616063    psFree(md);
    … …  
    1607916066}
    1608016067
    16081 bool p5DiffScfileDropTable(psDB *dbh)
    16082 {
    16083     return psDBDropTable(dbh, P5DIFFSCFILE_TABLE_NAME);
    16084 }
    16085 
    16086 bool p5DiffScfileInsert(psDB * dbh, psS32 p5_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     16068bool p5DiffSkyfileDropTable(psDB *dbh)
     16069{
     16070    return psDBDropTable(dbh, P5DIFFSKYFILE_TABLE_NAME);
     16071}
     16072
     16073bool p5DiffSkyfileInsert(psDB * dbh, psS32 p5_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1608716074{
    1608816075    psMetadata *md = psMetadataAlloc();
    … …  
    1609216079        return false;
    1609316080    }
    16094     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
    16095         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16096         psFree(md);
    16097         return false;
    16098     }
    16099     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    16100         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16101         psFree(md);
    16102         return false;
    16103     }
    1610416081    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1610516082        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1611816095    }
    1611916096
    16120     bool status = psDBInsertOneRow(dbh, P5DIFFSCFILE_TABLE_NAME, md);
     16097    bool status = psDBInsertOneRow(dbh, P5DIFFSKYFILE_TABLE_NAME, md);
    1612116098    psFree(md);
    1612216099
    … …  
    1612416101}
    1612516102
    16126 long long p5DiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16103long long p5DiffSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1612716104{
    1612816105    long long       deleted = 0;
    1612916106
    16130     long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit);
     16107    long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
    1613116108    if (count < 0) {
    16132         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile");
     16109        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
    1613316110        return count;
    1613416111
    … …  
    1613816115    return deleted;
    1613916116}
    16140 bool p5DiffScfileInsertObject(psDB *dbh, p5DiffScfileRow *object)
    16141 {
    16142     return p5DiffScfileInsert(dbh, object->p5_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev);
    16143 }
    16144 
    16145 bool p5DiffScfileInsertObjects(psDB *dbh, psArray *objects)
     16117bool p5DiffSkyfileInsertObject(psDB *dbh, p5DiffSkyfileRow *object)
     16118{
     16119    return p5DiffSkyfileInsert(dbh, object->p5_id, object->uri, object->bg, object->bg_mean_stdev);
     16120}
     16121
     16122bool p5DiffSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1614616123{
    1614716124    for (long i = 0; i < psArrayLength(objects); i++) {
    16148         if (!p5DiffScfileInsertObject(dbh, objects->data[i])) {
     16125        if (!p5DiffSkyfileInsertObject(dbh, objects->data[i])) {
    1614916126            return false;
    1615016127        }
    … …  
    1615416131}
    1615516132
    16156 bool p5DiffScfileInsertFits(psDB *dbh, const psFits *fits)
     16133bool p5DiffSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1615716134{
    1615816135    psArray         *rowSet;
    1615916136
    16160     // move to (the first?) extension named  P5DIFFSCFILE_TABLE_NAME
    16161     if (!psFitsMoveExtName(fits, P5DIFFSCFILE_TABLE_NAME)) {
    16162         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5DIFFSCFILE_TABLE_NAME);
     16137    // move to (the first?) extension named  P5DIFFSKYFILE_TABLE_NAME
     16138    if (!psFitsMoveExtName(fits, P5DIFFSKYFILE_TABLE_NAME)) {
     16139        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5DIFFSKYFILE_TABLE_NAME);
    1616316140        return false;
    1616416141    }
    … …  
    1617816155    }
    1617916156
    16180     if (!psDBInsertRows(dbh, P5DIFFSCFILE_TABLE_NAME, rowSet)) {
     16157    if (!psDBInsertRows(dbh, P5DIFFSKYFILE_TABLE_NAME, rowSet)) {
    1618116158        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1618216159        psFree(rowSet);
    … …  
    1618916166}
    1619016167
    16191 bool p5DiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16168bool p5DiffSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1619216169{
    1619316170    psArray         *rowSet;
    1619416171
    16195     rowSet = psDBSelectRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit);
     16172    rowSet = psDBSelectRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
    1619616173    if (!rowSet) {
    1619716174        return false;
    … …  
    1619916176
    1620016177    // output to fits
    16201     if (!psFitsWriteTable(fits, NULL, rowSet, P5DIFFSCFILE_TABLE_NAME)) {
     16178    if (!psFitsWriteTable(fits, NULL, rowSet, P5DIFFSKYFILE_TABLE_NAME)) {
    1620216179        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1620316180        psFree(rowSet);
    … …  
    1621016187}
    1621116188
    16212 psMetadata *p5DiffScfileMetadataFromObject(const p5DiffScfileRow *object)
     16189psMetadata *p5DiffSkyfileMetadataFromObject(const p5DiffSkyfileRow *object)
    1621316190{
    1621416191    psMetadata *md = psMetadataAlloc();
    … …  
    1621816195        return false;
    1621916196    }
    16220     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
    16221         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16222         psFree(md);
    16223         return false;
    16224     }
    16225     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
    16226         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16227         psFree(md);
    16228         return false;
    16229     }
    1623016197    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    1623116198        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1624816215}
    1624916216
    16250 p5DiffScfileRow *p5DiffScfileObjectFromMetadata(psMetadata *md)
     16217p5DiffSkyfileRow *p5DiffSkyfileObjectFromMetadata(psMetadata *md)
    1625116218{
    1625216219
    … …  
    1625716224        return false;
    1625816225    }
    16259     char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
    16260     if (!status) {
    16261         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
    16262         return false;
    16263     }
    16264     char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
    16265     if (!status) {
    16266         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    16267         return false;
    16268     }
    1626916226    char* uri = psMetadataLookupPtr(&status, md, "uri");
    1627016227    if (!status) {
    … …  
    1628316240    }
    1628416241
    16285     return p5DiffScfileRowAlloc(p5_id, skycell_id, tess_id, uri, bg, bg_mean_stdev);
    16286 }
    16287 psArray *p5DiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16242    return p5DiffSkyfileRowAlloc(p5_id, uri, bg, bg_mean_stdev);
     16243}
     16244psArray *p5DiffSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1628816245{
    1628916246    psArray         *rowSet;
    … …  
    1629116248    psU64           i;
    1629216249
    16293     rowSet = psDBSelectRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit);
     16250    rowSet = psDBSelectRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
    1629416251    if (!rowSet) {
    1629516252        return NULL;
    … …  
    1630116258
    1630216259    for (i = 0; i < rowSet->n; i++) {
    16303         p5DiffScfileRow *object = p5DiffScfileObjectFromMetadata(rowSet->data[i]);
     16260        p5DiffSkyfileRow *object = p5DiffSkyfileObjectFromMetadata(rowSet->data[i]);
    1630416261        psArrayAdd(returnSet, 0, object);
    1630516262        psFree(object);
    … …  
    1631016267    return returnSet;
    1631116268}
    16312 bool p5DiffScfileDeleteObject(psDB *dbh, const p5DiffScfileRow *object)
    16313 {
    16314     psMetadata *where = p5DiffScfileMetadataFromObject(object);
    16315     long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, 0);
     16269bool p5DiffSkyfileDeleteObject(psDB *dbh, const p5DiffSkyfileRow *object)
     16270{
     16271    psMetadata *where = p5DiffSkyfileMetadataFromObject(object);
     16272    long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, 0);
    1631616273    psFree(where);
    1631716274    if (count < 0) {
    16318         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile");
     16275        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
    1631916276        return false;
    1632016277    }
    … …  
    1632216279        // XXX should this be a psAbort() instead?  It is possible that
    1632316280        // having an object match multiple rows was by design.
    16324         psError(PS_ERR_UNKNOWN, true, "p5DiffScfileRow object matched more then one row.  Check your database schema");
    16325         return false;
    16326     }
    16327 
    16328     return true;
    16329 }
    16330 long long p5DiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16281        psError(PS_ERR_UNKNOWN, true, "p5DiffSkyfileRow object matched more then one row.  Check your database schema");
     16282        return false;
     16283    }
     16284
     16285    return true;
     16286}
     16287long long p5DiffSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1633116288{
    1633216289    long long       deleted = 0;
    1633316290
    1633416291    for (long long i = 0; i < objects->n; i++) {
    16335         p5DiffScfileRow *object = objects->data[i];
    16336         psMetadata *where = p5DiffScfileMetadataFromObject(object);
    16337         long long count = psDBDeleteRows(dbh, P5DIFFSCFILE_TABLE_NAME, where, limit);
     16292        p5DiffSkyfileRow *object = objects->data[i];
     16293        psMetadata *where = p5DiffSkyfileMetadataFromObject(object);
     16294        long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
    1633816295        psFree(where);
    1633916296        if (count < 0) {
    16340             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffScfile");
     16297            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
    1634116298            return count;
    1634216299        }
    … …  
    1634716304    return deleted;
    1634816305}
    16349 bool p5DiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     16306bool p5DiffSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1635016307{
    1635116308    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1635316310    psMetadata *output = psMetadataAlloc();
    1635416311    for (long i = 0; i < psArrayLength(objects); i++) {
    16355         psMetadata *md = p5DiffScfileMetadataFromObject(objects->data[i]);
     16312        psMetadata *md = p5DiffSkyfileMetadataFromObject(objects->data[i]);
    1635616313        if (!psMetadataAddMetadata(
    1635716314            output,
    1635816315            PS_LIST_TAIL,
    16359             P5DIFFSCFILE_TABLE_NAME,
     16316            P5DIFFSKYFILE_TABLE_NAME,
    1636016317            PS_META_DUPLICATE_OK,
    1636116318            NULL,
    … …  
    1637816335    return true;
    1637916336}
    16380 bool p5DiffScfilePrintObject(FILE *stream, p5DiffScfileRow *object, bool mdcf)
     16337bool p5DiffSkyfilePrintObject(FILE *stream, p5DiffSkyfileRow *object, bool mdcf)
    1638116338{
    1638216339    PS_ASSERT_PTR_NON_NULL(object, false);
    1638316340
    16384     psMetadata *md = p5DiffScfileMetadataFromObject(object);
     16341    psMetadata *md = p5DiffSkyfileMetadataFromObject(object);
    1638516342
    1638616343    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1639516352static void p6RunRowFree(p6RunRow *object);
    1639616353
    16397 p6RunRow *p6RunRowAlloc(psS32 p6_id, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     16354p6RunRow *p6RunRowAlloc(psS32 p6_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1639816355{
    1639916356    p6RunRow        *_object;
    … …  
    1640716364    _object->dvodb = psStringCopy(dvodb);
    1640816365    _object->registered = psTimeCopy(registered);
     16366    _object->skycell_id = psStringCopy(skycell_id);
     16367    _object->tess_id = psStringCopy(tess_id);
    1640916368
    1641016369    return _object;
    … …  
    1641716376    psFree(object->dvodb);
    1641816377    psFree(object->registered);
     16378    psFree(object->skycell_id);
     16379    psFree(object->tess_id);
    1641916380}
    1642016381
    … …  
    1644716408        return false;
    1644816409    }
     16410    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Key", "64")) {
     16411        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16412        psFree(md);
     16413        return false;
     16414    }
     16415    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Key", "64")) {
     16416        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     16417        psFree(md);
     16418        return false;
     16419    }
    1644916420
    1645016421    bool status = psDBCreateTable(dbh, P6RUN_TABLE_NAME, md);
    … …  
    1646016431}
    1646116432
    16462 bool p6RunInsert(psDB * dbh, psS32 p6_id, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     16433bool p6RunInsert(psDB * dbh, psS32 p6_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1646316434{
    1646416435    psMetadata *md = psMetadataAlloc();
    … …  
    1648516456    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
    1648616457        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
     16458        psFree(md);
     16459        return false;
     16460    }
     16461    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     16462        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16463        psFree(md);
     16464        return false;
     16465    }
     16466    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     16467        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1648716468        psFree(md);
    1648816469        return false;
    … …  
    1651116492bool p6RunInsertObject(psDB *dbh, p6RunRow *object)
    1651216493{
    16513     return p6RunInsert(dbh, object->p6_id, object->state, object->workdir, object->dvodb, object->registered);
     16494    return p6RunInsert(dbh, object->p6_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
    1651416495}
    1651516496
    … …  
    1660916590        return false;
    1661016591    }
     16592    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     16593        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16594        psFree(md);
     16595        return false;
     16596    }
     16597    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     16598        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     16599        psFree(md);
     16600        return false;
     16601    }
    1661116602
    1661216603
    … …  
    1664316634        return false;
    1664416635    }
    16645 
    16646     return p6RunRowAlloc(p6_id, state, workdir, dvodb, registered);
     16636    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     16637    if (!status) {
     16638        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     16639        return false;
     16640    }
     16641    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     16642    if (!status) {
     16643        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     16644        return false;
     16645    }
     16646
     16647    return p6RunRowAlloc(p6_id, state, workdir, dvodb, registered, skycell_id, tess_id);
    1664716648}
    1664816649psArray *p6RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1675416755    return true;
    1675516756}
    16756 static void p6InputScfileRowFree(p6InputScfileRow *object);
    16757 
    16758 p6InputScfileRow *p6InputScfileRowAlloc(psS32 p6_id, psS32 p4_id, const char *skycell_id, const char *tess_id)
    16759 {
    16760     p6InputScfileRow *_object;
    16761 
    16762     _object = psAlloc(sizeof(p6InputScfileRow));
    16763     psMemSetDeallocator(_object, (psFreeFunc)p6InputScfileRowFree);
     16757static void p6InputSkyfileRowFree(p6InputSkyfileRow *object);
     16758
     16759p6InputSkyfileRow *p6InputSkyfileRowAlloc(psS32 p6_id, psS32 p4_id)
     16760{
     16761    p6InputSkyfileRow *_object;
     16762
     16763    _object = psAlloc(sizeof(p6InputSkyfileRow));
     16764    psMemSetDeallocator(_object, (psFreeFunc)p6InputSkyfileRowFree);
    1676416765
    1676516766    _object->p6_id = p6_id;
    1676616767    _object->p4_id = p4_id;
    16767     _object->skycell_id = psStringCopy(skycell_id);
    16768     _object->tess_id = psStringCopy(tess_id);
    1676916768
    1677016769    return _object;
    1677116770}
    1677216771
    16773 static void p6InputScfileRowFree(p6InputScfileRow *object)
    16774 {
    16775     psFree(object->skycell_id);
    16776     psFree(object->tess_id);
    16777 }
    16778 
    16779 bool p6InputScfileCreateTable(psDB *dbh)
     16772static void p6InputSkyfileRowFree(p6InputSkyfileRow *object)
     16773{
     16774}
     16775
     16776bool p6InputSkyfileCreateTable(psDB *dbh)
    1678016777{
    1678116778    psMetadata *md = psMetadataAlloc();
    … …  
    1679016787        return false;
    1679116788    }
    16792     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
    16793         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16794         psFree(md);
    16795         return false;
    16796     }
    16797     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
    16798         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16799         psFree(md);
    16800         return false;
    16801     }
    16802 
    16803     bool status = psDBCreateTable(dbh, P6INPUTSCFILE_TABLE_NAME, md);
     16789
     16790    bool status = psDBCreateTable(dbh, P6INPUTSKYFILE_TABLE_NAME, md);
    1680416791
    1680516792    psFree(md);
    … …  
    1680816795}
    1680916796
    16810 bool p6InputScfileDropTable(psDB *dbh)
    16811 {
    16812     return psDBDropTable(dbh, P6INPUTSCFILE_TABLE_NAME);
    16813 }
    16814 
    16815 bool p6InputScfileInsert(psDB * dbh, psS32 p6_id, psS32 p4_id, const char *skycell_id, const char *tess_id)
     16797bool p6InputSkyfileDropTable(psDB *dbh)
     16798{
     16799    return psDBDropTable(dbh, P6INPUTSKYFILE_TABLE_NAME);
     16800}
     16801
     16802bool p6InputSkyfileInsert(psDB * dbh, psS32 p6_id, psS32 p4_id)
    1681616803{
    1681716804    psMetadata *md = psMetadataAlloc();
    … …  
    1682616813        return false;
    1682716814    }
    16828     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
    16829         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16830         psFree(md);
    16831         return false;
    16832     }
    16833     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    16834         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16835         psFree(md);
    16836         return false;
    16837     }
    16838 
    16839     bool status = psDBInsertOneRow(dbh, P6INPUTSCFILE_TABLE_NAME, md);
     16815
     16816    bool status = psDBInsertOneRow(dbh, P6INPUTSKYFILE_TABLE_NAME, md);
    1684016817    psFree(md);
    1684116818
    … …  
    1684316820}
    1684416821
    16845 long long p6InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16822long long p6InputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1684616823{
    1684716824    long long       deleted = 0;
    1684816825
    16849     long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit);
     16826    long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
    1685016827    if (count < 0) {
    16851         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile");
     16828        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
    1685216829        return count;
    1685316830
    … …  
    1685716834    return deleted;
    1685816835}
    16859 bool p6InputScfileInsertObject(psDB *dbh, p6InputScfileRow *object)
    16860 {
    16861     return p6InputScfileInsert(dbh, object->p6_id, object->p4_id, object->skycell_id, object->tess_id);
    16862 }
    16863 
    16864 bool p6InputScfileInsertObjects(psDB *dbh, psArray *objects)
     16836bool p6InputSkyfileInsertObject(psDB *dbh, p6InputSkyfileRow *object)
     16837{
     16838    return p6InputSkyfileInsert(dbh, object->p6_id, object->p4_id);
     16839}
     16840
     16841bool p6InputSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1686516842{
    1686616843    for (long i = 0; i < psArrayLength(objects); i++) {
    16867         if (!p6InputScfileInsertObject(dbh, objects->data[i])) {
     16844        if (!p6InputSkyfileInsertObject(dbh, objects->data[i])) {
    1686816845            return false;
    1686916846        }
    … …  
    1687316850}
    1687416851
    16875 bool p6InputScfileInsertFits(psDB *dbh, const psFits *fits)
     16852bool p6InputSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1687616853{
    1687716854    psArray         *rowSet;
    1687816855
    16879     // move to (the first?) extension named  P6INPUTSCFILE_TABLE_NAME
    16880     if (!psFitsMoveExtName(fits, P6INPUTSCFILE_TABLE_NAME)) {
    16881         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6INPUTSCFILE_TABLE_NAME);
     16856    // move to (the first?) extension named  P6INPUTSKYFILE_TABLE_NAME
     16857    if (!psFitsMoveExtName(fits, P6INPUTSKYFILE_TABLE_NAME)) {
     16858        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6INPUTSKYFILE_TABLE_NAME);
    1688216859        return false;
    1688316860    }
    … …  
    1689716874    }
    1689816875
    16899     if (!psDBInsertRows(dbh, P6INPUTSCFILE_TABLE_NAME, rowSet)) {
     16876    if (!psDBInsertRows(dbh, P6INPUTSKYFILE_TABLE_NAME, rowSet)) {
    1690016877        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1690116878        psFree(rowSet);
    … …  
    1690816885}
    1690916886
    16910 bool p6InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16887bool p6InputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1691116888{
    1691216889    psArray         *rowSet;
    1691316890
    16914     rowSet = psDBSelectRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit);
     16891    rowSet = psDBSelectRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
    1691516892    if (!rowSet) {
    1691616893        return false;
    … …  
    1691816895
    1691916896    // output to fits
    16920     if (!psFitsWriteTable(fits, NULL, rowSet, P6INPUTSCFILE_TABLE_NAME)) {
     16897    if (!psFitsWriteTable(fits, NULL, rowSet, P6INPUTSKYFILE_TABLE_NAME)) {
    1692116898        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1692216899        psFree(rowSet);
    … …  
    1692916906}
    1693016907
    16931 psMetadata *p6InputScfileMetadataFromObject(const p6InputScfileRow *object)
     16908psMetadata *p6InputSkyfileMetadataFromObject(const p6InputSkyfileRow *object)
    1693216909{
    1693316910    psMetadata *md = psMetadataAlloc();
    … …  
    1694216919        return false;
    1694316920    }
    16944     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
    16945         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    16946         psFree(md);
    16947         return false;
    16948     }
    16949     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
    16950         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    16951         psFree(md);
    16952         return false;
    16953     }
    1695416921
    1695516922
    … …  
    1695716924}
    1695816925
    16959 p6InputScfileRow *p6InputScfileObjectFromMetadata(psMetadata *md)
     16926p6InputSkyfileRow *p6InputSkyfileObjectFromMetadata(psMetadata *md)
    1696016927{
    1696116928
    … …  
    1697116938        return false;
    1697216939    }
    16973     char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
    16974     if (!status) {
    16975         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
    16976         return false;
    16977     }
    16978     char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
    16979     if (!status) {
    16980         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    16981         return false;
    16982     }
    16983 
    16984     return p6InputScfileRowAlloc(p6_id, p4_id, skycell_id, tess_id);
    16985 }
    16986 psArray *p6InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16940
     16941    return p6InputSkyfileRowAlloc(p6_id, p4_id);
     16942}
     16943psArray *p6InputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1698716944{
    1698816945    psArray         *rowSet;
    … …  
    1699016947    psU64           i;
    1699116948
    16992     rowSet = psDBSelectRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit);
     16949    rowSet = psDBSelectRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
    1699316950    if (!rowSet) {
    1699416951        return NULL;
    … …  
    1700016957
    1700116958    for (i = 0; i < rowSet->n; i++) {
    17002         p6InputScfileRow *object = p6InputScfileObjectFromMetadata(rowSet->data[i]);
     16959        p6InputSkyfileRow *object = p6InputSkyfileObjectFromMetadata(rowSet->data[i]);
    1700316960        psArrayAdd(returnSet, 0, object);
    1700416961        psFree(object);
    … …  
    1700916966    return returnSet;
    1701016967}
    17011 bool p6InputScfileDeleteObject(psDB *dbh, const p6InputScfileRow *object)
    17012 {
    17013     psMetadata *where = p6InputScfileMetadataFromObject(object);
    17014     long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, 0);
     16968bool p6InputSkyfileDeleteObject(psDB *dbh, const p6InputSkyfileRow *object)
     16969{
     16970    psMetadata *where = p6InputSkyfileMetadataFromObject(object);
     16971    long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, 0);
    1701516972    psFree(where);
    1701616973    if (count < 0) {
    17017         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile");
     16974        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
    1701816975        return false;
    1701916976    }
    … …  
    1702116978        // XXX should this be a psAbort() instead?  It is possible that
    1702216979        // having an object match multiple rows was by design.
    17023         psError(PS_ERR_UNKNOWN, true, "p6InputScfileRow object matched more then one row.  Check your database schema");
    17024         return false;
    17025     }
    17026 
    17027     return true;
    17028 }
    17029 long long p6InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16980        psError(PS_ERR_UNKNOWN, true, "p6InputSkyfileRow object matched more then one row.  Check your database schema");
     16981        return false;
     16982    }
     16983
     16984    return true;
     16985}
     16986long long p6InputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1703016987{
    1703116988    long long       deleted = 0;
    1703216989
    1703316990    for (long long i = 0; i < objects->n; i++) {
    17034         p6InputScfileRow *object = objects->data[i];
    17035         psMetadata *where = p6InputScfileMetadataFromObject(object);
    17036         long long count = psDBDeleteRows(dbh, P6INPUTSCFILE_TABLE_NAME, where, limit);
     16991        p6InputSkyfileRow *object = objects->data[i];
     16992        psMetadata *where = p6InputSkyfileMetadataFromObject(object);
     16993        long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
    1703716994        psFree(where);
    1703816995        if (count < 0) {
    17039             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputScfile");
     16996            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
    1704016997            return count;
    1704116998        }
    … …  
    1704617003    return deleted;
    1704717004}
    17048 bool p6InputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17005bool p6InputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1704917006{
    1705017007    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1705217009    psMetadata *output = psMetadataAlloc();
    1705317010    for (long i = 0; i < psArrayLength(objects); i++) {
    17054         psMetadata *md = p6InputScfileMetadataFromObject(objects->data[i]);
     17011        psMetadata *md = p6InputSkyfileMetadataFromObject(objects->data[i]);
    1705517012        if (!psMetadataAddMetadata(
    1705617013            output,
    1705717014            PS_LIST_TAIL,
    17058             P6INPUTSCFILE_TABLE_NAME,
     17015            P6INPUTSKYFILE_TABLE_NAME,
    1705917016            PS_META_DUPLICATE_OK,
    1706017017            NULL,
    … …  
    1707717034    return true;
    1707817035}
    17079 bool p6InputScfilePrintObject(FILE *stream, p6InputScfileRow *object, bool mdcf)
     17036bool p6InputSkyfilePrintObject(FILE *stream, p6InputSkyfileRow *object, bool mdcf)
    1708017037{
    1708117038    PS_ASSERT_PTR_NON_NULL(object, false);
    1708217039
    17083     psMetadata *md = p6InputScfileMetadataFromObject(object);
     17040    psMetadata *md = p6InputSkyfileMetadataFromObject(object);
    1708417041
    1708517042    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1709217049    return true;
    1709317050}
    17094 static void p6SumScfileRowFree(p6SumScfileRow *object);
    17095 
    17096 p6SumScfileRow *p6SumScfileRowAlloc(psS32 p6_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    17097 {
    17098     p6SumScfileRow *_object;
    17099 
    17100     _object = psAlloc(sizeof(p6SumScfileRow));
    17101     psMemSetDeallocator(_object, (psFreeFunc)p6SumScfileRowFree);
     17051static void p6SumSkyfileRowFree(p6SumSkyfileRow *object);
     17052
     17053p6SumSkyfileRow *p6SumSkyfileRowAlloc(psS32 p6_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     17054{
     17055    p6SumSkyfileRow *_object;
     17056
     17057    _object = psAlloc(sizeof(p6SumSkyfileRow));
     17058    psMemSetDeallocator(_object, (psFreeFunc)p6SumSkyfileRowFree);
    1710217059
    1710317060    _object->p6_id = p6_id;
    17104     _object->skycell_id = psStringCopy(skycell_id);
    17105     _object->tess_id = psStringCopy(tess_id);
    1710617061    _object->uri = psStringCopy(uri);
    1710717062    _object->bg = bg;
    … …  
    1711117066}
    1711217067
    17113 static void p6SumScfileRowFree(p6SumScfileRow *object)
    17114 {
    17115     psFree(object->skycell_id);
    17116     psFree(object->tess_id);
     17068static void p6SumSkyfileRowFree(p6SumSkyfileRow *object)
     17069{
    1711717070    psFree(object->uri);
    1711817071}
    1711917072
    17120 bool p6SumScfileCreateTable(psDB *dbh)
     17073bool p6SumSkyfileCreateTable(psDB *dbh)
    1712117074{
    1712217075    psMetadata *md = psMetadataAlloc();
    … …  
    1712617079        return false;
    1712717080    }
    17128     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
    17129         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    17130         psFree(md);
    17131         return false;
    17132     }
    17133     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
    17134         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    17135         psFree(md);
    17136         return false;
    17137     }
    1713817081    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1713917082        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1715217095    }
    1715317096
    17154     bool status = psDBCreateTable(dbh, P6SUMSCFILE_TABLE_NAME, md);
     17097    bool status = psDBCreateTable(dbh, P6SUMSKYFILE_TABLE_NAME, md);
    1715517098
    1715617099    psFree(md);
    … …  
    1715917102}
    1716017103
    17161 bool p6SumScfileDropTable(psDB *dbh)
    17162 {
    17163     return psDBDropTable(dbh, P6SUMSCFILE_TABLE_NAME);
    17164 }
    17165 
    17166 bool p6SumScfileInsert(psDB * dbh, psS32 p6_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     17104bool p6SumSkyfileDropTable(psDB *dbh)
     17105{
     17106    return psDBDropTable(dbh, P6SUMSKYFILE_TABLE_NAME);
     17107}
     17108
     17109bool p6SumSkyfileInsert(psDB * dbh, psS32 p6_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1716717110{
    1716817111    psMetadata *md = psMetadataAlloc();
    … …  
    1717217115        return false;
    1717317116    }
    17174     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
    17175         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    17176         psFree(md);
    17177         return false;
    17178     }
    17179     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    17180         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    17181         psFree(md);
    17182         return false;
    17183     }
    1718417117    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1718517118        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1719817131    }
    1719917132
    17200     bool status = psDBInsertOneRow(dbh, P6SUMSCFILE_TABLE_NAME, md);
     17133    bool status = psDBInsertOneRow(dbh, P6SUMSKYFILE_TABLE_NAME, md);
    1720117134    psFree(md);
    1720217135
    … …  
    1720417137}
    1720517138
    17206 long long p6SumScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17139long long p6SumSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1720717140{
    1720817141    long long       deleted = 0;
    1720917142
    17210     long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit);
     17143    long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
    1721117144    if (count < 0) {
    17212         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile");
     17145        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
    1721317146        return count;
    1721417147
    … …  
    1721817151    return deleted;
    1721917152}
    17220 bool p6SumScfileInsertObject(psDB *dbh, p6SumScfileRow *object)
    17221 {
    17222     return p6SumScfileInsert(dbh, object->p6_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev);
    17223 }
    17224 
    17225 bool p6SumScfileInsertObjects(psDB *dbh, psArray *objects)
     17153bool p6SumSkyfileInsertObject(psDB *dbh, p6SumSkyfileRow *object)
     17154{
     17155    return p6SumSkyfileInsert(dbh, object->p6_id, object->uri, object->bg, object->bg_mean_stdev);
     17156}
     17157
     17158bool p6SumSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1722617159{
    1722717160    for (long i = 0; i < psArrayLength(objects); i++) {
    17228         if (!p6SumScfileInsertObject(dbh, objects->data[i])) {
     17161        if (!p6SumSkyfileInsertObject(dbh, objects->data[i])) {
    1722917162            return false;
    1723017163        }
    … …  
    1723417167}
    1723517168
    17236 bool p6SumScfileInsertFits(psDB *dbh, const psFits *fits)
     17169bool p6SumSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1723717170{
    1723817171    psArray         *rowSet;
    1723917172
    17240     // move to (the first?) extension named  P6SUMSCFILE_TABLE_NAME
    17241     if (!psFitsMoveExtName(fits, P6SUMSCFILE_TABLE_NAME)) {
    17242         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6SUMSCFILE_TABLE_NAME);
     17173    // move to (the first?) extension named  P6SUMSKYFILE_TABLE_NAME
     17174    if (!psFitsMoveExtName(fits, P6SUMSKYFILE_TABLE_NAME)) {
     17175        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6SUMSKYFILE_TABLE_NAME);
    1724317176        return false;
    1724417177    }
    … …  
    1725817191    }
    1725917192
    17260     if (!psDBInsertRows(dbh, P6SUMSCFILE_TABLE_NAME, rowSet)) {
     17193    if (!psDBInsertRows(dbh, P6SUMSKYFILE_TABLE_NAME, rowSet)) {
    1726117194        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1726217195        psFree(rowSet);
    … …  
    1726917202}
    1727017203
    17271 bool p6SumScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     17204bool p6SumSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1727217205{
    1727317206    psArray         *rowSet;
    1727417207
    17275     rowSet = psDBSelectRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit);
     17208    rowSet = psDBSelectRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
    1727617209    if (!rowSet) {
    1727717210        return false;
    … …  
    1727917212
    1728017213    // output to fits
    17281     if (!psFitsWriteTable(fits, NULL, rowSet, P6SUMSCFILE_TABLE_NAME)) {
     17214    if (!psFitsWriteTable(fits, NULL, rowSet, P6SUMSKYFILE_TABLE_NAME)) {
    1728217215        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1728317216        psFree(rowSet);
    … …  
    1729017223}
    1729117224
    17292 psMetadata *p6SumScfileMetadataFromObject(const p6SumScfileRow *object)
     17225psMetadata *p6SumSkyfileMetadataFromObject(const p6SumSkyfileRow *object)
    1729317226{
    1729417227    psMetadata *md = psMetadataAlloc();
    … …  
    1729817231        return false;
    1729917232    }
    17300     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
    17301         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    17302         psFree(md);
    17303         return false;
    17304     }
    17305     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
    17306         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    17307         psFree(md);
    17308         return false;
    17309     }
    1731017233    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    1731117234        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1732817251}
    1732917252
    17330 p6SumScfileRow *p6SumScfileObjectFromMetadata(psMetadata *md)
     17253p6SumSkyfileRow *p6SumSkyfileObjectFromMetadata(psMetadata *md)
    1733117254{
    1733217255
    … …  
    1733717260        return false;
    1733817261    }
    17339     char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
    17340     if (!status) {
    17341         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
    17342         return false;
    17343     }
    17344     char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
    17345     if (!status) {
    17346         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    17347         return false;
    17348     }
    1734917262    char* uri = psMetadataLookupPtr(&status, md, "uri");
    1735017263    if (!status) {
    … …  
    1736317276    }
    1736417277
    17365     return p6SumScfileRowAlloc(p6_id, skycell_id, tess_id, uri, bg, bg_mean_stdev);
    17366 }
    17367 psArray *p6SumScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17278    return p6SumSkyfileRowAlloc(p6_id, uri, bg, bg_mean_stdev);
     17279}
     17280psArray *p6SumSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1736817281{
    1736917282    psArray         *rowSet;
    … …  
    1737117284    psU64           i;
    1737217285
    17373     rowSet = psDBSelectRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit);
     17286    rowSet = psDBSelectRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
    1737417287    if (!rowSet) {
    1737517288        return NULL;
    … …  
    1738117294
    1738217295    for (i = 0; i < rowSet->n; i++) {
    17383         p6SumScfileRow *object = p6SumScfileObjectFromMetadata(rowSet->data[i]);
     17296        p6SumSkyfileRow *object = p6SumSkyfileObjectFromMetadata(rowSet->data[i]);
    1738417297        psArrayAdd(returnSet, 0, object);
    1738517298        psFree(object);
    … …  
    1739017303    return returnSet;
    1739117304}
    17392 bool p6SumScfileDeleteObject(psDB *dbh, const p6SumScfileRow *object)
    17393 {
    17394     psMetadata *where = p6SumScfileMetadataFromObject(object);
    17395     long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, 0);
     17305bool p6SumSkyfileDeleteObject(psDB *dbh, const p6SumSkyfileRow *object)
     17306{
     17307    psMetadata *where = p6SumSkyfileMetadataFromObject(object);
     17308    long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, 0);
    1739617309    psFree(where);
    1739717310    if (count < 0) {
    17398         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile");
     17311        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
    1739917312        return false;
    1740017313    }
    … …  
    1740217315        // XXX should this be a psAbort() instead?  It is possible that
    1740317316        // having an object match multiple rows was by design.
    17404         psError(PS_ERR_UNKNOWN, true, "p6SumScfileRow object matched more then one row.  Check your database schema");
    17405         return false;
    17406     }
    17407 
    17408     return true;
    17409 }
    17410 long long p6SumScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     17317        psError(PS_ERR_UNKNOWN, true, "p6SumSkyfileRow object matched more then one row.  Check your database schema");
     17318        return false;
     17319    }
     17320
     17321    return true;
     17322}
     17323long long p6SumSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1741117324{
    1741217325    long long       deleted = 0;
    1741317326
    1741417327    for (long long i = 0; i < objects->n; i++) {
    17415         p6SumScfileRow *object = objects->data[i];
    17416         psMetadata *where = p6SumScfileMetadataFromObject(object);
    17417         long long count = psDBDeleteRows(dbh, P6SUMSCFILE_TABLE_NAME, where, limit);
     17328        p6SumSkyfileRow *object = objects->data[i];
     17329        psMetadata *where = p6SumSkyfileMetadataFromObject(object);
     17330        long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
    1741817331        psFree(where);
    1741917332        if (count < 0) {
    17420             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumScfile");
     17333            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
    1742117334            return count;
    1742217335        }
    … …  
    1742717340    return deleted;
    1742817341}
    17429 bool p6SumScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17342bool p6SumSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1743017343{
    1743117344    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1743317346    psMetadata *output = psMetadataAlloc();
    1743417347    for (long i = 0; i < psArrayLength(objects); i++) {
    17435         psMetadata *md = p6SumScfileMetadataFromObject(objects->data[i]);
     17348        psMetadata *md = p6SumSkyfileMetadataFromObject(objects->data[i]);
    1743617349        if (!psMetadataAddMetadata(
    1743717350            output,
    1743817351            PS_LIST_TAIL,
    17439             P6SUMSCFILE_TABLE_NAME,
     17352            P6SUMSKYFILE_TABLE_NAME,
    1744017353            PS_META_DUPLICATE_OK,
    1744117354            NULL,
    … …  
    1745817371    return true;
    1745917372}
    17460 bool p6SumScfilePrintObject(FILE *stream, p6SumScfileRow *object, bool mdcf)
     17373bool p6SumSkyfilePrintObject(FILE *stream, p6SumSkyfileRow *object, bool mdcf)
    1746117374{
    1746217375    PS_ASSERT_PTR_NON_NULL(object, false);
    1746317376
    17464     psMetadata *md = p6SumScfileMetadataFromObject(object);
     17377    psMetadata *md = p6SumSkyfileMetadataFromObject(object);
    1746517378
    1746617379    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
Note: See TracChangeset for help on using the changeset viewer.