IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 14169 for trunk/ippdb/src


Ignore:
Timestamp:
Jul 12, 2007, 12:27:55 PM (19 years ago)
Author:
jhoblitt
Message:

dev version

Location:
trunk/ippdb/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r14061 r14169  
    4343#define GUIDEPENDINGEXP_TABLE_NAME "guidePendingExp"
    4444#define CHIPRUN_TABLE_NAME "chipRun"
    45 #define CHIPINPUTIMFILE_TABLE_NAME "chipInputImfile"
    4645#define CHIPPROCESSEDIMFILE_TABLE_NAME "chipProcessedImfile"
    4746#define CHIPMASK_TABLE_NAME "chipMask"
    … …  
    25262525static void newExpRowFree(newExpRow *object);
    25272526
    2528 newExpRow *newExpRowAlloc(psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state)
     2527newExpRow *newExpRowAlloc(psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state, const char *reduction)
    25292528{
    25302529    newExpRow       *_object;
    … …  
    25402539    _object->workdir = psStringCopy(workdir);
    25412540    _object->workdir_state = psStringCopy(workdir_state);
     2541    _object->reduction = psStringCopy(reduction);
    25422542
    25432543    return _object;
    … …  
    25522552    psFree(object->workdir);
    25532553    psFree(object->workdir_state);
     2554    psFree(object->reduction);
    25542555}
    25552556
    … …  
    25922593        return false;
    25932594    }
     2595    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) {
     2596        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     2597        psFree(md);
     2598        return false;
     2599    }
    25942600
    25952601    bool status = psDBCreateTable(dbh, NEWEXP_TABLE_NAME, md);
    … …  
    26052611}
    26062612
    2607 bool newExpInsert(psDB * dbh, psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state)
     2613bool newExpInsert(psDB * dbh, psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state, const char *reduction)
    26082614{
    26092615    psMetadata *md = psMetadataAlloc();
    … …  
    26402646    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, workdir_state)) {
    26412647        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state");
     2648        psFree(md);
     2649        return false;
     2650    }
     2651    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) {
     2652        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
    26422653        psFree(md);
    26432654        return false;
    … …  
    26662677bool newExpInsertObject(psDB *dbh, newExpRow *object)
    26672678{
    2668     return newExpInsert(dbh, object->exp_id, object->tmp_exp_name, object->tmp_camera, object->tmp_telescope, object->state, object->workdir, object->workdir_state);
     2679    return newExpInsert(dbh, object->exp_id, object->tmp_exp_name, object->tmp_camera, object->tmp_telescope, object->state, object->workdir, object->workdir_state, object->reduction);
    26692680}
    26702681
    … …  
    27742785        return false;
    27752786    }
     2787    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) {
     2788        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     2789        psFree(md);
     2790        return false;
     2791    }
    27762792
    27772793
    … …  
    28182834        return false;
    28192835    }
    2820 
    2821     return newExpRowAlloc(exp_id, tmp_exp_name, tmp_camera, tmp_telescope, state, workdir, workdir_state);
     2836    char* reduction = psMetadataLookupPtr(&status, md, "reduction");
     2837    if (!status) {
     2838        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction");
     2839        return false;
     2840    }
     2841
     2842    return newExpRowAlloc(exp_id, tmp_exp_name, tmp_camera, tmp_telescope, state, workdir, workdir_state, reduction);
    28222843}
    28232844psArray *newExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    32483269static void rawExpRowFree(rawExpRow *object);
    32493270
    3250 rawExpRow *rawExpRowAlloc(psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault)
     3271rawExpRow *rawExpRowAlloc(psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *reduction, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault)
    32513272{
    32523273    rawExpRow       *_object;
    … …  
    32643285    _object->filelevel = psStringCopy(filelevel);
    32653286    _object->workdir = psStringCopy(workdir);
     3287    _object->reduction = psStringCopy(reduction);
    32663288    _object->filter = psStringCopy(filter);
    32673289    _object->airmass = airmass;
    … …  
    32993321    psFree(object->filelevel);
    33003322    psFree(object->workdir);
     3323    psFree(object->reduction);
    33013324    psFree(object->filter);
    33023325    psFree(object->object);
    … …  
    33513374        return false;
    33523375    }
     3376    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) {
     3377        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     3378        psFree(md);
     3379        return false;
     3380    }
    33533381    if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) {
    33543382        psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    … …  
    34693497}
    34703498
    3471 bool rawExpInsert(psDB * dbh, psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault)
     3499bool rawExpInsert(psDB * dbh, psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *reduction, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault)
    34723500{
    34733501    psMetadata *md = psMetadataAlloc();
    … …  
    35143542    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
    35153543        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     3544        psFree(md);
     3545        return false;
     3546    }
     3547    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) {
     3548        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
    35163549        psFree(md);
    35173550        return false;
    … …  
    36453678bool rawExpInsertObject(psDB *dbh, rawExpRow *object)
    36463679{
    3647     return rawExpInsert(dbh, object->exp_id, object->exp_name, object->camera, object->telescope, object->dateobs, object->exp_tag, object->exp_type, object->filelevel, object->workdir, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->sat_pixel_frac, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->object, object->solang, object->fault);
     3680    return rawExpInsert(dbh, object->exp_id, object->exp_name, object->camera, object->telescope, object->dateobs, object->exp_tag, object->exp_type, object->filelevel, object->workdir, object->reduction, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->sat_pixel_frac, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->object, object->solang, object->fault);
    36483681}
    36493682
    … …  
    37633796        return false;
    37643797    }
     3798    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) {
     3799        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     3800        psFree(md);
     3801        return false;
     3802    }
    37653803    if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) {
    37663804        psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    … …  
    39223960        return false;
    39233961    }
     3962    char* reduction = psMetadataLookupPtr(&status, md, "reduction");
     3963    if (!status) {
     3964        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction");
     3965        return false;
     3966    }
    39243967    char* filter = psMetadataLookupPtr(&status, md, "filter");
    39253968    if (!status) {
    … …  
    40284071    }
    40294072
    4030     return rawExpRowAlloc(exp_id, exp_name, camera, telescope, dateobs, exp_tag, exp_type, filelevel, workdir, filter, airmass, ra, decl, exp_time, sat_pixel_frac, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, user_1, user_2, user_3, user_4, user_5, object, solang, fault);
     4073    return rawExpRowAlloc(exp_id, exp_name, camera, telescope, dateobs, exp_tag, exp_type, filelevel, workdir, reduction, filter, airmass, ra, decl, exp_time, sat_pixel_frac, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, user_1, user_2, user_3, user_4, user_5, object, solang, fault);
    40314074}
    40324075psArray *rawExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    53495392static void chipRunRowFree(chipRunRow *object);
    53505393
    5351 chipRunRow *chipRunRowAlloc(psS64 chip_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb)
     5394chipRunRow *chipRunRowAlloc(psS64 chip_id, psS64 exp_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb)
    53525395{
    53535396    chipRunRow      *_object;
    … …  
    53575400
    53585401    _object->chip_id = chip_id;
     5402    _object->exp_id = exp_id;
    53595403    _object->state = psStringCopy(state);
    53605404    _object->workdir = psStringCopy(workdir);
    … …  
    53875431        return false;
    53885432    }
    5389     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "key", "64")) {
     5433    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Key INDEX(chip_id, exp_id) fkey (exp_id) ref rawExp(exp_id)", 64)) {
     5434        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     5435        psFree(md);
     5436        return false;
     5437    }
     5438    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
    53905439        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    53915440        psFree(md);
    … …  
    53975446        return false;
    53985447    }
    5399     if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "key", "64")) {
     5448    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "Key", "64")) {
    54005449        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state");
    54015450        psFree(md);
    54025451        return false;
    54035452    }
    5404     if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "key", "64")) {
     5453    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Key", "64")) {
    54055454        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
    54065455        psFree(md);
    … …  
    54125461        return false;
    54135462    }
    5414     if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, "key", "64")) {
     5463    if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, "Key", "64")) {
    54155464        psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup");
    54165465        psFree(md);
    … …  
    54355484}
    54365485
    5437 bool chipRunInsert(psDB * dbh, psS64 chip_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb)
     5486bool chipRunInsert(psDB * dbh, psS64 chip_id, psS64 exp_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb)
    54385487{
    54395488    psMetadata *md = psMetadataAlloc();
    54405489    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
    54415490        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5491        psFree(md);
     5492        return false;
     5493    }
     5494    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) {
     5495        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    54425496        psFree(md);
    54435497        return false;
    … …  
    55015555bool chipRunInsertObject(psDB *dbh, chipRunRow *object)
    55025556{
    5503     return chipRunInsert(dbh, object->chip_id, object->state, object->workdir, object->workdir_state, object->label, object->reduction, object->expgroup, object->dvodb);
     5557    return chipRunInsert(dbh, object->chip_id, object->exp_id, object->state, object->workdir, object->workdir_state, object->label, object->reduction, object->expgroup, object->dvodb);
    55045558}
    55055559
    … …  
    55795633        return false;
    55805634    }
     5635    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) {
     5636        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     5637        psFree(md);
     5638        return false;
     5639    }
    55815640    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
    55825641        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
    … …  
    56285687        return false;
    56295688    }
     5689    psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     5690    if (!status) {
     5691        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
     5692        return false;
     5693    }
    56305694    char* state = psMetadataLookupPtr(&status, md, "state");
    56315695    if (!status) {
    … …  
    56645728    }
    56655729
    5666     return chipRunRowAlloc(chip_id, state, workdir, workdir_state, label, reduction, expgroup, dvodb);
     5730    return chipRunRowAlloc(chip_id, exp_id, state, workdir, workdir_state, label, reduction, expgroup, dvodb);
    56675731}
    56685732psArray *chipRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    57645828
    57655829    psMetadata *md = chipRunMetadataFromObject(object);
    5766 
    5767     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    5768         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    5769         psFree(md);
    5770     }
    5771 
    5772     psFree(md);
    5773 
    5774     return true;
    5775 }
    5776 static void chipInputImfileRowFree(chipInputImfileRow *object);
    5777 
    5778 chipInputImfileRow *chipInputImfileRowAlloc(psS64 chip_id, psS64 exp_id, const char *class_id)
    5779 {
    5780     chipInputImfileRow *_object;
    5781 
    5782     _object = psAlloc(sizeof(chipInputImfileRow));
    5783     psMemSetDeallocator(_object, (psFreeFunc)chipInputImfileRowFree);
    5784 
    5785     _object->chip_id = chip_id;
    5786     _object->exp_id = exp_id;
    5787     _object->class_id = psStringCopy(class_id);
    5788 
    5789     return _object;
    5790 }
    5791 
    5792 static void chipInputImfileRowFree(chipInputImfileRow *object)
    5793 {
    5794     psFree(object->class_id);
    5795 }
    5796 
    5797 bool chipInputImfileCreateTable(psDB *dbh)
    5798 {
    5799     psMetadata *md = psMetadataAlloc();
    5800     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey (chip_id) ref chipRun(chip_id)", 0)) {
    5801         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    5802         psFree(md);
    5803         return false;
    5804     }
    5805     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey (exp_id, class_id) ref rawImfile (exp_id, class_id)", 64)) {
    5806         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    5807         psFree(md);
    5808         return false;
    5809     }
    5810     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    5811         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    5812         psFree(md);
    5813         return false;
    5814     }
    5815 
    5816     bool status = psDBCreateTable(dbh, CHIPINPUTIMFILE_TABLE_NAME, md);
    5817 
    5818     psFree(md);
    5819 
    5820     return status;
    5821 }
    5822 
    5823 bool chipInputImfileDropTable(psDB *dbh)
    5824 {
    5825     return psDBDropTable(dbh, CHIPINPUTIMFILE_TABLE_NAME);
    5826 }
    5827 
    5828 bool chipInputImfileInsert(psDB * dbh, psS64 chip_id, psS64 exp_id, const char *class_id)
    5829 {
    5830     psMetadata *md = psMetadataAlloc();
    5831     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
    5832         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    5833         psFree(md);
    5834         return false;
    5835     }
    5836     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) {
    5837         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    5838         psFree(md);
    5839         return false;
    5840     }
    5841     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    5842         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    5843         psFree(md);
    5844         return false;
    5845     }
    5846 
    5847     bool status = psDBInsertOneRow(dbh, CHIPINPUTIMFILE_TABLE_NAME, md);
    5848     psFree(md);
    5849 
    5850     return status;
    5851 }
    5852 
    5853 long long chipInputImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    5854 {
    5855     long long       deleted = 0;
    5856 
    5857     long long count = psDBDeleteRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, where, limit);
    5858     if (count < 0) {
    5859         psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipInputImfile");
    5860         return count;
    5861 
    5862         deleted += count;
    5863     }
    5864 
    5865     return deleted;
    5866 }
    5867 bool chipInputImfileInsertObject(psDB *dbh, chipInputImfileRow *object)
    5868 {
    5869     return chipInputImfileInsert(dbh, object->chip_id, object->exp_id, object->class_id);
    5870 }
    5871 
    5872 bool chipInputImfileInsertObjects(psDB *dbh, psArray *objects)
    5873 {
    5874     for (long i = 0; i < psArrayLength(objects); i++) {
    5875         if (!chipInputImfileInsertObject(dbh, objects->data[i])) {
    5876             return false;
    5877         }
    5878     }
    5879 
    5880     return true;
    5881 }
    5882 
    5883 bool chipInputImfileInsertFits(psDB *dbh, const psFits *fits)
    5884 {
    5885     psArray         *rowSet;
    5886 
    5887     // move to (the first?) extension named  CHIPINPUTIMFILE_TABLE_NAME
    5888     if (!psFitsMoveExtName(fits, CHIPINPUTIMFILE_TABLE_NAME)) {
    5889         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPINPUTIMFILE_TABLE_NAME);
    5890         return false;
    5891     }
    5892 
    5893     // check HDU type
    5894     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    5895         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    5896         return false;
    5897     }
    5898 
    5899     // read fits table
    5900     rowSet = psFitsReadTable(fits);
    5901     if (!rowSet) {
    5902         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    5903         psFree(rowSet);
    5904         return false;
    5905     }
    5906 
    5907     if (!psDBInsertRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, rowSet)) {
    5908         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    5909         psFree(rowSet);
    5910         return false;
    5911     }
    5912 
    5913     psFree(rowSet);
    5914 
    5915     return true;
    5916 }
    5917 
    5918 bool chipInputImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    5919 {
    5920     psArray         *rowSet;
    5921 
    5922     rowSet = psDBSelectRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, where, limit);
    5923     if (!rowSet) {
    5924         return false;
    5925     }
    5926 
    5927     // output to fits
    5928     if (!psFitsWriteTable(fits, NULL, rowSet, CHIPINPUTIMFILE_TABLE_NAME)) {
    5929         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    5930         psFree(rowSet);
    5931         return false;
    5932     }
    5933 
    5934     psFree(rowSet);
    5935 
    5936     return true;
    5937 }
    5938 
    5939 psMetadata *chipInputImfileMetadataFromObject(const chipInputImfileRow *object)
    5940 {
    5941     psMetadata *md = psMetadataAlloc();
    5942     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
    5943         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    5944         psFree(md);
    5945         return false;
    5946     }
    5947     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) {
    5948         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    5949         psFree(md);
    5950         return false;
    5951     }
    5952     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    5953         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    5954         psFree(md);
    5955         return false;
    5956     }
    5957 
    5958 
    5959     return md;
    5960 }
    5961 
    5962 chipInputImfileRow *chipInputImfileObjectFromMetadata(psMetadata *md)
    5963 {
    5964 
    5965 bool status = false;
    5966     psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
    5967     if (!status) {
    5968         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
    5969         return false;
    5970     }
    5971     psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    5972     if (!status) {
    5973         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
    5974         return false;
    5975     }
    5976     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    5977     if (!status) {
    5978         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    5979         return false;
    5980     }
    5981 
    5982     return chipInputImfileRowAlloc(chip_id, exp_id, class_id);
    5983 }
    5984 psArray *chipInputImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    5985 {
    5986     psArray         *rowSet;
    5987     psArray         *returnSet;
    5988     psU64           i;
    5989 
    5990     rowSet = psDBSelectRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, where, limit);
    5991     if (!rowSet) {
    5992         return NULL;
    5993     }
    5994 
    5995     // convert psMetadata rows to row objects
    5996 
    5997     returnSet = psArrayAllocEmpty(rowSet->n);
    5998 
    5999     for (i = 0; i < rowSet->n; i++) {
    6000         chipInputImfileRow *object = chipInputImfileObjectFromMetadata(rowSet->data[i]);
    6001         psArrayAdd(returnSet, 0, object);
    6002         psFree(object);
    6003     }
    6004 
    6005     psFree(rowSet);
    6006 
    6007     return returnSet;
    6008 }
    6009 bool chipInputImfileDeleteObject(psDB *dbh, const chipInputImfileRow *object)
    6010 {
    6011     psMetadata *where = chipInputImfileMetadataFromObject(object);
    6012     long long count = psDBDeleteRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, where, 0);
    6013     psFree(where);
    6014     if (count < 0) {
    6015         psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipInputImfile");
    6016         return false;
    6017     }
    6018     if (count > 1) {
    6019         // XXX should this be a psAbort() instead?  It is possible that
    6020         // having an object match multiple rows was by design.
    6021         psError(PS_ERR_UNKNOWN, true, "chipInputImfileRow object matched more then one row.  Check your database schema");
    6022         return false;
    6023     }
    6024 
    6025     return true;
    6026 }
    6027 long long chipInputImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    6028 {
    6029     long long       deleted = 0;
    6030 
    6031     for (long long i = 0; i < objects->n; i++) {
    6032         chipInputImfileRow *object = objects->data[i];
    6033         psMetadata *where = chipInputImfileMetadataFromObject(object);
    6034         long long count = psDBDeleteRows(dbh, CHIPINPUTIMFILE_TABLE_NAME, where, limit);
    6035         psFree(where);
    6036         if (count < 0) {
    6037             psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipInputImfile");
    6038             return count;
    6039         }
    6040 
    6041         deleted += count;
    6042     }
    6043 
    6044     return deleted;
    6045 }
    6046 bool chipInputImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    6047 {
    6048     PS_ASSERT_PTR_NON_NULL(objects, false);
    6049 
    6050     psMetadata *output = psMetadataAlloc();
    6051     for (long i = 0; i < psArrayLength(objects); i++) {
    6052         psMetadata *md = chipInputImfileMetadataFromObject(objects->data[i]);
    6053         if (!psMetadataAddMetadata(
    6054             output,
    6055             PS_LIST_TAIL,
    6056             CHIPINPUTIMFILE_TABLE_NAME,
    6057             PS_META_DUPLICATE_OK,
    6058             NULL,
    6059             md
    6060         )) {
    6061             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    6062             psFree(md);
    6063             psFree(output);
    6064             return false;
    6065         }
    6066         psFree(md);
    6067     }
    6068 
    6069     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    6070         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    6071         psFree(output);
    6072     }
    6073     psFree(output);
    6074 
    6075     return true;
    6076 }
    6077 bool chipInputImfilePrintObject(FILE *stream, chipInputImfileRow *object, bool mdcf)
    6078 {
    6079     PS_ASSERT_PTR_NON_NULL(object, false);
    6080 
    6081     psMetadata *md = chipInputImfileMetadataFromObject(object);
    60825830
    60835831    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    61375885{
    61385886    psMetadata *md = psMetadataAlloc();
    6139     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey (chip_id, exp_id, class_id) ref chipInputImfile(chip_id, exp_id, class_id)", 0)) {
     5887    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey (chip_id, exp_id) ref chipRun(chip_id, exp_id)", 0)) {
    61405888        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    61415889        psFree(md);
    61425890        return false;
    61435891    }
    6144     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key", 64)) {
     5892    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey (exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) {
    61455893        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    61465894        psFree(md);
    … …  
    71646912        return false;
    71656913    }
    7166     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey(chip_id) ref chipRun(chip_id)", 0)) {
     6914    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Key INDEX(cam_id, chip_id) fkey(chip_id) ref chipRun(chip_id)", 0)) {
    71676915        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    71686916        psFree(md);
    … …  
    95589306static void warpSkyfileRowFree(warpSkyfileRow *object);
    95599307
    9560 warpSkyfileRow *warpSkyfileRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     9308warpSkyfileRow *warpSkyfileRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    95619309{
    95629310    warpSkyfileRow  *_object;
    … …  
    95729320    _object->bg = bg;
    95739321    _object->bg_stdev = bg_stdev;
     9322    _object->fault = fault;
    95749323
    95759324    return _object;
    … …  
    96229371        return false;
    96239372    }
     9373    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) {
     9374        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     9375        psFree(md);
     9376        return false;
     9377    }
    96249378
    96259379    bool status = psDBCreateTable(dbh, WARPSKYFILE_TABLE_NAME, md);
    … …  
    96359389}
    96369390
    9637 bool warpSkyfileInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     9391bool warpSkyfileInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    96389392{
    96399393    psMetadata *md = psMetadataAlloc();
    … …  
    96709424    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
    96719425        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     9426        psFree(md);
     9427        return false;
     9428    }
     9429    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     9430        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    96729431        psFree(md);
    96739432        return false;
    … …  
    96969455bool warpSkyfileInsertObject(psDB *dbh, warpSkyfileRow *object)
    96979456{
    9698     return warpSkyfileInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->uri, object->path_base, object->bg, object->bg_stdev);
     9457    return warpSkyfileInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->fault);
    96999458}
    97009459
    … …  
    98049563        return false;
    98059564    }
     9565    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     9566        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     9567        psFree(md);
     9568        return false;
     9569    }
    98069570
    98079571
    … …  
    98489612        return false;
    98499613    }
    9850 
    9851     return warpSkyfileRowAlloc(warp_id, skycell_id, tess_id, uri, path_base, bg, bg_stdev);
     9614    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     9615    if (!status) {
     9616        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     9617        return false;
     9618    }
     9619
     9620    return warpSkyfileRowAlloc(warp_id, skycell_id, tess_id, uri, path_base, bg, bg_stdev, fault);
    98529621}
    98539622psArray *warpSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1074710516static void diffSkyfileRowFree(diffSkyfileRow *object);
    1074810517
    10749 diffSkyfileRow *diffSkyfileRowAlloc(psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     10518diffSkyfileRow *diffSkyfileRowAlloc(psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    1075010519{
    1075110520    diffSkyfileRow  *_object;
    … …  
    1075910528    _object->bg = bg;
    1076010529    _object->bg_stdev = bg_stdev;
     10530    _object->fault = fault;
    1076110531
    1076210532    return _object;
    … …  
    1079710567        return false;
    1079810568    }
     10569    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) {
     10570        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     10571        psFree(md);
     10572        return false;
     10573    }
    1079910574
    1080010575    bool status = psDBCreateTable(dbh, DIFFSKYFILE_TABLE_NAME, md);
    … …  
    1081010585}
    1081110586
    10812 bool diffSkyfileInsert(psDB * dbh, psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     10587bool diffSkyfileInsert(psDB * dbh, psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    1081310588{
    1081410589    psMetadata *md = psMetadataAlloc();
    … …  
    1083510610    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
    1083610611        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     10612        psFree(md);
     10613        return false;
     10614    }
     10615    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     10616        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    1083710617        psFree(md);
    1083810618        return false;
    … …  
    1086110641bool diffSkyfileInsertObject(psDB *dbh, diffSkyfileRow *object)
    1086210642{
    10863     return diffSkyfileInsert(dbh, object->diff_id, object->uri, object->path_base, object->bg, object->bg_stdev);
     10643    return diffSkyfileInsert(dbh, object->diff_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->fault);
    1086410644}
    1086510645
    … …  
    1095910739        return false;
    1096010740    }
     10741    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     10742        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     10743        psFree(md);
     10744        return false;
     10745    }
    1096110746
    1096210747
    … …  
    1099310778        return false;
    1099410779    }
    10995 
    10996     return diffSkyfileRowAlloc(diff_id, uri, path_base, bg, bg_stdev);
     10780    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     10781    if (!status) {
     10782        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     10783        return false;
     10784    }
     10785
     10786    return diffSkyfileRowAlloc(diff_id, uri, path_base, bg, bg_stdev, fault);
    1099710787}
    1099810788psArray *diffSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1180511595static void stackSumSkyfileRowFree(stackSumSkyfileRow *object);
    1180611596
    11807 stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     11597stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    1180811598{
    1180911599    stackSumSkyfileRow *_object;
    … …  
    1181711607    _object->bg = bg;
    1181811608    _object->bg_stdev = bg_stdev;
     11609    _object->fault = fault;
    1181911610
    1182011611    return _object;
    … …  
    1185511646        return false;
    1185611647    }
     11648    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) {
     11649        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     11650        psFree(md);
     11651        return false;
     11652    }
    1185711653
    1185811654    bool status = psDBCreateTable(dbh, STACKSUMSKYFILE_TABLE_NAME, md);
    … …  
    1186811664}
    1186911665
    11870 bool stackSumSkyfileInsert(psDB * dbh, psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev)
     11666bool stackSumSkyfileInsert(psDB * dbh, psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault)
    1187111667{
    1187211668    psMetadata *md = psMetadataAlloc();
    … …  
    1189311689    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
    1189411690        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     11691        psFree(md);
     11692        return false;
     11693    }
     11694    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     11695        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    1189511696        psFree(md);
    1189611697        return false;
    … …  
    1191911720bool stackSumSkyfileInsertObject(psDB *dbh, stackSumSkyfileRow *object)
    1192011721{
    11921     return stackSumSkyfileInsert(dbh, object->stack_id, object->uri, object->path_base, object->bg, object->bg_stdev);
     11722    return stackSumSkyfileInsert(dbh, object->stack_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->fault);
    1192211723}
    1192311724
    … …  
    1201711818        return false;
    1201811819    }
     11820    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     11821        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     11822        psFree(md);
     11823        return false;
     11824    }
    1201911825
    1202011826
    … …  
    1205111857        return false;
    1205211858    }
    12053 
    12054     return stackSumSkyfileRowAlloc(stack_id, uri, path_base, bg, bg_stdev);
     11859    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     11860    if (!status) {
     11861        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     11862        return false;
     11863    }
     11864
     11865    return stackSumSkyfileRowAlloc(stack_id, uri, path_base, bg, bg_stdev, fault);
    1205511866}
    1205611867psArray *stackSumSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1306312874{
    1306412875    psMetadata *md = psMetadataAlloc();
    13065     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     12876    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key INDEX(det_id, exp_id) fkey (det_id) ref detRun(det_id)", 0)) {
    1306612877        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1306712878        psFree(md);
    1306812879        return false;
    1306912880    }
    13070     if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key", 0)) {
     12881    if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key INDEX(det_id, iteration)", 0)) {
    1307112882        psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    1307212883        psFree(md);
    1307312884        return false;
    1307412885    }
    13075     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key", 64)) {
     12886    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey (exp_id) ref rawExp(exp_id)", 64)) {
    1307612887        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1307712888        psFree(md);
    … …  
    1341713228{
    1341813229    psMetadata *md = psMetadataAlloc();
    13419     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     13230    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey (det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) {
    1342013231        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1342113232        psFree(md);
    1342213233        return false;
    1342313234    }
    13424     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key", 64)) {
     13235    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey (exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) {
    1342513236        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1342613237        psFree(md);
    1342713238        return false;
    1342813239    }
    13429     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     13240    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key INDEX(det_id, class_id)", "64")) {
    1343013241        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    1343113242        psFree(md);
    … …  
    1404713858{
    1404813859    psMetadata *md = psMetadataAlloc();
    14049     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     13860    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) {
    1405013861        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1405113862        psFree(md);
    … …  
    1463614447{
    1463714448    psMetadata *md = psMetadataAlloc();
    14638     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     14449    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) {
    1463914450        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1464014451        psFree(md);
    1464114452        return false;
    1464214453    }
    14643     if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key", 0)) {
     14454    if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, class_id) ref  detProcessedImfile(det_id, class_id)", 0)) {
    1464414455        psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    1464514456        psFree(md);
    … …  
    1517414985{
    1517514986    psMetadata *md = psMetadataAlloc();
    15176     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     14987    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration, class_id) ref detStackedImfile(det_id, iteration, class_id)", 0)) {
    1517714988        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1517814989        psFree(md);
    … …  
    1554315354{
    1554415355    psMetadata *md = psMetadataAlloc();
    15545     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     15356    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key INDEX(det_id, iteration) fkey(det_id) ref detInputExp(det_id)", 0)) {
    1554615357        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1554715358        psFree(md);
    … …  
    1609015901{
    1609115902    psMetadata *md = psMetadataAlloc();
    16092     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     15903    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detNormalizedImfile(det_id, iteration)", 0)) {
    1609315904        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1609415905        psFree(md);
    … …  
    1793817749{
    1793917750    psMetadata *md = psMetadataAlloc();
    17940     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
     17751    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) {
    1794117752        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1794217753        psFree(md);

  • trunk/ippdb/src/ippdb.h

    r14061 r14169  
    13951395    char            *workdir;
    13961396    char            *workdir_state;
     1397    char            *reduction;
    13971398} newExpRow;
    13981399
    … …  
    14091410    const char      *state,
    14101411    const char      *workdir,
    1411     const char      *workdir_state
     1412    const char      *workdir_state,
     1413    const char      *reduction
    14121414);
    14131415
    … …  
    14451447    const char      *state,
    14461448    const char      *workdir,
    1447     const char      *workdir_state
     1449    const char      *workdir_state,
     1450    const char      *reduction
    14481451);
    14491452
    … …  
    18111814    char            *filelevel;
    18121815    char            *workdir;
     1816    char            *reduction;
    18131817    char            *filter;
    18141818    psF32           airmass;
    … …  
    18491853    const char      *filelevel,
    18501854    const char      *workdir,
     1855    const char      *reduction,
    18511856    const char      *filter,
    18521857    psF32           airmass,
    … …  
    19081913    const char      *filelevel,
    19091914    const char      *workdir,
     1915    const char      *reduction,
    19101916    const char      *filter,
    19111917    psF32           airmass,
    … …  
    25682574typedef struct {
    25692575    psS64           chip_id;
     2576    psS64           exp_id;
    25702577    char            *state;
    25712578    char            *workdir;
    … …  
    25842591chipRunRow *chipRunRowAlloc(
    25852592    psS64           chip_id,
     2593    psS64           exp_id,
    25862594    const char      *state,
    25872595    const char      *workdir,
    … …  
    26212629    psDB            *dbh,               ///< Database handle
    26222630    psS64           chip_id,
     2631    psS64           exp_id,
    26232632    const char      *state,
    26242633    const char      *workdir,
    … …  
    27752784    FILE            *stream,            ///< a stream
    27762785    chipRunRow *object,    ///< an chipRunRow object
    2777     bool            mdcf                ///< format as mdconfig or simple
    2778 );
    2779 /** chipInputImfileRow data structure
    2780  *
    2781  * Structure for representing a single row of chipInputImfile table data.
    2782  */
    2783 
    2784 typedef struct {
    2785     psS64           chip_id;
    2786     psS64           exp_id;
    2787     char            *class_id;
    2788 } chipInputImfileRow;
    2789 
    2790 /** Creates a new chipInputImfileRow object
    2791  *
    2792  *  @return A new chipInputImfileRow object or NULL on failure.
    2793  */
    2794 
    2795 chipInputImfileRow *chipInputImfileRowAlloc(
    2796     psS64           chip_id,
    2797     psS64           exp_id,
    2798     const char      *class_id
    2799 );
    2800 
    2801 /** Creates a new chipInputImfile table
    2802  *
    2803  * @return true on success
    2804  */
    2805 
    2806 bool chipInputImfileCreateTable(
    2807     psDB            *dbh                ///< Database handle
    2808 );
    2809 
    2810 /** Deletes a chipInputImfile table
    2811  *
    2812  * @return true on success
    2813  */
    2814 
    2815 bool chipInputImfileDropTable(
    2816     psDB            *dbh                ///< Database handle
    2817 );
    2818 
    2819 /** Insert a single row into a table
    2820  *
    2821  * This function constructs and inserts a single row based on it's parameters.
    2822  *
    2823  * @return true on success
    2824  */
    2825 
    2826 bool chipInputImfileInsert(
    2827     psDB            *dbh,               ///< Database handle
    2828     psS64           chip_id,
    2829     psS64           exp_id,
    2830     const char      *class_id
    2831 );
    2832 
    2833 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    2834  *
    2835  * @return A The number of rows removed or a negative value on error
    2836  */
    2837 
    2838 long long chipInputImfileDelete(
    2839     psDB            *dbh,               ///< Database handle
    2840     const psMetadata *where,            ///< Row match criteria
    2841     unsigned long long limit            ///< Maximum number of elements to delete
    2842 );
    2843 
    2844 /** Insert a single chipInputImfileRow object into a table
    2845  *
    2846  * This function constructs and inserts a single row based on it's parameters.
    2847  *
    2848  * @return true on success
    2849  */
    2850 
    2851 bool chipInputImfileInsertObject(
    2852     psDB            *dbh,               ///< Database handle
    2853     chipInputImfileRow *object             ///< chipInputImfileRow object
    2854 );
    2855 
    2856 /** Insert an array of chipInputImfileRow object into a table
    2857  *
    2858  * This function constructs and inserts multiple rows based on it's parameters.
    2859  *
    2860  * @return true on success
    2861  */
    2862 
    2863 bool chipInputImfileInsertObjects(
    2864     psDB            *dbh,               ///< Database handle
    2865     psArray         *objects            ///< array of chipInputImfileRow objects
    2866 );
    2867 
    2868 /** Insert data from a binary FITS table chipInputImfileRow into the database
    2869  *
    2870  * This function expects a psFits object with a FITS table as the first
    2871  * extension.  The table must have at least one row of data in it, that is of
    2872  * the appropriate format (number of columns and their type).  All other
    2873  * extensions are ignored.
    2874  *
    2875  * @return true on success
    2876  */
    2877 
    2878 bool chipInputImfileInsertFits(
    2879     psDB            *dbh,               ///< Database handle
    2880     const psFits    *fits               ///< psFits object
    2881 );
    2882 
    2883 /** Selects up to limit from the database and returns them in a binary FITS table
    2884  *
    2885  * This function assumes an empty psFits object and will create a FITS table
    2886  * as the first extension.
    2887  *
    2888  *  See psDBSelectRows() for documentation on the format of where.
    2889  *
    2890  * @return true on success
    2891  */
    2892 
    2893 bool chipInputImfileSelectRowsFits(
    2894     psDB            *dbh,               ///< Database handle
    2895     psFits          *fits,              ///< psFits object
    2896     const psMetadata *where,            ///< Row match criteria
    2897     unsigned long long limit            ///< Maximum number of elements to return
    2898 );
    2899 
    2900 /** Convert a chipInputImfileRow into an equivalent psMetadata
    2901  *
    2902  * @return A psMetadata pointer or NULL on error
    2903  */
    2904 
    2905 psMetadata *chipInputImfileMetadataFromObject(
    2906     const chipInputImfileRow *object             ///< fooRow to convert into a psMetadata
    2907 );
    2908 
    2909 /** Convert a psMetadata into an equivalent fooRow
    2910  *
    2911  * @return A chipInputImfileRow pointer or NULL on error
    2912  */
    2913 
    2914 chipInputImfileRow *chipInputImfileObjectFromMetadata(
    2915     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    2916 );
    2917 /** Selects up to limit rows from the database and returns as chipInputImfileRow objects in a psArray
    2918  *
    2919  *  See psDBSelectRows() for documentation on the format of where.
    2920  *
    2921  * @return A psArray pointer or NULL on error
    2922  */
    2923 
    2924 psArray *chipInputImfileSelectRowObjects(
    2925     psDB            *dbh,               ///< Database handle
    2926     const psMetadata *where,            ///< Row match criteria
    2927     unsigned long long limit            ///< Maximum number of elements to return
    2928 );
    2929 /** Deletes a row from the database coresponding to an chipInputImfile
    2930  *
    2931  *  Note that a 'where' search psMetadata is constructed from each object and
    2932  *  used to find rows to delete.
    2933  *
    2934  * @return A The number of rows removed or a negative value on error
    2935  */
    2936 
    2937 bool chipInputImfileDeleteObject(
    2938     psDB            *dbh,               ///< Database handle
    2939     const chipInputImfileRow *object    ///< Object to delete
    2940 );
    2941 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    2942  *
    2943  *  Note that a 'where' search psMetadata is constructed from each object and
    2944  *  used to find rows to delete.
    2945  *
    2946  * @return A The number of rows removed or a negative value on error
    2947  */
    2948 
    2949 long long chipInputImfileDeleteRowObjects(
    2950     psDB            *dbh,               ///< Database handle
    2951     const psArray   *objects,           ///< Array of objects to delete
    2952     unsigned long long limit            ///< Maximum number of elements to delete
    2953 );
    2954 /** Formats and prints an array of chipInputImfileRow objects
    2955  *
    2956  * When mdcf is set the formated output is in psMetadataConfig
    2957  * format, otherwise it is in a simple tabular format.
    2958  *
    2959  * @return true on success
    2960  */
    2961 
    2962 bool chipInputImfilePrintObjects(
    2963     FILE            *stream,            ///< a stream
    2964     psArray         *objects,           ///< An array of chipInputImfileRow objects
    2965     bool            mdcf                ///< format as mdconfig or simple
    2966 );
    2967 /** Formats and prints an chipInputImfileRow object
    2968  *
    2969  * When mdcf is set the formated output is in psMetadataConfig
    2970  * format, otherwise it is in a simple tabular format.
    2971  *
    2972  * @return true on success
    2973  */
    2974 
    2975 bool chipInputImfilePrintObject(
    2976     FILE            *stream,            ///< a stream
    2977     chipInputImfileRow *object,    ///< an chipInputImfileRow object
    29782786    bool            mdcf                ///< format as mdconfig or simple
    29792787);
    … …  
    47314539    psF64           bg;
    47324540    psF64           bg_stdev;
     4541    psS16           fault;
    47334542} warpSkyfileRow;
    47344543
    … …  
    47454554    const char      *path_base,
    47464555    psF64           bg,
    4747     psF64           bg_stdev
     4556    psF64           bg_stdev,
     4557    psS16           fault
    47484558);
    47494559
    … …  
    47814591    const char      *path_base,
    47824592    psF64           bg,
    4783     psF64           bg_stdev
     4593    psF64           bg_stdev,
     4594    psS16           fault
    47844595);
    47854596
    … …  
    53655176    psF64           bg;
    53665177    psF64           bg_stdev;
     5178    psS16           fault;
    53675179} diffSkyfileRow;
    53685180
    … …  
    53775189    const char      *path_base,
    53785190    psF64           bg,
    5379     psF64           bg_stdev
     5191    psF64           bg_stdev,
     5192    psS16           fault
    53805193);
    53815194
    … …  
    54115224    const char      *path_base,
    54125225    psF64           bg,
    5413     psF64           bg_stdev
     5226    psF64           bg_stdev,
     5227    psS16           fault
    54145228);
    54155229
    … …  
    59835797    psF64           bg;
    59845798    psF64           bg_stdev;
     5799    psS16           fault;
    59855800} stackSumSkyfileRow;
    59865801
    … …  
    59955810    const char      *path_base,
    59965811    psF64           bg,
    5997     psF64           bg_stdev
     5812    psF64           bg_stdev,
     5813    psS16           fault
    59985814);
    59995815
    … …  
    60295845    const char      *path_base,
    60305846    psF64           bg,
    6031     psF64           bg_stdev
     5847    psF64           bg_stdev,
     5848    psS16           fault
    60325849);
    60335850
Note: See TracChangeset for help on using the changeset viewer.