IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 23, 2007, 4:28:07 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.11

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r11988 r12026  
    4242#define RAWEXP_TABLE_NAME "rawExp"
    4343#define RAWIMFILE_TABLE_NAME "rawImfile"
    44 #define P1PENDINGEXP_TABLE_NAME "p1PendingExp"
    45 #define P2PENDINGEXP_TABLE_NAME "p2PendingExp"
    46 #define P2PENDINGIMFILE_TABLE_NAME "p2PendingImfile"
    47 #define P2PROCESSEDEXP_TABLE_NAME "p2ProcessedExp"
    48 #define P2MASK_TABLE_NAME "p2Mask"
    49 #define P2PROCESSEDIMFILE_TABLE_NAME "p2ProcessedImfile"
    50 #define P3PENDINGEXP_TABLE_NAME "p3PendingExp"
    51 #define P3PROCESSEDEXP_TABLE_NAME "p3ProcessedExp"
    52 #define P3MASK_TABLE_NAME "p3Mask"
     44#define GUIDEPENDINGEXP_TABLE_NAME "guidePendingExp"
     45#define CHIPPENDINGEXP_TABLE_NAME "chipPendingExp"
     46#define CHIPPENDINGIMFILE_TABLE_NAME "chipPendingImfile"
     47#define CHIPPROCESSEDEXP_TABLE_NAME "chipProcessedExp"
     48#define CHIPMASK_TABLE_NAME "chipMask"
     49#define CHIPPROCESSEDIMFILE_TABLE_NAME "chipProcessedImfile"
     50#define CAMPENDINGEXP_TABLE_NAME "camPendingExp"
     51#define CAMPROCESSEDEXP_TABLE_NAME "camProcessedExp"
     52#define CAMMASK_TABLE_NAME "camMask"
    5353#define DETRUN_TABLE_NAME "detRun"
    5454#define DETINPUTEXP_TABLE_NAME "detInputExp"
    … …  
    6262#define DETRESIDEXP_TABLE_NAME "detResidExp"
    6363#define DETRUNSUMMARY_TABLE_NAME "detRunSummary"
    64 #define P4RUN_TABLE_NAME "p4Run"
    65 #define P4INPUTEXP_TABLE_NAME "p4InputExp"
    66 #define P4SKYCELLMAP_TABLE_NAME "p4SkyCellMap"
    67 #define P4SKYFILE_TABLE_NAME "p4Skyfile"
    68 #define P5RUN_TABLE_NAME "p5Run"
    69 #define P5INPUTSKYFILE_TABLE_NAME "p5InputSkyfile"
    70 #define P5DIFFSKYFILE_TABLE_NAME "p5DiffSkyfile"
    71 #define P6RUN_TABLE_NAME "p6Run"
    72 #define P6INPUTSKYFILE_TABLE_NAME "p6InputSkyfile"
    73 #define P6SUMSKYFILE_TABLE_NAME "p6SumSkyfile"
     64#define WARPRUN_TABLE_NAME "warpRun"
     65#define WARPINPUTEXP_TABLE_NAME "warpInputExp"
     66#define WARPSKYCELLMAP_TABLE_NAME "warpSkyCellMap"
     67#define WARPSKYFILE_TABLE_NAME "warpSkyfile"
     68#define DIFFRUN_TABLE_NAME "diffRun"
     69#define DIFFINPUTSKYFILE_TABLE_NAME "diffInputSkyfile"
     70#define DIFFSKYFILE_TABLE_NAME "diffSkyfile"
     71#define STACKRUN_TABLE_NAME "stackRun"
     72#define STACKINPUTSKYFILE_TABLE_NAME "stackInputSkyfile"
     73#define STACKSUMSKYFILE_TABLE_NAME "stackSumSkyfile"
    7474#define MAX_STRING_LENGTH 1024
    7575
    … …  
    49484948    return true;
    49494949}
    4950 static void p1PendingExpRowFree(p1PendingExpRow *object);
    4951 
    4952 p1PendingExpRow *p1PendingExpRowAlloc(const char *exp_tag, psS32 p1_version, const char *recipe)
    4953 {
    4954     p1PendingExpRow *_object;
    4955 
    4956     _object = psAlloc(sizeof(p1PendingExpRow));
    4957     psMemSetDeallocator(_object, (psFreeFunc)p1PendingExpRowFree);
     4950static void guidePendingExpRowFree(guidePendingExpRow *object);
     4951
     4952guidePendingExpRow *guidePendingExpRowAlloc(const char *exp_tag, psS32 guide_version, const char *recipe)
     4953{
     4954    guidePendingExpRow *_object;
     4955
     4956    _object = psAlloc(sizeof(guidePendingExpRow));
     4957    psMemSetDeallocator(_object, (psFreeFunc)guidePendingExpRowFree);
    49584958
    49594959    _object->exp_tag = psStringCopy(exp_tag);
    4960     _object->p1_version = p1_version;
     4960    _object->guide_version = guide_version;
    49614961    _object->recipe = psStringCopy(recipe);
    49624962
    … …  
    49644964}
    49654965
    4966 static void p1PendingExpRowFree(p1PendingExpRow *object)
     4966static void guidePendingExpRowFree(guidePendingExpRow *object)
    49674967{
    49684968    psFree(object->exp_tag);
    … …  
    49704970}
    49714971
    4972 bool p1PendingExpCreateTable(psDB *dbh)
     4972bool guidePendingExpCreateTable(psDB *dbh)
    49734973{
    49744974    psMetadata *md = psMetadataAlloc();
    … …  
    49784978        return false;
    49794979    }
    4980     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, "Primary Key", 0)) {
    4981         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     4980    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, "Primary Key", 0)) {
     4981        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    49824982        psFree(md);
    49834983        return false;
    … …  
    49894989    }
    49904990
    4991     bool status = psDBCreateTable(dbh, P1PENDINGEXP_TABLE_NAME, md);
     4991    bool status = psDBCreateTable(dbh, GUIDEPENDINGEXP_TABLE_NAME, md);
    49924992
    49934993    psFree(md);
    … …  
    49964996}
    49974997
    4998 bool p1PendingExpDropTable(psDB *dbh)
    4999 {
    5000     return psDBDropTable(dbh, P1PENDINGEXP_TABLE_NAME);
    5001 }
    5002 
    5003 bool p1PendingExpInsert(psDB * dbh, const char *exp_tag, psS32 p1_version, const char *recipe)
     4998bool guidePendingExpDropTable(psDB *dbh)
     4999{
     5000    return psDBDropTable(dbh, GUIDEPENDINGEXP_TABLE_NAME);
     5001}
     5002
     5003bool guidePendingExpInsert(psDB * dbh, const char *exp_tag, psS32 guide_version, const char *recipe)
    50045004{
    50055005    psMetadata *md = psMetadataAlloc();
    … …  
    50095009        return false;
    50105010    }
    5011     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) {
    5012         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5011    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
     5012        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    50135013        psFree(md);
    50145014        return false;
    … …  
    50205020    }
    50215021
    5022     bool status = psDBInsertOneRow(dbh, P1PENDINGEXP_TABLE_NAME, md);
     5022    bool status = psDBInsertOneRow(dbh, GUIDEPENDINGEXP_TABLE_NAME, md);
    50235023    psFree(md);
    50245024
    … …  
    50265026}
    50275027
    5028 long long p1PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5028long long guidePendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    50295029{
    50305030    long long       deleted = 0;
    50315031
    5032     long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
     5032    long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit);
    50335033    if (count < 0) {
    5034         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp");
     5034        psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp");
    50355035        return count;
    50365036
    … …  
    50405040    return deleted;
    50415041}
    5042 bool p1PendingExpInsertObject(psDB *dbh, p1PendingExpRow *object)
    5043 {
    5044     return p1PendingExpInsert(dbh, object->exp_tag, object->p1_version, object->recipe);
    5045 }
    5046 
    5047 bool p1PendingExpInsertObjects(psDB *dbh, psArray *objects)
     5042bool guidePendingExpInsertObject(psDB *dbh, guidePendingExpRow *object)
     5043{
     5044    return guidePendingExpInsert(dbh, object->exp_tag, object->guide_version, object->recipe);
     5045}
     5046
     5047bool guidePendingExpInsertObjects(psDB *dbh, psArray *objects)
    50485048{
    50495049    for (long i = 0; i < psArrayLength(objects); i++) {
    5050         if (!p1PendingExpInsertObject(dbh, objects->data[i])) {
     5050        if (!guidePendingExpInsertObject(dbh, objects->data[i])) {
    50515051            return false;
    50525052        }
    … …  
    50565056}
    50575057
    5058 bool p1PendingExpInsertFits(psDB *dbh, const psFits *fits)
     5058bool guidePendingExpInsertFits(psDB *dbh, const psFits *fits)
    50595059{
    50605060    psArray         *rowSet;
    50615061
    5062     // move to (the first?) extension named  P1PENDINGEXP_TABLE_NAME
    5063     if (!psFitsMoveExtName(fits, P1PENDINGEXP_TABLE_NAME)) {
    5064         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P1PENDINGEXP_TABLE_NAME);
     5062    // move to (the first?) extension named  GUIDEPENDINGEXP_TABLE_NAME
     5063    if (!psFitsMoveExtName(fits, GUIDEPENDINGEXP_TABLE_NAME)) {
     5064        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", GUIDEPENDINGEXP_TABLE_NAME);
    50655065        return false;
    50665066    }
    … …  
    50805080    }
    50815081
    5082     if (!psDBInsertRows(dbh, P1PENDINGEXP_TABLE_NAME, rowSet)) {
     5082    if (!psDBInsertRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, rowSet)) {
    50835083        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    50845084        psFree(rowSet);
    … …  
    50915091}
    50925092
    5093 bool p1PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     5093bool guidePendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    50945094{
    50955095    psArray         *rowSet;
    50965096
    5097     rowSet = psDBSelectRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
     5097    rowSet = psDBSelectRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit);
    50985098    if (!rowSet) {
    50995099        return false;
    … …  
    51015101
    51025102    // output to fits
    5103     if (!psFitsWriteTable(fits, NULL, rowSet, P1PENDINGEXP_TABLE_NAME)) {
     5103    if (!psFitsWriteTable(fits, NULL, rowSet, GUIDEPENDINGEXP_TABLE_NAME)) {
    51045104        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    51055105        psFree(rowSet);
    … …  
    51125112}
    51135113
    5114 psMetadata *p1PendingExpMetadataFromObject(const p1PendingExpRow *object)
     5114psMetadata *guidePendingExpMetadataFromObject(const guidePendingExpRow *object)
    51155115{
    51165116    psMetadata *md = psMetadataAlloc();
    … …  
    51205120        return false;
    51215121    }
    5122     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) {
    5123         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5122    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
     5123        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    51245124        psFree(md);
    51255125        return false;
    … …  
    51355135}
    51365136
    5137 p1PendingExpRow *p1PendingExpObjectFromMetadata(psMetadata *md)
     5137guidePendingExpRow *guidePendingExpObjectFromMetadata(psMetadata *md)
    51385138{
    51395139
    … …  
    51445144        return false;
    51455145    }
    5146     psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version");
    5147     if (!status) {
    5148         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
     5146    psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
     5147    if (!status) {
     5148        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    51495149        return false;
    51505150    }
    … …  
    51555155    }
    51565156
    5157     return p1PendingExpRowAlloc(exp_tag, p1_version, recipe);
    5158 }
    5159 psArray *p1PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5157    return guidePendingExpRowAlloc(exp_tag, guide_version, recipe);
     5158}
     5159psArray *guidePendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    51605160{
    51615161    psArray         *rowSet;
    … …  
    51635163    psU64           i;
    51645164
    5165     rowSet = psDBSelectRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
     5165    rowSet = psDBSelectRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit);
    51665166    if (!rowSet) {
    51675167        return NULL;
    … …  
    51735173
    51745174    for (i = 0; i < rowSet->n; i++) {
    5175         p1PendingExpRow *object = p1PendingExpObjectFromMetadata(rowSet->data[i]);
     5175        guidePendingExpRow *object = guidePendingExpObjectFromMetadata(rowSet->data[i]);
    51765176        psArrayAdd(returnSet, 0, object);
    51775177        psFree(object);
    … …  
    51825182    return returnSet;
    51835183}
    5184 bool p1PendingExpDeleteObject(psDB *dbh, const p1PendingExpRow *object)
    5185 {
    5186     psMetadata *where = p1PendingExpMetadataFromObject(object);
    5187     long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, 0);
     5184bool guidePendingExpDeleteObject(psDB *dbh, const guidePendingExpRow *object)
     5185{
     5186    psMetadata *where = guidePendingExpMetadataFromObject(object);
     5187    long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, 0);
    51885188    psFree(where);
    51895189    if (count < 0) {
    5190         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp");
     5190        psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp");
    51915191        return false;
    51925192    }
    … …  
    51945194        // XXX should this be a psAbort() instead?  It is possible that
    51955195        // having an object match multiple rows was by design.
    5196         psError(PS_ERR_UNKNOWN, true, "p1PendingExpRow object matched more then one row.  Check your database schema");
    5197         return false;
    5198     }
    5199 
    5200     return true;
    5201 }
    5202 long long p1PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     5196        psError(PS_ERR_UNKNOWN, true, "guidePendingExpRow object matched more then one row.  Check your database schema");
     5197        return false;
     5198    }
     5199
     5200    return true;
     5201}
     5202long long guidePendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    52035203{
    52045204    long long       deleted = 0;
    52055205
    52065206    for (long long i = 0; i < objects->n; i++) {
    5207         p1PendingExpRow *object = objects->data[i];
    5208         psMetadata *where = p1PendingExpMetadataFromObject(object);
    5209         long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
     5207        guidePendingExpRow *object = objects->data[i];
     5208        psMetadata *where = guidePendingExpMetadataFromObject(object);
     5209        long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit);
    52105210        psFree(where);
    52115211        if (count < 0) {
    5212             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp");
     5212            psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp");
    52135213            return count;
    52145214        }
    … …  
    52195219    return deleted;
    52205220}
    5221 bool p1PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     5221bool guidePendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    52225222{
    52235223    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    52255225    psMetadata *output = psMetadataAlloc();
    52265226    for (long i = 0; i < psArrayLength(objects); i++) {
    5227         psMetadata *md = p1PendingExpMetadataFromObject(objects->data[i]);
     5227        psMetadata *md = guidePendingExpMetadataFromObject(objects->data[i]);
    52285228        if (!psMetadataAddMetadata(
    52295229            output,
    52305230            PS_LIST_TAIL,
    5231             P1PENDINGEXP_TABLE_NAME,
     5231            GUIDEPENDINGEXP_TABLE_NAME,
    52325232            PS_META_DUPLICATE_OK,
    52335233            NULL,
    … …  
    52505250    return true;
    52515251}
    5252 bool p1PendingExpPrintObject(FILE *stream, p1PendingExpRow *object, bool mdcf)
     5252bool guidePendingExpPrintObject(FILE *stream, guidePendingExpRow *object, bool mdcf)
    52535253{
    52545254    PS_ASSERT_PTR_NON_NULL(object, false);
    52555255
    5256     psMetadata *md = p1PendingExpMetadataFromObject(object);
     5256    psMetadata *md = guidePendingExpMetadataFromObject(object);
    52575257
    52585258    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    52655265    return true;
    52665266}
    5267 static void p2PendingExpRowFree(p2PendingExpRow *object);
    5268 
    5269 p2PendingExpRow *p2PendingExpRowAlloc(const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
    5270 {
    5271     p2PendingExpRow *_object;
    5272 
    5273     _object = psAlloc(sizeof(p2PendingExpRow));
    5274     psMemSetDeallocator(_object, (psFreeFunc)p2PendingExpRowFree);
     5267static void chipPendingExpRowFree(chipPendingExpRow *object);
     5268
     5269chipPendingExpRow *chipPendingExpRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
     5270{
     5271    chipPendingExpRow *_object;
     5272
     5273    _object = psAlloc(sizeof(chipPendingExpRow));
     5274    psMemSetDeallocator(_object, (psFreeFunc)chipPendingExpRowFree);
    52755275
    52765276    _object->exp_tag = psStringCopy(exp_tag);
    5277     _object->p2_version = p2_version;
    5278     _object->p1_version = p1_version;
     5277    _object->chip_version = chip_version;
     5278    _object->guide_version = guide_version;
    52795279    _object->label = psStringCopy(label);
    52805280    _object->recipe = psStringCopy(recipe);
    … …  
    52855285}
    52865286
    5287 static void p2PendingExpRowFree(p2PendingExpRow *object)
     5287static void chipPendingExpRowFree(chipPendingExpRow *object)
    52885288{
    52895289    psFree(object->exp_tag);
    … …  
    52945294}
    52955295
    5296 bool p2PendingExpCreateTable(psDB *dbh)
     5296bool chipPendingExpCreateTable(psDB *dbh)
    52975297{
    52985298    psMetadata *md = psMetadataAlloc();
    … …  
    53025302        return false;
    53035303    }
    5304     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, "Primary Key", 0)) {
    5305         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5306         psFree(md);
    5307         return false;
    5308     }
    5309     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) {
    5310         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5304    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
     5305        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5306        psFree(md);
     5307        return false;
     5308    }
     5309    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
     5310        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    53115311        psFree(md);
    53125312        return false;
    … …  
    53335333    }
    53345334
    5335     bool status = psDBCreateTable(dbh, P2PENDINGEXP_TABLE_NAME, md);
     5335    bool status = psDBCreateTable(dbh, CHIPPENDINGEXP_TABLE_NAME, md);
    53365336
    53375337    psFree(md);
    … …  
    53405340}
    53415341
    5342 bool p2PendingExpDropTable(psDB *dbh)
    5343 {
    5344     return psDBDropTable(dbh, P2PENDINGEXP_TABLE_NAME);
    5345 }
    5346 
    5347 bool p2PendingExpInsert(psDB * dbh, const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
     5342bool chipPendingExpDropTable(psDB *dbh)
     5343{
     5344    return psDBDropTable(dbh, CHIPPENDINGEXP_TABLE_NAME);
     5345}
     5346
     5347bool chipPendingExpInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
    53485348{
    53495349    psMetadata *md = psMetadataAlloc();
    … …  
    53535353        return false;
    53545354    }
    5355     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    5356         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5357         psFree(md);
    5358         return false;
    5359     }
    5360     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) {
    5361         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5355    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     5356        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5357        psFree(md);
     5358        return false;
     5359    }
     5360    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
     5361        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    53625362        psFree(md);
    53635363        return false;
    … …  
    53845384    }
    53855385
    5386     bool status = psDBInsertOneRow(dbh, P2PENDINGEXP_TABLE_NAME, md);
     5386    bool status = psDBInsertOneRow(dbh, CHIPPENDINGEXP_TABLE_NAME, md);
    53875387    psFree(md);
    53885388
    … …  
    53905390}
    53915391
    5392 long long p2PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5392long long chipPendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    53935393{
    53945394    long long       deleted = 0;
    53955395
    5396     long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
     5396    long long count = psDBDeleteRows(dbh, CHIPPENDINGEXP_TABLE_NAME, where, limit);
    53975397    if (count < 0) {
    5398         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp");
     5398        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingExp");
    53995399        return count;
    54005400
    … …  
    54045404    return deleted;
    54055405}
    5406 bool p2PendingExpInsertObject(psDB *dbh, p2PendingExpRow *object)
    5407 {
    5408     return p2PendingExpInsert(dbh, object->exp_tag, object->p2_version, object->p1_version, object->label, object->recipe, object->expgroup, object->dvodb);
    5409 }
    5410 
    5411 bool p2PendingExpInsertObjects(psDB *dbh, psArray *objects)
     5406bool chipPendingExpInsertObject(psDB *dbh, chipPendingExpRow *object)
     5407{
     5408    return chipPendingExpInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->label, object->recipe, object->expgroup, object->dvodb);
     5409}
     5410
     5411bool chipPendingExpInsertObjects(psDB *dbh, psArray *objects)
    54125412{
    54135413    for (long i = 0; i < psArrayLength(objects); i++) {
    5414         if (!p2PendingExpInsertObject(dbh, objects->data[i])) {
     5414        if (!chipPendingExpInsertObject(dbh, objects->data[i])) {
    54155415            return false;
    54165416        }
    … …  
    54205420}
    54215421
    5422 bool p2PendingExpInsertFits(psDB *dbh, const psFits *fits)
     5422bool chipPendingExpInsertFits(psDB *dbh, const psFits *fits)
    54235423{
    54245424    psArray         *rowSet;
    54255425
    5426     // move to (the first?) extension named  P2PENDINGEXP_TABLE_NAME
    5427     if (!psFitsMoveExtName(fits, P2PENDINGEXP_TABLE_NAME)) {
    5428         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PENDINGEXP_TABLE_NAME);
     5426    // move to (the first?) extension named  CHIPPENDINGEXP_TABLE_NAME
     5427    if (!psFitsMoveExtName(fits, CHIPPENDINGEXP_TABLE_NAME)) {
     5428        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPPENDINGEXP_TABLE_NAME);
    54295429        return false;
    54305430    }
    … …  
    54445444    }
    54455445
    5446     if (!psDBInsertRows(dbh, P2PENDINGEXP_TABLE_NAME, rowSet)) {
     5446    if (!psDBInsertRows(dbh, CHIPPENDINGEXP_TABLE_NAME, rowSet)) {
    54475447        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    54485448        psFree(rowSet);
    … …  
    54555455}
    54565456
    5457 bool p2PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     5457bool chipPendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    54585458{
    54595459    psArray         *rowSet;
    54605460
    5461     rowSet = psDBSelectRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
     5461    rowSet = psDBSelectRows(dbh, CHIPPENDINGEXP_TABLE_NAME, where, limit);
    54625462    if (!rowSet) {
    54635463        return false;
    … …  
    54655465
    54665466    // output to fits
    5467     if (!psFitsWriteTable(fits, NULL, rowSet, P2PENDINGEXP_TABLE_NAME)) {
     5467    if (!psFitsWriteTable(fits, NULL, rowSet, CHIPPENDINGEXP_TABLE_NAME)) {
    54685468        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    54695469        psFree(rowSet);
    … …  
    54765476}
    54775477
    5478 psMetadata *p2PendingExpMetadataFromObject(const p2PendingExpRow *object)
     5478psMetadata *chipPendingExpMetadataFromObject(const chipPendingExpRow *object)
    54795479{
    54805480    psMetadata *md = psMetadataAlloc();
    … …  
    54845484        return false;
    54855485    }
    5486     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    5487         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5488         psFree(md);
    5489         return false;
    5490     }
    5491     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) {
    5492         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5486    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     5487        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5488        psFree(md);
     5489        return false;
     5490    }
     5491    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
     5492        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    54935493        psFree(md);
    54945494        return false;
    … …  
    55195519}
    55205520
    5521 p2PendingExpRow *p2PendingExpObjectFromMetadata(psMetadata *md)
     5521chipPendingExpRow *chipPendingExpObjectFromMetadata(psMetadata *md)
    55225522{
    55235523
    … …  
    55285528        return false;
    55295529    }
    5530     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    5531     if (!status) {
    5532         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    5533         return false;
    5534     }
    5535     psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version");
    5536     if (!status) {
    5537         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
     5530    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     5531    if (!status) {
     5532        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     5533        return false;
     5534    }
     5535    psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
     5536    if (!status) {
     5537        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    55385538        return false;
    55395539    }
    … …  
    55595559    }
    55605560
    5561     return p2PendingExpRowAlloc(exp_tag, p2_version, p1_version, label, recipe, expgroup, dvodb);
    5562 }
    5563 psArray *p2PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5561    return chipPendingExpRowAlloc(exp_tag, chip_version, guide_version, label, recipe, expgroup, dvodb);
     5562}
     5563psArray *chipPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    55645564{
    55655565    psArray         *rowSet;
    … …  
    55675567    psU64           i;
    55685568
    5569     rowSet = psDBSelectRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
     5569    rowSet = psDBSelectRows(dbh, CHIPPENDINGEXP_TABLE_NAME, where, limit);
    55705570    if (!rowSet) {
    55715571        return NULL;
    … …  
    55775577
    55785578    for (i = 0; i < rowSet->n; i++) {
    5579         p2PendingExpRow *object = p2PendingExpObjectFromMetadata(rowSet->data[i]);
     5579        chipPendingExpRow *object = chipPendingExpObjectFromMetadata(rowSet->data[i]);
    55805580        psArrayAdd(returnSet, 0, object);
    55815581        psFree(object);
    … …  
    55865586    return returnSet;
    55875587}
    5588 bool p2PendingExpDeleteObject(psDB *dbh, const p2PendingExpRow *object)
    5589 {
    5590     psMetadata *where = p2PendingExpMetadataFromObject(object);
    5591     long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, 0);
     5588bool chipPendingExpDeleteObject(psDB *dbh, const chipPendingExpRow *object)
     5589{
     5590    psMetadata *where = chipPendingExpMetadataFromObject(object);
     5591    long long count = psDBDeleteRows(dbh, CHIPPENDINGEXP_TABLE_NAME, where, 0);
    55925592    psFree(where);
    55935593    if (count < 0) {
    5594         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp");
     5594        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingExp");
    55955595        return false;
    55965596    }
    … …  
    55985598        // XXX should this be a psAbort() instead?  It is possible that
    55995599        // having an object match multiple rows was by design.
    5600         psError(PS_ERR_UNKNOWN, true, "p2PendingExpRow object matched more then one row.  Check your database schema");
    5601         return false;
    5602     }
    5603 
    5604     return true;
    5605 }
    5606 long long p2PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     5600        psError(PS_ERR_UNKNOWN, true, "chipPendingExpRow object matched more then one row.  Check your database schema");
     5601        return false;
     5602    }
     5603
     5604    return true;
     5605}
     5606long long chipPendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    56075607{
    56085608    long long       deleted = 0;
    56095609
    56105610    for (long long i = 0; i < objects->n; i++) {
    5611         p2PendingExpRow *object = objects->data[i];
    5612         psMetadata *where = p2PendingExpMetadataFromObject(object);
    5613         long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
     5611        chipPendingExpRow *object = objects->data[i];
     5612        psMetadata *where = chipPendingExpMetadataFromObject(object);
     5613        long long count = psDBDeleteRows(dbh, CHIPPENDINGEXP_TABLE_NAME, where, limit);
    56145614        psFree(where);
    56155615        if (count < 0) {
    5616             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp");
     5616            psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingExp");
    56175617            return count;
    56185618        }
    … …  
    56235623    return deleted;
    56245624}
    5625 bool p2PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     5625bool chipPendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    56265626{
    56275627    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    56295629    psMetadata *output = psMetadataAlloc();
    56305630    for (long i = 0; i < psArrayLength(objects); i++) {
    5631         psMetadata *md = p2PendingExpMetadataFromObject(objects->data[i]);
     5631        psMetadata *md = chipPendingExpMetadataFromObject(objects->data[i]);
    56325632        if (!psMetadataAddMetadata(
    56335633            output,
    56345634            PS_LIST_TAIL,
    5635             P2PENDINGEXP_TABLE_NAME,
     5635            CHIPPENDINGEXP_TABLE_NAME,
    56365636            PS_META_DUPLICATE_OK,
    56375637            NULL,
    … …  
    56545654    return true;
    56555655}
    5656 bool p2PendingExpPrintObject(FILE *stream, p2PendingExpRow *object, bool mdcf)
     5656bool chipPendingExpPrintObject(FILE *stream, chipPendingExpRow *object, bool mdcf)
    56575657{
    56585658    PS_ASSERT_PTR_NON_NULL(object, false);
    56595659
    5660     psMetadata *md = p2PendingExpMetadataFromObject(object);
     5660    psMetadata *md = chipPendingExpMetadataFromObject(object);
    56615661
    56625662    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    56695669    return true;
    56705670}
    5671 static void p2PendingImfileRowFree(p2PendingImfileRow *object);
    5672 
    5673 p2PendingImfileRow *p2PendingImfileRowAlloc(const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *class_id, const char *recipe, const char *uri)
    5674 {
    5675     p2PendingImfileRow *_object;
    5676 
    5677     _object = psAlloc(sizeof(p2PendingImfileRow));
    5678     psMemSetDeallocator(_object, (psFreeFunc)p2PendingImfileRowFree);
     5671static void chipPendingImfileRowFree(chipPendingImfileRow *object);
     5672
     5673chipPendingImfileRow *chipPendingImfileRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri)
     5674{
     5675    chipPendingImfileRow *_object;
     5676
     5677    _object = psAlloc(sizeof(chipPendingImfileRow));
     5678    psMemSetDeallocator(_object, (psFreeFunc)chipPendingImfileRowFree);
    56795679
    56805680    _object->exp_tag = psStringCopy(exp_tag);
    5681     _object->p2_version = p2_version;
    5682     _object->p1_version = p1_version;
     5681    _object->chip_version = chip_version;
     5682    _object->guide_version = guide_version;
    56835683    _object->class_id = psStringCopy(class_id);
    56845684    _object->recipe = psStringCopy(recipe);
    … …  
    56885688}
    56895689
    5690 static void p2PendingImfileRowFree(p2PendingImfileRow *object)
     5690static void chipPendingImfileRowFree(chipPendingImfileRow *object)
    56915691{
    56925692    psFree(object->exp_tag);
    … …  
    56965696}
    56975697
    5698 bool p2PendingImfileCreateTable(psDB *dbh)
     5698bool chipPendingImfileCreateTable(psDB *dbh)
    56995699{
    57005700    psMetadata *md = psMetadataAlloc();
    … …  
    57045704        return false;
    57055705    }
    5706     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, "Primary Key", 0)) {
    5707         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5708         psFree(md);
    5709         return false;
    5710     }
    5711     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) {
    5712         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5706    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
     5707        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5708        psFree(md);
     5709        return false;
     5710    }
     5711    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
     5712        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    57135713        psFree(md);
    57145714        return false;
    … …  
    57305730    }
    57315731
    5732     bool status = psDBCreateTable(dbh, P2PENDINGIMFILE_TABLE_NAME, md);
     5732    bool status = psDBCreateTable(dbh, CHIPPENDINGIMFILE_TABLE_NAME, md);
    57335733
    57345734    psFree(md);
    … …  
    57375737}
    57385738
    5739 bool p2PendingImfileDropTable(psDB *dbh)
    5740 {
    5741     return psDBDropTable(dbh, P2PENDINGIMFILE_TABLE_NAME);
    5742 }
    5743 
    5744 bool p2PendingImfileInsert(psDB * dbh, const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *class_id, const char *recipe, const char *uri)
     5739bool chipPendingImfileDropTable(psDB *dbh)
     5740{
     5741    return psDBDropTable(dbh, CHIPPENDINGIMFILE_TABLE_NAME);
     5742}
     5743
     5744bool chipPendingImfileInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri)
    57455745{
    57465746    psMetadata *md = psMetadataAlloc();
    … …  
    57505750        return false;
    57515751    }
    5752     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    5753         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5754         psFree(md);
    5755         return false;
    5756     }
    5757     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) {
    5758         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5752    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     5753        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5754        psFree(md);
     5755        return false;
     5756    }
     5757    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
     5758        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    57595759        psFree(md);
    57605760        return false;
    … …  
    57765776    }
    57775777
    5778     bool status = psDBInsertOneRow(dbh, P2PENDINGIMFILE_TABLE_NAME, md);
     5778    bool status = psDBInsertOneRow(dbh, CHIPPENDINGIMFILE_TABLE_NAME, md);
    57795779    psFree(md);
    57805780
    … …  
    57825782}
    57835783
    5784 long long p2PendingImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5784long long chipPendingImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    57855785{
    57865786    long long       deleted = 0;
    57875787
    5788     long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
     5788    long long count = psDBDeleteRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, where, limit);
    57895789    if (count < 0) {
    5790         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile");
     5790        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingImfile");
    57915791        return count;
    57925792
    … …  
    57965796    return deleted;
    57975797}
    5798 bool p2PendingImfileInsertObject(psDB *dbh, p2PendingImfileRow *object)
    5799 {
    5800     return p2PendingImfileInsert(dbh, object->exp_tag, object->p2_version, object->p1_version, object->class_id, object->recipe, object->uri);
    5801 }
    5802 
    5803 bool p2PendingImfileInsertObjects(psDB *dbh, psArray *objects)
     5798bool chipPendingImfileInsertObject(psDB *dbh, chipPendingImfileRow *object)
     5799{
     5800    return chipPendingImfileInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->class_id, object->recipe, object->uri);
     5801}
     5802
     5803bool chipPendingImfileInsertObjects(psDB *dbh, psArray *objects)
    58045804{
    58055805    for (long i = 0; i < psArrayLength(objects); i++) {
    5806         if (!p2PendingImfileInsertObject(dbh, objects->data[i])) {
     5806        if (!chipPendingImfileInsertObject(dbh, objects->data[i])) {
    58075807            return false;
    58085808        }
    … …  
    58125812}
    58135813
    5814 bool p2PendingImfileInsertFits(psDB *dbh, const psFits *fits)
     5814bool chipPendingImfileInsertFits(psDB *dbh, const psFits *fits)
    58155815{
    58165816    psArray         *rowSet;
    58175817
    5818     // move to (the first?) extension named  P2PENDINGIMFILE_TABLE_NAME
    5819     if (!psFitsMoveExtName(fits, P2PENDINGIMFILE_TABLE_NAME)) {
    5820         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PENDINGIMFILE_TABLE_NAME);
     5818    // move to (the first?) extension named  CHIPPENDINGIMFILE_TABLE_NAME
     5819    if (!psFitsMoveExtName(fits, CHIPPENDINGIMFILE_TABLE_NAME)) {
     5820        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPPENDINGIMFILE_TABLE_NAME);
    58215821        return false;
    58225822    }
    … …  
    58365836    }
    58375837
    5838     if (!psDBInsertRows(dbh, P2PENDINGIMFILE_TABLE_NAME, rowSet)) {
     5838    if (!psDBInsertRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, rowSet)) {
    58395839        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    58405840        psFree(rowSet);
    … …  
    58475847}
    58485848
    5849 bool p2PendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     5849bool chipPendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    58505850{
    58515851    psArray         *rowSet;
    58525852
    5853     rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
     5853    rowSet = psDBSelectRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, where, limit);
    58545854    if (!rowSet) {
    58555855        return false;
    … …  
    58575857
    58585858    // output to fits
    5859     if (!psFitsWriteTable(fits, NULL, rowSet, P2PENDINGIMFILE_TABLE_NAME)) {
     5859    if (!psFitsWriteTable(fits, NULL, rowSet, CHIPPENDINGIMFILE_TABLE_NAME)) {
    58605860        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    58615861        psFree(rowSet);
    … …  
    58685868}
    58695869
    5870 psMetadata *p2PendingImfileMetadataFromObject(const p2PendingImfileRow *object)
     5870psMetadata *chipPendingImfileMetadataFromObject(const chipPendingImfileRow *object)
    58715871{
    58725872    psMetadata *md = psMetadataAlloc();
    … …  
    58765876        return false;
    58775877    }
    5878     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    5879         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    5880         psFree(md);
    5881         return false;
    5882     }
    5883     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) {
    5884         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     5878    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     5879        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     5880        psFree(md);
     5881        return false;
     5882    }
     5883    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
     5884        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    58855885        psFree(md);
    58865886        return false;
    … …  
    59065906}
    59075907
    5908 p2PendingImfileRow *p2PendingImfileObjectFromMetadata(psMetadata *md)
     5908chipPendingImfileRow *chipPendingImfileObjectFromMetadata(psMetadata *md)
    59095909{
    59105910
    … …  
    59155915        return false;
    59165916    }
    5917     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    5918     if (!status) {
    5919         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    5920         return false;
    5921     }
    5922     psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version");
    5923     if (!status) {
    5924         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
     5917    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     5918    if (!status) {
     5919        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     5920        return false;
     5921    }
     5922    psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
     5923    if (!status) {
     5924        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    59255925        return false;
    59265926    }
    … …  
    59415941    }
    59425942
    5943     return p2PendingImfileRowAlloc(exp_tag, p2_version, p1_version, class_id, recipe, uri);
    5944 }
    5945 psArray *p2PendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     5943    return chipPendingImfileRowAlloc(exp_tag, chip_version, guide_version, class_id, recipe, uri);
     5944}
     5945psArray *chipPendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    59465946{
    59475947    psArray         *rowSet;
    … …  
    59495949    psU64           i;
    59505950
    5951     rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
     5951    rowSet = psDBSelectRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, where, limit);
    59525952    if (!rowSet) {
    59535953        return NULL;
    … …  
    59595959
    59605960    for (i = 0; i < rowSet->n; i++) {
    5961         p2PendingImfileRow *object = p2PendingImfileObjectFromMetadata(rowSet->data[i]);
     5961        chipPendingImfileRow *object = chipPendingImfileObjectFromMetadata(rowSet->data[i]);
    59625962        psArrayAdd(returnSet, 0, object);
    59635963        psFree(object);
    … …  
    59685968    return returnSet;
    59695969}
    5970 bool p2PendingImfileDeleteObject(psDB *dbh, const p2PendingImfileRow *object)
    5971 {
    5972     psMetadata *where = p2PendingImfileMetadataFromObject(object);
    5973     long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, 0);
     5970bool chipPendingImfileDeleteObject(psDB *dbh, const chipPendingImfileRow *object)
     5971{
     5972    psMetadata *where = chipPendingImfileMetadataFromObject(object);
     5973    long long count = psDBDeleteRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, where, 0);
    59745974    psFree(where);
    59755975    if (count < 0) {
    5976         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile");
     5976        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingImfile");
    59775977        return false;
    59785978    }
    … …  
    59805980        // XXX should this be a psAbort() instead?  It is possible that
    59815981        // having an object match multiple rows was by design.
    5982         psError(PS_ERR_UNKNOWN, true, "p2PendingImfileRow object matched more then one row.  Check your database schema");
    5983         return false;
    5984     }
    5985 
    5986     return true;
    5987 }
    5988 long long p2PendingImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     5982        psError(PS_ERR_UNKNOWN, true, "chipPendingImfileRow object matched more then one row.  Check your database schema");
     5983        return false;
     5984    }
     5985
     5986    return true;
     5987}
     5988long long chipPendingImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    59895989{
    59905990    long long       deleted = 0;
    59915991
    59925992    for (long long i = 0; i < objects->n; i++) {
    5993         p2PendingImfileRow *object = objects->data[i];
    5994         psMetadata *where = p2PendingImfileMetadataFromObject(object);
    5995         long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
     5993        chipPendingImfileRow *object = objects->data[i];
     5994        psMetadata *where = chipPendingImfileMetadataFromObject(object);
     5995        long long count = psDBDeleteRows(dbh, CHIPPENDINGIMFILE_TABLE_NAME, where, limit);
    59965996        psFree(where);
    59975997        if (count < 0) {
    5998             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile");
     5998            psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipPendingImfile");
    59995999            return count;
    60006000        }
    … …  
    60056005    return deleted;
    60066006}
    6007 bool p2PendingImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     6007bool chipPendingImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    60086008{
    60096009    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    60116011    psMetadata *output = psMetadataAlloc();
    60126012    for (long i = 0; i < psArrayLength(objects); i++) {
    6013         psMetadata *md = p2PendingImfileMetadataFromObject(objects->data[i]);
     6013        psMetadata *md = chipPendingImfileMetadataFromObject(objects->data[i]);
    60146014        if (!psMetadataAddMetadata(
    60156015            output,
    60166016            PS_LIST_TAIL,
    6017             P2PENDINGIMFILE_TABLE_NAME,
     6017            CHIPPENDINGIMFILE_TABLE_NAME,
    60186018            PS_META_DUPLICATE_OK,
    60196019            NULL,
    … …  
    60366036    return true;
    60376037}
    6038 bool p2PendingImfilePrintObject(FILE *stream, p2PendingImfileRow *object, bool mdcf)
     6038bool chipPendingImfilePrintObject(FILE *stream, chipPendingImfileRow *object, bool mdcf)
    60396039{
    60406040    PS_ASSERT_PTR_NON_NULL(object, false);
    60416041
    6042     psMetadata *md = p2PendingImfileMetadataFromObject(object);
     6042    psMetadata *md = chipPendingImfileMetadataFromObject(object);
    60436043
    60446044    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    60516051    return true;
    60526052}
    6053 static void p2ProcessedExpRowFree(p2ProcessedExpRow *object);
    6054 
    6055 p2ProcessedExpRow *p2ProcessedExpRowAlloc(const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *label, const char *expgroup, const char *dvodb)
    6056 {
    6057     p2ProcessedExpRow *_object;
    6058 
    6059     _object = psAlloc(sizeof(p2ProcessedExpRow));
    6060     psMemSetDeallocator(_object, (psFreeFunc)p2ProcessedExpRowFree);
     6053static void chipProcessedExpRowFree(chipProcessedExpRow *object);
     6054
     6055chipProcessedExpRow *chipProcessedExpRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *expgroup, const char *dvodb)
     6056{
     6057    chipProcessedExpRow *_object;
     6058
     6059    _object = psAlloc(sizeof(chipProcessedExpRow));
     6060    psMemSetDeallocator(_object, (psFreeFunc)chipProcessedExpRowFree);
    60616061
    60626062    _object->exp_tag = psStringCopy(exp_tag);
    6063     _object->p2_version = p2_version;
    6064     _object->p1_version = p1_version;
     6063    _object->chip_version = chip_version;
     6064    _object->guide_version = guide_version;
    60656065    _object->label = psStringCopy(label);
    60666066    _object->expgroup = psStringCopy(expgroup);
    … …  
    60706070}
    60716071
    6072 static void p2ProcessedExpRowFree(p2ProcessedExpRow *object)
     6072static void chipProcessedExpRowFree(chipProcessedExpRow *object)
    60736073{
    60746074    psFree(object->exp_tag);
    … …  
    60786078}
    60796079
    6080 bool p2ProcessedExpCreateTable(psDB *dbh)
     6080bool chipProcessedExpCreateTable(psDB *dbh)
    60816081{
    60826082    psMetadata *md = psMetadataAlloc();
    … …  
    60866086        return false;
    60876087    }
    6088     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, "Primary Key", 0)) {
    6089         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6090         psFree(md);
    6091         return false;
    6092     }
    6093     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) {
    6094         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6088    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
     6089        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6090        psFree(md);
     6091        return false;
     6092    }
     6093    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
     6094        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    60956095        psFree(md);
    60966096        return false;
    … …  
    61126112    }
    61136113
    6114     bool status = psDBCreateTable(dbh, P2PROCESSEDEXP_TABLE_NAME, md);
     6114    bool status = psDBCreateTable(dbh, CHIPPROCESSEDEXP_TABLE_NAME, md);
    61156115
    61166116    psFree(md);
    … …  
    61196119}
    61206120
    6121 bool p2ProcessedExpDropTable(psDB *dbh)
    6122 {
    6123     return psDBDropTable(dbh, P2PROCESSEDEXP_TABLE_NAME);
    6124 }
    6125 
    6126 bool p2ProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *label, const char *expgroup, const char *dvodb)
     6121bool chipProcessedExpDropTable(psDB *dbh)
     6122{
     6123    return psDBDropTable(dbh, CHIPPROCESSEDEXP_TABLE_NAME);
     6124}
     6125
     6126bool chipProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *expgroup, const char *dvodb)
    61276127{
    61286128    psMetadata *md = psMetadataAlloc();
    … …  
    61326132        return false;
    61336133    }
    6134     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    6135         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6136         psFree(md);
    6137         return false;
    6138     }
    6139     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) {
    6140         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6134    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     6135        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6136        psFree(md);
     6137        return false;
     6138    }
     6139    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
     6140        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    61416141        psFree(md);
    61426142        return false;
    … …  
    61586158    }
    61596159
    6160     bool status = psDBInsertOneRow(dbh, P2PROCESSEDEXP_TABLE_NAME, md);
     6160    bool status = psDBInsertOneRow(dbh, CHIPPROCESSEDEXP_TABLE_NAME, md);
    61616161    psFree(md);
    61626162
    … …  
    61646164}
    61656165
    6166 long long p2ProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     6166long long chipProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    61676167{
    61686168    long long       deleted = 0;
    61696169
    6170     long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
     6170    long long count = psDBDeleteRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, where, limit);
    61716171    if (count < 0) {
    6172         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp");
     6172        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedExp");
    61736173        return count;
    61746174
    … …  
    61786178    return deleted;
    61796179}
    6180 bool p2ProcessedExpInsertObject(psDB *dbh, p2ProcessedExpRow *object)
    6181 {
    6182     return p2ProcessedExpInsert(dbh, object->exp_tag, object->p2_version, object->p1_version, object->label, object->expgroup, object->dvodb);
    6183 }
    6184 
    6185 bool p2ProcessedExpInsertObjects(psDB *dbh, psArray *objects)
     6180bool chipProcessedExpInsertObject(psDB *dbh, chipProcessedExpRow *object)
     6181{
     6182    return chipProcessedExpInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->label, object->expgroup, object->dvodb);
     6183}
     6184
     6185bool chipProcessedExpInsertObjects(psDB *dbh, psArray *objects)
    61866186{
    61876187    for (long i = 0; i < psArrayLength(objects); i++) {
    6188         if (!p2ProcessedExpInsertObject(dbh, objects->data[i])) {
     6188        if (!chipProcessedExpInsertObject(dbh, objects->data[i])) {
    61896189            return false;
    61906190        }
    … …  
    61946194}
    61956195
    6196 bool p2ProcessedExpInsertFits(psDB *dbh, const psFits *fits)
     6196bool chipProcessedExpInsertFits(psDB *dbh, const psFits *fits)
    61976197{
    61986198    psArray         *rowSet;
    61996199
    6200     // move to (the first?) extension named  P2PROCESSEDEXP_TABLE_NAME
    6201     if (!psFitsMoveExtName(fits, P2PROCESSEDEXP_TABLE_NAME)) {
    6202         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PROCESSEDEXP_TABLE_NAME);
     6200    // move to (the first?) extension named  CHIPPROCESSEDEXP_TABLE_NAME
     6201    if (!psFitsMoveExtName(fits, CHIPPROCESSEDEXP_TABLE_NAME)) {
     6202        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPPROCESSEDEXP_TABLE_NAME);
    62036203        return false;
    62046204    }
    … …  
    62186218    }
    62196219
    6220     if (!psDBInsertRows(dbh, P2PROCESSEDEXP_TABLE_NAME, rowSet)) {
     6220    if (!psDBInsertRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, rowSet)) {
    62216221        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    62226222        psFree(rowSet);
    … …  
    62296229}
    62306230
    6231 bool p2ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     6231bool chipProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    62326232{
    62336233    psArray         *rowSet;
    62346234
    6235     rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
     6235    rowSet = psDBSelectRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, where, limit);
    62366236    if (!rowSet) {
    62376237        return false;
    … …  
    62396239
    62406240    // output to fits
    6241     if (!psFitsWriteTable(fits, NULL, rowSet, P2PROCESSEDEXP_TABLE_NAME)) {
     6241    if (!psFitsWriteTable(fits, NULL, rowSet, CHIPPROCESSEDEXP_TABLE_NAME)) {
    62426242        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    62436243        psFree(rowSet);
    … …  
    62506250}
    62516251
    6252 psMetadata *p2ProcessedExpMetadataFromObject(const p2ProcessedExpRow *object)
     6252psMetadata *chipProcessedExpMetadataFromObject(const chipProcessedExpRow *object)
    62536253{
    62546254    psMetadata *md = psMetadataAlloc();
    … …  
    62586258        return false;
    62596259    }
    6260     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    6261         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6262         psFree(md);
    6263         return false;
    6264     }
    6265     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) {
    6266         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6260    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     6261        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6262        psFree(md);
     6263        return false;
     6264    }
     6265    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
     6266        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    62676267        psFree(md);
    62686268        return false;
    … …  
    62886288}
    62896289
    6290 p2ProcessedExpRow *p2ProcessedExpObjectFromMetadata(psMetadata *md)
     6290chipProcessedExpRow *chipProcessedExpObjectFromMetadata(psMetadata *md)
    62916291{
    62926292
    … …  
    62976297        return false;
    62986298    }
    6299     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    6300     if (!status) {
    6301         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    6302         return false;
    6303     }
    6304     psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version");
    6305     if (!status) {
    6306         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
     6299    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     6300    if (!status) {
     6301        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     6302        return false;
     6303    }
     6304    psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
     6305    if (!status) {
     6306        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    63076307        return false;
    63086308    }
    … …  
    63236323    }
    63246324
    6325     return p2ProcessedExpRowAlloc(exp_tag, p2_version, p1_version, label, expgroup, dvodb);
    6326 }
    6327 psArray *p2ProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     6325    return chipProcessedExpRowAlloc(exp_tag, chip_version, guide_version, label, expgroup, dvodb);
     6326}
     6327psArray *chipProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    63286328{
    63296329    psArray         *rowSet;
    … …  
    63316331    psU64           i;
    63326332
    6333     rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
     6333    rowSet = psDBSelectRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, where, limit);
    63346334    if (!rowSet) {
    63356335        return NULL;
    … …  
    63416341
    63426342    for (i = 0; i < rowSet->n; i++) {
    6343         p2ProcessedExpRow *object = p2ProcessedExpObjectFromMetadata(rowSet->data[i]);
     6343        chipProcessedExpRow *object = chipProcessedExpObjectFromMetadata(rowSet->data[i]);
    63446344        psArrayAdd(returnSet, 0, object);
    63456345        psFree(object);
    … …  
    63506350    return returnSet;
    63516351}
    6352 bool p2ProcessedExpDeleteObject(psDB *dbh, const p2ProcessedExpRow *object)
    6353 {
    6354     psMetadata *where = p2ProcessedExpMetadataFromObject(object);
    6355     long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, 0);
     6352bool chipProcessedExpDeleteObject(psDB *dbh, const chipProcessedExpRow *object)
     6353{
     6354    psMetadata *where = chipProcessedExpMetadataFromObject(object);
     6355    long long count = psDBDeleteRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, where, 0);
    63566356    psFree(where);
    63576357    if (count < 0) {
    6358         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp");
     6358        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedExp");
    63596359        return false;
    63606360    }
    … …  
    63626362        // XXX should this be a psAbort() instead?  It is possible that
    63636363        // having an object match multiple rows was by design.
    6364         psError(PS_ERR_UNKNOWN, true, "p2ProcessedExpRow object matched more then one row.  Check your database schema");
    6365         return false;
    6366     }
    6367 
    6368     return true;
    6369 }
    6370 long long p2ProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     6364        psError(PS_ERR_UNKNOWN, true, "chipProcessedExpRow object matched more then one row.  Check your database schema");
     6365        return false;
     6366    }
     6367
     6368    return true;
     6369}
     6370long long chipProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    63716371{
    63726372    long long       deleted = 0;
    63736373
    63746374    for (long long i = 0; i < objects->n; i++) {
    6375         p2ProcessedExpRow *object = objects->data[i];
    6376         psMetadata *where = p2ProcessedExpMetadataFromObject(object);
    6377         long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
     6375        chipProcessedExpRow *object = objects->data[i];
     6376        psMetadata *where = chipProcessedExpMetadataFromObject(object);
     6377        long long count = psDBDeleteRows(dbh, CHIPPROCESSEDEXP_TABLE_NAME, where, limit);
    63786378        psFree(where);
    63796379        if (count < 0) {
    6380             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp");
     6380            psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedExp");
    63816381            return count;
    63826382        }
    … …  
    63876387    return deleted;
    63886388}
    6389 bool p2ProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     6389bool chipProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    63906390{
    63916391    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    63936393    psMetadata *output = psMetadataAlloc();
    63946394    for (long i = 0; i < psArrayLength(objects); i++) {
    6395         psMetadata *md = p2ProcessedExpMetadataFromObject(objects->data[i]);
     6395        psMetadata *md = chipProcessedExpMetadataFromObject(objects->data[i]);
    63966396        if (!psMetadataAddMetadata(
    63976397            output,
    63986398            PS_LIST_TAIL,
    6399             P2PROCESSEDEXP_TABLE_NAME,
     6399            CHIPPROCESSEDEXP_TABLE_NAME,
    64006400            PS_META_DUPLICATE_OK,
    64016401            NULL,
    … …  
    64186418    return true;
    64196419}
    6420 bool p2ProcessedExpPrintObject(FILE *stream, p2ProcessedExpRow *object, bool mdcf)
     6420bool chipProcessedExpPrintObject(FILE *stream, chipProcessedExpRow *object, bool mdcf)
    64216421{
    64226422    PS_ASSERT_PTR_NON_NULL(object, false);
    64236423
    6424     psMetadata *md = p2ProcessedExpMetadataFromObject(object);
     6424    psMetadata *md = chipProcessedExpMetadataFromObject(object);
    64256425
    64266426    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    64336433    return true;
    64346434}
    6435 static void p2MaskRowFree(p2MaskRow *object);
    6436 
    6437 p2MaskRow *p2MaskRowAlloc(const char *label)
    6438 {
    6439     p2MaskRow       *_object;
    6440 
    6441     _object = psAlloc(sizeof(p2MaskRow));
    6442     psMemSetDeallocator(_object, (psFreeFunc)p2MaskRowFree);
     6435static void chipMaskRowFree(chipMaskRow *object);
     6436
     6437chipMaskRow *chipMaskRowAlloc(const char *label)
     6438{
     6439    chipMaskRow     *_object;
     6440
     6441    _object = psAlloc(sizeof(chipMaskRow));
     6442    psMemSetDeallocator(_object, (psFreeFunc)chipMaskRowFree);
    64436443
    64446444    _object->label = psStringCopy(label);
    … …  
    64476447}
    64486448
    6449 static void p2MaskRowFree(p2MaskRow *object)
     6449static void chipMaskRowFree(chipMaskRow *object)
    64506450{
    64516451    psFree(object->label);
    64526452}
    64536453
    6454 bool p2MaskCreateTable(psDB *dbh)
     6454bool chipMaskCreateTable(psDB *dbh)
    64556455{
    64566456    psMetadata *md = psMetadataAlloc();
    … …  
    64616461    }
    64626462
    6463     bool status = psDBCreateTable(dbh, P2MASK_TABLE_NAME, md);
     6463    bool status = psDBCreateTable(dbh, CHIPMASK_TABLE_NAME, md);
    64646464
    64656465    psFree(md);
    … …  
    64686468}
    64696469
    6470 bool p2MaskDropTable(psDB *dbh)
    6471 {
    6472     return psDBDropTable(dbh, P2MASK_TABLE_NAME);
    6473 }
    6474 
    6475 bool p2MaskInsert(psDB * dbh, const char *label)
     6470bool chipMaskDropTable(psDB *dbh)
     6471{
     6472    return psDBDropTable(dbh, CHIPMASK_TABLE_NAME);
     6473}
     6474
     6475bool chipMaskInsert(psDB * dbh, const char *label)
    64766476{
    64776477    psMetadata *md = psMetadataAlloc();
    … …  
    64826482    }
    64836483
    6484     bool status = psDBInsertOneRow(dbh, P2MASK_TABLE_NAME, md);
     6484    bool status = psDBInsertOneRow(dbh, CHIPMASK_TABLE_NAME, md);
    64856485    psFree(md);
    64866486
    … …  
    64886488}
    64896489
    6490 long long p2MaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     6490long long chipMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    64916491{
    64926492    long long       deleted = 0;
    64936493
    6494     long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, limit);
     6494    long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, limit);
    64956495    if (count < 0) {
    6496         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask");
     6496        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask");
    64976497        return count;
    64986498
    … …  
    65026502    return deleted;
    65036503}
    6504 bool p2MaskInsertObject(psDB *dbh, p2MaskRow *object)
    6505 {
    6506     return p2MaskInsert(dbh, object->label);
    6507 }
    6508 
    6509 bool p2MaskInsertObjects(psDB *dbh, psArray *objects)
     6504bool chipMaskInsertObject(psDB *dbh, chipMaskRow *object)
     6505{
     6506    return chipMaskInsert(dbh, object->label);
     6507}
     6508
     6509bool chipMaskInsertObjects(psDB *dbh, psArray *objects)
    65106510{
    65116511    for (long i = 0; i < psArrayLength(objects); i++) {
    6512         if (!p2MaskInsertObject(dbh, objects->data[i])) {
     6512        if (!chipMaskInsertObject(dbh, objects->data[i])) {
    65136513            return false;
    65146514        }
    … …  
    65186518}
    65196519
    6520 bool p2MaskInsertFits(psDB *dbh, const psFits *fits)
     6520bool chipMaskInsertFits(psDB *dbh, const psFits *fits)
    65216521{
    65226522    psArray         *rowSet;
    65236523
    6524     // move to (the first?) extension named  P2MASK_TABLE_NAME
    6525     if (!psFitsMoveExtName(fits, P2MASK_TABLE_NAME)) {
    6526         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2MASK_TABLE_NAME);
     6524    // move to (the first?) extension named  CHIPMASK_TABLE_NAME
     6525    if (!psFitsMoveExtName(fits, CHIPMASK_TABLE_NAME)) {
     6526        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPMASK_TABLE_NAME);
    65276527        return false;
    65286528    }
    … …  
    65426542    }
    65436543
    6544     if (!psDBInsertRows(dbh, P2MASK_TABLE_NAME, rowSet)) {
     6544    if (!psDBInsertRows(dbh, CHIPMASK_TABLE_NAME, rowSet)) {
    65456545        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    65466546        psFree(rowSet);
    … …  
    65536553}
    65546554
    6555 bool p2MaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     6555bool chipMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    65566556{
    65576557    psArray         *rowSet;
    65586558
    6559     rowSet = psDBSelectRows(dbh, P2MASK_TABLE_NAME, where, limit);
     6559    rowSet = psDBSelectRows(dbh, CHIPMASK_TABLE_NAME, where, limit);
    65606560    if (!rowSet) {
    65616561        return false;
    … …  
    65636563
    65646564    // output to fits
    6565     if (!psFitsWriteTable(fits, NULL, rowSet, P2MASK_TABLE_NAME)) {
     6565    if (!psFitsWriteTable(fits, NULL, rowSet, CHIPMASK_TABLE_NAME)) {
    65666566        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    65676567        psFree(rowSet);
    … …  
    65746574}
    65756575
    6576 psMetadata *p2MaskMetadataFromObject(const p2MaskRow *object)
     6576psMetadata *chipMaskMetadataFromObject(const chipMaskRow *object)
    65776577{
    65786578    psMetadata *md = psMetadataAlloc();
    … …  
    65876587}
    65886588
    6589 p2MaskRow *p2MaskObjectFromMetadata(psMetadata *md)
     6589chipMaskRow *chipMaskObjectFromMetadata(psMetadata *md)
    65906590{
    65916591
    … …  
    65976597    }
    65986598
    6599     return p2MaskRowAlloc(label);
    6600 }
    6601 psArray *p2MaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     6599    return chipMaskRowAlloc(label);
     6600}
     6601psArray *chipMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    66026602{
    66036603    psArray         *rowSet;
    … …  
    66056605    psU64           i;
    66066606
    6607     rowSet = psDBSelectRows(dbh, P2MASK_TABLE_NAME, where, limit);
     6607    rowSet = psDBSelectRows(dbh, CHIPMASK_TABLE_NAME, where, limit);
    66086608    if (!rowSet) {
    66096609        return NULL;
    … …  
    66156615
    66166616    for (i = 0; i < rowSet->n; i++) {
    6617         p2MaskRow *object = p2MaskObjectFromMetadata(rowSet->data[i]);
     6617        chipMaskRow *object = chipMaskObjectFromMetadata(rowSet->data[i]);
    66186618        psArrayAdd(returnSet, 0, object);
    66196619        psFree(object);
    … …  
    66246624    return returnSet;
    66256625}
    6626 bool p2MaskDeleteObject(psDB *dbh, const p2MaskRow *object)
    6627 {
    6628     psMetadata *where = p2MaskMetadataFromObject(object);
    6629     long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, 0);
     6626bool chipMaskDeleteObject(psDB *dbh, const chipMaskRow *object)
     6627{
     6628    psMetadata *where = chipMaskMetadataFromObject(object);
     6629    long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, 0);
    66306630    psFree(where);
    66316631    if (count < 0) {
    6632         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask");
     6632        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask");
    66336633        return false;
    66346634    }
    … …  
    66366636        // XXX should this be a psAbort() instead?  It is possible that
    66376637        // having an object match multiple rows was by design.
    6638         psError(PS_ERR_UNKNOWN, true, "p2MaskRow object matched more then one row.  Check your database schema");
    6639         return false;
    6640     }
    6641 
    6642     return true;
    6643 }
    6644 long long p2MaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     6638        psError(PS_ERR_UNKNOWN, true, "chipMaskRow object matched more then one row.  Check your database schema");
     6639        return false;
     6640    }
     6641
     6642    return true;
     6643}
     6644long long chipMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    66456645{
    66466646    long long       deleted = 0;
    66476647
    66486648    for (long long i = 0; i < objects->n; i++) {
    6649         p2MaskRow *object = objects->data[i];
    6650         psMetadata *where = p2MaskMetadataFromObject(object);
    6651         long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, limit);
     6649        chipMaskRow *object = objects->data[i];
     6650        psMetadata *where = chipMaskMetadataFromObject(object);
     6651        long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, limit);
    66526652        psFree(where);
    66536653        if (count < 0) {
    6654             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask");
     6654            psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask");
    66556655            return count;
    66566656        }
    … …  
    66616661    return deleted;
    66626662}
    6663 bool p2MaskPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     6663bool chipMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    66646664{
    66656665    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    66676667    psMetadata *output = psMetadataAlloc();
    66686668    for (long i = 0; i < psArrayLength(objects); i++) {
    6669         psMetadata *md = p2MaskMetadataFromObject(objects->data[i]);
     6669        psMetadata *md = chipMaskMetadataFromObject(objects->data[i]);
    66706670        if (!psMetadataAddMetadata(
    66716671            output,
    66726672            PS_LIST_TAIL,
    6673             P2MASK_TABLE_NAME,
     6673            CHIPMASK_TABLE_NAME,
    66746674            PS_META_DUPLICATE_OK,
    66756675            NULL,
    … …  
    66926692    return true;
    66936693}
    6694 bool p2MaskPrintObject(FILE *stream, p2MaskRow *object, bool mdcf)
     6694bool chipMaskPrintObject(FILE *stream, chipMaskRow *object, bool mdcf)
    66956695{
    66966696    PS_ASSERT_PTR_NON_NULL(object, false);
    66976697
    6698     psMetadata *md = p2MaskMetadataFromObject(object);
     6698    psMetadata *md = chipMaskMetadataFromObject(object);
    66996699
    67006700    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    67076707    return true;
    67086708}
    6709 static void p2ProcessedImfileRowFree(p2ProcessedImfileRow *object);
    6710 
    6711 p2ProcessedImfileRow *p2ProcessedImfileRowAlloc(const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault)
    6712 {
    6713     p2ProcessedImfileRow *_object;
    6714 
    6715     _object = psAlloc(sizeof(p2ProcessedImfileRow));
    6716     psMemSetDeallocator(_object, (psFreeFunc)p2ProcessedImfileRowFree);
     6709static void chipProcessedImfileRowFree(chipProcessedImfileRow *object);
     6710
     6711chipProcessedImfileRow *chipProcessedImfileRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault)
     6712{
     6713    chipProcessedImfileRow *_object;
     6714
     6715    _object = psAlloc(sizeof(chipProcessedImfileRow));
     6716    psMemSetDeallocator(_object, (psFreeFunc)chipProcessedImfileRowFree);
    67176717
    67186718    _object->exp_tag = psStringCopy(exp_tag);
    6719     _object->p2_version = p2_version;
    6720     _object->p1_version = p1_version;
     6719    _object->chip_version = chip_version;
     6720    _object->guide_version = guide_version;
    67216721    _object->class_id = psStringCopy(class_id);
    67226722    _object->recipe = psStringCopy(recipe);
    … …  
    67326732}
    67336733
    6734 static void p2ProcessedImfileRowFree(p2ProcessedImfileRow *object)
     6734static void chipProcessedImfileRowFree(chipProcessedImfileRow *object)
    67356735{
    67366736    psFree(object->exp_tag);
    … …  
    67426742}
    67436743
    6744 bool p2ProcessedImfileCreateTable(psDB *dbh)
     6744bool chipProcessedImfileCreateTable(psDB *dbh)
    67456745{
    67466746    psMetadata *md = psMetadataAlloc();
    … …  
    67506750        return false;
    67516751    }
    6752     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, "Primary Key", 0)) {
    6753         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6754         psFree(md);
    6755         return false;
    6756     }
    6757     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) {
    6758         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6752    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
     6753        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6754        psFree(md);
     6755        return false;
     6756    }
     6757    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
     6758        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    67596759        psFree(md);
    67606760        return false;
    … …  
    68066806    }
    68076807
    6808     bool status = psDBCreateTable(dbh, P2PROCESSEDIMFILE_TABLE_NAME, md);
     6808    bool status = psDBCreateTable(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, md);
    68096809
    68106810    psFree(md);
    … …  
    68136813}
    68146814
    6815 bool p2ProcessedImfileDropTable(psDB *dbh)
    6816 {
    6817     return psDBDropTable(dbh, P2PROCESSEDIMFILE_TABLE_NAME);
    6818 }
    6819 
    6820 bool p2ProcessedImfileInsert(psDB * dbh, const char *exp_tag, psS32 p2_version, psS32 p1_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault)
     6815bool chipProcessedImfileDropTable(psDB *dbh)
     6816{
     6817    return psDBDropTable(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME);
     6818}
     6819
     6820bool chipProcessedImfileInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault)
    68216821{
    68226822    psMetadata *md = psMetadataAlloc();
    … …  
    68266826        return false;
    68276827    }
    6828     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    6829         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6830         psFree(md);
    6831         return false;
    6832     }
    6833     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) {
    6834         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6828    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     6829        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6830        psFree(md);
     6831        return false;
     6832    }
     6833    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
     6834        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    68356835        psFree(md);
    68366836        return false;
    … …  
    68826882    }
    68836883
    6884     bool status = psDBInsertOneRow(dbh, P2PROCESSEDIMFILE_TABLE_NAME, md);
     6884    bool status = psDBInsertOneRow(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, md);
    68856885    psFree(md);
    68866886
    … …  
    68886888}
    68896889
    6890 long long p2ProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     6890long long chipProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    68916891{
    68926892    long long       deleted = 0;
    68936893
    6894     long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
     6894    long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit);
    68956895    if (count < 0) {
    6896         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile");
     6896        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile");
    68976897        return count;
    68986898
    … …  
    69026902    return deleted;
    69036903}
    6904 bool p2ProcessedImfileInsertObject(psDB *dbh, p2ProcessedImfileRow *object)
    6905 {
    6906     return p2ProcessedImfileInsert(dbh, object->exp_tag, object->p2_version, object->p1_version, object->class_id, object->recipe, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, object->fault);
    6907 }
    6908 
    6909 bool p2ProcessedImfileInsertObjects(psDB *dbh, psArray *objects)
     6904bool chipProcessedImfileInsertObject(psDB *dbh, chipProcessedImfileRow *object)
     6905{
     6906    return chipProcessedImfileInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->class_id, object->recipe, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, object->fault);
     6907}
     6908
     6909bool chipProcessedImfileInsertObjects(psDB *dbh, psArray *objects)
    69106910{
    69116911    for (long i = 0; i < psArrayLength(objects); i++) {
    6912         if (!p2ProcessedImfileInsertObject(dbh, objects->data[i])) {
     6912        if (!chipProcessedImfileInsertObject(dbh, objects->data[i])) {
    69136913            return false;
    69146914        }
    … …  
    69186918}
    69196919
    6920 bool p2ProcessedImfileInsertFits(psDB *dbh, const psFits *fits)
     6920bool chipProcessedImfileInsertFits(psDB *dbh, const psFits *fits)
    69216921{
    69226922    psArray         *rowSet;
    69236923
    6924     // move to (the first?) extension named  P2PROCESSEDIMFILE_TABLE_NAME
    6925     if (!psFitsMoveExtName(fits, P2PROCESSEDIMFILE_TABLE_NAME)) {
    6926         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PROCESSEDIMFILE_TABLE_NAME);
     6924    // move to (the first?) extension named  CHIPPROCESSEDIMFILE_TABLE_NAME
     6925    if (!psFitsMoveExtName(fits, CHIPPROCESSEDIMFILE_TABLE_NAME)) {
     6926        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPPROCESSEDIMFILE_TABLE_NAME);
    69276927        return false;
    69286928    }
    … …  
    69426942    }
    69436943
    6944     if (!psDBInsertRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, rowSet)) {
     6944    if (!psDBInsertRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, rowSet)) {
    69456945        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    69466946        psFree(rowSet);
    … …  
    69536953}
    69546954
    6955 bool p2ProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     6955bool chipProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    69566956{
    69576957    psArray         *rowSet;
    69586958
    6959     rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
     6959    rowSet = psDBSelectRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit);
    69606960    if (!rowSet) {
    69616961        return false;
    … …  
    69636963
    69646964    // output to fits
    6965     if (!psFitsWriteTable(fits, NULL, rowSet, P2PROCESSEDIMFILE_TABLE_NAME)) {
     6965    if (!psFitsWriteTable(fits, NULL, rowSet, CHIPPROCESSEDIMFILE_TABLE_NAME)) {
    69666966        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    69676967        psFree(rowSet);
    … …  
    69746974}
    69756975
    6976 psMetadata *p2ProcessedImfileMetadataFromObject(const p2ProcessedImfileRow *object)
     6976psMetadata *chipProcessedImfileMetadataFromObject(const chipProcessedImfileRow *object)
    69776977{
    69786978    psMetadata *md = psMetadataAlloc();
    … …  
    69826982        return false;
    69836983    }
    6984     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    6985         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
    6986         psFree(md);
    6987         return false;
    6988     }
    6989     if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) {
    6990         psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version");
     6984    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     6985        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     6986        psFree(md);
     6987        return false;
     6988    }
     6989    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
     6990        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    69916991        psFree(md);
    69926992        return false;
    … …  
    70427042}
    70437043
    7044 p2ProcessedImfileRow *p2ProcessedImfileObjectFromMetadata(psMetadata *md)
     7044chipProcessedImfileRow *chipProcessedImfileObjectFromMetadata(psMetadata *md)
    70457045{
    70467046
    … …  
    70517051        return false;
    70527052    }
    7053     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    7054     if (!status) {
    7055         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    7056         return false;
    7057     }
    7058     psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version");
    7059     if (!status) {
    7060         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
     7053    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     7054    if (!status) {
     7055        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     7056        return false;
     7057    }
     7058    psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
     7059    if (!status) {
     7060        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    70617061        return false;
    70627062    }
    … …  
    71077107    }
    71087108
    7109     return p2ProcessedImfileRowAlloc(exp_tag, p2_version, p1_version, class_id, recipe, uri, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, fault);
    7110 }
    7111 psArray *p2ProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     7109    return chipProcessedImfileRowAlloc(exp_tag, chip_version, guide_version, class_id, recipe, uri, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, fault);
     7110}
     7111psArray *chipProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    71127112{
    71137113    psArray         *rowSet;
    … …  
    71157115    psU64           i;
    71167116
    7117     rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
     7117    rowSet = psDBSelectRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit);
    71187118    if (!rowSet) {
    71197119        return NULL;
    … …  
    71257125
    71267126    for (i = 0; i < rowSet->n; i++) {
    7127         p2ProcessedImfileRow *object = p2ProcessedImfileObjectFromMetadata(rowSet->data[i]);
     7127        chipProcessedImfileRow *object = chipProcessedImfileObjectFromMetadata(rowSet->data[i]);
    71287128        psArrayAdd(returnSet, 0, object);
    71297129        psFree(object);
    … …  
    71347134    return returnSet;
    71357135}
    7136 bool p2ProcessedImfileDeleteObject(psDB *dbh, const p2ProcessedImfileRow *object)
    7137 {
    7138     psMetadata *where = p2ProcessedImfileMetadataFromObject(object);
    7139     long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, 0);
     7136bool chipProcessedImfileDeleteObject(psDB *dbh, const chipProcessedImfileRow *object)
     7137{
     7138    psMetadata *where = chipProcessedImfileMetadataFromObject(object);
     7139    long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, 0);
    71407140    psFree(where);
    71417141    if (count < 0) {
    7142         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile");
     7142        psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile");
    71437143        return false;
    71447144    }
    … …  
    71467146        // XXX should this be a psAbort() instead?  It is possible that
    71477147        // having an object match multiple rows was by design.
    7148         psError(PS_ERR_UNKNOWN, true, "p2ProcessedImfileRow object matched more then one row.  Check your database schema");
    7149         return false;
    7150     }
    7151 
    7152     return true;
    7153 }
    7154 long long p2ProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     7148        psError(PS_ERR_UNKNOWN, true, "chipProcessedImfileRow object matched more then one row.  Check your database schema");
     7149        return false;
     7150    }
     7151
     7152    return true;
     7153}
     7154long long chipProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    71557155{
    71567156    long long       deleted = 0;
    71577157
    71587158    for (long long i = 0; i < objects->n; i++) {
    7159         p2ProcessedImfileRow *object = objects->data[i];
    7160         psMetadata *where = p2ProcessedImfileMetadataFromObject(object);
    7161         long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
     7159        chipProcessedImfileRow *object = objects->data[i];
     7160        psMetadata *where = chipProcessedImfileMetadataFromObject(object);
     7161        long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit);
    71627162        psFree(where);
    71637163        if (count < 0) {
    7164             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile");
     7164            psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile");
    71657165            return count;
    71667166        }
    … …  
    71717171    return deleted;
    71727172}
    7173 bool p2ProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     7173bool chipProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    71747174{
    71757175    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    71777177    psMetadata *output = psMetadataAlloc();
    71787178    for (long i = 0; i < psArrayLength(objects); i++) {
    7179         psMetadata *md = p2ProcessedImfileMetadataFromObject(objects->data[i]);
     7179        psMetadata *md = chipProcessedImfileMetadataFromObject(objects->data[i]);
    71807180        if (!psMetadataAddMetadata(
    71817181            output,
    71827182            PS_LIST_TAIL,
    7183             P2PROCESSEDIMFILE_TABLE_NAME,
     7183            CHIPPROCESSEDIMFILE_TABLE_NAME,
    71847184            PS_META_DUPLICATE_OK,
    71857185            NULL,
    … …  
    72027202    return true;
    72037203}
    7204 bool p2ProcessedImfilePrintObject(FILE *stream, p2ProcessedImfileRow *object, bool mdcf)
     7204bool chipProcessedImfilePrintObject(FILE *stream, chipProcessedImfileRow *object, bool mdcf)
    72057205{
    72067206    PS_ASSERT_PTR_NON_NULL(object, false);
    72077207
    7208     psMetadata *md = p2ProcessedImfileMetadataFromObject(object);
     7208    psMetadata *md = chipProcessedImfileMetadataFromObject(object);
    72097209
    72107210    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    72177217    return true;
    72187218}
    7219 static void p3PendingExpRowFree(p3PendingExpRow *object);
    7220 
    7221 p3PendingExpRow *p3PendingExpRowAlloc(const char *exp_tag, psS32 p3_version, psS32 p2_version, const char *label, const char *expgroup, const char *dvodb)
    7222 {
    7223     p3PendingExpRow *_object;
    7224 
    7225     _object = psAlloc(sizeof(p3PendingExpRow));
    7226     psMemSetDeallocator(_object, (psFreeFunc)p3PendingExpRowFree);
     7219static void camPendingExpRowFree(camPendingExpRow *object);
     7220
     7221camPendingExpRow *camPendingExpRowAlloc(const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *expgroup, const char *dvodb)
     7222{
     7223    camPendingExpRow *_object;
     7224
     7225    _object = psAlloc(sizeof(camPendingExpRow));
     7226    psMemSetDeallocator(_object, (psFreeFunc)camPendingExpRowFree);
    72277227
    72287228    _object->exp_tag = psStringCopy(exp_tag);
    7229     _object->p3_version = p3_version;
    7230     _object->p2_version = p2_version;
     7229    _object->cam_version = cam_version;
     7230    _object->chip_version = chip_version;
    72317231    _object->label = psStringCopy(label);
    72327232    _object->expgroup = psStringCopy(expgroup);
    … …  
    72367236}
    72377237
    7238 static void p3PendingExpRowFree(p3PendingExpRow *object)
     7238static void camPendingExpRowFree(camPendingExpRow *object)
    72397239{
    72407240    psFree(object->exp_tag);
    … …  
    72447244}
    72457245
    7246 bool p3PendingExpCreateTable(psDB *dbh)
     7246bool camPendingExpCreateTable(psDB *dbh)
    72477247{
    72487248    psMetadata *md = psMetadataAlloc();
    … …  
    72527252        return false;
    72537253    }
    7254     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
    7255         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7256         psFree(md);
    7257         return false;
    7258     }
    7259     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) {
    7260         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7254    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
     7255        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7256        psFree(md);
     7257        return false;
     7258    }
     7259    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, 0)) {
     7260        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    72617261        psFree(md);
    72627262        return false;
    … …  
    72787278    }
    72797279
    7280     bool status = psDBCreateTable(dbh, P3PENDINGEXP_TABLE_NAME, md);
     7280    bool status = psDBCreateTable(dbh, CAMPENDINGEXP_TABLE_NAME, md);
    72817281
    72827282    psFree(md);
    … …  
    72857285}
    72867286
    7287 bool p3PendingExpDropTable(psDB *dbh)
    7288 {
    7289     return psDBDropTable(dbh, P3PENDINGEXP_TABLE_NAME);
    7290 }
    7291 
    7292 bool p3PendingExpInsert(psDB * dbh, const char *exp_tag, psS32 p3_version, psS32 p2_version, const char *label, const char *expgroup, const char *dvodb)
     7287bool camPendingExpDropTable(psDB *dbh)
     7288{
     7289    return psDBDropTable(dbh, CAMPENDINGEXP_TABLE_NAME);
     7290}
     7291
     7292bool camPendingExpInsert(psDB * dbh, const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *expgroup, const char *dvodb)
    72937293{
    72947294    psMetadata *md = psMetadataAlloc();
    … …  
    72987298        return false;
    72997299    }
    7300     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    7301         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7302         psFree(md);
    7303         return false;
    7304     }
    7305     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    7306         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7300    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
     7301        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7302        psFree(md);
     7303        return false;
     7304    }
     7305    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     7306        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    73077307        psFree(md);
    73087308        return false;
    … …  
    73247324    }
    73257325
    7326     bool status = psDBInsertOneRow(dbh, P3PENDINGEXP_TABLE_NAME, md);
     7326    bool status = psDBInsertOneRow(dbh, CAMPENDINGEXP_TABLE_NAME, md);
    73277327    psFree(md);
    73287328
    … …  
    73307330}
    73317331
    7332 long long p3PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     7332long long camPendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    73337333{
    73347334    long long       deleted = 0;
    73357335
    7336     long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
     7336    long long count = psDBDeleteRows(dbh, CAMPENDINGEXP_TABLE_NAME, where, limit);
    73377337    if (count < 0) {
    7338         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp");
     7338        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camPendingExp");
    73397339        return count;
    73407340
    … …  
    73447344    return deleted;
    73457345}
    7346 bool p3PendingExpInsertObject(psDB *dbh, p3PendingExpRow *object)
    7347 {
    7348     return p3PendingExpInsert(dbh, object->exp_tag, object->p3_version, object->p2_version, object->label, object->expgroup, object->dvodb);
    7349 }
    7350 
    7351 bool p3PendingExpInsertObjects(psDB *dbh, psArray *objects)
     7346bool camPendingExpInsertObject(psDB *dbh, camPendingExpRow *object)
     7347{
     7348    return camPendingExpInsert(dbh, object->exp_tag, object->cam_version, object->chip_version, object->label, object->expgroup, object->dvodb);
     7349}
     7350
     7351bool camPendingExpInsertObjects(psDB *dbh, psArray *objects)
    73527352{
    73537353    for (long i = 0; i < psArrayLength(objects); i++) {
    7354         if (!p3PendingExpInsertObject(dbh, objects->data[i])) {
     7354        if (!camPendingExpInsertObject(dbh, objects->data[i])) {
    73557355            return false;
    73567356        }
    … …  
    73607360}
    73617361
    7362 bool p3PendingExpInsertFits(psDB *dbh, const psFits *fits)
     7362bool camPendingExpInsertFits(psDB *dbh, const psFits *fits)
    73637363{
    73647364    psArray         *rowSet;
    73657365
    7366     // move to (the first?) extension named  P3PENDINGEXP_TABLE_NAME
    7367     if (!psFitsMoveExtName(fits, P3PENDINGEXP_TABLE_NAME)) {
    7368         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3PENDINGEXP_TABLE_NAME);
     7366    // move to (the first?) extension named  CAMPENDINGEXP_TABLE_NAME
     7367    if (!psFitsMoveExtName(fits, CAMPENDINGEXP_TABLE_NAME)) {
     7368        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMPENDINGEXP_TABLE_NAME);
    73697369        return false;
    73707370    }
    … …  
    73847384    }
    73857385
    7386     if (!psDBInsertRows(dbh, P3PENDINGEXP_TABLE_NAME, rowSet)) {
     7386    if (!psDBInsertRows(dbh, CAMPENDINGEXP_TABLE_NAME, rowSet)) {
    73877387        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    73887388        psFree(rowSet);
    … …  
    73957395}
    73967396
    7397 bool p3PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     7397bool camPendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    73987398{
    73997399    psArray         *rowSet;
    74007400
    7401     rowSet = psDBSelectRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
     7401    rowSet = psDBSelectRows(dbh, CAMPENDINGEXP_TABLE_NAME, where, limit);
    74027402    if (!rowSet) {
    74037403        return false;
    … …  
    74057405
    74067406    // output to fits
    7407     if (!psFitsWriteTable(fits, NULL, rowSet, P3PENDINGEXP_TABLE_NAME)) {
     7407    if (!psFitsWriteTable(fits, NULL, rowSet, CAMPENDINGEXP_TABLE_NAME)) {
    74087408        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    74097409        psFree(rowSet);
    … …  
    74167416}
    74177417
    7418 psMetadata *p3PendingExpMetadataFromObject(const p3PendingExpRow *object)
     7418psMetadata *camPendingExpMetadataFromObject(const camPendingExpRow *object)
    74197419{
    74207420    psMetadata *md = psMetadataAlloc();
    … …  
    74247424        return false;
    74257425    }
    7426     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    7427         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7428         psFree(md);
    7429         return false;
    7430     }
    7431     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    7432         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7426    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
     7427        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7428        psFree(md);
     7429        return false;
     7430    }
     7431    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     7432        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    74337433        psFree(md);
    74347434        return false;
    … …  
    74547454}
    74557455
    7456 p3PendingExpRow *p3PendingExpObjectFromMetadata(psMetadata *md)
     7456camPendingExpRow *camPendingExpObjectFromMetadata(psMetadata *md)
    74577457{
    74587458
    … …  
    74637463        return false;
    74647464    }
    7465     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    7466     if (!status) {
    7467         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    7468         return false;
    7469     }
    7470     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    7471     if (!status) {
    7472         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
     7465    psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
     7466    if (!status) {
     7467        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
     7468        return false;
     7469    }
     7470    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     7471    if (!status) {
     7472        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    74737473        return false;
    74747474    }
    … …  
    74897489    }
    74907490
    7491     return p3PendingExpRowAlloc(exp_tag, p3_version, p2_version, label, expgroup, dvodb);
    7492 }
    7493 psArray *p3PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     7491    return camPendingExpRowAlloc(exp_tag, cam_version, chip_version, label, expgroup, dvodb);
     7492}
     7493psArray *camPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    74947494{
    74957495    psArray         *rowSet;
    … …  
    74977497    psU64           i;
    74987498
    7499     rowSet = psDBSelectRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
     7499    rowSet = psDBSelectRows(dbh, CAMPENDINGEXP_TABLE_NAME, where, limit);
    75007500    if (!rowSet) {
    75017501        return NULL;
    … …  
    75077507
    75087508    for (i = 0; i < rowSet->n; i++) {
    7509         p3PendingExpRow *object = p3PendingExpObjectFromMetadata(rowSet->data[i]);
     7509        camPendingExpRow *object = camPendingExpObjectFromMetadata(rowSet->data[i]);
    75107510        psArrayAdd(returnSet, 0, object);
    75117511        psFree(object);
    … …  
    75167516    return returnSet;
    75177517}
    7518 bool p3PendingExpDeleteObject(psDB *dbh, const p3PendingExpRow *object)
    7519 {
    7520     psMetadata *where = p3PendingExpMetadataFromObject(object);
    7521     long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, 0);
     7518bool camPendingExpDeleteObject(psDB *dbh, const camPendingExpRow *object)
     7519{
     7520    psMetadata *where = camPendingExpMetadataFromObject(object);
     7521    long long count = psDBDeleteRows(dbh, CAMPENDINGEXP_TABLE_NAME, where, 0);
    75227522    psFree(where);
    75237523    if (count < 0) {
    7524         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp");
     7524        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camPendingExp");
    75257525        return false;
    75267526    }
    … …  
    75287528        // XXX should this be a psAbort() instead?  It is possible that
    75297529        // having an object match multiple rows was by design.
    7530         psError(PS_ERR_UNKNOWN, true, "p3PendingExpRow object matched more then one row.  Check your database schema");
    7531         return false;
    7532     }
    7533 
    7534     return true;
    7535 }
    7536 long long p3PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     7530        psError(PS_ERR_UNKNOWN, true, "camPendingExpRow object matched more then one row.  Check your database schema");
     7531        return false;
     7532    }
     7533
     7534    return true;
     7535}
     7536long long camPendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    75377537{
    75387538    long long       deleted = 0;
    75397539
    75407540    for (long long i = 0; i < objects->n; i++) {
    7541         p3PendingExpRow *object = objects->data[i];
    7542         psMetadata *where = p3PendingExpMetadataFromObject(object);
    7543         long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
     7541        camPendingExpRow *object = objects->data[i];
     7542        psMetadata *where = camPendingExpMetadataFromObject(object);
     7543        long long count = psDBDeleteRows(dbh, CAMPENDINGEXP_TABLE_NAME, where, limit);
    75447544        psFree(where);
    75457545        if (count < 0) {
    7546             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp");
     7546            psError(PS_ERR_UNKNOWN, true, "failed to delete row from camPendingExp");
    75477547            return count;
    75487548        }
    … …  
    75537553    return deleted;
    75547554}
    7555 bool p3PendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     7555bool camPendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    75567556{
    75577557    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    75597559    psMetadata *output = psMetadataAlloc();
    75607560    for (long i = 0; i < psArrayLength(objects); i++) {
    7561         psMetadata *md = p3PendingExpMetadataFromObject(objects->data[i]);
     7561        psMetadata *md = camPendingExpMetadataFromObject(objects->data[i]);
    75627562        if (!psMetadataAddMetadata(
    75637563            output,
    75647564            PS_LIST_TAIL,
    7565             P3PENDINGEXP_TABLE_NAME,
     7565            CAMPENDINGEXP_TABLE_NAME,
    75667566            PS_META_DUPLICATE_OK,
    75677567            NULL,
    … …  
    75847584    return true;
    75857585}
    7586 bool p3PendingExpPrintObject(FILE *stream, p3PendingExpRow *object, bool mdcf)
     7586bool camPendingExpPrintObject(FILE *stream, camPendingExpRow *object, bool mdcf)
    75877587{
    75887588    PS_ASSERT_PTR_NON_NULL(object, false);
    75897589
    7590     psMetadata *md = p3PendingExpMetadataFromObject(object);
     7590    psMetadata *md = camPendingExpMetadataFromObject(object);
    75917591
    75927592    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    75997599    return true;
    76007600}
    7601 static void p3ProcessedExpRowFree(p3ProcessedExpRow *object);
    7602 
    7603 p3ProcessedExpRow *p3ProcessedExpRowAlloc(const char *exp_tag, psS32 p3_version, psS32 p2_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
    7604 {
    7605     p3ProcessedExpRow *_object;
    7606 
    7607     _object = psAlloc(sizeof(p3ProcessedExpRow));
    7608     psMemSetDeallocator(_object, (psFreeFunc)p3ProcessedExpRowFree);
     7601static void camProcessedExpRowFree(camProcessedExpRow *object);
     7602
     7603camProcessedExpRow *camProcessedExpRowAlloc(const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
     7604{
     7605    camProcessedExpRow *_object;
     7606
     7607    _object = psAlloc(sizeof(camProcessedExpRow));
     7608    psMemSetDeallocator(_object, (psFreeFunc)camProcessedExpRowFree);
    76097609
    76107610    _object->exp_tag = psStringCopy(exp_tag);
    7611     _object->p3_version = p3_version;
    7612     _object->p2_version = p2_version;
     7611    _object->cam_version = cam_version;
     7612    _object->chip_version = chip_version;
    76137613    _object->label = psStringCopy(label);
    76147614    _object->uri = psStringCopy(uri);
    … …  
    76317631}
    76327632
    7633 static void p3ProcessedExpRowFree(p3ProcessedExpRow *object)
     7633static void camProcessedExpRowFree(camProcessedExpRow *object)
    76347634{
    76357635    psFree(object->exp_tag);
    … …  
    76437643}
    76447644
    7645 bool p3ProcessedExpCreateTable(psDB *dbh)
     7645bool camProcessedExpCreateTable(psDB *dbh)
    76467646{
    76477647    psMetadata *md = psMetadataAlloc();
    … …  
    76517651        return false;
    76527652    }
    7653     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
    7654         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7655         psFree(md);
    7656         return false;
    7657     }
    7658     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) {
    7659         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7653    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
     7654        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7655        psFree(md);
     7656        return false;
     7657    }
     7658    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, 0)) {
     7659        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    76607660        psFree(md);
    76617661        return false;
    … …  
    77427742    }
    77437743
    7744     bool status = psDBCreateTable(dbh, P3PROCESSEDEXP_TABLE_NAME, md);
     7744    bool status = psDBCreateTable(dbh, CAMPROCESSEDEXP_TABLE_NAME, md);
    77457745
    77467746    psFree(md);
    … …  
    77497749}
    77507750
    7751 bool p3ProcessedExpDropTable(psDB *dbh)
    7752 {
    7753     return psDBDropTable(dbh, P3PROCESSEDEXP_TABLE_NAME);
    7754 }
    7755 
    7756 bool p3ProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 p3_version, psS32 p2_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
     7751bool camProcessedExpDropTable(psDB *dbh)
     7752{
     7753    return psDBDropTable(dbh, CAMPROCESSEDEXP_TABLE_NAME);
     7754}
     7755
     7756bool camProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
    77577757{
    77587758    psMetadata *md = psMetadataAlloc();
    … …  
    77627762        return false;
    77637763    }
    7764     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    7765         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7766         psFree(md);
    7767         return false;
    7768     }
    7769     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) {
    7770         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7764    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
     7765        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7766        psFree(md);
     7767        return false;
     7768    }
     7769    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
     7770        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    77717771        psFree(md);
    77727772        return false;
    … …  
    78537853    }
    78547854
    7855     bool status = psDBInsertOneRow(dbh, P3PROCESSEDEXP_TABLE_NAME, md);
     7855    bool status = psDBInsertOneRow(dbh, CAMPROCESSEDEXP_TABLE_NAME, md);
    78567856    psFree(md);
    78577857
    … …  
    78597859}
    78607860
    7861 long long p3ProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     7861long long camProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    78627862{
    78637863    long long       deleted = 0;
    78647864
    7865     long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     7865    long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit);
    78667866    if (count < 0) {
    7867         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     7867        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp");
    78687868        return count;
    78697869
    … …  
    78737873    return deleted;
    78747874}
    7875 bool p3ProcessedExpInsertObject(psDB *dbh, p3ProcessedExpRow *object)
    7876 {
    7877     return p3ProcessedExpInsert(dbh, object->exp_tag, object->p3_version, object->p2_version, object->label, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->b1_uri, object->b2_uri, object->zp_mean, object->zp_stdev, object->fault, object->expgroup, object->dvodb);
    7878 }
    7879 
    7880 bool p3ProcessedExpInsertObjects(psDB *dbh, psArray *objects)
     7875bool camProcessedExpInsertObject(psDB *dbh, camProcessedExpRow *object)
     7876{
     7877    return camProcessedExpInsert(dbh, object->exp_tag, object->cam_version, object->chip_version, object->label, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->b1_uri, object->b2_uri, object->zp_mean, object->zp_stdev, object->fault, object->expgroup, object->dvodb);
     7878}
     7879
     7880bool camProcessedExpInsertObjects(psDB *dbh, psArray *objects)
    78817881{
    78827882    for (long i = 0; i < psArrayLength(objects); i++) {
    7883         if (!p3ProcessedExpInsertObject(dbh, objects->data[i])) {
     7883        if (!camProcessedExpInsertObject(dbh, objects->data[i])) {
    78847884            return false;
    78857885        }
    … …  
    78897889}
    78907890
    7891 bool p3ProcessedExpInsertFits(psDB *dbh, const psFits *fits)
     7891bool camProcessedExpInsertFits(psDB *dbh, const psFits *fits)
    78927892{
    78937893    psArray         *rowSet;
    78947894
    7895     // move to (the first?) extension named  P3PROCESSEDEXP_TABLE_NAME
    7896     if (!psFitsMoveExtName(fits, P3PROCESSEDEXP_TABLE_NAME)) {
    7897         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3PROCESSEDEXP_TABLE_NAME);
     7895    // move to (the first?) extension named  CAMPROCESSEDEXP_TABLE_NAME
     7896    if (!psFitsMoveExtName(fits, CAMPROCESSEDEXP_TABLE_NAME)) {
     7897        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMPROCESSEDEXP_TABLE_NAME);
    78987898        return false;
    78997899    }
    … …  
    79137913    }
    79147914
    7915     if (!psDBInsertRows(dbh, P3PROCESSEDEXP_TABLE_NAME, rowSet)) {
     7915    if (!psDBInsertRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, rowSet)) {
    79167916        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    79177917        psFree(rowSet);
    … …  
    79247924}
    79257925
    7926 bool p3ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     7926bool camProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    79277927{
    79287928    psArray         *rowSet;
    79297929
    7930     rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     7930    rowSet = psDBSelectRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit);
    79317931    if (!rowSet) {
    79327932        return false;
    … …  
    79347934
    79357935    // output to fits
    7936     if (!psFitsWriteTable(fits, NULL, rowSet, P3PROCESSEDEXP_TABLE_NAME)) {
     7936    if (!psFitsWriteTable(fits, NULL, rowSet, CAMPROCESSEDEXP_TABLE_NAME)) {
    79377937        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    79387938        psFree(rowSet);
    … …  
    79457945}
    79467946
    7947 psMetadata *p3ProcessedExpMetadataFromObject(const p3ProcessedExpRow *object)
     7947psMetadata *camProcessedExpMetadataFromObject(const camProcessedExpRow *object)
    79487948{
    79497949    psMetadata *md = psMetadataAlloc();
    … …  
    79537953        return false;
    79547954    }
    7955     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    7956         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
    7957         psFree(md);
    7958         return false;
    7959     }
    7960     if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) {
    7961         psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     7955    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
     7956        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     7957        psFree(md);
     7958        return false;
     7959    }
     7960    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
     7961        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    79627962        psFree(md);
    79637963        return false;
    … …  
    80488048}
    80498049
    8050 p3ProcessedExpRow *p3ProcessedExpObjectFromMetadata(psMetadata *md)
     8050camProcessedExpRow *camProcessedExpObjectFromMetadata(psMetadata *md)
    80518051{
    80528052
    … …  
    80578057        return false;
    80588058    }
    8059     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    8060     if (!status) {
    8061         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    8062         return false;
    8063     }
    8064     psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version");
    8065     if (!status) {
    8066         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
     8059    psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
     8060    if (!status) {
     8061        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
     8062        return false;
     8063    }
     8064    psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
     8065    if (!status) {
     8066        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    80678067        return false;
    80688068    }
    … …  
    81488148    }
    81498149
    8150     return p3ProcessedExpRowAlloc(exp_tag, p3_version, p2_version, label, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, zp_mean, zp_stdev, fault, expgroup, dvodb);
    8151 }
    8152 psArray *p3ProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     8150    return camProcessedExpRowAlloc(exp_tag, cam_version, chip_version, label, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, zp_mean, zp_stdev, fault, expgroup, dvodb);
     8151}
     8152psArray *camProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    81538153{
    81548154    psArray         *rowSet;
    … …  
    81568156    psU64           i;
    81578157
    8158     rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     8158    rowSet = psDBSelectRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit);
    81598159    if (!rowSet) {
    81608160        return NULL;
    … …  
    81668166
    81678167    for (i = 0; i < rowSet->n; i++) {
    8168         p3ProcessedExpRow *object = p3ProcessedExpObjectFromMetadata(rowSet->data[i]);
     8168        camProcessedExpRow *object = camProcessedExpObjectFromMetadata(rowSet->data[i]);
    81698169        psArrayAdd(returnSet, 0, object);
    81708170        psFree(object);
    … …  
    81758175    return returnSet;
    81768176}
    8177 bool p3ProcessedExpDeleteObject(psDB *dbh, const p3ProcessedExpRow *object)
    8178 {
    8179     psMetadata *where = p3ProcessedExpMetadataFromObject(object);
    8180     long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, 0);
     8177bool camProcessedExpDeleteObject(psDB *dbh, const camProcessedExpRow *object)
     8178{
     8179    psMetadata *where = camProcessedExpMetadataFromObject(object);
     8180    long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, 0);
    81818181    psFree(where);
    81828182    if (count < 0) {
    8183         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     8183        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp");
    81848184        return false;
    81858185    }
    … …  
    81878187        // XXX should this be a psAbort() instead?  It is possible that
    81888188        // having an object match multiple rows was by design.
    8189         psError(PS_ERR_UNKNOWN, true, "p3ProcessedExpRow object matched more then one row.  Check your database schema");
    8190         return false;
    8191     }
    8192 
    8193     return true;
    8194 }
    8195 long long p3ProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     8189        psError(PS_ERR_UNKNOWN, true, "camProcessedExpRow object matched more then one row.  Check your database schema");
     8190        return false;
     8191    }
     8192
     8193    return true;
     8194}
     8195long long camProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    81968196{
    81978197    long long       deleted = 0;
    81988198
    81998199    for (long long i = 0; i < objects->n; i++) {
    8200         p3ProcessedExpRow *object = objects->data[i];
    8201         psMetadata *where = p3ProcessedExpMetadataFromObject(object);
    8202         long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     8200        camProcessedExpRow *object = objects->data[i];
     8201        psMetadata *where = camProcessedExpMetadataFromObject(object);
     8202        long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit);
    82038203        psFree(where);
    82048204        if (count < 0) {
    8205             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     8205            psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp");
    82068206            return count;
    82078207        }
    … …  
    82128212    return deleted;
    82138213}
    8214 bool p3ProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     8214bool camProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    82158215{
    82168216    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    82188218    psMetadata *output = psMetadataAlloc();
    82198219    for (long i = 0; i < psArrayLength(objects); i++) {
    8220         psMetadata *md = p3ProcessedExpMetadataFromObject(objects->data[i]);
     8220        psMetadata *md = camProcessedExpMetadataFromObject(objects->data[i]);
    82218221        if (!psMetadataAddMetadata(
    82228222            output,
    82238223            PS_LIST_TAIL,
    8224             P3PROCESSEDEXP_TABLE_NAME,
     8224            CAMPROCESSEDEXP_TABLE_NAME,
    82258225            PS_META_DUPLICATE_OK,
    82268226            NULL,
    … …  
    82438243    return true;
    82448244}
    8245 bool p3ProcessedExpPrintObject(FILE *stream, p3ProcessedExpRow *object, bool mdcf)
     8245bool camProcessedExpPrintObject(FILE *stream, camProcessedExpRow *object, bool mdcf)
    82468246{
    82478247    PS_ASSERT_PTR_NON_NULL(object, false);
    82488248
    8249     psMetadata *md = p3ProcessedExpMetadataFromObject(object);
     8249    psMetadata *md = camProcessedExpMetadataFromObject(object);
    82508250
    82518251    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    82588258    return true;
    82598259}
    8260 static void p3MaskRowFree(p3MaskRow *object);
    8261 
    8262 p3MaskRow *p3MaskRowAlloc(const char *label)
    8263 {
    8264     p3MaskRow       *_object;
    8265 
    8266     _object = psAlloc(sizeof(p3MaskRow));
    8267     psMemSetDeallocator(_object, (psFreeFunc)p3MaskRowFree);
     8260static void camMaskRowFree(camMaskRow *object);
     8261
     8262camMaskRow *camMaskRowAlloc(const char *label)
     8263{
     8264    camMaskRow      *_object;
     8265
     8266    _object = psAlloc(sizeof(camMaskRow));
     8267    psMemSetDeallocator(_object, (psFreeFunc)camMaskRowFree);
    82688268
    82698269    _object->label = psStringCopy(label);
    … …  
    82728272}
    82738273
    8274 static void p3MaskRowFree(p3MaskRow *object)
     8274static void camMaskRowFree(camMaskRow *object)
    82758275{
    82768276    psFree(object->label);
    82778277}
    82788278
    8279 bool p3MaskCreateTable(psDB *dbh)
     8279bool camMaskCreateTable(psDB *dbh)
    82808280{
    82818281    psMetadata *md = psMetadataAlloc();
    … …  
    82868286    }
    82878287
    8288     bool status = psDBCreateTable(dbh, P3MASK_TABLE_NAME, md);
     8288    bool status = psDBCreateTable(dbh, CAMMASK_TABLE_NAME, md);
    82898289
    82908290    psFree(md);
    … …  
    82938293}
    82948294
    8295 bool p3MaskDropTable(psDB *dbh)
    8296 {
    8297     return psDBDropTable(dbh, P3MASK_TABLE_NAME);
    8298 }
    8299 
    8300 bool p3MaskInsert(psDB * dbh, const char *label)
     8295bool camMaskDropTable(psDB *dbh)
     8296{
     8297    return psDBDropTable(dbh, CAMMASK_TABLE_NAME);
     8298}
     8299
     8300bool camMaskInsert(psDB * dbh, const char *label)
    83018301{
    83028302    psMetadata *md = psMetadataAlloc();
    … …  
    83078307    }
    83088308
    8309     bool status = psDBInsertOneRow(dbh, P3MASK_TABLE_NAME, md);
     8309    bool status = psDBInsertOneRow(dbh, CAMMASK_TABLE_NAME, md);
    83108310    psFree(md);
    83118311
    … …  
    83138313}
    83148314
    8315 long long p3MaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     8315long long camMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    83168316{
    83178317    long long       deleted = 0;
    83188318
    8319     long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, limit);
     8319    long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, limit);
    83208320    if (count < 0) {
    8321         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask");
     8321        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask");
    83228322        return count;
    83238323
    … …  
    83278327    return deleted;
    83288328}
    8329 bool p3MaskInsertObject(psDB *dbh, p3MaskRow *object)
    8330 {
    8331     return p3MaskInsert(dbh, object->label);
    8332 }
    8333 
    8334 bool p3MaskInsertObjects(psDB *dbh, psArray *objects)
     8329bool camMaskInsertObject(psDB *dbh, camMaskRow *object)
     8330{
     8331    return camMaskInsert(dbh, object->label);
     8332}
     8333
     8334bool camMaskInsertObjects(psDB *dbh, psArray *objects)
    83358335{
    83368336    for (long i = 0; i < psArrayLength(objects); i++) {
    8337         if (!p3MaskInsertObject(dbh, objects->data[i])) {
     8337        if (!camMaskInsertObject(dbh, objects->data[i])) {
    83388338            return false;
    83398339        }
    … …  
    83438343}
    83448344
    8345 bool p3MaskInsertFits(psDB *dbh, const psFits *fits)
     8345bool camMaskInsertFits(psDB *dbh, const psFits *fits)
    83468346{
    83478347    psArray         *rowSet;
    83488348
    8349     // move to (the first?) extension named  P3MASK_TABLE_NAME
    8350     if (!psFitsMoveExtName(fits, P3MASK_TABLE_NAME)) {
    8351         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3MASK_TABLE_NAME);
     8349    // move to (the first?) extension named  CAMMASK_TABLE_NAME
     8350    if (!psFitsMoveExtName(fits, CAMMASK_TABLE_NAME)) {
     8351        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMMASK_TABLE_NAME);
    83528352        return false;
    83538353    }
    … …  
    83678367    }
    83688368
    8369     if (!psDBInsertRows(dbh, P3MASK_TABLE_NAME, rowSet)) {
     8369    if (!psDBInsertRows(dbh, CAMMASK_TABLE_NAME, rowSet)) {
    83708370        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    83718371        psFree(rowSet);
    … …  
    83788378}
    83798379
    8380 bool p3MaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     8380bool camMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    83818381{
    83828382    psArray         *rowSet;
    83838383
    8384     rowSet = psDBSelectRows(dbh, P3MASK_TABLE_NAME, where, limit);
     8384    rowSet = psDBSelectRows(dbh, CAMMASK_TABLE_NAME, where, limit);
    83858385    if (!rowSet) {
    83868386        return false;
    … …  
    83888388
    83898389    // output to fits
    8390     if (!psFitsWriteTable(fits, NULL, rowSet, P3MASK_TABLE_NAME)) {
     8390    if (!psFitsWriteTable(fits, NULL, rowSet, CAMMASK_TABLE_NAME)) {
    83918391        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    83928392        psFree(rowSet);
    … …  
    83998399}
    84008400
    8401 psMetadata *p3MaskMetadataFromObject(const p3MaskRow *object)
     8401psMetadata *camMaskMetadataFromObject(const camMaskRow *object)
    84028402{
    84038403    psMetadata *md = psMetadataAlloc();
    … …  
    84128412}
    84138413
    8414 p3MaskRow *p3MaskObjectFromMetadata(psMetadata *md)
     8414camMaskRow *camMaskObjectFromMetadata(psMetadata *md)
    84158415{
    84168416
    … …  
    84228422    }
    84238423
    8424     return p3MaskRowAlloc(label);
    8425 }
    8426 psArray *p3MaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     8424    return camMaskRowAlloc(label);
     8425}
     8426psArray *camMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    84278427{
    84288428    psArray         *rowSet;
    … …  
    84308430    psU64           i;
    84318431
    8432     rowSet = psDBSelectRows(dbh, P3MASK_TABLE_NAME, where, limit);
     8432    rowSet = psDBSelectRows(dbh, CAMMASK_TABLE_NAME, where, limit);
    84338433    if (!rowSet) {
    84348434        return NULL;
    … …  
    84408440
    84418441    for (i = 0; i < rowSet->n; i++) {
    8442         p3MaskRow *object = p3MaskObjectFromMetadata(rowSet->data[i]);
     8442        camMaskRow *object = camMaskObjectFromMetadata(rowSet->data[i]);
    84438443        psArrayAdd(returnSet, 0, object);
    84448444        psFree(object);
    … …  
    84498449    return returnSet;
    84508450}
    8451 bool p3MaskDeleteObject(psDB *dbh, const p3MaskRow *object)
    8452 {
    8453     psMetadata *where = p3MaskMetadataFromObject(object);
    8454     long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, 0);
     8451bool camMaskDeleteObject(psDB *dbh, const camMaskRow *object)
     8452{
     8453    psMetadata *where = camMaskMetadataFromObject(object);
     8454    long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, 0);
    84558455    psFree(where);
    84568456    if (count < 0) {
    8457         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask");
     8457        psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask");
    84588458        return false;
    84598459    }
    … …  
    84618461        // XXX should this be a psAbort() instead?  It is possible that
    84628462        // having an object match multiple rows was by design.
    8463         psError(PS_ERR_UNKNOWN, true, "p3MaskRow object matched more then one row.  Check your database schema");
    8464         return false;
    8465     }
    8466 
    8467     return true;
    8468 }
    8469 long long p3MaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     8463        psError(PS_ERR_UNKNOWN, true, "camMaskRow object matched more then one row.  Check your database schema");
     8464        return false;
     8465    }
     8466
     8467    return true;
     8468}
     8469long long camMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    84708470{
    84718471    long long       deleted = 0;
    84728472
    84738473    for (long long i = 0; i < objects->n; i++) {
    8474         p3MaskRow *object = objects->data[i];
    8475         psMetadata *where = p3MaskMetadataFromObject(object);
    8476         long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, limit);
     8474        camMaskRow *object = objects->data[i];
     8475        psMetadata *where = camMaskMetadataFromObject(object);
     8476        long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, limit);
    84778477        psFree(where);
    84788478        if (count < 0) {
    8479             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask");
     8479            psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask");
    84808480            return count;
    84818481        }
    … …  
    84868486    return deleted;
    84878487}
    8488 bool p3MaskPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     8488bool camMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    84898489{
    84908490    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    84928492    psMetadata *output = psMetadataAlloc();
    84938493    for (long i = 0; i < psArrayLength(objects); i++) {
    8494         psMetadata *md = p3MaskMetadataFromObject(objects->data[i]);
     8494        psMetadata *md = camMaskMetadataFromObject(objects->data[i]);
    84958495        if (!psMetadataAddMetadata(
    84968496            output,
    84978497            PS_LIST_TAIL,
    8498             P3MASK_TABLE_NAME,
     8498            CAMMASK_TABLE_NAME,
    84998499            PS_META_DUPLICATE_OK,
    85008500            NULL,
    … …  
    85178517    return true;
    85188518}
    8519 bool p3MaskPrintObject(FILE *stream, p3MaskRow *object, bool mdcf)
     8519bool camMaskPrintObject(FILE *stream, camMaskRow *object, bool mdcf)
    85208520{
    85218521    PS_ASSERT_PTR_NON_NULL(object, false);
    85228522
    8523     psMetadata *md = p3MaskMetadataFromObject(object);
     8523    psMetadata *md = camMaskMetadataFromObject(object);
    85248524
    85258525    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1374413744    return true;
    1374513745}
    13746 static void p4RunRowFree(p4RunRow *object);
    13747 
    13748 p4RunRow *p4RunRowAlloc(psS32 p4_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
    13749 {
    13750     p4RunRow        *_object;
    13751 
    13752     _object = psAlloc(sizeof(p4RunRow));
    13753     psMemSetDeallocator(_object, (psFreeFunc)p4RunRowFree);
    13754 
    13755     _object->p4_id = p4_id;
     13746static void warpRunRowFree(warpRunRow *object);
     13747
     13748warpRunRow *warpRunRowAlloc(psS32 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     13749{
     13750    warpRunRow      *_object;
     13751
     13752    _object = psAlloc(sizeof(warpRunRow));
     13753    psMemSetDeallocator(_object, (psFreeFunc)warpRunRowFree);
     13754
     13755    _object->warp_id = warp_id;
    1375613756    _object->mode = psStringCopy(mode);
    1375713757    _object->state = psStringCopy(state);
    … …  
    1376313763}
    1376413764
    13765 static void p4RunRowFree(p4RunRow *object)
     13765static void warpRunRowFree(warpRunRow *object)
    1376613766{
    1376713767    psFree(object->mode);
    … …  
    1377213772}
    1377313773
    13774 bool p4RunCreateTable(psDB *dbh)
     13774bool warpRunCreateTable(psDB *dbh)
    1377513775{
    1377613776    psMetadata *md = psMetadataAlloc();
    13777     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
    13778         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13777    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     13778        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1377913779        psFree(md);
    1378013780        return false;
    … …  
    1380613806    }
    1380713807
    13808     bool status = psDBCreateTable(dbh, P4RUN_TABLE_NAME, md);
     13808    bool status = psDBCreateTable(dbh, WARPRUN_TABLE_NAME, md);
    1380913809
    1381013810    psFree(md);
    … …  
    1381313813}
    1381413814
    13815 bool p4RunDropTable(psDB *dbh)
    13816 {
    13817     return psDBDropTable(dbh, P4RUN_TABLE_NAME);
    13818 }
    13819 
    13820 bool p4RunInsert(psDB * dbh, psS32 p4_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     13815bool warpRunDropTable(psDB *dbh)
     13816{
     13817    return psDBDropTable(dbh, WARPRUN_TABLE_NAME);
     13818}
     13819
     13820bool warpRunInsert(psDB * dbh, psS32 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
    1382113821{
    1382213822    psMetadata *md = psMetadataAlloc();
    13823     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    13824         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13823    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     13824        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1382513825        psFree(md);
    1382613826        return false;
    … …  
    1385213852    }
    1385313853
    13854     bool status = psDBInsertOneRow(dbh, P4RUN_TABLE_NAME, md);
     13854    bool status = psDBInsertOneRow(dbh, WARPRUN_TABLE_NAME, md);
    1385513855    psFree(md);
    1385613856
    … …  
    1385813858}
    1385913859
    13860 long long p4RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13860long long warpRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1386113861{
    1386213862    long long       deleted = 0;
    1386313863
    13864     long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
     13864    long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, limit);
    1386513865    if (count < 0) {
    13866         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     13866        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun");
    1386713867        return count;
    1386813868
    … …  
    1387213872    return deleted;
    1387313873}
    13874 bool p4RunInsertObject(psDB *dbh, p4RunRow *object)
    13875 {
    13876     return p4RunInsert(dbh, object->p4_id, object->mode, object->state, object->workdir, object->dvodb, object->registered);
    13877 }
    13878 
    13879 bool p4RunInsertObjects(psDB *dbh, psArray *objects)
     13874bool warpRunInsertObject(psDB *dbh, warpRunRow *object)
     13875{
     13876    return warpRunInsert(dbh, object->warp_id, object->mode, object->state, object->workdir, object->dvodb, object->registered);
     13877}
     13878
     13879bool warpRunInsertObjects(psDB *dbh, psArray *objects)
    1388013880{
    1388113881    for (long i = 0; i < psArrayLength(objects); i++) {
    13882         if (!p4RunInsertObject(dbh, objects->data[i])) {
     13882        if (!warpRunInsertObject(dbh, objects->data[i])) {
    1388313883            return false;
    1388413884        }
    … …  
    1388813888}
    1388913889
    13890 bool p4RunInsertFits(psDB *dbh, const psFits *fits)
     13890bool warpRunInsertFits(psDB *dbh, const psFits *fits)
    1389113891{
    1389213892    psArray         *rowSet;
    1389313893
    13894     // move to (the first?) extension named  P4RUN_TABLE_NAME
    13895     if (!psFitsMoveExtName(fits, P4RUN_TABLE_NAME)) {
    13896         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4RUN_TABLE_NAME);
     13894    // move to (the first?) extension named  WARPRUN_TABLE_NAME
     13895    if (!psFitsMoveExtName(fits, WARPRUN_TABLE_NAME)) {
     13896        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPRUN_TABLE_NAME);
    1389713897        return false;
    1389813898    }
    … …  
    1391213912    }
    1391313913
    13914     if (!psDBInsertRows(dbh, P4RUN_TABLE_NAME, rowSet)) {
     13914    if (!psDBInsertRows(dbh, WARPRUN_TABLE_NAME, rowSet)) {
    1391513915        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1391613916        psFree(rowSet);
    … …  
    1392313923}
    1392413924
    13925 bool p4RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13925bool warpRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1392613926{
    1392713927    psArray         *rowSet;
    1392813928
    13929     rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     13929    rowSet = psDBSelectRows(dbh, WARPRUN_TABLE_NAME, where, limit);
    1393013930    if (!rowSet) {
    1393113931        return false;
    … …  
    1393313933
    1393413934    // output to fits
    13935     if (!psFitsWriteTable(fits, NULL, rowSet, P4RUN_TABLE_NAME)) {
     13935    if (!psFitsWriteTable(fits, NULL, rowSet, WARPRUN_TABLE_NAME)) {
    1393613936        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1393713937        psFree(rowSet);
    … …  
    1394413944}
    1394513945
    13946 psMetadata *p4RunMetadataFromObject(const p4RunRow *object)
     13946psMetadata *warpRunMetadataFromObject(const warpRunRow *object)
    1394713947{
    1394813948    psMetadata *md = psMetadataAlloc();
    13949     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    13950         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13949    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     13950        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1395113951        psFree(md);
    1395213952        return false;
    … …  
    1398213982}
    1398313983
    13984 p4RunRow *p4RunObjectFromMetadata(psMetadata *md)
     13984warpRunRow *warpRunObjectFromMetadata(psMetadata *md)
    1398513985{
    1398613986
    1398713987bool status = false;
    13988     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    13989     if (!status) {
    13990         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     13988    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     13989    if (!status) {
     13990        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1399113991        return false;
    1399213992    }
    … …  
    1401714017    }
    1401814018
    14019     return p4RunRowAlloc(p4_id, mode, state, workdir, dvodb, registered);
    14020 }
    14021 psArray *p4RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14019    return warpRunRowAlloc(warp_id, mode, state, workdir, dvodb, registered);
     14020}
     14021psArray *warpRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1402214022{
    1402314023    psArray         *rowSet;
    … …  
    1402514025    psU64           i;
    1402614026
    14027     rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     14027    rowSet = psDBSelectRows(dbh, WARPRUN_TABLE_NAME, where, limit);
    1402814028    if (!rowSet) {
    1402914029        return NULL;
    … …  
    1403514035
    1403614036    for (i = 0; i < rowSet->n; i++) {
    14037         p4RunRow *object = p4RunObjectFromMetadata(rowSet->data[i]);
     14037        warpRunRow *object = warpRunObjectFromMetadata(rowSet->data[i]);
    1403814038        psArrayAdd(returnSet, 0, object);
    1403914039        psFree(object);
    … …  
    1404414044    return returnSet;
    1404514045}
    14046 bool p4RunDeleteObject(psDB *dbh, const p4RunRow *object)
    14047 {
    14048     psMetadata *where = p4RunMetadataFromObject(object);
    14049     long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, 0);
     14046bool warpRunDeleteObject(psDB *dbh, const warpRunRow *object)
     14047{
     14048    psMetadata *where = warpRunMetadataFromObject(object);
     14049    long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, 0);
    1405014050    psFree(where);
    1405114051    if (count < 0) {
    14052         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     14052        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun");
    1405314053        return false;
    1405414054    }
    … …  
    1405614056        // XXX should this be a psAbort() instead?  It is possible that
    1405714057        // having an object match multiple rows was by design.
    14058         psError(PS_ERR_UNKNOWN, true, "p4RunRow object matched more then one row.  Check your database schema");
    14059         return false;
    14060     }
    14061 
    14062     return true;
    14063 }
    14064 long long p4RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14058        psError(PS_ERR_UNKNOWN, true, "warpRunRow object matched more then one row.  Check your database schema");
     14059        return false;
     14060    }
     14061
     14062    return true;
     14063}
     14064long long warpRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1406514065{
    1406614066    long long       deleted = 0;
    1406714067
    1406814068    for (long long i = 0; i < objects->n; i++) {
    14069         p4RunRow *object = objects->data[i];
    14070         psMetadata *where = p4RunMetadataFromObject(object);
    14071         long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
     14069        warpRunRow *object = objects->data[i];
     14070        psMetadata *where = warpRunMetadataFromObject(object);
     14071        long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, limit);
    1407214072        psFree(where);
    1407314073        if (count < 0) {
    14074             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     14074            psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun");
    1407514075            return count;
    1407614076        }
    … …  
    1408114081    return deleted;
    1408214082}
    14083 bool p4RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14083bool warpRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1408414084{
    1408514085    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1408714087    psMetadata *output = psMetadataAlloc();
    1408814088    for (long i = 0; i < psArrayLength(objects); i++) {
    14089         psMetadata *md = p4RunMetadataFromObject(objects->data[i]);
     14089        psMetadata *md = warpRunMetadataFromObject(objects->data[i]);
    1409014090        if (!psMetadataAddMetadata(
    1409114091            output,
    1409214092            PS_LIST_TAIL,
    14093             P4RUN_TABLE_NAME,
     14093            WARPRUN_TABLE_NAME,
    1409414094            PS_META_DUPLICATE_OK,
    1409514095            NULL,
    … …  
    1411214112    return true;
    1411314113}
    14114 bool p4RunPrintObject(FILE *stream, p4RunRow *object, bool mdcf)
     14114bool warpRunPrintObject(FILE *stream, warpRunRow *object, bool mdcf)
    1411514115{
    1411614116    PS_ASSERT_PTR_NON_NULL(object, false);
    1411714117
    14118     psMetadata *md = p4RunMetadataFromObject(object);
     14118    psMetadata *md = warpRunMetadataFromObject(object);
    1411914119
    1412014120    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1412714127    return true;
    1412814128}
    14129 static void p4InputExpRowFree(p4InputExpRow *object);
    14130 
    14131 p4InputExpRow *p4InputExpRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, bool magiced)
    14132 {
    14133     p4InputExpRow  *_object;
    14134 
    14135     _object = psAlloc(sizeof(p4InputExpRow));
    14136     psMemSetDeallocator(_object, (psFreeFunc)p4InputExpRowFree);
    14137 
    14138     _object->p4_id = p4_id;
     14129static void warpInputExpRowFree(warpInputExpRow *object);
     14130
     14131warpInputExpRow *warpInputExpRowAlloc(psS32 warp_id, const char *exp_tag, psS32 cam_version, bool magiced)
     14132{
     14133    warpInputExpRow *_object;
     14134
     14135    _object = psAlloc(sizeof(warpInputExpRow));
     14136    psMemSetDeallocator(_object, (psFreeFunc)warpInputExpRowFree);
     14137
     14138    _object->warp_id = warp_id;
    1413914139    _object->exp_tag = psStringCopy(exp_tag);
    14140     _object->p3_version = p3_version;
     14140    _object->cam_version = cam_version;
    1414114141    _object->magiced = magiced;
    1414214142
    … …  
    1414414144}
    1414514145
    14146 static void p4InputExpRowFree(p4InputExpRow *object)
     14146static void warpInputExpRowFree(warpInputExpRow *object)
    1414714147{
    1414814148    psFree(object->exp_tag);
    1414914149}
    1415014150
    14151 bool p4InputExpCreateTable(psDB *dbh)
     14151bool warpInputExpCreateTable(psDB *dbh)
    1415214152{
    1415314153    psMetadata *md = psMetadataAlloc();
    14154     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    14155         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14154    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     14155        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1415614156        psFree(md);
    1415714157        return false;
    … …  
    1416214162        return false;
    1416314163    }
    14164     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Key", 0)) {
    14165         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14164    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Key", 0)) {
     14165        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1416614166        psFree(md);
    1416714167        return false;
    … …  
    1417314173    }
    1417414174
    14175     bool status = psDBCreateTable(dbh, P4INPUTEXP_TABLE_NAME, md);
     14175    bool status = psDBCreateTable(dbh, WARPINPUTEXP_TABLE_NAME, md);
    1417614176
    1417714177    psFree(md);
    … …  
    1418014180}
    1418114181
    14182 bool p4InputExpDropTable(psDB *dbh)
    14183 {
    14184     return psDBDropTable(dbh, P4INPUTEXP_TABLE_NAME);
    14185 }
    14186 
    14187 bool p4InputExpInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, bool magiced)
     14182bool warpInputExpDropTable(psDB *dbh)
     14183{
     14184    return psDBDropTable(dbh, WARPINPUTEXP_TABLE_NAME);
     14185}
     14186
     14187bool warpInputExpInsert(psDB * dbh, psS32 warp_id, const char *exp_tag, psS32 cam_version, bool magiced)
    1418814188{
    1418914189    psMetadata *md = psMetadataAlloc();
    14190     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14191         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14190    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     14191        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1419214192        psFree(md);
    1419314193        return false;
    … …  
    1419814198        return false;
    1419914199    }
    14200     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    14201         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14200    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
     14201        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1420214202        psFree(md);
    1420314203        return false;
    … …  
    1420914209    }
    1421014210
    14211     bool status = psDBInsertOneRow(dbh, P4INPUTEXP_TABLE_NAME, md);
     14211    bool status = psDBInsertOneRow(dbh, WARPINPUTEXP_TABLE_NAME, md);
    1421214212    psFree(md);
    1421314213
    … …  
    1421514215}
    1421614216
    14217 long long p4InputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14217long long warpInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1421814218{
    1421914219    long long       deleted = 0;
    1422014220
    14221     long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     14221    long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    1422214222    if (count < 0) {
    14223         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
     14223        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    1422414224        return count;
    1422514225
    … …  
    1422914229    return deleted;
    1423014230}
    14231 bool p4InputExpInsertObject(psDB *dbh, p4InputExpRow *object)
    14232 {
    14233     return p4InputExpInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->magiced);
    14234 }
    14235 
    14236 bool p4InputExpInsertObjects(psDB *dbh, psArray *objects)
     14231bool warpInputExpInsertObject(psDB *dbh, warpInputExpRow *object)
     14232{
     14233    return warpInputExpInsert(dbh, object->warp_id, object->exp_tag, object->cam_version, object->magiced);
     14234}
     14235
     14236bool warpInputExpInsertObjects(psDB *dbh, psArray *objects)
    1423714237{
    1423814238    for (long i = 0; i < psArrayLength(objects); i++) {
    14239         if (!p4InputExpInsertObject(dbh, objects->data[i])) {
     14239        if (!warpInputExpInsertObject(dbh, objects->data[i])) {
    1424014240            return false;
    1424114241        }
    … …  
    1424514245}
    1424614246
    14247 bool p4InputExpInsertFits(psDB *dbh, const psFits *fits)
     14247bool warpInputExpInsertFits(psDB *dbh, const psFits *fits)
    1424814248{
    1424914249    psArray         *rowSet;
    1425014250
    14251     // move to (the first?) extension named  P4INPUTEXP_TABLE_NAME
    14252     if (!psFitsMoveExtName(fits, P4INPUTEXP_TABLE_NAME)) {
    14253         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTEXP_TABLE_NAME);
     14251    // move to (the first?) extension named  WARPINPUTEXP_TABLE_NAME
     14252    if (!psFitsMoveExtName(fits, WARPINPUTEXP_TABLE_NAME)) {
     14253        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPINPUTEXP_TABLE_NAME);
    1425414254        return false;
    1425514255    }
    … …  
    1426914269    }
    1427014270
    14271     if (!psDBInsertRows(dbh, P4INPUTEXP_TABLE_NAME, rowSet)) {
     14271    if (!psDBInsertRows(dbh, WARPINPUTEXP_TABLE_NAME, rowSet)) {
    1427214272        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1427314273        psFree(rowSet);
    … …  
    1428014280}
    1428114281
    14282 bool p4InputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14282bool warpInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1428314283{
    1428414284    psArray         *rowSet;
    1428514285
    14286     rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     14286    rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    1428714287    if (!rowSet) {
    1428814288        return false;
    … …  
    1429014290
    1429114291    // output to fits
    14292     if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTEXP_TABLE_NAME)) {
     14292    if (!psFitsWriteTable(fits, NULL, rowSet, WARPINPUTEXP_TABLE_NAME)) {
    1429314293        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1429414294        psFree(rowSet);
    … …  
    1430114301}
    1430214302
    14303 psMetadata *p4InputExpMetadataFromObject(const p4InputExpRow *object)
     14303psMetadata *warpInputExpMetadataFromObject(const warpInputExpRow *object)
    1430414304{
    1430514305    psMetadata *md = psMetadataAlloc();
    14306     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    14307         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14306    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     14307        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1430814308        psFree(md);
    1430914309        return false;
    … …  
    1431414314        return false;
    1431514315    }
    14316     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    14317         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14316    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
     14317        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1431814318        psFree(md);
    1431914319        return false;
    … …  
    1432914329}
    1433014330
    14331 p4InputExpRow *p4InputExpObjectFromMetadata(psMetadata *md)
     14331warpInputExpRow *warpInputExpObjectFromMetadata(psMetadata *md)
    1433214332{
    1433314333
    1433414334bool status = false;
    14335     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    14336     if (!status) {
    14337         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     14335    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     14336    if (!status) {
     14337        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1433814338        return false;
    1433914339    }
    … …  
    1434314343        return false;
    1434414344    }
    14345     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    14346     if (!status) {
    14347         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     14345    psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
     14346    if (!status) {
     14347        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
    1434814348        return false;
    1434914349    }
    … …  
    1435414354    }
    1435514355
    14356     return p4InputExpRowAlloc(p4_id, exp_tag, p3_version, magiced);
    14357 }
    14358 psArray *p4InputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14356    return warpInputExpRowAlloc(warp_id, exp_tag, cam_version, magiced);
     14357}
     14358psArray *warpInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1435914359{
    1436014360    psArray         *rowSet;
    … …  
    1436214362    psU64           i;
    1436314363
    14364     rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     14364    rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    1436514365    if (!rowSet) {
    1436614366        return NULL;
    … …  
    1437214372
    1437314373    for (i = 0; i < rowSet->n; i++) {
    14374         p4InputExpRow *object = p4InputExpObjectFromMetadata(rowSet->data[i]);
     14374        warpInputExpRow *object = warpInputExpObjectFromMetadata(rowSet->data[i]);
    1437514375        psArrayAdd(returnSet, 0, object);
    1437614376        psFree(object);
    … …  
    1438114381    return returnSet;
    1438214382}
    14383 bool p4InputExpDeleteObject(psDB *dbh, const p4InputExpRow *object)
    14384 {
    14385     psMetadata *where = p4InputExpMetadataFromObject(object);
    14386     long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, 0);
     14383bool warpInputExpDeleteObject(psDB *dbh, const warpInputExpRow *object)
     14384{
     14385    psMetadata *where = warpInputExpMetadataFromObject(object);
     14386    long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, 0);
    1438714387    psFree(where);
    1438814388    if (count < 0) {
    14389         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
     14389        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    1439014390        return false;
    1439114391    }
    … …  
    1439314393        // XXX should this be a psAbort() instead?  It is possible that
    1439414394        // having an object match multiple rows was by design.
    14395         psError(PS_ERR_UNKNOWN, true, "p4InputExpRow object matched more then one row.  Check your database schema");
    14396         return false;
    14397     }
    14398 
    14399     return true;
    14400 }
    14401 long long p4InputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14395        psError(PS_ERR_UNKNOWN, true, "warpInputExpRow object matched more then one row.  Check your database schema");
     14396        return false;
     14397    }
     14398
     14399    return true;
     14400}
     14401long long warpInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1440214402{
    1440314403    long long       deleted = 0;
    1440414404
    1440514405    for (long long i = 0; i < objects->n; i++) {
    14406         p4InputExpRow *object = objects->data[i];
    14407         psMetadata *where = p4InputExpMetadataFromObject(object);
    14408         long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     14406        warpInputExpRow *object = objects->data[i];
     14407        psMetadata *where = warpInputExpMetadataFromObject(object);
     14408        long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    1440914409        psFree(where);
    1441014410        if (count < 0) {
    14411             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
     14411            psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    1441214412            return count;
    1441314413        }
    … …  
    1441814418    return deleted;
    1441914419}
    14420 bool p4InputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14420bool warpInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1442114421{
    1442214422    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1442414424    psMetadata *output = psMetadataAlloc();
    1442514425    for (long i = 0; i < psArrayLength(objects); i++) {
    14426         psMetadata *md = p4InputExpMetadataFromObject(objects->data[i]);
     14426        psMetadata *md = warpInputExpMetadataFromObject(objects->data[i]);
    1442714427        if (!psMetadataAddMetadata(
    1442814428            output,
    1442914429            PS_LIST_TAIL,
    14430             P4INPUTEXP_TABLE_NAME,
     14430            WARPINPUTEXP_TABLE_NAME,
    1443114431            PS_META_DUPLICATE_OK,
    1443214432            NULL,
    … …  
    1444914449    return true;
    1445014450}
    14451 bool p4InputExpPrintObject(FILE *stream, p4InputExpRow *object, bool mdcf)
     14451bool warpInputExpPrintObject(FILE *stream, warpInputExpRow *object, bool mdcf)
    1445214452{
    1445314453    PS_ASSERT_PTR_NON_NULL(object, false);
    1445414454
    14455     psMetadata *md = p4InputExpMetadataFromObject(object);
     14455    psMetadata *md = warpInputExpMetadataFromObject(object);
    1445614456
    1445714457    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1446414464    return true;
    1446514465}
    14466 static void p4SkyCellMapRowFree(p4SkyCellMapRow *object);
    14467 
    14468 p4SkyCellMapRow *p4SkyCellMapRowAlloc(psS32 p4_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *class_id)
    14469 {
    14470     p4SkyCellMapRow *_object;
    14471 
    14472     _object = psAlloc(sizeof(p4SkyCellMapRow));
    14473     psMemSetDeallocator(_object, (psFreeFunc)p4SkyCellMapRowFree);
    14474 
    14475     _object->p4_id = p4_id;
     14466static void warpSkyCellMapRowFree(warpSkyCellMapRow *object);
     14467
     14468warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS32 warp_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 cam_version, const char *class_id)
     14469{
     14470    warpSkyCellMapRow *_object;
     14471
     14472    _object = psAlloc(sizeof(warpSkyCellMapRow));
     14473    psMemSetDeallocator(_object, (psFreeFunc)warpSkyCellMapRowFree);
     14474
     14475    _object->warp_id = warp_id;
    1447614476    _object->skycell_id = psStringCopy(skycell_id);
    1447714477    _object->tess_id = psStringCopy(tess_id);
    1447814478    _object->exp_tag = psStringCopy(exp_tag);
    14479     _object->p3_version = p3_version;
     14479    _object->cam_version = cam_version;
    1448014480    _object->class_id = psStringCopy(class_id);
    1448114481
    … …  
    1448314483}
    1448414484
    14485 static void p4SkyCellMapRowFree(p4SkyCellMapRow *object)
     14485static void warpSkyCellMapRowFree(warpSkyCellMapRow *object)
    1448614486{
    1448714487    psFree(object->skycell_id);
    … …  
    1449114491}
    1449214492
    14493 bool p4SkyCellMapCreateTable(psDB *dbh)
     14493bool warpSkyCellMapCreateTable(psDB *dbh)
    1449414494{
    1449514495    psMetadata *md = psMetadataAlloc();
    14496     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    14497         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14496    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     14497        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1449814498        psFree(md);
    1449914499        return false;
    … …  
    1451414514        return false;
    1451514515    }
    14516     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
    14517         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14516    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
     14517        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1451814518        psFree(md);
    1451914519        return false;
    … …  
    1452514525    }
    1452614526
    14527     bool status = psDBCreateTable(dbh, P4SKYCELLMAP_TABLE_NAME, md);
     14527    bool status = psDBCreateTable(dbh, WARPSKYCELLMAP_TABLE_NAME, md);
    1452814528
    1452914529    psFree(md);
    … …  
    1453214532}
    1453314533
    14534 bool p4SkyCellMapDropTable(psDB *dbh)
    14535 {
    14536     return psDBDropTable(dbh, P4SKYCELLMAP_TABLE_NAME);
    14537 }
    14538 
    14539 bool p4SkyCellMapInsert(psDB * dbh, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *class_id)
     14534bool warpSkyCellMapDropTable(psDB *dbh)
     14535{
     14536    return psDBDropTable(dbh, WARPSKYCELLMAP_TABLE_NAME);
     14537}
     14538
     14539bool warpSkyCellMapInsert(psDB * dbh, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 cam_version, const char *class_id)
    1454014540{
    1454114541    psMetadata *md = psMetadataAlloc();
    14542     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14543         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14542    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     14543        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1454414544        psFree(md);
    1454514545        return false;
    … …  
    1456014560        return false;
    1456114561    }
    14562     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
    14563         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14562    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
     14563        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1456414564        psFree(md);
    1456514565        return false;
    … …  
    1457114571    }
    1457214572
    14573     bool status = psDBInsertOneRow(dbh, P4SKYCELLMAP_TABLE_NAME, md);
     14573    bool status = psDBInsertOneRow(dbh, WARPSKYCELLMAP_TABLE_NAME, md);
    1457414574    psFree(md);
    1457514575
    … …  
    1457714577}
    1457814578
    14579 long long p4SkyCellMapDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14579long long warpSkyCellMapDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1458014580{
    1458114581    long long       deleted = 0;
    1458214582
    14583     long long count = psDBDeleteRows(dbh, P4SKYCELLMAP_TABLE_NAME, where, limit);
     14583    long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit);
    1458414584    if (count < 0) {
    14585         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4SkyCellMap");
     14585        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap");
    1458614586        return count;
    1458714587
    … …  
    1459114591    return deleted;
    1459214592}
    14593 bool p4SkyCellMapInsertObject(psDB *dbh, p4SkyCellMapRow *object)
    14594 {
    14595     return p4SkyCellMapInsert(dbh, object->p4_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->class_id);
    14596 }
    14597 
    14598 bool p4SkyCellMapInsertObjects(psDB *dbh, psArray *objects)
     14593bool warpSkyCellMapInsertObject(psDB *dbh, warpSkyCellMapRow *object)
     14594{
     14595    return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->exp_tag, object->cam_version, object->class_id);
     14596}
     14597
     14598bool warpSkyCellMapInsertObjects(psDB *dbh, psArray *objects)
    1459914599{
    1460014600    for (long i = 0; i < psArrayLength(objects); i++) {
    14601         if (!p4SkyCellMapInsertObject(dbh, objects->data[i])) {
     14601        if (!warpSkyCellMapInsertObject(dbh, objects->data[i])) {
    1460214602            return false;
    1460314603        }
    … …  
    1460714607}
    1460814608
    14609 bool p4SkyCellMapInsertFits(psDB *dbh, const psFits *fits)
     14609bool warpSkyCellMapInsertFits(psDB *dbh, const psFits *fits)
    1461014610{
    1461114611    psArray         *rowSet;
    1461214612
    14613     // move to (the first?) extension named  P4SKYCELLMAP_TABLE_NAME
    14614     if (!psFitsMoveExtName(fits, P4SKYCELLMAP_TABLE_NAME)) {
    14615         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4SKYCELLMAP_TABLE_NAME);
     14613    // move to (the first?) extension named  WARPSKYCELLMAP_TABLE_NAME
     14614    if (!psFitsMoveExtName(fits, WARPSKYCELLMAP_TABLE_NAME)) {
     14615        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPSKYCELLMAP_TABLE_NAME);
    1461614616        return false;
    1461714617    }
    … …  
    1463114631    }
    1463214632
    14633     if (!psDBInsertRows(dbh, P4SKYCELLMAP_TABLE_NAME, rowSet)) {
     14633    if (!psDBInsertRows(dbh, WARPSKYCELLMAP_TABLE_NAME, rowSet)) {
    1463414634        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1463514635        psFree(rowSet);
    … …  
    1464214642}
    1464314643
    14644 bool p4SkyCellMapSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14644bool warpSkyCellMapSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1464514645{
    1464614646    psArray         *rowSet;
    1464714647
    14648     rowSet = psDBSelectRows(dbh, P4SKYCELLMAP_TABLE_NAME, where, limit);
     14648    rowSet = psDBSelectRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit);
    1464914649    if (!rowSet) {
    1465014650        return false;
    … …  
    1465214652
    1465314653    // output to fits
    14654     if (!psFitsWriteTable(fits, NULL, rowSet, P4SKYCELLMAP_TABLE_NAME)) {
     14654    if (!psFitsWriteTable(fits, NULL, rowSet, WARPSKYCELLMAP_TABLE_NAME)) {
    1465514655        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1465614656        psFree(rowSet);
    … …  
    1466314663}
    1466414664
    14665 psMetadata *p4SkyCellMapMetadataFromObject(const p4SkyCellMapRow *object)
     14665psMetadata *warpSkyCellMapMetadataFromObject(const warpSkyCellMapRow *object)
    1466614666{
    1466714667    psMetadata *md = psMetadataAlloc();
    14668     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    14669         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14668    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     14669        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1467014670        psFree(md);
    1467114671        return false;
    … …  
    1468614686        return false;
    1468714687    }
    14688     if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
    14689         psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     14688    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
     14689        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    1469014690        psFree(md);
    1469114691        return false;
    … …  
    1470114701}
    1470214702
    14703 p4SkyCellMapRow *p4SkyCellMapObjectFromMetadata(psMetadata *md)
     14703warpSkyCellMapRow *warpSkyCellMapObjectFromMetadata(psMetadata *md)
    1470414704{
    1470514705
    1470614706bool status = false;
    14707     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    14708     if (!status) {
    14709         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     14707    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     14708    if (!status) {
     14709        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1471014710        return false;
    1471114711    }
    … …  
    1472514725        return false;
    1472614726    }
    14727     psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
    14728     if (!status) {
    14729         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     14727    psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
     14728    if (!status) {
     14729        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
    1473014730        return false;
    1473114731    }
    … …  
    1473614736    }
    1473714737
    14738     return p4SkyCellMapRowAlloc(p4_id, skycell_id, tess_id, exp_tag, p3_version, class_id);
    14739 }
    14740 psArray *p4SkyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14738    return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, exp_tag, cam_version, class_id);
     14739}
     14740psArray *warpSkyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1474114741{
    1474214742    psArray         *rowSet;
    … …  
    1474414744    psU64           i;
    1474514745
    14746     rowSet = psDBSelectRows(dbh, P4SKYCELLMAP_TABLE_NAME, where, limit);
     14746    rowSet = psDBSelectRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit);
    1474714747    if (!rowSet) {
    1474814748        return NULL;
    … …  
    1475414754
    1475514755    for (i = 0; i < rowSet->n; i++) {
    14756         p4SkyCellMapRow *object = p4SkyCellMapObjectFromMetadata(rowSet->data[i]);
     14756        warpSkyCellMapRow *object = warpSkyCellMapObjectFromMetadata(rowSet->data[i]);
    1475714757        psArrayAdd(returnSet, 0, object);
    1475814758        psFree(object);
    … …  
    1476314763    return returnSet;
    1476414764}
    14765 bool p4SkyCellMapDeleteObject(psDB *dbh, const p4SkyCellMapRow *object)
    14766 {
    14767     psMetadata *where = p4SkyCellMapMetadataFromObject(object);
    14768     long long count = psDBDeleteRows(dbh, P4SKYCELLMAP_TABLE_NAME, where, 0);
     14765bool warpSkyCellMapDeleteObject(psDB *dbh, const warpSkyCellMapRow *object)
     14766{
     14767    psMetadata *where = warpSkyCellMapMetadataFromObject(object);
     14768    long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, 0);
    1476914769    psFree(where);
    1477014770    if (count < 0) {
    14771         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4SkyCellMap");
     14771        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap");
    1477214772        return false;
    1477314773    }
    … …  
    1477514775        // XXX should this be a psAbort() instead?  It is possible that
    1477614776        // having an object match multiple rows was by design.
    14777         psError(PS_ERR_UNKNOWN, true, "p4SkyCellMapRow object matched more then one row.  Check your database schema");
    14778         return false;
    14779     }
    14780 
    14781     return true;
    14782 }
    14783 long long p4SkyCellMapDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14777        psError(PS_ERR_UNKNOWN, true, "warpSkyCellMapRow object matched more then one row.  Check your database schema");
     14778        return false;
     14779    }
     14780
     14781    return true;
     14782}
     14783long long warpSkyCellMapDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1478414784{
    1478514785    long long       deleted = 0;
    1478614786
    1478714787    for (long long i = 0; i < objects->n; i++) {
    14788         p4SkyCellMapRow *object = objects->data[i];
    14789         psMetadata *where = p4SkyCellMapMetadataFromObject(object);
    14790         long long count = psDBDeleteRows(dbh, P4SKYCELLMAP_TABLE_NAME, where, limit);
     14788        warpSkyCellMapRow *object = objects->data[i];
     14789        psMetadata *where = warpSkyCellMapMetadataFromObject(object);
     14790        long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit);
    1479114791        psFree(where);
    1479214792        if (count < 0) {
    14793             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4SkyCellMap");
     14793            psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap");
    1479414794            return count;
    1479514795        }
    … …  
    1480014800    return deleted;
    1480114801}
    14802 bool p4SkyCellMapPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14802bool warpSkyCellMapPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1480314803{
    1480414804    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1480614806    psMetadata *output = psMetadataAlloc();
    1480714807    for (long i = 0; i < psArrayLength(objects); i++) {
    14808         psMetadata *md = p4SkyCellMapMetadataFromObject(objects->data[i]);
     14808        psMetadata *md = warpSkyCellMapMetadataFromObject(objects->data[i]);
    1480914809        if (!psMetadataAddMetadata(
    1481014810            output,
    1481114811            PS_LIST_TAIL,
    14812             P4SKYCELLMAP_TABLE_NAME,
     14812            WARPSKYCELLMAP_TABLE_NAME,
    1481314813            PS_META_DUPLICATE_OK,
    1481414814            NULL,
    … …  
    1483114831    return true;
    1483214832}
    14833 bool p4SkyCellMapPrintObject(FILE *stream, p4SkyCellMapRow *object, bool mdcf)
     14833bool warpSkyCellMapPrintObject(FILE *stream, warpSkyCellMapRow *object, bool mdcf)
    1483414834{
    1483514835    PS_ASSERT_PTR_NON_NULL(object, false);
    1483614836
    14837     psMetadata *md = p4SkyCellMapMetadataFromObject(object);
     14837    psMetadata *md = warpSkyCellMapMetadataFromObject(object);
    1483814838
    1483914839    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1484614846    return true;
    1484714847}
    14848 static void p4SkyfileRowFree(p4SkyfileRow *object);
    14849 
    14850 p4SkyfileRow *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);
    14856 
    14857     _object->p4_id = p4_id;
     14848static void warpSkyfileRowFree(warpSkyfileRow *object);
     14849
     14850warpSkyfileRow *warpSkyfileRowAlloc(psS32 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14851{
     14852    warpSkyfileRow  *_object;
     14853
     14854    _object = psAlloc(sizeof(warpSkyfileRow));
     14855    psMemSetDeallocator(_object, (psFreeFunc)warpSkyfileRowFree);
     14856
     14857    _object->warp_id = warp_id;
    1485814858    _object->skycell_id = psStringCopy(skycell_id);
    1485914859    _object->tess_id = psStringCopy(tess_id);
    … …  
    1486514865}
    1486614866
    14867 static void p4SkyfileRowFree(p4SkyfileRow *object)
     14867static void warpSkyfileRowFree(warpSkyfileRow *object)
    1486814868{
    1486914869    psFree(object->skycell_id);
    … …  
    1487214872}
    1487314873
    14874 bool p4SkyfileCreateTable(psDB *dbh)
     14874bool warpSkyfileCreateTable(psDB *dbh)
    1487514875{
    1487614876    psMetadata *md = psMetadataAlloc();
    14877     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    14878         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14877    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     14878        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1487914879        psFree(md);
    1488014880        return false;
    … …  
    1490614906    }
    1490714907
    14908     bool status = psDBCreateTable(dbh, P4SKYFILE_TABLE_NAME, md);
     14908    bool status = psDBCreateTable(dbh, WARPSKYFILE_TABLE_NAME, md);
    1490914909
    1491014910    psFree(md);
    … …  
    1491314913}
    1491414914
    14915 bool p4SkyfileDropTable(psDB *dbh)
    14916 {
    14917     return psDBDropTable(dbh, P4SKYFILE_TABLE_NAME);
    14918 }
    14919 
    14920 bool p4SkyfileInsert(psDB * dbh, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14915bool warpSkyfileDropTable(psDB *dbh)
     14916{
     14917    return psDBDropTable(dbh, WARPSKYFILE_TABLE_NAME);
     14918}
     14919
     14920bool warpSkyfileInsert(psDB * dbh, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1492114921{
    1492214922    psMetadata *md = psMetadataAlloc();
    14923     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14924         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14923    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     14924        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1492514925        psFree(md);
    1492614926        return false;
    … …  
    1495214952    }
    1495314953
    14954     bool status = psDBInsertOneRow(dbh, P4SKYFILE_TABLE_NAME, md);
     14954    bool status = psDBInsertOneRow(dbh, WARPSKYFILE_TABLE_NAME, md);
    1495514955    psFree(md);
    1495614956
    … …  
    1495814958}
    1495914959
    14960 long long p4SkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14960long long warpSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1496114961{
    1496214962    long long       deleted = 0;
    1496314963
    14964     long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
     14964    long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit);
    1496514965    if (count < 0) {
    14966         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
     14966        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile");
    1496714967        return count;
    1496814968
    … …  
    1497214972    return deleted;
    1497314973}
    14974 bool 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 
    14979 bool p4SkyfileInsertObjects(psDB *dbh, psArray *objects)
     14974bool warpSkyfileInsertObject(psDB *dbh, warpSkyfileRow *object)
     14975{
     14976    return warpSkyfileInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->uri, object->bg, object->bg_mean_stdev);
     14977}
     14978
     14979bool warpSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1498014980{
    1498114981    for (long i = 0; i < psArrayLength(objects); i++) {
    14982         if (!p4SkyfileInsertObject(dbh, objects->data[i])) {
     14982        if (!warpSkyfileInsertObject(dbh, objects->data[i])) {
    1498314983            return false;
    1498414984        }
    … …  
    1498814988}
    1498914989
    14990 bool p4SkyfileInsertFits(psDB *dbh, const psFits *fits)
     14990bool warpSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1499114991{
    1499214992    psArray         *rowSet;
    1499314993
    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);
     14994    // move to (the first?) extension named  WARPSKYFILE_TABLE_NAME
     14995    if (!psFitsMoveExtName(fits, WARPSKYFILE_TABLE_NAME)) {
     14996        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPSKYFILE_TABLE_NAME);
    1499714997        return false;
    1499814998    }
    … …  
    1501215012    }
    1501315013
    15014     if (!psDBInsertRows(dbh, P4SKYFILE_TABLE_NAME, rowSet)) {
     15014    if (!psDBInsertRows(dbh, WARPSKYFILE_TABLE_NAME, rowSet)) {
    1501515015        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1501615016        psFree(rowSet);
    … …  
    1502315023}
    1502415024
    15025 bool p4SkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15025bool warpSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1502615026{
    1502715027    psArray         *rowSet;
    1502815028
    15029     rowSet = psDBSelectRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
     15029    rowSet = psDBSelectRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit);
    1503015030    if (!rowSet) {
    1503115031        return false;
    … …  
    1503315033
    1503415034    // output to fits
    15035     if (!psFitsWriteTable(fits, NULL, rowSet, P4SKYFILE_TABLE_NAME)) {
     15035    if (!psFitsWriteTable(fits, NULL, rowSet, WARPSKYFILE_TABLE_NAME)) {
    1503615036        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1503715037        psFree(rowSet);
    … …  
    1504415044}
    1504515045
    15046 psMetadata *p4SkyfileMetadataFromObject(const p4SkyfileRow *object)
     15046psMetadata *warpSkyfileMetadataFromObject(const warpSkyfileRow *object)
    1504715047{
    1504815048    psMetadata *md = psMetadataAlloc();
    15049     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    15050         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15049    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     15050        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1505115051        psFree(md);
    1505215052        return false;
    … …  
    1508215082}
    1508315083
    15084 p4SkyfileRow *p4SkyfileObjectFromMetadata(psMetadata *md)
     15084warpSkyfileRow *warpSkyfileObjectFromMetadata(psMetadata *md)
    1508515085{
    1508615086
    1508715087bool status = false;
    15088     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    15089     if (!status) {
    15090         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     15088    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     15089    if (!status) {
     15090        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1509115091        return false;
    1509215092    }
    … …  
    1511715117    }
    1511815118
    15119     return p4SkyfileRowAlloc(p4_id, skycell_id, tess_id, uri, bg, bg_mean_stdev);
    15120 }
    15121 psArray *p4SkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15119    return warpSkyfileRowAlloc(warp_id, skycell_id, tess_id, uri, bg, bg_mean_stdev);
     15120}
     15121psArray *warpSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1512215122{
    1512315123    psArray         *rowSet;
    … …  
    1512515125    psU64           i;
    1512615126
    15127     rowSet = psDBSelectRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
     15127    rowSet = psDBSelectRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit);
    1512815128    if (!rowSet) {
    1512915129        return NULL;
    … …  
    1513515135
    1513615136    for (i = 0; i < rowSet->n; i++) {
    15137         p4SkyfileRow *object = p4SkyfileObjectFromMetadata(rowSet->data[i]);
     15137        warpSkyfileRow *object = warpSkyfileObjectFromMetadata(rowSet->data[i]);
    1513815138        psArrayAdd(returnSet, 0, object);
    1513915139        psFree(object);
    … …  
    1514415144    return returnSet;
    1514515145}
    15146 bool p4SkyfileDeleteObject(psDB *dbh, const p4SkyfileRow *object)
    15147 {
    15148     psMetadata *where = p4SkyfileMetadataFromObject(object);
    15149     long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, 0);
     15146bool warpSkyfileDeleteObject(psDB *dbh, const warpSkyfileRow *object)
     15147{
     15148    psMetadata *where = warpSkyfileMetadataFromObject(object);
     15149    long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, 0);
    1515015150    psFree(where);
    1515115151    if (count < 0) {
    15152         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
     15152        psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile");
    1515315153        return false;
    1515415154    }
    … …  
    1515615156        // XXX should this be a psAbort() instead?  It is possible that
    1515715157        // having an object match multiple rows was by design.
    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 }
    15164 long long p4SkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15158        psError(PS_ERR_UNKNOWN, true, "warpSkyfileRow object matched more then one row.  Check your database schema");
     15159        return false;
     15160    }
     15161
     15162    return true;
     15163}
     15164long long warpSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1516515165{
    1516615166    long long       deleted = 0;
    1516715167
    1516815168    for (long long i = 0; i < objects->n; i++) {
    15169         p4SkyfileRow *object = objects->data[i];
    15170         psMetadata *where = p4SkyfileMetadataFromObject(object);
    15171         long long count = psDBDeleteRows(dbh, P4SKYFILE_TABLE_NAME, where, limit);
     15169        warpSkyfileRow *object = objects->data[i];
     15170        psMetadata *where = warpSkyfileMetadataFromObject(object);
     15171        long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit);
    1517215172        psFree(where);
    1517315173        if (count < 0) {
    15174             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Skyfile");
     15174            psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile");
    1517515175            return count;
    1517615176        }
    … …  
    1518115181    return deleted;
    1518215182}
    15183 bool p4SkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15183bool warpSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1518415184{
    1518515185    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1518715187    psMetadata *output = psMetadataAlloc();
    1518815188    for (long i = 0; i < psArrayLength(objects); i++) {
    15189         psMetadata *md = p4SkyfileMetadataFromObject(objects->data[i]);
     15189        psMetadata *md = warpSkyfileMetadataFromObject(objects->data[i]);
    1519015190        if (!psMetadataAddMetadata(
    1519115191            output,
    1519215192            PS_LIST_TAIL,
    15193             P4SKYFILE_TABLE_NAME,
     15193            WARPSKYFILE_TABLE_NAME,
    1519415194            PS_META_DUPLICATE_OK,
    1519515195            NULL,
    … …  
    1521215212    return true;
    1521315213}
    15214 bool p4SkyfilePrintObject(FILE *stream, p4SkyfileRow *object, bool mdcf)
     15214bool warpSkyfilePrintObject(FILE *stream, warpSkyfileRow *object, bool mdcf)
    1521515215{
    1521615216    PS_ASSERT_PTR_NON_NULL(object, false);
    1521715217
    15218     psMetadata *md = p4SkyfileMetadataFromObject(object);
     15218    psMetadata *md = warpSkyfileMetadataFromObject(object);
    1521915219
    1522015220    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1522715227    return true;
    1522815228}
    15229 static void p5RunRowFree(p5RunRow *object);
    15230 
    15231 p5RunRow *p5RunRowAlloc(psS32 p5_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    15232 {
    15233     p5RunRow        *_object;
    15234 
    15235     _object = psAlloc(sizeof(p5RunRow));
    15236     psMemSetDeallocator(_object, (psFreeFunc)p5RunRowFree);
    15237 
    15238     _object->p5_id = p5_id;
     15229static void diffRunRowFree(diffRunRow *object);
     15230
     15231diffRunRow *diffRunRowAlloc(psS32 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     15232{
     15233    diffRunRow      *_object;
     15234
     15235    _object = psAlloc(sizeof(diffRunRow));
     15236    psMemSetDeallocator(_object, (psFreeFunc)diffRunRowFree);
     15237
     15238    _object->diff_id = diff_id;
    1523915239    _object->state = psStringCopy(state);
    1524015240    _object->workdir = psStringCopy(workdir);
    … …  
    1524715247}
    1524815248
    15249 static void p5RunRowFree(p5RunRow *object)
     15249static void diffRunRowFree(diffRunRow *object)
    1525015250{
    1525115251    psFree(object->state);
    … …  
    1525715257}
    1525815258
    15259 bool p5RunCreateTable(psDB *dbh)
     15259bool diffRunCreateTable(psDB *dbh)
    1526015260{
    1526115261    psMetadata *md = psMetadataAlloc();
    15262     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
    15263         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     15262    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     15263        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1526415264        psFree(md);
    1526515265        return false;
    … …  
    1529615296    }
    1529715297
    15298     bool status = psDBCreateTable(dbh, P5RUN_TABLE_NAME, md);
     15298    bool status = psDBCreateTable(dbh, DIFFRUN_TABLE_NAME, md);
    1529915299
    1530015300    psFree(md);
    … …  
    1530315303}
    1530415304
    15305 bool p5RunDropTable(psDB *dbh)
    15306 {
    15307     return psDBDropTable(dbh, P5RUN_TABLE_NAME);
    15308 }
    15309 
    15310 bool 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)
     15305bool diffRunDropTable(psDB *dbh)
     15306{
     15307    return psDBDropTable(dbh, DIFFRUN_TABLE_NAME);
     15308}
     15309
     15310bool diffRunInsert(psDB * dbh, psS32 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1531115311{
    1531215312    psMetadata *md = psMetadataAlloc();
    15313     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) {
    15314         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     15313    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     15314        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1531515315        psFree(md);
    1531615316        return false;
    … …  
    1534715347    }
    1534815348
    15349     bool status = psDBInsertOneRow(dbh, P5RUN_TABLE_NAME, md);
     15349    bool status = psDBInsertOneRow(dbh, DIFFRUN_TABLE_NAME, md);
    1535015350    psFree(md);
    1535115351
    … …  
    1535315353}
    1535415354
    15355 long long p5RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15355long long diffRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1535615356{
    1535715357    long long       deleted = 0;
    1535815358
    15359     long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, limit);
     15359    long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, limit);
    1536015360    if (count < 0) {
    15361         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run");
     15361        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun");
    1536215362        return count;
    1536315363
    … …  
    1536715367    return deleted;
    1536815368}
    15369 bool p5RunInsertObject(psDB *dbh, p5RunRow *object)
    15370 {
    15371     return p5RunInsert(dbh, object->p5_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
    15372 }
    15373 
    15374 bool p5RunInsertObjects(psDB *dbh, psArray *objects)
     15369bool diffRunInsertObject(psDB *dbh, diffRunRow *object)
     15370{
     15371    return diffRunInsert(dbh, object->diff_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
     15372}
     15373
     15374bool diffRunInsertObjects(psDB *dbh, psArray *objects)
    1537515375{
    1537615376    for (long i = 0; i < psArrayLength(objects); i++) {
    15377         if (!p5RunInsertObject(dbh, objects->data[i])) {
     15377        if (!diffRunInsertObject(dbh, objects->data[i])) {
    1537815378            return false;
    1537915379        }
    … …  
    1538315383}
    1538415384
    15385 bool p5RunInsertFits(psDB *dbh, const psFits *fits)
     15385bool diffRunInsertFits(psDB *dbh, const psFits *fits)
    1538615386{
    1538715387    psArray         *rowSet;
    1538815388
    15389     // move to (the first?) extension named  P5RUN_TABLE_NAME
    15390     if (!psFitsMoveExtName(fits, P5RUN_TABLE_NAME)) {
    15391         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P5RUN_TABLE_NAME);
     15389    // move to (the first?) extension named  DIFFRUN_TABLE_NAME
     15390    if (!psFitsMoveExtName(fits, DIFFRUN_TABLE_NAME)) {
     15391        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFRUN_TABLE_NAME);
    1539215392        return false;
    1539315393    }
    … …  
    1540715407    }
    1540815408
    15409     if (!psDBInsertRows(dbh, P5RUN_TABLE_NAME, rowSet)) {
     15409    if (!psDBInsertRows(dbh, DIFFRUN_TABLE_NAME, rowSet)) {
    1541015410        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1541115411        psFree(rowSet);
    … …  
    1541815418}
    1541915419
    15420 bool p5RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15420bool diffRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1542115421{
    1542215422    psArray         *rowSet;
    1542315423
    15424     rowSet = psDBSelectRows(dbh, P5RUN_TABLE_NAME, where, limit);
     15424    rowSet = psDBSelectRows(dbh, DIFFRUN_TABLE_NAME, where, limit);
    1542515425    if (!rowSet) {
    1542615426        return false;
    … …  
    1542815428
    1542915429    // output to fits
    15430     if (!psFitsWriteTable(fits, NULL, rowSet, P5RUN_TABLE_NAME)) {
     15430    if (!psFitsWriteTable(fits, NULL, rowSet, DIFFRUN_TABLE_NAME)) {
    1543115431        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1543215432        psFree(rowSet);
    … …  
    1543915439}
    1544015440
    15441 psMetadata *p5RunMetadataFromObject(const p5RunRow *object)
     15441psMetadata *diffRunMetadataFromObject(const diffRunRow *object)
    1544215442{
    1544315443    psMetadata *md = psMetadataAlloc();
    15444     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) {
    15445         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     15444    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     15445        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1544615446        psFree(md);
    1544715447        return false;
    … …  
    1548215482}
    1548315483
    15484 p5RunRow *p5RunObjectFromMetadata(psMetadata *md)
     15484diffRunRow *diffRunObjectFromMetadata(psMetadata *md)
    1548515485{
    1548615486
    1548715487bool status = false;
    15488     psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id");
    15489     if (!status) {
    15490         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_id");
     15488    psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     15489    if (!status) {
     15490        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
    1549115491        return false;
    1549215492    }
    … …  
    1552215522    }
    1552315523
    15524     return p5RunRowAlloc(p5_id, state, workdir, dvodb, registered, skycell_id, tess_id);
    15525 }
    15526 psArray *p5RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15524    return diffRunRowAlloc(diff_id, state, workdir, dvodb, registered, skycell_id, tess_id);
     15525}
     15526psArray *diffRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1552715527{
    1552815528    psArray         *rowSet;
    … …  
    1553015530    psU64           i;
    1553115531
    15532     rowSet = psDBSelectRows(dbh, P5RUN_TABLE_NAME, where, limit);
     15532    rowSet = psDBSelectRows(dbh, DIFFRUN_TABLE_NAME, where, limit);
    1553315533    if (!rowSet) {
    1553415534        return NULL;
    … …  
    1554015540
    1554115541    for (i = 0; i < rowSet->n; i++) {
    15542         p5RunRow *object = p5RunObjectFromMetadata(rowSet->data[i]);
     15542        diffRunRow *object = diffRunObjectFromMetadata(rowSet->data[i]);
    1554315543        psArrayAdd(returnSet, 0, object);
    1554415544        psFree(object);
    … …  
    1554915549    return returnSet;
    1555015550}
    15551 bool p5RunDeleteObject(psDB *dbh, const p5RunRow *object)
    15552 {
    15553     psMetadata *where = p5RunMetadataFromObject(object);
    15554     long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, 0);
     15551bool diffRunDeleteObject(psDB *dbh, const diffRunRow *object)
     15552{
     15553    psMetadata *where = diffRunMetadataFromObject(object);
     15554    long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, 0);
    1555515555    psFree(where);
    1555615556    if (count < 0) {
    15557         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run");
     15557        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun");
    1555815558        return false;
    1555915559    }
    … …  
    1556115561        // XXX should this be a psAbort() instead?  It is possible that
    1556215562        // having an object match multiple rows was by design.
    15563         psError(PS_ERR_UNKNOWN, true, "p5RunRow object matched more then one row.  Check your database schema");
    15564         return false;
    15565     }
    15566 
    15567     return true;
    15568 }
    15569 long long p5RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15563        psError(PS_ERR_UNKNOWN, true, "diffRunRow object matched more then one row.  Check your database schema");
     15564        return false;
     15565    }
     15566
     15567    return true;
     15568}
     15569long long diffRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1557015570{
    1557115571    long long       deleted = 0;
    1557215572
    1557315573    for (long long i = 0; i < objects->n; i++) {
    15574         p5RunRow *object = objects->data[i];
    15575         psMetadata *where = p5RunMetadataFromObject(object);
    15576         long long count = psDBDeleteRows(dbh, P5RUN_TABLE_NAME, where, limit);
     15574        diffRunRow *object = objects->data[i];
     15575        psMetadata *where = diffRunMetadataFromObject(object);
     15576        long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, limit);
    1557715577        psFree(where);
    1557815578        if (count < 0) {
    15579             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5Run");
     15579            psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun");
    1558015580            return count;
    1558115581        }
    … …  
    1558615586    return deleted;
    1558715587}
    15588 bool p5RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15588bool diffRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1558915589{
    1559015590    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1559215592    psMetadata *output = psMetadataAlloc();
    1559315593    for (long i = 0; i < psArrayLength(objects); i++) {
    15594         psMetadata *md = p5RunMetadataFromObject(objects->data[i]);
     15594        psMetadata *md = diffRunMetadataFromObject(objects->data[i]);
    1559515595        if (!psMetadataAddMetadata(
    1559615596            output,
    1559715597            PS_LIST_TAIL,
    15598             P5RUN_TABLE_NAME,
     15598            DIFFRUN_TABLE_NAME,
    1559915599            PS_META_DUPLICATE_OK,
    1560015600            NULL,
    … …  
    1561715617    return true;
    1561815618}
    15619 bool p5RunPrintObject(FILE *stream, p5RunRow *object, bool mdcf)
     15619bool diffRunPrintObject(FILE *stream, diffRunRow *object, bool mdcf)
    1562015620{
    1562115621    PS_ASSERT_PTR_NON_NULL(object, false);
    1562215622
    15623     psMetadata *md = p5RunMetadataFromObject(object);
     15623    psMetadata *md = diffRunMetadataFromObject(object);
    1562415624
    1562515625    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1563215632    return true;
    1563315633}
    15634 static void p5InputSkyfileRowFree(p5InputSkyfileRow *object);
    15635 
    15636 p5InputSkyfileRow *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);
    15642 
    15643     _object->p5_id = p5_id;
    15644     _object->p4_id = p4_id;
     15634static void diffInputSkyfileRowFree(diffInputSkyfileRow *object);
     15635
     15636diffInputSkyfileRow *diffInputSkyfileRowAlloc(psS32 diff_id, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15637{
     15638    diffInputSkyfileRow *_object;
     15639
     15640    _object = psAlloc(sizeof(diffInputSkyfileRow));
     15641    psMemSetDeallocator(_object, (psFreeFunc)diffInputSkyfileRowFree);
     15642
     15643    _object->diff_id = diff_id;
     15644    _object->warp_id = warp_id;
    1564515645    _object->skycell_id = psStringCopy(skycell_id);
    1564615646    _object->tess_id = psStringCopy(tess_id);
    … …  
    1565115651}
    1565215652
    15653 static void p5InputSkyfileRowFree(p5InputSkyfileRow *object)
     15653static void diffInputSkyfileRowFree(diffInputSkyfileRow *object)
    1565415654{
    1565515655    psFree(object->skycell_id);
    … …  
    1565815658}
    1565915659
    15660 bool p5InputSkyfileCreateTable(psDB *dbh)
     15660bool diffInputSkyfileCreateTable(psDB *dbh)
    1566115661{
    1566215662    psMetadata *md = psMetadataAlloc();
    15663     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key", 0)) {
    15664         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
    15665         psFree(md);
    15666         return false;
    15667     }
    15668     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    15669         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15663    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key", 0)) {
     15664        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
     15665        psFree(md);
     15666        return false;
     15667    }
     15668    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     15669        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1567015670        psFree(md);
    1567115671        return false;
    … …  
    1569215692    }
    1569315693
    15694     bool status = psDBCreateTable(dbh, P5INPUTSKYFILE_TABLE_NAME, md);
     15694    bool status = psDBCreateTable(dbh, DIFFINPUTSKYFILE_TABLE_NAME, md);
    1569515695
    1569615696    psFree(md);
    … …  
    1569915699}
    1570015700
    15701 bool p5InputSkyfileDropTable(psDB *dbh)
    15702 {
    15703     return psDBDropTable(dbh, P5INPUTSKYFILE_TABLE_NAME);
    15704 }
    15705 
    15706 bool p5InputSkyfileInsert(psDB * dbh, psS32 p5_id, psS32 p4_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15701bool diffInputSkyfileDropTable(psDB *dbh)
     15702{
     15703    return psDBDropTable(dbh, DIFFINPUTSKYFILE_TABLE_NAME);
     15704}
     15705
     15706bool diffInputSkyfileInsert(psDB * dbh, psS32 diff_id, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
    1570715707{
    1570815708    psMetadata *md = psMetadataAlloc();
    15709     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) {
    15710         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
    15711         psFree(md);
    15712         return false;
    15713     }
    15714     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    15715         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15709    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     15710        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
     15711        psFree(md);
     15712        return false;
     15713    }
     15714    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     15715        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1571615716        psFree(md);
    1571715717        return false;
    … …  
    1573815738    }
    1573915739
    15740     bool status = psDBInsertOneRow(dbh, P5INPUTSKYFILE_TABLE_NAME, md);
     15740    bool status = psDBInsertOneRow(dbh, DIFFINPUTSKYFILE_TABLE_NAME, md);
    1574115741    psFree(md);
    1574215742
    … …  
    1574415744}
    1574515745
    15746 long long p5InputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15746long long diffInputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1574715747{
    1574815748    long long       deleted = 0;
    1574915749
    15750     long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
     15750    long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit);
    1575115751    if (count < 0) {
    15752         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
     15752        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile");
    1575315753        return count;
    1575415754
    … …  
    1575815758    return deleted;
    1575915759}
    15760 bool 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 
    15765 bool p5InputSkyfileInsertObjects(psDB *dbh, psArray *objects)
     15760bool diffInputSkyfileInsertObject(psDB *dbh, diffInputSkyfileRow *object)
     15761{
     15762    return diffInputSkyfileInsert(dbh, object->diff_id, object->warp_id, object->skycell_id, object->tess_id, object->kind, object->template);
     15763}
     15764
     15765bool diffInputSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1576615766{
    1576715767    for (long i = 0; i < psArrayLength(objects); i++) {
    15768         if (!p5InputSkyfileInsertObject(dbh, objects->data[i])) {
     15768        if (!diffInputSkyfileInsertObject(dbh, objects->data[i])) {
    1576915769            return false;
    1577015770        }
    … …  
    1577415774}
    1577515775
    15776 bool p5InputSkyfileInsertFits(psDB *dbh, const psFits *fits)
     15776bool diffInputSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1577715777{
    1577815778    psArray         *rowSet;
    1577915779
    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);
     15780    // move to (the first?) extension named  DIFFINPUTSKYFILE_TABLE_NAME
     15781    if (!psFitsMoveExtName(fits, DIFFINPUTSKYFILE_TABLE_NAME)) {
     15782        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFINPUTSKYFILE_TABLE_NAME);
    1578315783        return false;
    1578415784    }
    … …  
    1579815798    }
    1579915799
    15800     if (!psDBInsertRows(dbh, P5INPUTSKYFILE_TABLE_NAME, rowSet)) {
     15800    if (!psDBInsertRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, rowSet)) {
    1580115801        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1580215802        psFree(rowSet);
    … …  
    1580915809}
    1581015810
    15811 bool p5InputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15811bool diffInputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1581215812{
    1581315813    psArray         *rowSet;
    1581415814
    15815     rowSet = psDBSelectRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
     15815    rowSet = psDBSelectRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit);
    1581615816    if (!rowSet) {
    1581715817        return false;
    … …  
    1581915819
    1582015820    // output to fits
    15821     if (!psFitsWriteTable(fits, NULL, rowSet, P5INPUTSKYFILE_TABLE_NAME)) {
     15821    if (!psFitsWriteTable(fits, NULL, rowSet, DIFFINPUTSKYFILE_TABLE_NAME)) {
    1582215822        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1582315823        psFree(rowSet);
    … …  
    1583015830}
    1583115831
    15832 psMetadata *p5InputSkyfileMetadataFromObject(const p5InputSkyfileRow *object)
     15832psMetadata *diffInputSkyfileMetadataFromObject(const diffInputSkyfileRow *object)
    1583315833{
    1583415834    psMetadata *md = psMetadataAlloc();
    15835     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) {
    15836         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
    15837         psFree(md);
    15838         return false;
    15839     }
    15840     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    15841         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15835    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     15836        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
     15837        psFree(md);
     15838        return false;
     15839    }
     15840    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     15841        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1584215842        psFree(md);
    1584315843        return false;
    … …  
    1586815868}
    1586915869
    15870 p5InputSkyfileRow *p5InputSkyfileObjectFromMetadata(psMetadata *md)
     15870diffInputSkyfileRow *diffInputSkyfileObjectFromMetadata(psMetadata *md)
    1587115871{
    1587215872
    1587315873bool status = false;
    15874     psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id");
    15875     if (!status) {
    15876         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_id");
    15877         return false;
    15878     }
    15879     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    15880     if (!status) {
    15881         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     15874    psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     15875    if (!status) {
     15876        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
     15877        return false;
     15878    }
     15879    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     15880    if (!status) {
     15881        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1588215882        return false;
    1588315883    }
    … …  
    1590315903    }
    1590415904
    15905     return p5InputSkyfileRowAlloc(p5_id, p4_id, skycell_id, tess_id, kind, template);
    15906 }
    15907 psArray *p5InputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15905    return diffInputSkyfileRowAlloc(diff_id, warp_id, skycell_id, tess_id, kind, template);
     15906}
     15907psArray *diffInputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1590815908{
    1590915909    psArray         *rowSet;
    … …  
    1591115911    psU64           i;
    1591215912
    15913     rowSet = psDBSelectRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
     15913    rowSet = psDBSelectRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit);
    1591415914    if (!rowSet) {
    1591515915        return NULL;
    … …  
    1592115921
    1592215922    for (i = 0; i < rowSet->n; i++) {
    15923         p5InputSkyfileRow *object = p5InputSkyfileObjectFromMetadata(rowSet->data[i]);
     15923        diffInputSkyfileRow *object = diffInputSkyfileObjectFromMetadata(rowSet->data[i]);
    1592415924        psArrayAdd(returnSet, 0, object);
    1592515925        psFree(object);
    … …  
    1593015930    return returnSet;
    1593115931}
    15932 bool p5InputSkyfileDeleteObject(psDB *dbh, const p5InputSkyfileRow *object)
    15933 {
    15934     psMetadata *where = p5InputSkyfileMetadataFromObject(object);
    15935     long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, 0);
     15932bool diffInputSkyfileDeleteObject(psDB *dbh, const diffInputSkyfileRow *object)
     15933{
     15934    psMetadata *where = diffInputSkyfileMetadataFromObject(object);
     15935    long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, 0);
    1593615936    psFree(where);
    1593715937    if (count < 0) {
    15938         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
     15938        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile");
    1593915939        return false;
    1594015940    }
    … …  
    1594215942        // XXX should this be a psAbort() instead?  It is possible that
    1594315943        // having an object match multiple rows was by design.
    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 }
    15950 long long p5InputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15944        psError(PS_ERR_UNKNOWN, true, "diffInputSkyfileRow object matched more then one row.  Check your database schema");
     15945        return false;
     15946    }
     15947
     15948    return true;
     15949}
     15950long long diffInputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1595115951{
    1595215952    long long       deleted = 0;
    1595315953
    1595415954    for (long long i = 0; i < objects->n; i++) {
    15955         p5InputSkyfileRow *object = objects->data[i];
    15956         psMetadata *where = p5InputSkyfileMetadataFromObject(object);
    15957         long long count = psDBDeleteRows(dbh, P5INPUTSKYFILE_TABLE_NAME, where, limit);
     15955        diffInputSkyfileRow *object = objects->data[i];
     15956        psMetadata *where = diffInputSkyfileMetadataFromObject(object);
     15957        long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit);
    1595815958        psFree(where);
    1595915959        if (count < 0) {
    15960             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5InputSkyfile");
     15960            psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile");
    1596115961            return count;
    1596215962        }
    … …  
    1596715967    return deleted;
    1596815968}
    15969 bool p5InputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15969bool diffInputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1597015970{
    1597115971    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1597315973    psMetadata *output = psMetadataAlloc();
    1597415974    for (long i = 0; i < psArrayLength(objects); i++) {
    15975         psMetadata *md = p5InputSkyfileMetadataFromObject(objects->data[i]);
     15975        psMetadata *md = diffInputSkyfileMetadataFromObject(objects->data[i]);
    1597615976        if (!psMetadataAddMetadata(
    1597715977            output,
    1597815978            PS_LIST_TAIL,
    15979             P5INPUTSKYFILE_TABLE_NAME,
     15979            DIFFINPUTSKYFILE_TABLE_NAME,
    1598015980            PS_META_DUPLICATE_OK,
    1598115981            NULL,
    … …  
    1599815998    return true;
    1599915999}
    16000 bool p5InputSkyfilePrintObject(FILE *stream, p5InputSkyfileRow *object, bool mdcf)
     16000bool diffInputSkyfilePrintObject(FILE *stream, diffInputSkyfileRow *object, bool mdcf)
    1600116001{
    1600216002    PS_ASSERT_PTR_NON_NULL(object, false);
    1600316003
    16004     psMetadata *md = p5InputSkyfileMetadataFromObject(object);
     16004    psMetadata *md = diffInputSkyfileMetadataFromObject(object);
    1600516005
    1600616006    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1601316013    return true;
    1601416014}
    16015 static void p5DiffSkyfileRowFree(p5DiffSkyfileRow *object);
    16016 
    16017 p5DiffSkyfileRow *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);
    16023 
    16024     _object->p5_id = p5_id;
     16015static void diffSkyfileRowFree(diffSkyfileRow *object);
     16016
     16017diffSkyfileRow *diffSkyfileRowAlloc(psS32 diff_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     16018{
     16019    diffSkyfileRow *_object;
     16020
     16021    _object = psAlloc(sizeof(diffSkyfileRow));
     16022    psMemSetDeallocator(_object, (psFreeFunc)diffSkyfileRowFree);
     16023
     16024    _object->diff_id = diff_id;
    1602516025    _object->uri = psStringCopy(uri);
    1602616026    _object->bg = bg;
    … …  
    1603016030}
    1603116031
    16032 static void p5DiffSkyfileRowFree(p5DiffSkyfileRow *object)
     16032static void diffSkyfileRowFree(diffSkyfileRow *object)
    1603316033{
    1603416034    psFree(object->uri);
    1603516035}
    1603616036
    16037 bool p5DiffSkyfileCreateTable(psDB *dbh)
     16037bool diffSkyfileCreateTable(psDB *dbh)
    1603816038{
    1603916039    psMetadata *md = psMetadataAlloc();
    16040     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, "Primary Key", 0)) {
    16041         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     16040    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key", 0)) {
     16041        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1604216042        psFree(md);
    1604316043        return false;
    … …  
    1605916059    }
    1606016060
    16061     bool status = psDBCreateTable(dbh, P5DIFFSKYFILE_TABLE_NAME, md);
     16061    bool status = psDBCreateTable(dbh, DIFFSKYFILE_TABLE_NAME, md);
    1606216062
    1606316063    psFree(md);
    … …  
    1606616066}
    1606716067
    16068 bool p5DiffSkyfileDropTable(psDB *dbh)
    16069 {
    16070     return psDBDropTable(dbh, P5DIFFSKYFILE_TABLE_NAME);
    16071 }
    16072 
    16073 bool p5DiffSkyfileInsert(psDB * dbh, psS32 p5_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     16068bool diffSkyfileDropTable(psDB *dbh)
     16069{
     16070    return psDBDropTable(dbh, DIFFSKYFILE_TABLE_NAME);
     16071}
     16072
     16073bool diffSkyfileInsert(psDB * dbh, psS32 diff_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1607416074{
    1607516075    psMetadata *md = psMetadataAlloc();
    16076     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, p5_id)) {
    16077         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     16076    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     16077        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1607816078        psFree(md);
    1607916079        return false;
    … …  
    1609516095    }
    1609616096
    16097     bool status = psDBInsertOneRow(dbh, P5DIFFSKYFILE_TABLE_NAME, md);
     16097    bool status = psDBInsertOneRow(dbh, DIFFSKYFILE_TABLE_NAME, md);
    1609816098    psFree(md);
    1609916099
    … …  
    1610116101}
    1610216102
    16103 long long p5DiffSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16103long long diffSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1610416104{
    1610516105    long long       deleted = 0;
    1610616106
    16107     long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
     16107    long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit);
    1610816108    if (count < 0) {
    16109         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
     16109        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile");
    1611016110        return count;
    1611116111
    … …  
    1611516115    return deleted;
    1611616116}
    16117 bool p5DiffSkyfileInsertObject(psDB *dbh, p5DiffSkyfileRow *object)
    16118 {
    16119     return p5DiffSkyfileInsert(dbh, object->p5_id, object->uri, object->bg, object->bg_mean_stdev);
    16120 }
    16121 
    16122 bool p5DiffSkyfileInsertObjects(psDB *dbh, psArray *objects)
     16117bool diffSkyfileInsertObject(psDB *dbh, diffSkyfileRow *object)
     16118{
     16119    return diffSkyfileInsert(dbh, object->diff_id, object->uri, object->bg, object->bg_mean_stdev);
     16120}
     16121
     16122bool diffSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1612316123{
    1612416124    for (long i = 0; i < psArrayLength(objects); i++) {
    16125         if (!p5DiffSkyfileInsertObject(dbh, objects->data[i])) {
     16125        if (!diffSkyfileInsertObject(dbh, objects->data[i])) {
    1612616126            return false;
    1612716127        }
    … …  
    1613116131}
    1613216132
    16133 bool p5DiffSkyfileInsertFits(psDB *dbh, const psFits *fits)
     16133bool diffSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1613416134{
    1613516135    psArray         *rowSet;
    1613616136
    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);
     16137    // move to (the first?) extension named  DIFFSKYFILE_TABLE_NAME
     16138    if (!psFitsMoveExtName(fits, DIFFSKYFILE_TABLE_NAME)) {
     16139        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFSKYFILE_TABLE_NAME);
    1614016140        return false;
    1614116141    }
    … …  
    1615516155    }
    1615616156
    16157     if (!psDBInsertRows(dbh, P5DIFFSKYFILE_TABLE_NAME, rowSet)) {
     16157    if (!psDBInsertRows(dbh, DIFFSKYFILE_TABLE_NAME, rowSet)) {
    1615816158        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1615916159        psFree(rowSet);
    … …  
    1616616166}
    1616716167
    16168 bool p5DiffSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16168bool diffSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1616916169{
    1617016170    psArray         *rowSet;
    1617116171
    16172     rowSet = psDBSelectRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
     16172    rowSet = psDBSelectRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit);
    1617316173    if (!rowSet) {
    1617416174        return false;
    … …  
    1617616176
    1617716177    // output to fits
    16178     if (!psFitsWriteTable(fits, NULL, rowSet, P5DIFFSKYFILE_TABLE_NAME)) {
     16178    if (!psFitsWriteTable(fits, NULL, rowSet, DIFFSKYFILE_TABLE_NAME)) {
    1617916179        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1618016180        psFree(rowSet);
    … …  
    1618716187}
    1618816188
    16189 psMetadata *p5DiffSkyfileMetadataFromObject(const p5DiffSkyfileRow *object)
     16189psMetadata *diffSkyfileMetadataFromObject(const diffSkyfileRow *object)
    1619016190{
    1619116191    psMetadata *md = psMetadataAlloc();
    16192     if (!psMetadataAdd(md, PS_LIST_TAIL, "p5_id", PS_DATA_S32, NULL, object->p5_id)) {
    16193         psError(PS_ERR_UNKNOWN, false, "failed to add item p5_id");
     16192    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     16193        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1619416194        psFree(md);
    1619516195        return false;
    … …  
    1621516215}
    1621616216
    16217 p5DiffSkyfileRow *p5DiffSkyfileObjectFromMetadata(psMetadata *md)
     16217diffSkyfileRow *diffSkyfileObjectFromMetadata(psMetadata *md)
    1621816218{
    1621916219
    1622016220bool status = false;
    16221     psS32 p5_id = psMetadataLookupS32(&status, md, "p5_id");
    16222     if (!status) {
    16223         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p5_id");
     16221    psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     16222    if (!status) {
     16223        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
    1622416224        return false;
    1622516225    }
    … …  
    1624016240    }
    1624116241
    16242     return p5DiffSkyfileRowAlloc(p5_id, uri, bg, bg_mean_stdev);
    16243 }
    16244 psArray *p5DiffSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16242    return diffSkyfileRowAlloc(diff_id, uri, bg, bg_mean_stdev);
     16243}
     16244psArray *diffSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1624516245{
    1624616246    psArray         *rowSet;
    … …  
    1624816248    psU64           i;
    1624916249
    16250     rowSet = psDBSelectRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
     16250    rowSet = psDBSelectRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit);
    1625116251    if (!rowSet) {
    1625216252        return NULL;
    … …  
    1625816258
    1625916259    for (i = 0; i < rowSet->n; i++) {
    16260         p5DiffSkyfileRow *object = p5DiffSkyfileObjectFromMetadata(rowSet->data[i]);
     16260        diffSkyfileRow *object = diffSkyfileObjectFromMetadata(rowSet->data[i]);
    1626116261        psArrayAdd(returnSet, 0, object);
    1626216262        psFree(object);
    … …  
    1626716267    return returnSet;
    1626816268}
    16269 bool p5DiffSkyfileDeleteObject(psDB *dbh, const p5DiffSkyfileRow *object)
    16270 {
    16271     psMetadata *where = p5DiffSkyfileMetadataFromObject(object);
    16272     long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, 0);
     16269bool diffSkyfileDeleteObject(psDB *dbh, const diffSkyfileRow *object)
     16270{
     16271    psMetadata *where = diffSkyfileMetadataFromObject(object);
     16272    long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, 0);
    1627316273    psFree(where);
    1627416274    if (count < 0) {
    16275         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
     16275        psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile");
    1627616276        return false;
    1627716277    }
    … …  
    1627916279        // XXX should this be a psAbort() instead?  It is possible that
    1628016280        // having an object match multiple rows was by design.
    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 }
    16287 long long p5DiffSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16281        psError(PS_ERR_UNKNOWN, true, "diffSkyfileRow object matched more then one row.  Check your database schema");
     16282        return false;
     16283    }
     16284
     16285    return true;
     16286}
     16287long long diffSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1628816288{
    1628916289    long long       deleted = 0;
    1629016290
    1629116291    for (long long i = 0; i < objects->n; i++) {
    16292         p5DiffSkyfileRow *object = objects->data[i];
    16293         psMetadata *where = p5DiffSkyfileMetadataFromObject(object);
    16294         long long count = psDBDeleteRows(dbh, P5DIFFSKYFILE_TABLE_NAME, where, limit);
     16292        diffSkyfileRow *object = objects->data[i];
     16293        psMetadata *where = diffSkyfileMetadataFromObject(object);
     16294        long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit);
    1629516295        psFree(where);
    1629616296        if (count < 0) {
    16297             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p5DiffSkyfile");
     16297            psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile");
    1629816298            return count;
    1629916299        }
    … …  
    1630416304    return deleted;
    1630516305}
    16306 bool p5DiffSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     16306bool diffSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1630716307{
    1630816308    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1631016310    psMetadata *output = psMetadataAlloc();
    1631116311    for (long i = 0; i < psArrayLength(objects); i++) {
    16312         psMetadata *md = p5DiffSkyfileMetadataFromObject(objects->data[i]);
     16312        psMetadata *md = diffSkyfileMetadataFromObject(objects->data[i]);
    1631316313        if (!psMetadataAddMetadata(
    1631416314            output,
    1631516315            PS_LIST_TAIL,
    16316             P5DIFFSKYFILE_TABLE_NAME,
     16316            DIFFSKYFILE_TABLE_NAME,
    1631716317            PS_META_DUPLICATE_OK,
    1631816318            NULL,
    … …  
    1633516335    return true;
    1633616336}
    16337 bool p5DiffSkyfilePrintObject(FILE *stream, p5DiffSkyfileRow *object, bool mdcf)
     16337bool diffSkyfilePrintObject(FILE *stream, diffSkyfileRow *object, bool mdcf)
    1633816338{
    1633916339    PS_ASSERT_PTR_NON_NULL(object, false);
    1634016340
    16341     psMetadata *md = p5DiffSkyfileMetadataFromObject(object);
     16341    psMetadata *md = diffSkyfileMetadataFromObject(object);
    1634216342
    1634316343    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1635016350    return true;
    1635116351}
    16352 static void p6RunRowFree(p6RunRow *object);
    16353 
    16354 p6RunRow *p6RunRowAlloc(psS32 p6_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    16355 {
    16356     p6RunRow        *_object;
    16357 
    16358     _object = psAlloc(sizeof(p6RunRow));
    16359     psMemSetDeallocator(_object, (psFreeFunc)p6RunRowFree);
    16360 
    16361     _object->p6_id = p6_id;
     16352static void stackRunRowFree(stackRunRow *object);
     16353
     16354stackRunRow *stackRunRowAlloc(psS32 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     16355{
     16356    stackRunRow     *_object;
     16357
     16358    _object = psAlloc(sizeof(stackRunRow));
     16359    psMemSetDeallocator(_object, (psFreeFunc)stackRunRowFree);
     16360
     16361    _object->stack_id = stack_id;
    1636216362    _object->state = psStringCopy(state);
    1636316363    _object->workdir = psStringCopy(workdir);
    … …  
    1637016370}
    1637116371
    16372 static void p6RunRowFree(p6RunRow *object)
     16372static void stackRunRowFree(stackRunRow *object)
    1637316373{
    1637416374    psFree(object->state);
    … …  
    1638016380}
    1638116381
    16382 bool p6RunCreateTable(psDB *dbh)
     16382bool stackRunCreateTable(psDB *dbh)
    1638316383{
    1638416384    psMetadata *md = psMetadataAlloc();
    16385     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
    16386         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     16385    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     16386        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1638716387        psFree(md);
    1638816388        return false;
    … …  
    1641916419    }
    1642016420
    16421     bool status = psDBCreateTable(dbh, P6RUN_TABLE_NAME, md);
     16421    bool status = psDBCreateTable(dbh, STACKRUN_TABLE_NAME, md);
    1642216422
    1642316423    psFree(md);
    … …  
    1642616426}
    1642716427
    16428 bool p6RunDropTable(psDB *dbh)
    16429 {
    16430     return psDBDropTable(dbh, P6RUN_TABLE_NAME);
    16431 }
    16432 
    16433 bool 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)
     16428bool stackRunDropTable(psDB *dbh)
     16429{
     16430    return psDBDropTable(dbh, STACKRUN_TABLE_NAME);
     16431}
     16432
     16433bool stackRunInsert(psDB * dbh, psS32 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1643416434{
    1643516435    psMetadata *md = psMetadataAlloc();
    16436     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, p6_id)) {
    16437         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     16436    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     16437        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1643816438        psFree(md);
    1643916439        return false;
    … …  
    1647016470    }
    1647116471
    16472     bool status = psDBInsertOneRow(dbh, P6RUN_TABLE_NAME, md);
     16472    bool status = psDBInsertOneRow(dbh, STACKRUN_TABLE_NAME, md);
    1647316473    psFree(md);
    1647416474
    … …  
    1647616476}
    1647716477
    16478 long long p6RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16478long long stackRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1647916479{
    1648016480    long long       deleted = 0;
    1648116481
    16482     long long count = psDBDeleteRows(dbh, P6RUN_TABLE_NAME, where, limit);
     16482    long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, limit);
    1648316483    if (count < 0) {
    16484         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6Run");
     16484        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun");
    1648516485        return count;
    1648616486
    … …  
    1649016490    return deleted;
    1649116491}
    16492 bool p6RunInsertObject(psDB *dbh, p6RunRow *object)
    16493 {
    16494     return p6RunInsert(dbh, object->p6_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
    16495 }
    16496 
    16497 bool p6RunInsertObjects(psDB *dbh, psArray *objects)
     16492bool stackRunInsertObject(psDB *dbh, stackRunRow *object)
     16493{
     16494    return stackRunInsert(dbh, object->stack_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id);
     16495}
     16496
     16497bool stackRunInsertObjects(psDB *dbh, psArray *objects)
    1649816498{
    1649916499    for (long i = 0; i < psArrayLength(objects); i++) {
    16500         if (!p6RunInsertObject(dbh, objects->data[i])) {
     16500        if (!stackRunInsertObject(dbh, objects->data[i])) {
    1650116501            return false;
    1650216502        }
    … …  
    1650616506}
    1650716507
    16508 bool p6RunInsertFits(psDB *dbh, const psFits *fits)
     16508bool stackRunInsertFits(psDB *dbh, const psFits *fits)
    1650916509{
    1651016510    psArray         *rowSet;
    1651116511
    16512     // move to (the first?) extension named  P6RUN_TABLE_NAME
    16513     if (!psFitsMoveExtName(fits, P6RUN_TABLE_NAME)) {
    16514         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P6RUN_TABLE_NAME);
     16512    // move to (the first?) extension named  STACKRUN_TABLE_NAME
     16513    if (!psFitsMoveExtName(fits, STACKRUN_TABLE_NAME)) {
     16514        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKRUN_TABLE_NAME);
    1651516515        return false;
    1651616516    }
    … …  
    1653016530    }
    1653116531
    16532     if (!psDBInsertRows(dbh, P6RUN_TABLE_NAME, rowSet)) {
     16532    if (!psDBInsertRows(dbh, STACKRUN_TABLE_NAME, rowSet)) {
    1653316533        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1653416534        psFree(rowSet);
    … …  
    1654116541}
    1654216542
    16543 bool p6RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16543bool stackRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1654416544{
    1654516545    psArray         *rowSet;
    1654616546
    16547     rowSet = psDBSelectRows(dbh, P6RUN_TABLE_NAME, where, limit);
     16547    rowSet = psDBSelectRows(dbh, STACKRUN_TABLE_NAME, where, limit);
    1654816548    if (!rowSet) {
    1654916549        return false;
    … …  
    1655116551
    1655216552    // output to fits
    16553     if (!psFitsWriteTable(fits, NULL, rowSet, P6RUN_TABLE_NAME)) {
     16553    if (!psFitsWriteTable(fits, NULL, rowSet, STACKRUN_TABLE_NAME)) {
    1655416554        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1655516555        psFree(rowSet);
    … …  
    1656216562}
    1656316563
    16564 psMetadata *p6RunMetadataFromObject(const p6RunRow *object)
     16564psMetadata *stackRunMetadataFromObject(const stackRunRow *object)
    1656516565{
    1656616566    psMetadata *md = psMetadataAlloc();
    16567     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, object->p6_id)) {
    16568         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     16567    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     16568        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1656916569        psFree(md);
    1657016570        return false;
    … …  
    1660516605}
    1660616606
    16607 p6RunRow *p6RunObjectFromMetadata(psMetadata *md)
     16607stackRunRow *stackRunObjectFromMetadata(psMetadata *md)
    1660816608{
    1660916609
    1661016610bool status = false;
    16611     psS32 p6_id = psMetadataLookupS32(&status, md, "p6_id");
    16612     if (!status) {
    16613         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p6_id");
     16611    psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     16612    if (!status) {
     16613        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");
    1661416614        return false;
    1661516615    }
    … …  
    1664516645    }
    1664616646
    16647     return p6RunRowAlloc(p6_id, state, workdir, dvodb, registered, skycell_id, tess_id);
    16648 }
    16649 psArray *p6RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16647    return stackRunRowAlloc(stack_id, state, workdir, dvodb, registered, skycell_id, tess_id);
     16648}
     16649psArray *stackRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1665016650{
    1665116651    psArray         *rowSet;
    … …  
    1665316653    psU64           i;
    1665416654
    16655     rowSet = psDBSelectRows(dbh, P6RUN_TABLE_NAME, where, limit);
     16655    rowSet = psDBSelectRows(dbh, STACKRUN_TABLE_NAME, where, limit);
    1665616656    if (!rowSet) {
    1665716657        return NULL;
    … …  
    1666316663
    1666416664    for (i = 0; i < rowSet->n; i++) {
    16665         p6RunRow *object = p6RunObjectFromMetadata(rowSet->data[i]);
     16665        stackRunRow *object = stackRunObjectFromMetadata(rowSet->data[i]);
    1666616666        psArrayAdd(returnSet, 0, object);
    1666716667        psFree(object);
    … …  
    1667216672    return returnSet;
    1667316673}
    16674 bool p6RunDeleteObject(psDB *dbh, const p6RunRow *object)
    16675 {
    16676     psMetadata *where = p6RunMetadataFromObject(object);
    16677     long long count = psDBDeleteRows(dbh, P6RUN_TABLE_NAME, where, 0);
     16674bool stackRunDeleteObject(psDB *dbh, const stackRunRow *object)
     16675{
     16676    psMetadata *where = stackRunMetadataFromObject(object);
     16677    long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, 0);
    1667816678    psFree(where);
    1667916679    if (count < 0) {
    16680         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6Run");
     16680        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun");
    1668116681        return false;
    1668216682    }
    … …  
    1668416684        // XXX should this be a psAbort() instead?  It is possible that
    1668516685        // having an object match multiple rows was by design.
    16686         psError(PS_ERR_UNKNOWN, true, "p6RunRow object matched more then one row.  Check your database schema");
    16687         return false;
    16688     }
    16689 
    16690     return true;
    16691 }
    16692 long long p6RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16686        psError(PS_ERR_UNKNOWN, true, "stackRunRow object matched more then one row.  Check your database schema");
     16687        return false;
     16688    }
     16689
     16690    return true;
     16691}
     16692long long stackRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1669316693{
    1669416694    long long       deleted = 0;
    1669516695
    1669616696    for (long long i = 0; i < objects->n; i++) {
    16697         p6RunRow *object = objects->data[i];
    16698         psMetadata *where = p6RunMetadataFromObject(object);
    16699         long long count = psDBDeleteRows(dbh, P6RUN_TABLE_NAME, where, limit);
     16697        stackRunRow *object = objects->data[i];
     16698        psMetadata *where = stackRunMetadataFromObject(object);
     16699        long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, limit);
    1670016700        psFree(where);
    1670116701        if (count < 0) {
    16702             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6Run");
     16702            psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun");
    1670316703            return count;
    1670416704        }
    … …  
    1670916709    return deleted;
    1671016710}
    16711 bool p6RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     16711bool stackRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1671216712{
    1671316713    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1671516715    psMetadata *output = psMetadataAlloc();
    1671616716    for (long i = 0; i < psArrayLength(objects); i++) {
    16717         psMetadata *md = p6RunMetadataFromObject(objects->data[i]);
     16717        psMetadata *md = stackRunMetadataFromObject(objects->data[i]);
    1671816718        if (!psMetadataAddMetadata(
    1671916719            output,
    1672016720            PS_LIST_TAIL,
    16721             P6RUN_TABLE_NAME,
     16721            STACKRUN_TABLE_NAME,
    1672216722            PS_META_DUPLICATE_OK,
    1672316723            NULL,
    … …  
    1674016740    return true;
    1674116741}
    16742 bool p6RunPrintObject(FILE *stream, p6RunRow *object, bool mdcf)
     16742bool stackRunPrintObject(FILE *stream, stackRunRow *object, bool mdcf)
    1674316743{
    1674416744    PS_ASSERT_PTR_NON_NULL(object, false);
    1674516745
    16746     psMetadata *md = p6RunMetadataFromObject(object);
     16746    psMetadata *md = stackRunMetadataFromObject(object);
    1674716747
    1674816748    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1675516755    return true;
    1675616756}
    16757 static void p6InputSkyfileRowFree(p6InputSkyfileRow *object);
    16758 
    16759 p6InputSkyfileRow *p6InputSkyfileRowAlloc(psS32 p6_id, psS32 p4_id)
    16760 {
    16761     p6InputSkyfileRow *_object;
    16762 
    16763     _object = psAlloc(sizeof(p6InputSkyfileRow));
    16764     psMemSetDeallocator(_object, (psFreeFunc)p6InputSkyfileRowFree);
    16765 
    16766     _object->p6_id = p6_id;
    16767     _object->p4_id = p4_id;
     16757static void stackInputSkyfileRowFree(stackInputSkyfileRow *object);
     16758
     16759stackInputSkyfileRow *stackInputSkyfileRowAlloc(psS32 stack_id, psS32 warp_id)
     16760{
     16761    stackInputSkyfileRow *_object;
     16762
     16763    _object = psAlloc(sizeof(stackInputSkyfileRow));
     16764    psMemSetDeallocator(_object, (psFreeFunc)stackInputSkyfileRowFree);
     16765
     16766    _object->stack_id = stack_id;
     16767    _object->warp_id = warp_id;
    1676816768
    1676916769    return _object;
    1677016770}
    1677116771
    16772 static void p6InputSkyfileRowFree(p6InputSkyfileRow *object)
    16773 {
    16774 }
    16775 
    16776 bool p6InputSkyfileCreateTable(psDB *dbh)
     16772static void stackInputSkyfileRowFree(stackInputSkyfileRow *object)
     16773{
     16774}
     16775
     16776bool stackInputSkyfileCreateTable(psDB *dbh)
    1677716777{
    1677816778    psMetadata *md = psMetadataAlloc();
    16779     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, "Primary Key", 0)) {
    16780         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
    16781         psFree(md);
    16782         return false;
    16783     }
    16784     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    16785         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    16786         psFree(md);
    16787         return false;
    16788     }
    16789 
    16790     bool status = psDBCreateTable(dbh, P6INPUTSKYFILE_TABLE_NAME, md);
     16779    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key", 0)) {
     16780        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
     16781        psFree(md);
     16782        return false;
     16783    }
     16784    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     16785        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
     16786        psFree(md);
     16787        return false;
     16788    }
     16789
     16790    bool status = psDBCreateTable(dbh, STACKINPUTSKYFILE_TABLE_NAME, md);
    1679116791
    1679216792    psFree(md);
    … …  
    1679516795}
    1679616796
    16797 bool p6InputSkyfileDropTable(psDB *dbh)
    16798 {
    16799     return psDBDropTable(dbh, P6INPUTSKYFILE_TABLE_NAME);
    16800 }
    16801 
    16802 bool p6InputSkyfileInsert(psDB * dbh, psS32 p6_id, psS32 p4_id)
     16797bool stackInputSkyfileDropTable(psDB *dbh)
     16798{
     16799    return psDBDropTable(dbh, STACKINPUTSKYFILE_TABLE_NAME);
     16800}
     16801
     16802bool stackInputSkyfileInsert(psDB * dbh, psS32 stack_id, psS32 warp_id)
    1680316803{
    1680416804    psMetadata *md = psMetadataAlloc();
    16805     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, p6_id)) {
    16806         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
    16807         psFree(md);
    16808         return false;
    16809     }
    16810     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    16811         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    16812         psFree(md);
    16813         return false;
    16814     }
    16815 
    16816     bool status = psDBInsertOneRow(dbh, P6INPUTSKYFILE_TABLE_NAME, md);
     16805    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     16806        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
     16807        psFree(md);
     16808        return false;
     16809    }
     16810    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     16811        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
     16812        psFree(md);
     16813        return false;
     16814    }
     16815
     16816    bool status = psDBInsertOneRow(dbh, STACKINPUTSKYFILE_TABLE_NAME, md);
    1681716817    psFree(md);
    1681816818
    … …  
    1682016820}
    1682116821
    16822 long long p6InputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16822long long stackInputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1682316823{
    1682416824    long long       deleted = 0;
    1682516825
    16826     long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
     16826    long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit);
    1682716827    if (count < 0) {
    16828         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
     16828        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile");
    1682916829        return count;
    1683016830
    … …  
    1683416834    return deleted;
    1683516835}
    16836 bool p6InputSkyfileInsertObject(psDB *dbh, p6InputSkyfileRow *object)
    16837 {
    16838     return p6InputSkyfileInsert(dbh, object->p6_id, object->p4_id);
    16839 }
    16840 
    16841 bool p6InputSkyfileInsertObjects(psDB *dbh, psArray *objects)
     16836bool stackInputSkyfileInsertObject(psDB *dbh, stackInputSkyfileRow *object)
     16837{
     16838    return stackInputSkyfileInsert(dbh, object->stack_id, object->warp_id);
     16839}
     16840
     16841bool stackInputSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1684216842{
    1684316843    for (long i = 0; i < psArrayLength(objects); i++) {
    16844         if (!p6InputSkyfileInsertObject(dbh, objects->data[i])) {
     16844        if (!stackInputSkyfileInsertObject(dbh, objects->data[i])) {
    1684516845            return false;
    1684616846        }
    … …  
    1685016850}
    1685116851
    16852 bool p6InputSkyfileInsertFits(psDB *dbh, const psFits *fits)
     16852bool stackInputSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1685316853{
    1685416854    psArray         *rowSet;
    1685516855
    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);
     16856    // move to (the first?) extension named  STACKINPUTSKYFILE_TABLE_NAME
     16857    if (!psFitsMoveExtName(fits, STACKINPUTSKYFILE_TABLE_NAME)) {
     16858        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKINPUTSKYFILE_TABLE_NAME);
    1685916859        return false;
    1686016860    }
    … …  
    1687416874    }
    1687516875
    16876     if (!psDBInsertRows(dbh, P6INPUTSKYFILE_TABLE_NAME, rowSet)) {
     16876    if (!psDBInsertRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, rowSet)) {
    1687716877        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1687816878        psFree(rowSet);
    … …  
    1688516885}
    1688616886
    16887 bool p6InputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16887bool stackInputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1688816888{
    1688916889    psArray         *rowSet;
    1689016890
    16891     rowSet = psDBSelectRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
     16891    rowSet = psDBSelectRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit);
    1689216892    if (!rowSet) {
    1689316893        return false;
    … …  
    1689516895
    1689616896    // output to fits
    16897     if (!psFitsWriteTable(fits, NULL, rowSet, P6INPUTSKYFILE_TABLE_NAME)) {
     16897    if (!psFitsWriteTable(fits, NULL, rowSet, STACKINPUTSKYFILE_TABLE_NAME)) {
    1689816898        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1689916899        psFree(rowSet);
    … …  
    1690616906}
    1690716907
    16908 psMetadata *p6InputSkyfileMetadataFromObject(const p6InputSkyfileRow *object)
     16908psMetadata *stackInputSkyfileMetadataFromObject(const stackInputSkyfileRow *object)
    1690916909{
    1691016910    psMetadata *md = psMetadataAlloc();
    16911     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, object->p6_id)) {
    16912         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
    16913         psFree(md);
    16914         return false;
    16915     }
    16916     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    16917         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     16911    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     16912        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
     16913        psFree(md);
     16914        return false;
     16915    }
     16916    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     16917        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1691816918        psFree(md);
    1691916919        return false;
    … …  
    1692416924}
    1692516925
    16926 p6InputSkyfileRow *p6InputSkyfileObjectFromMetadata(psMetadata *md)
     16926stackInputSkyfileRow *stackInputSkyfileObjectFromMetadata(psMetadata *md)
    1692716927{
    1692816928
    1692916929bool status = false;
    16930     psS32 p6_id = psMetadataLookupS32(&status, md, "p6_id");
    16931     if (!status) {
    16932         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p6_id");
    16933         return false;
    16934     }
    16935     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    16936     if (!status) {
    16937         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
    16938         return false;
    16939     }
    16940 
    16941     return p6InputSkyfileRowAlloc(p6_id, p4_id);
    16942 }
    16943 psArray *p6InputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16930    psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     16931    if (!status) {
     16932        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");
     16933        return false;
     16934    }
     16935    psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     16936    if (!status) {
     16937        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
     16938        return false;
     16939    }
     16940
     16941    return stackInputSkyfileRowAlloc(stack_id, warp_id);
     16942}
     16943psArray *stackInputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1694416944{
    1694516945    psArray         *rowSet;
    … …  
    1694716947    psU64           i;
    1694816948
    16949     rowSet = psDBSelectRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
     16949    rowSet = psDBSelectRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit);
    1695016950    if (!rowSet) {
    1695116951        return NULL;
    … …  
    1695716957
    1695816958    for (i = 0; i < rowSet->n; i++) {
    16959         p6InputSkyfileRow *object = p6InputSkyfileObjectFromMetadata(rowSet->data[i]);
     16959        stackInputSkyfileRow *object = stackInputSkyfileObjectFromMetadata(rowSet->data[i]);
    1696016960        psArrayAdd(returnSet, 0, object);
    1696116961        psFree(object);
    … …  
    1696616966    return returnSet;
    1696716967}
    16968 bool p6InputSkyfileDeleteObject(psDB *dbh, const p6InputSkyfileRow *object)
    16969 {
    16970     psMetadata *where = p6InputSkyfileMetadataFromObject(object);
    16971     long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, 0);
     16968bool stackInputSkyfileDeleteObject(psDB *dbh, const stackInputSkyfileRow *object)
     16969{
     16970    psMetadata *where = stackInputSkyfileMetadataFromObject(object);
     16971    long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, 0);
    1697216972    psFree(where);
    1697316973    if (count < 0) {
    16974         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
     16974        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile");
    1697516975        return false;
    1697616976    }
    … …  
    1697816978        // XXX should this be a psAbort() instead?  It is possible that
    1697916979        // having an object match multiple rows was by design.
    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 }
    16986 long long p6InputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16980        psError(PS_ERR_UNKNOWN, true, "stackInputSkyfileRow object matched more then one row.  Check your database schema");
     16981        return false;
     16982    }
     16983
     16984    return true;
     16985}
     16986long long stackInputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1698716987{
    1698816988    long long       deleted = 0;
    1698916989
    1699016990    for (long long i = 0; i < objects->n; i++) {
    16991         p6InputSkyfileRow *object = objects->data[i];
    16992         psMetadata *where = p6InputSkyfileMetadataFromObject(object);
    16993         long long count = psDBDeleteRows(dbh, P6INPUTSKYFILE_TABLE_NAME, where, limit);
     16991        stackInputSkyfileRow *object = objects->data[i];
     16992        psMetadata *where = stackInputSkyfileMetadataFromObject(object);
     16993        long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit);
    1699416994        psFree(where);
    1699516995        if (count < 0) {
    16996             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6InputSkyfile");
     16996            psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile");
    1699716997            return count;
    1699816998        }
    … …  
    1700317003    return deleted;
    1700417004}
    17005 bool p6InputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17005bool stackInputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1700617006{
    1700717007    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1700917009    psMetadata *output = psMetadataAlloc();
    1701017010    for (long i = 0; i < psArrayLength(objects); i++) {
    17011         psMetadata *md = p6InputSkyfileMetadataFromObject(objects->data[i]);
     17011        psMetadata *md = stackInputSkyfileMetadataFromObject(objects->data[i]);
    1701217012        if (!psMetadataAddMetadata(
    1701317013            output,
    1701417014            PS_LIST_TAIL,
    17015             P6INPUTSKYFILE_TABLE_NAME,
     17015            STACKINPUTSKYFILE_TABLE_NAME,
    1701617016            PS_META_DUPLICATE_OK,
    1701717017            NULL,
    … …  
    1703417034    return true;
    1703517035}
    17036 bool p6InputSkyfilePrintObject(FILE *stream, p6InputSkyfileRow *object, bool mdcf)
     17036bool stackInputSkyfilePrintObject(FILE *stream, stackInputSkyfileRow *object, bool mdcf)
    1703717037{
    1703817038    PS_ASSERT_PTR_NON_NULL(object, false);
    1703917039
    17040     psMetadata *md = p6InputSkyfileMetadataFromObject(object);
     17040    psMetadata *md = stackInputSkyfileMetadataFromObject(object);
    1704117041
    1704217042    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1704917049    return true;
    1705017050}
    17051 static void p6SumSkyfileRowFree(p6SumSkyfileRow *object);
    17052 
    17053 p6SumSkyfileRow *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);
    17059 
    17060     _object->p6_id = p6_id;
     17051static void stackSumSkyfileRowFree(stackSumSkyfileRow *object);
     17052
     17053stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS32 stack_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     17054{
     17055    stackSumSkyfileRow *_object;
     17056
     17057    _object = psAlloc(sizeof(stackSumSkyfileRow));
     17058    psMemSetDeallocator(_object, (psFreeFunc)stackSumSkyfileRowFree);
     17059
     17060    _object->stack_id = stack_id;
    1706117061    _object->uri = psStringCopy(uri);
    1706217062    _object->bg = bg;
    … …  
    1706617066}
    1706717067
    17068 static void p6SumSkyfileRowFree(p6SumSkyfileRow *object)
     17068static void stackSumSkyfileRowFree(stackSumSkyfileRow *object)
    1706917069{
    1707017070    psFree(object->uri);
    1707117071}
    1707217072
    17073 bool p6SumSkyfileCreateTable(psDB *dbh)
     17073bool stackSumSkyfileCreateTable(psDB *dbh)
    1707417074{
    1707517075    psMetadata *md = psMetadataAlloc();
    17076     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, "Primary Key", 0)) {
    17077         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     17076    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key", 0)) {
     17077        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1707817078        psFree(md);
    1707917079        return false;
    … …  
    1709517095    }
    1709617096
    17097     bool status = psDBCreateTable(dbh, P6SUMSKYFILE_TABLE_NAME, md);
     17097    bool status = psDBCreateTable(dbh, STACKSUMSKYFILE_TABLE_NAME, md);
    1709817098
    1709917099    psFree(md);
    … …  
    1710217102}
    1710317103
    17104 bool p6SumSkyfileDropTable(psDB *dbh)
    17105 {
    17106     return psDBDropTable(dbh, P6SUMSKYFILE_TABLE_NAME);
    17107 }
    17108 
    17109 bool p6SumSkyfileInsert(psDB * dbh, psS32 p6_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     17104bool stackSumSkyfileDropTable(psDB *dbh)
     17105{
     17106    return psDBDropTable(dbh, STACKSUMSKYFILE_TABLE_NAME);
     17107}
     17108
     17109bool stackSumSkyfileInsert(psDB * dbh, psS32 stack_id, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1711017110{
    1711117111    psMetadata *md = psMetadataAlloc();
    17112     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, p6_id)) {
    17113         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     17112    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     17113        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1711417114        psFree(md);
    1711517115        return false;
    … …  
    1713117131    }
    1713217132
    17133     bool status = psDBInsertOneRow(dbh, P6SUMSKYFILE_TABLE_NAME, md);
     17133    bool status = psDBInsertOneRow(dbh, STACKSUMSKYFILE_TABLE_NAME, md);
    1713417134    psFree(md);
    1713517135
    … …  
    1713717137}
    1713817138
    17139 long long p6SumSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17139long long stackSumSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1714017140{
    1714117141    long long       deleted = 0;
    1714217142
    17143     long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
     17143    long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit);
    1714417144    if (count < 0) {
    17145         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
     17145        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile");
    1714617146        return count;
    1714717147
    … …  
    1715117151    return deleted;
    1715217152}
    17153 bool p6SumSkyfileInsertObject(psDB *dbh, p6SumSkyfileRow *object)
    17154 {
    17155     return p6SumSkyfileInsert(dbh, object->p6_id, object->uri, object->bg, object->bg_mean_stdev);
    17156 }
    17157 
    17158 bool p6SumSkyfileInsertObjects(psDB *dbh, psArray *objects)
     17153bool stackSumSkyfileInsertObject(psDB *dbh, stackSumSkyfileRow *object)
     17154{
     17155    return stackSumSkyfileInsert(dbh, object->stack_id, object->uri, object->bg, object->bg_mean_stdev);
     17156}
     17157
     17158bool stackSumSkyfileInsertObjects(psDB *dbh, psArray *objects)
    1715917159{
    1716017160    for (long i = 0; i < psArrayLength(objects); i++) {
    17161         if (!p6SumSkyfileInsertObject(dbh, objects->data[i])) {
     17161        if (!stackSumSkyfileInsertObject(dbh, objects->data[i])) {
    1716217162            return false;
    1716317163        }
    … …  
    1716717167}
    1716817168
    17169 bool p6SumSkyfileInsertFits(psDB *dbh, const psFits *fits)
     17169bool stackSumSkyfileInsertFits(psDB *dbh, const psFits *fits)
    1717017170{
    1717117171    psArray         *rowSet;
    1717217172
    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);
     17173    // move to (the first?) extension named  STACKSUMSKYFILE_TABLE_NAME
     17174    if (!psFitsMoveExtName(fits, STACKSUMSKYFILE_TABLE_NAME)) {
     17175        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKSUMSKYFILE_TABLE_NAME);
    1717617176        return false;
    1717717177    }
    … …  
    1719117191    }
    1719217192
    17193     if (!psDBInsertRows(dbh, P6SUMSKYFILE_TABLE_NAME, rowSet)) {
     17193    if (!psDBInsertRows(dbh, STACKSUMSKYFILE_TABLE_NAME, rowSet)) {
    1719417194        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1719517195        psFree(rowSet);
    … …  
    1720217202}
    1720317203
    17204 bool p6SumSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     17204bool stackSumSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1720517205{
    1720617206    psArray         *rowSet;
    1720717207
    17208     rowSet = psDBSelectRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
     17208    rowSet = psDBSelectRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit);
    1720917209    if (!rowSet) {
    1721017210        return false;
    … …  
    1721217212
    1721317213    // output to fits
    17214     if (!psFitsWriteTable(fits, NULL, rowSet, P6SUMSKYFILE_TABLE_NAME)) {
     17214    if (!psFitsWriteTable(fits, NULL, rowSet, STACKSUMSKYFILE_TABLE_NAME)) {
    1721517215        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1721617216        psFree(rowSet);
    … …  
    1722317223}
    1722417224
    17225 psMetadata *p6SumSkyfileMetadataFromObject(const p6SumSkyfileRow *object)
     17225psMetadata *stackSumSkyfileMetadataFromObject(const stackSumSkyfileRow *object)
    1722617226{
    1722717227    psMetadata *md = psMetadataAlloc();
    17228     if (!psMetadataAdd(md, PS_LIST_TAIL, "p6_id", PS_DATA_S32, NULL, object->p6_id)) {
    17229         psError(PS_ERR_UNKNOWN, false, "failed to add item p6_id");
     17228    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     17229        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1723017230        psFree(md);
    1723117231        return false;
    … …  
    1725117251}
    1725217252
    17253 p6SumSkyfileRow *p6SumSkyfileObjectFromMetadata(psMetadata *md)
     17253stackSumSkyfileRow *stackSumSkyfileObjectFromMetadata(psMetadata *md)
    1725417254{
    1725517255
    1725617256bool status = false;
    17257     psS32 p6_id = psMetadataLookupS32(&status, md, "p6_id");
    17258     if (!status) {
    17259         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p6_id");
     17257    psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     17258    if (!status) {
     17259        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");
    1726017260        return false;
    1726117261    }
    … …  
    1727617276    }
    1727717277
    17278     return p6SumSkyfileRowAlloc(p6_id, uri, bg, bg_mean_stdev);
    17279 }
    17280 psArray *p6SumSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17278    return stackSumSkyfileRowAlloc(stack_id, uri, bg, bg_mean_stdev);
     17279}
     17280psArray *stackSumSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1728117281{
    1728217282    psArray         *rowSet;
    … …  
    1728417284    psU64           i;
    1728517285
    17286     rowSet = psDBSelectRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
     17286    rowSet = psDBSelectRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit);
    1728717287    if (!rowSet) {
    1728817288        return NULL;
    … …  
    1729417294
    1729517295    for (i = 0; i < rowSet->n; i++) {
    17296         p6SumSkyfileRow *object = p6SumSkyfileObjectFromMetadata(rowSet->data[i]);
     17296        stackSumSkyfileRow *object = stackSumSkyfileObjectFromMetadata(rowSet->data[i]);
    1729717297        psArrayAdd(returnSet, 0, object);
    1729817298        psFree(object);
    … …  
    1730317303    return returnSet;
    1730417304}
    17305 bool p6SumSkyfileDeleteObject(psDB *dbh, const p6SumSkyfileRow *object)
    17306 {
    17307     psMetadata *where = p6SumSkyfileMetadataFromObject(object);
    17308     long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, 0);
     17305bool stackSumSkyfileDeleteObject(psDB *dbh, const stackSumSkyfileRow *object)
     17306{
     17307    psMetadata *where = stackSumSkyfileMetadataFromObject(object);
     17308    long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, 0);
    1730917309    psFree(where);
    1731017310    if (count < 0) {
    17311         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
     17311        psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile");
    1731217312        return false;
    1731317313    }
    … …  
    1731517315        // XXX should this be a psAbort() instead?  It is possible that
    1731617316        // having an object match multiple rows was by design.
    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 }
    17323 long long p6SumSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     17317        psError(PS_ERR_UNKNOWN, true, "stackSumSkyfileRow object matched more then one row.  Check your database schema");
     17318        return false;
     17319    }
     17320
     17321    return true;
     17322}
     17323long long stackSumSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1732417324{
    1732517325    long long       deleted = 0;
    1732617326
    1732717327    for (long long i = 0; i < objects->n; i++) {
    17328         p6SumSkyfileRow *object = objects->data[i];
    17329         psMetadata *where = p6SumSkyfileMetadataFromObject(object);
    17330         long long count = psDBDeleteRows(dbh, P6SUMSKYFILE_TABLE_NAME, where, limit);
     17328        stackSumSkyfileRow *object = objects->data[i];
     17329        psMetadata *where = stackSumSkyfileMetadataFromObject(object);
     17330        long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit);
    1733117331        psFree(where);
    1733217332        if (count < 0) {
    17333             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p6SumSkyfile");
     17333            psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile");
    1733417334            return count;
    1733517335        }
    … …  
    1734017340    return deleted;
    1734117341}
    17342 bool p6SumSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17342bool stackSumSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1734317343{
    1734417344    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1734617346    psMetadata *output = psMetadataAlloc();
    1734717347    for (long i = 0; i < psArrayLength(objects); i++) {
    17348         psMetadata *md = p6SumSkyfileMetadataFromObject(objects->data[i]);
     17348        psMetadata *md = stackSumSkyfileMetadataFromObject(objects->data[i]);
    1734917349        if (!psMetadataAddMetadata(
    1735017350            output,
    1735117351            PS_LIST_TAIL,
    17352             P6SUMSKYFILE_TABLE_NAME,
     17352            STACKSUMSKYFILE_TABLE_NAME,
    1735317353            PS_META_DUPLICATE_OK,
    1735417354            NULL,
    … …  
    1737117371    return true;
    1737217372}
    17373 bool p6SumSkyfilePrintObject(FILE *stream, p6SumSkyfileRow *object, bool mdcf)
     17373bool stackSumSkyfilePrintObject(FILE *stream, stackSumSkyfileRow *object, bool mdcf)
    1737417374{
    1737517375    PS_ASSERT_PTR_NON_NULL(object, false);
    1737617376
    17377     psMetadata *md = p6SumSkyfileMetadataFromObject(object);
     17377    psMetadata *md = stackSumSkyfileMetadataFromObject(object);
    1737817378
    1737917379    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
Note: See TracChangeset for help on using the changeset viewer.