IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 9, 2008, 5:11:49 PM (18 years ago)
Author:
jhoblitt
Message:

faketool merge

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r17872 r18044  
    4747#define CAMPROCESSEDEXP_TABLE_NAME "camProcessedExp"
    4848#define CAMMASK_TABLE_NAME "camMask"
     49#define FAKERUN_TABLE_NAME "fakeRun"
     50#define FAKEPROCESSEDIMFILE_TABLE_NAME "fakeProcessedImfile"
     51#define FAKEMASK_TABLE_NAME "fakeMask"
    4952#define WARPRUN_TABLE_NAME "warpRun"
    5053#define WARPSKYCELLMAP_TABLE_NAME "warpSkyCellMap"
    … …  
    86178620static void camProcessedExpRowFree(camProcessedExpRow *object);
    86188621
    8619 camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm_major, psF32 fwhm_minor, psF32 dtime_detrend, psF32 dtime_photom, psF32 dtime_astrom, const char *hostname, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
     8622camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm_major, psF32 fwhm_minor, psF32 dtime_detrend, psF32 dtime_photom, psF32 dtime_astrom, const char *hostname, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    86208623{
    86218624    camProcessedExpRow *_object;
    … …  
    86258628
    86268629    _object->cam_id = cam_id;
    8627     _object->chip_id = chip_id;
    86288630    _object->uri = psStringCopy(uri);
    86298631    _object->bg = bg;
    … …  
    86728674        return false;
    86738675    }
    8674     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey(cam_id, chip_id) ref camRun(cam_id, chip_id)", 0)) {
    8675         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    8676         psFree(md);
    8677         return false;
    8678     }
    8679     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     8676    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, "fkey(cam_id) ref camRun(cam_id)", "255")) {
    86808677        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    86818678        psFree(md);
    … …  
    88258822}
    88268823
    8827 bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm_major, psF32 fwhm_minor, psF32 dtime_detrend, psF32 dtime_photom, psF32 dtime_astrom, const char *hostname, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
     8824bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm_major, psF32 fwhm_minor, psF32 dtime_detrend, psF32 dtime_photom, psF32 dtime_astrom, const char *hostname, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault)
    88288825{
    88298826    psMetadata *md = psMetadataAlloc();
    88308827    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
    88318828        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    8832         psFree(md);
    8833         return false;
    8834     }
    8835     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
    8836         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    88378829        psFree(md);
    88388830        return false;
    … …  
    89968988bool camProcessedExpInsertObject(psDB *dbh, camProcessedExpRow *object)
    89978989{
    8998     return camProcessedExpInsert(dbh, object->cam_id, object->chip_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bias, object->bias_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->sigma_ra, object->sigma_dec, object->ap_resid, object->ap_resid_stdev, object->zp_mean, object->zp_stdev, object->fwhm_major, object->fwhm_minor, object->dtime_detrend, object->dtime_photom, object->dtime_astrom, object->hostname, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault);
     8990    return camProcessedExpInsert(dbh, object->cam_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bias, object->bias_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->sigma_ra, object->sigma_dec, object->ap_resid, object->ap_resid_stdev, object->zp_mean, object->zp_stdev, object->fwhm_major, object->fwhm_minor, object->dtime_detrend, object->dtime_photom, object->dtime_astrom, object->hostname, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault);
    89998991}
    90008992
    … …  
    90749066        return false;
    90759067    }
    9076     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
    9077         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    9078         psFree(md);
    9079         return false;
    9080     }
    90819068    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    90829069        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    92289215        return false;
    92299216    }
    9230     psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
    9231     if (!status) {
    9232         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
    9233         return false;
    9234     }
    92359217    char* uri = psMetadataLookupPtr(&status, md, "uri");
    92369218    if (!status) {
    … …  
    93699351    }
    93709352
    9371     return camProcessedExpRowAlloc(cam_id, chip_id, uri, bg, bg_stdev, bg_mean_stdev, bias, bias_stdev, fringe_0, fringe_1, fringe_2, sigma_ra, sigma_dec, ap_resid, ap_resid_stdev, zp_mean, zp_stdev, fwhm_major, fwhm_minor, dtime_detrend, dtime_photom, dtime_astrom, hostname, n_stars, n_extended, n_cr, n_astrom, path_base, fault);
     9353    return camProcessedExpRowAlloc(cam_id, uri, bg, bg_stdev, bg_mean_stdev, bias, bias_stdev, fringe_0, fringe_1, fringe_2, sigma_ra, sigma_dec, ap_resid, ap_resid_stdev, zp_mean, zp_stdev, fwhm_major, fwhm_minor, dtime_detrend, dtime_photom, dtime_astrom, hostname, n_stars, n_extended, n_cr, n_astrom, path_base, fault);
    93729354}
    93739355psArray *camProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    97659747    return true;
    97669748}
     9749static void fakeRunRowFree(fakeRunRow *object);
     9750
     9751fakeRunRow *fakeRunRowAlloc(psS64 fake_id, psS64 cam_id, const char *state, const char *workdir, const char *label, const char *reduction, const char *expgroup, const char *dvodb, const char *tess_id, const char *end_stage, psTime* epoch)
     9752{
     9753    fakeRunRow      *_object;
     9754
     9755    _object = psAlloc(sizeof(fakeRunRow));
     9756    psMemSetDeallocator(_object, (psFreeFunc)fakeRunRowFree);
     9757
     9758    _object->fake_id = fake_id;
     9759    _object->cam_id = cam_id;
     9760    _object->state = psStringCopy(state);
     9761    _object->workdir = psStringCopy(workdir);
     9762    _object->label = psStringCopy(label);
     9763    _object->reduction = psStringCopy(reduction);
     9764    _object->expgroup = psStringCopy(expgroup);
     9765    _object->dvodb = psStringCopy(dvodb);
     9766    _object->tess_id = psStringCopy(tess_id);
     9767    _object->end_stage = psStringCopy(end_stage);
     9768    _object->epoch = psTimeCopy(epoch);
     9769
     9770    return _object;
     9771}
     9772
     9773static void fakeRunRowFree(fakeRunRow *object)
     9774{
     9775    psFree(object->state);
     9776    psFree(object->workdir);
     9777    psFree(object->label);
     9778    psFree(object->reduction);
     9779    psFree(object->expgroup);
     9780    psFree(object->dvodb);
     9781    psFree(object->tess_id);
     9782    psFree(object->end_stage);
     9783    psFree(object->epoch);
     9784}
     9785
     9786bool fakeRunCreateTable(psDB *dbh)
     9787{
     9788    psMetadata *md = psMetadataAlloc();
     9789    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
     9790        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     9791        psFree(md);
     9792        return false;
     9793    }
     9794    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Key INDEX(fake_id, cam_id) fkey (cam_id) ref camRun(cam_id)", 0)) {
     9795        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     9796        psFree(md);
     9797        return false;
     9798    }
     9799    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
     9800        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     9801        psFree(md);
     9802        return false;
     9803    }
     9804    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
     9805        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     9806        psFree(md);
     9807        return false;
     9808    }
     9809    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Key", "64")) {
     9810        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     9811        psFree(md);
     9812        return false;
     9813    }
     9814    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) {
     9815        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     9816        psFree(md);
     9817        return false;
     9818    }
     9819    if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, "Key", "64")) {
     9820        psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup");
     9821        psFree(md);
     9822        return false;
     9823    }
     9824    if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) {
     9825        psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb");
     9826        psFree(md);
     9827        return false;
     9828    }
     9829    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, "64")) {
     9830        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     9831        psFree(md);
     9832        return false;
     9833    }
     9834    if (!psMetadataAdd(md, PS_LIST_TAIL, "end_stage", PS_DATA_STRING, "Key", "64")) {
     9835        psError(PS_ERR_UNKNOWN, false, "failed to add item end_stage");
     9836        psFree(md);
     9837        return false;
     9838    }
     9839    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, NULL)) {
     9840        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     9841        psFree(md);
     9842        return false;
     9843    }
     9844
     9845    bool status = psDBCreateTable(dbh, FAKERUN_TABLE_NAME, md);
     9846
     9847    psFree(md);
     9848
     9849    return status;
     9850}
     9851
     9852bool fakeRunDropTable(psDB *dbh)
     9853{
     9854    return psDBDropTable(dbh, FAKERUN_TABLE_NAME);
     9855}
     9856
     9857bool fakeRunInsert(psDB * dbh, psS64 fake_id, psS64 cam_id, const char *state, const char *workdir, const char *label, const char *reduction, const char *expgroup, const char *dvodb, const char *tess_id, const char *end_stage, psTime* epoch)
     9858{
     9859    psMetadata *md = psMetadataAlloc();
     9860    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, fake_id)) {
     9861        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     9862        psFree(md);
     9863        return false;
     9864    }
     9865    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     9866        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     9867        psFree(md);
     9868        return false;
     9869    }
     9870    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
     9871        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     9872        psFree(md);
     9873        return false;
     9874    }
     9875    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
     9876        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     9877        psFree(md);
     9878        return false;
     9879    }
     9880    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) {
     9881        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     9882        psFree(md);
     9883        return false;
     9884    }
     9885    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) {
     9886        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     9887        psFree(md);
     9888        return false;
     9889    }
     9890    if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, expgroup)) {
     9891        psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup");
     9892        psFree(md);
     9893        return false;
     9894    }
     9895    if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) {
     9896        psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb");
     9897        psFree(md);
     9898        return false;
     9899    }
     9900    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     9901        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     9902        psFree(md);
     9903        return false;
     9904    }
     9905    if (!psMetadataAdd(md, PS_LIST_TAIL, "end_stage", PS_DATA_STRING, NULL, end_stage)) {
     9906        psError(PS_ERR_UNKNOWN, false, "failed to add item end_stage");
     9907        psFree(md);
     9908        return false;
     9909    }
     9910    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, epoch)) {
     9911        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     9912        psFree(md);
     9913        return false;
     9914    }
     9915
     9916    bool status = psDBInsertOneRow(dbh, FAKERUN_TABLE_NAME, md);
     9917    psFree(md);
     9918
     9919    return status;
     9920}
     9921
     9922long long fakeRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     9923{
     9924    long long       deleted = 0;
     9925
     9926    long long count = psDBDeleteRows(dbh, FAKERUN_TABLE_NAME, where, limit);
     9927    if (count < 0) {
     9928        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeRun");
     9929        return count;
     9930
     9931        deleted += count;
     9932    }
     9933
     9934    return deleted;
     9935}
     9936bool fakeRunInsertObject(psDB *dbh, fakeRunRow *object)
     9937{
     9938    return fakeRunInsert(dbh, object->fake_id, object->cam_id, object->state, object->workdir, object->label, object->reduction, object->expgroup, object->dvodb, object->tess_id, object->end_stage, object->epoch);
     9939}
     9940
     9941bool fakeRunInsertObjects(psDB *dbh, psArray *objects)
     9942{
     9943    for (long i = 0; i < psArrayLength(objects); i++) {
     9944        if (!fakeRunInsertObject(dbh, objects->data[i])) {
     9945            return false;
     9946        }
     9947    }
     9948
     9949    return true;
     9950}
     9951
     9952bool fakeRunInsertFits(psDB *dbh, const psFits *fits)
     9953{
     9954    psArray         *rowSet;
     9955
     9956    // move to (the first?) extension named  FAKERUN_TABLE_NAME
     9957    if (!psFitsMoveExtName(fits, FAKERUN_TABLE_NAME)) {
     9958        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", FAKERUN_TABLE_NAME);
     9959        return false;
     9960    }
     9961
     9962    // check HDU type
     9963    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     9964        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     9965        return false;
     9966    }
     9967
     9968    // read fits table
     9969    rowSet = psFitsReadTable(fits);
     9970    if (!rowSet) {
     9971        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     9972        psFree(rowSet);
     9973        return false;
     9974    }
     9975
     9976    if (!psDBInsertRows(dbh, FAKERUN_TABLE_NAME, rowSet)) {
     9977        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     9978        psFree(rowSet);
     9979        return false;
     9980    }
     9981
     9982    psFree(rowSet);
     9983
     9984    return true;
     9985}
     9986
     9987bool fakeRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     9988{
     9989    psArray         *rowSet;
     9990
     9991    rowSet = psDBSelectRows(dbh, FAKERUN_TABLE_NAME, where, limit);
     9992    if (!rowSet) {
     9993        return false;
     9994    }
     9995
     9996    // output to fits
     9997    if (!psFitsWriteTable(fits, NULL, rowSet, FAKERUN_TABLE_NAME)) {
     9998        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     9999        psFree(rowSet);
     10000        return false;
     10001    }
     10002
     10003    psFree(rowSet);
     10004
     10005    return true;
     10006}
     10007
     10008psMetadata *fakeRunMetadataFromObject(const fakeRunRow *object)
     10009{
     10010    psMetadata *md = psMetadataAlloc();
     10011    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, object->fake_id)) {
     10012        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     10013        psFree(md);
     10014        return false;
     10015    }
     10016    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     10017        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     10018        psFree(md);
     10019        return false;
     10020    }
     10021    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
     10022        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     10023        psFree(md);
     10024        return false;
     10025    }
     10026    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
     10027        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     10028        psFree(md);
     10029        return false;
     10030    }
     10031    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) {
     10032        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     10033        psFree(md);
     10034        return false;
     10035    }
     10036    if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) {
     10037        psError(PS_ERR_UNKNOWN, false, "failed to add item reduction");
     10038        psFree(md);
     10039        return false;
     10040    }
     10041    if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, object->expgroup)) {
     10042        psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup");
     10043        psFree(md);
     10044        return false;
     10045    }
     10046    if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) {
     10047        psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb");
     10048        psFree(md);
     10049        return false;
     10050    }
     10051    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     10052        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     10053        psFree(md);
     10054        return false;
     10055    }
     10056    if (!psMetadataAdd(md, PS_LIST_TAIL, "end_stage", PS_DATA_STRING, NULL, object->end_stage)) {
     10057        psError(PS_ERR_UNKNOWN, false, "failed to add item end_stage");
     10058        psFree(md);
     10059        return false;
     10060    }
     10061    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, object->epoch)) {
     10062        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     10063        psFree(md);
     10064        return false;
     10065    }
     10066
     10067
     10068    return md;
     10069}
     10070
     10071fakeRunRow *fakeRunObjectFromMetadata(psMetadata *md)
     10072{
     10073
     10074bool status = false;
     10075    psS64 fake_id = psMetadataLookupS64(&status, md, "fake_id");
     10076    if (!status) {
     10077        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fake_id");
     10078        return false;
     10079    }
     10080    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     10081    if (!status) {
     10082        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
     10083        return false;
     10084    }
     10085    char* state = psMetadataLookupPtr(&status, md, "state");
     10086    if (!status) {
     10087        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
     10088        return false;
     10089    }
     10090    char* workdir = psMetadataLookupPtr(&status, md, "workdir");
     10091    if (!status) {
     10092        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
     10093        return false;
     10094    }
     10095    char* label = psMetadataLookupPtr(&status, md, "label");
     10096    if (!status) {
     10097        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label");
     10098        return false;
     10099    }
     10100    char* reduction = psMetadataLookupPtr(&status, md, "reduction");
     10101    if (!status) {
     10102        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction");
     10103        return false;
     10104    }
     10105    char* expgroup = psMetadataLookupPtr(&status, md, "expgroup");
     10106    if (!status) {
     10107        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item expgroup");
     10108        return false;
     10109    }
     10110    char* dvodb = psMetadataLookupPtr(&status, md, "dvodb");
     10111    if (!status) {
     10112        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb");
     10113        return false;
     10114    }
     10115    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     10116    if (!status) {
     10117        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     10118        return false;
     10119    }
     10120    char* end_stage = psMetadataLookupPtr(&status, md, "end_stage");
     10121    if (!status) {
     10122        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item end_stage");
     10123        return false;
     10124    }
     10125    psTime* epoch = psMetadataLookupPtr(&status, md, "epoch");
     10126    if (!status) {
     10127        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item epoch");
     10128        return false;
     10129    }
     10130
     10131    return fakeRunRowAlloc(fake_id, cam_id, state, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage, epoch);
     10132}
     10133psArray *fakeRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     10134{
     10135    psArray         *rowSet;
     10136    psArray         *returnSet;
     10137    psU64           i;
     10138
     10139    rowSet = psDBSelectRows(dbh, FAKERUN_TABLE_NAME, where, limit);
     10140    if (!rowSet) {
     10141        return NULL;
     10142    }
     10143
     10144    // convert psMetadata rows to row objects
     10145
     10146    returnSet = psArrayAllocEmpty(rowSet->n);
     10147
     10148    for (i = 0; i < rowSet->n; i++) {
     10149        fakeRunRow *object = fakeRunObjectFromMetadata(rowSet->data[i]);
     10150        if (!object) {
     10151            psFree(object);
     10152            psFree(returnSet);
     10153            psError(PS_ERR_UNKNOWN, false, "database error");
     10154            return NULL;
     10155        }
     10156        psArrayAdd(returnSet, 0, object);
     10157        psFree(object);
     10158    }
     10159
     10160    psFree(rowSet);
     10161
     10162    return returnSet;
     10163}
     10164bool fakeRunDeleteObject(psDB *dbh, const fakeRunRow *object)
     10165{
     10166    psMetadata *where = fakeRunMetadataFromObject(object);
     10167    long long count = psDBDeleteRows(dbh, FAKERUN_TABLE_NAME, where, 0);
     10168    psFree(where);
     10169    if (count < 0) {
     10170        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeRun");
     10171        return false;
     10172    }
     10173    if (count > 1) {
     10174        // XXX should this be a psAbort() instead?  It is possible that
     10175        // having an object match multiple rows was by design.
     10176        psError(PS_ERR_UNKNOWN, true, "fakeRunRow object matched more then one row.  Check your database schema");
     10177        return false;
     10178    }
     10179
     10180    return true;
     10181}
     10182long long fakeRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     10183{
     10184    long long       deleted = 0;
     10185
     10186    for (long long i = 0; i < objects->n; i++) {
     10187        fakeRunRow *object = objects->data[i];
     10188        psMetadata *where = fakeRunMetadataFromObject(object);
     10189        long long count = psDBDeleteRows(dbh, FAKERUN_TABLE_NAME, where, limit);
     10190        psFree(where);
     10191        if (count < 0) {
     10192            psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeRun");
     10193            return count;
     10194        }
     10195
     10196        deleted += count;
     10197    }
     10198
     10199    return deleted;
     10200}
     10201bool fakeRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     10202{
     10203    PS_ASSERT_PTR_NON_NULL(objects, false);
     10204
     10205    psMetadata *output = psMetadataAlloc();
     10206    for (long i = 0; i < psArrayLength(objects); i++) {
     10207        psMetadata *md = fakeRunMetadataFromObject(objects->data[i]);
     10208        if (!psMetadataAddMetadata(
     10209            output,
     10210            PS_LIST_TAIL,
     10211            FAKERUN_TABLE_NAME,
     10212            PS_META_DUPLICATE_OK,
     10213            NULL,
     10214            md
     10215        )) {
     10216            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     10217            psFree(md);
     10218            psFree(output);
     10219            return false;
     10220        }
     10221        psFree(md);
     10222    }
     10223
     10224    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     10225        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10226        psFree(output);
     10227    }
     10228    psFree(output);
     10229
     10230    return true;
     10231}
     10232bool fakeRunPrintObject(FILE *stream, fakeRunRow *object, bool mdcf)
     10233{
     10234    PS_ASSERT_PTR_NON_NULL(object, false);
     10235
     10236    psMetadata *md = fakeRunMetadataFromObject(object);
     10237
     10238    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     10239        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10240        psFree(md);
     10241    }
     10242
     10243    psFree(md);
     10244
     10245    return true;
     10246}
     10247static void fakeProcessedImfileRowFree(fakeProcessedImfileRow *object);
     10248
     10249fakeProcessedImfileRow *fakeProcessedImfileRowAlloc(psS64 fake_id, psS64 exp_id, const char *class_id, const char *uri, psF32 dtime_fake, const char *hostname, const char *path_base, psS16 fault, psTime* epoch)
     10250{
     10251    fakeProcessedImfileRow *_object;
     10252
     10253    _object = psAlloc(sizeof(fakeProcessedImfileRow));
     10254    psMemSetDeallocator(_object, (psFreeFunc)fakeProcessedImfileRowFree);
     10255
     10256    _object->fake_id = fake_id;
     10257    _object->exp_id = exp_id;
     10258    _object->class_id = psStringCopy(class_id);
     10259    _object->uri = psStringCopy(uri);
     10260    _object->dtime_fake = dtime_fake;
     10261    _object->hostname = psStringCopy(hostname);
     10262    _object->path_base = psStringCopy(path_base);
     10263    _object->fault = fault;
     10264    _object->epoch = psTimeCopy(epoch);
     10265
     10266    return _object;
     10267}
     10268
     10269static void fakeProcessedImfileRowFree(fakeProcessedImfileRow *object)
     10270{
     10271    psFree(object->class_id);
     10272    psFree(object->uri);
     10273    psFree(object->hostname);
     10274    psFree(object->path_base);
     10275    psFree(object->epoch);
     10276}
     10277
     10278bool fakeProcessedImfileCreateTable(psDB *dbh)
     10279{
     10280    psMetadata *md = psMetadataAlloc();
     10281    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, "Primary Key fkey (fake_id) ref fakeRun(fake_id)", 0)) {
     10282        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     10283        psFree(md);
     10284        return false;
     10285    }
     10286    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)) {
     10287        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     10288        psFree(md);
     10289        return false;
     10290    }
     10291    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     10292        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     10293        psFree(md);
     10294        return false;
     10295    }
     10296    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     10297        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     10298        psFree(md);
     10299        return false;
     10300    }
     10301    if (!psMetadataAdd(md, PS_LIST_TAIL, "dtime_fake", PS_DATA_F32, NULL, 0.0)) {
     10302        psError(PS_ERR_UNKNOWN, false, "failed to add item dtime_fake");
     10303        psFree(md);
     10304        return false;
     10305    }
     10306    if (!psMetadataAdd(md, PS_LIST_TAIL, "hostname", PS_DATA_STRING, NULL, "64")) {
     10307        psError(PS_ERR_UNKNOWN, false, "failed to add item hostname");
     10308        psFree(md);
     10309        return false;
     10310    }
     10311    if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) {
     10312        psError(PS_ERR_UNKNOWN, false, "failed to add item path_base");
     10313        psFree(md);
     10314        return false;
     10315    }
     10316    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) {
     10317        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     10318        psFree(md);
     10319        return false;
     10320    }
     10321    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, NULL)) {
     10322        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     10323        psFree(md);
     10324        return false;
     10325    }
     10326
     10327    bool status = psDBCreateTable(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, md);
     10328
     10329    psFree(md);
     10330
     10331    return status;
     10332}
     10333
     10334bool fakeProcessedImfileDropTable(psDB *dbh)
     10335{
     10336    return psDBDropTable(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME);
     10337}
     10338
     10339bool fakeProcessedImfileInsert(psDB * dbh, psS64 fake_id, psS64 exp_id, const char *class_id, const char *uri, psF32 dtime_fake, const char *hostname, const char *path_base, psS16 fault, psTime* epoch)
     10340{
     10341    psMetadata *md = psMetadataAlloc();
     10342    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, fake_id)) {
     10343        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     10344        psFree(md);
     10345        return false;
     10346    }
     10347    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) {
     10348        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     10349        psFree(md);
     10350        return false;
     10351    }
     10352    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
     10353        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     10354        psFree(md);
     10355        return false;
     10356    }
     10357    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
     10358        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     10359        psFree(md);
     10360        return false;
     10361    }
     10362    if (!psMetadataAdd(md, PS_LIST_TAIL, "dtime_fake", PS_DATA_F32, NULL, dtime_fake)) {
     10363        psError(PS_ERR_UNKNOWN, false, "failed to add item dtime_fake");
     10364        psFree(md);
     10365        return false;
     10366    }
     10367    if (!psMetadataAdd(md, PS_LIST_TAIL, "hostname", PS_DATA_STRING, NULL, hostname)) {
     10368        psError(PS_ERR_UNKNOWN, false, "failed to add item hostname");
     10369        psFree(md);
     10370        return false;
     10371    }
     10372    if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) {
     10373        psError(PS_ERR_UNKNOWN, false, "failed to add item path_base");
     10374        psFree(md);
     10375        return false;
     10376    }
     10377    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     10378        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     10379        psFree(md);
     10380        return false;
     10381    }
     10382    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, epoch)) {
     10383        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     10384        psFree(md);
     10385        return false;
     10386    }
     10387
     10388    bool status = psDBInsertOneRow(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, md);
     10389    psFree(md);
     10390
     10391    return status;
     10392}
     10393
     10394long long fakeProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     10395{
     10396    long long       deleted = 0;
     10397
     10398    long long count = psDBDeleteRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, where, limit);
     10399    if (count < 0) {
     10400        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeProcessedImfile");
     10401        return count;
     10402
     10403        deleted += count;
     10404    }
     10405
     10406    return deleted;
     10407}
     10408bool fakeProcessedImfileInsertObject(psDB *dbh, fakeProcessedImfileRow *object)
     10409{
     10410    return fakeProcessedImfileInsert(dbh, object->fake_id, object->exp_id, object->class_id, object->uri, object->dtime_fake, object->hostname, object->path_base, object->fault, object->epoch);
     10411}
     10412
     10413bool fakeProcessedImfileInsertObjects(psDB *dbh, psArray *objects)
     10414{
     10415    for (long i = 0; i < psArrayLength(objects); i++) {
     10416        if (!fakeProcessedImfileInsertObject(dbh, objects->data[i])) {
     10417            return false;
     10418        }
     10419    }
     10420
     10421    return true;
     10422}
     10423
     10424bool fakeProcessedImfileInsertFits(psDB *dbh, const psFits *fits)
     10425{
     10426    psArray         *rowSet;
     10427
     10428    // move to (the first?) extension named  FAKEPROCESSEDIMFILE_TABLE_NAME
     10429    if (!psFitsMoveExtName(fits, FAKEPROCESSEDIMFILE_TABLE_NAME)) {
     10430        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", FAKEPROCESSEDIMFILE_TABLE_NAME);
     10431        return false;
     10432    }
     10433
     10434    // check HDU type
     10435    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     10436        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     10437        return false;
     10438    }
     10439
     10440    // read fits table
     10441    rowSet = psFitsReadTable(fits);
     10442    if (!rowSet) {
     10443        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     10444        psFree(rowSet);
     10445        return false;
     10446    }
     10447
     10448    if (!psDBInsertRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, rowSet)) {
     10449        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     10450        psFree(rowSet);
     10451        return false;
     10452    }
     10453
     10454    psFree(rowSet);
     10455
     10456    return true;
     10457}
     10458
     10459bool fakeProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     10460{
     10461    psArray         *rowSet;
     10462
     10463    rowSet = psDBSelectRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, where, limit);
     10464    if (!rowSet) {
     10465        return false;
     10466    }
     10467
     10468    // output to fits
     10469    if (!psFitsWriteTable(fits, NULL, rowSet, FAKEPROCESSEDIMFILE_TABLE_NAME)) {
     10470        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     10471        psFree(rowSet);
     10472        return false;
     10473    }
     10474
     10475    psFree(rowSet);
     10476
     10477    return true;
     10478}
     10479
     10480psMetadata *fakeProcessedImfileMetadataFromObject(const fakeProcessedImfileRow *object)
     10481{
     10482    psMetadata *md = psMetadataAlloc();
     10483    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, object->fake_id)) {
     10484        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
     10485        psFree(md);
     10486        return false;
     10487    }
     10488    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) {
     10489        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     10490        psFree(md);
     10491        return false;
     10492    }
     10493    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
     10494        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     10495        psFree(md);
     10496        return false;
     10497    }
     10498    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
     10499        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     10500        psFree(md);
     10501        return false;
     10502    }
     10503    if (!psMetadataAdd(md, PS_LIST_TAIL, "dtime_fake", PS_DATA_F32, NULL, object->dtime_fake)) {
     10504        psError(PS_ERR_UNKNOWN, false, "failed to add item dtime_fake");
     10505        psFree(md);
     10506        return false;
     10507    }
     10508    if (!psMetadataAdd(md, PS_LIST_TAIL, "hostname", PS_DATA_STRING, NULL, object->hostname)) {
     10509        psError(PS_ERR_UNKNOWN, false, "failed to add item hostname");
     10510        psFree(md);
     10511        return false;
     10512    }
     10513    if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) {
     10514        psError(PS_ERR_UNKNOWN, false, "failed to add item path_base");
     10515        psFree(md);
     10516        return false;
     10517    }
     10518    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     10519        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     10520        psFree(md);
     10521        return false;
     10522    }
     10523    if (!psMetadataAdd(md, PS_LIST_TAIL, "epoch", PS_DATA_TIME, NULL, object->epoch)) {
     10524        psError(PS_ERR_UNKNOWN, false, "failed to add item epoch");
     10525        psFree(md);
     10526        return false;
     10527    }
     10528
     10529
     10530    return md;
     10531}
     10532
     10533fakeProcessedImfileRow *fakeProcessedImfileObjectFromMetadata(psMetadata *md)
     10534{
     10535
     10536bool status = false;
     10537    psS64 fake_id = psMetadataLookupS64(&status, md, "fake_id");
     10538    if (!status) {
     10539        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fake_id");
     10540        return false;
     10541    }
     10542    psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     10543    if (!status) {
     10544        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
     10545        return false;
     10546    }
     10547    char* class_id = psMetadataLookupPtr(&status, md, "class_id");
     10548    if (!status) {
     10549        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
     10550        return false;
     10551    }
     10552    char* uri = psMetadataLookupPtr(&status, md, "uri");
     10553    if (!status) {
     10554        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     10555        return false;
     10556    }
     10557    psF32 dtime_fake = psMetadataLookupF32(&status, md, "dtime_fake");
     10558    if (!status) {
     10559        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dtime_fake");
     10560        return false;
     10561    }
     10562    char* hostname = psMetadataLookupPtr(&status, md, "hostname");
     10563    if (!status) {
     10564        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item hostname");
     10565        return false;
     10566    }
     10567    char* path_base = psMetadataLookupPtr(&status, md, "path_base");
     10568    if (!status) {
     10569        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base");
     10570        return false;
     10571    }
     10572    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     10573    if (!status) {
     10574        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     10575        return false;
     10576    }
     10577    psTime* epoch = psMetadataLookupPtr(&status, md, "epoch");
     10578    if (!status) {
     10579        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item epoch");
     10580        return false;
     10581    }
     10582
     10583    return fakeProcessedImfileRowAlloc(fake_id, exp_id, class_id, uri, dtime_fake, hostname, path_base, fault, epoch);
     10584}
     10585psArray *fakeProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     10586{
     10587    psArray         *rowSet;
     10588    psArray         *returnSet;
     10589    psU64           i;
     10590
     10591    rowSet = psDBSelectRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, where, limit);
     10592    if (!rowSet) {
     10593        return NULL;
     10594    }
     10595
     10596    // convert psMetadata rows to row objects
     10597
     10598    returnSet = psArrayAllocEmpty(rowSet->n);
     10599
     10600    for (i = 0; i < rowSet->n; i++) {
     10601        fakeProcessedImfileRow *object = fakeProcessedImfileObjectFromMetadata(rowSet->data[i]);
     10602        if (!object) {
     10603            psFree(object);
     10604            psFree(returnSet);
     10605            psError(PS_ERR_UNKNOWN, false, "database error");
     10606            return NULL;
     10607        }
     10608        psArrayAdd(returnSet, 0, object);
     10609        psFree(object);
     10610    }
     10611
     10612    psFree(rowSet);
     10613
     10614    return returnSet;
     10615}
     10616bool fakeProcessedImfileDeleteObject(psDB *dbh, const fakeProcessedImfileRow *object)
     10617{
     10618    psMetadata *where = fakeProcessedImfileMetadataFromObject(object);
     10619    long long count = psDBDeleteRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, where, 0);
     10620    psFree(where);
     10621    if (count < 0) {
     10622        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeProcessedImfile");
     10623        return false;
     10624    }
     10625    if (count > 1) {
     10626        // XXX should this be a psAbort() instead?  It is possible that
     10627        // having an object match multiple rows was by design.
     10628        psError(PS_ERR_UNKNOWN, true, "fakeProcessedImfileRow object matched more then one row.  Check your database schema");
     10629        return false;
     10630    }
     10631
     10632    return true;
     10633}
     10634long long fakeProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     10635{
     10636    long long       deleted = 0;
     10637
     10638    for (long long i = 0; i < objects->n; i++) {
     10639        fakeProcessedImfileRow *object = objects->data[i];
     10640        psMetadata *where = fakeProcessedImfileMetadataFromObject(object);
     10641        long long count = psDBDeleteRows(dbh, FAKEPROCESSEDIMFILE_TABLE_NAME, where, limit);
     10642        psFree(where);
     10643        if (count < 0) {
     10644            psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeProcessedImfile");
     10645            return count;
     10646        }
     10647
     10648        deleted += count;
     10649    }
     10650
     10651    return deleted;
     10652}
     10653bool fakeProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     10654{
     10655    PS_ASSERT_PTR_NON_NULL(objects, false);
     10656
     10657    psMetadata *output = psMetadataAlloc();
     10658    for (long i = 0; i < psArrayLength(objects); i++) {
     10659        psMetadata *md = fakeProcessedImfileMetadataFromObject(objects->data[i]);
     10660        if (!psMetadataAddMetadata(
     10661            output,
     10662            PS_LIST_TAIL,
     10663            FAKEPROCESSEDIMFILE_TABLE_NAME,
     10664            PS_META_DUPLICATE_OK,
     10665            NULL,
     10666            md
     10667        )) {
     10668            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     10669            psFree(md);
     10670            psFree(output);
     10671            return false;
     10672        }
     10673        psFree(md);
     10674    }
     10675
     10676    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     10677        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10678        psFree(output);
     10679    }
     10680    psFree(output);
     10681
     10682    return true;
     10683}
     10684bool fakeProcessedImfilePrintObject(FILE *stream, fakeProcessedImfileRow *object, bool mdcf)
     10685{
     10686    PS_ASSERT_PTR_NON_NULL(object, false);
     10687
     10688    psMetadata *md = fakeProcessedImfileMetadataFromObject(object);
     10689
     10690    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     10691        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10692        psFree(md);
     10693    }
     10694
     10695    psFree(md);
     10696
     10697    return true;
     10698}
     10699static void fakeMaskRowFree(fakeMaskRow *object);
     10700
     10701fakeMaskRow *fakeMaskRowAlloc(const char *label)
     10702{
     10703    fakeMaskRow     *_object;
     10704
     10705    _object = psAlloc(sizeof(fakeMaskRow));
     10706    psMemSetDeallocator(_object, (psFreeFunc)fakeMaskRowFree);
     10707
     10708    _object->label = psStringCopy(label);
     10709
     10710    return _object;
     10711}
     10712
     10713static void fakeMaskRowFree(fakeMaskRow *object)
     10714{
     10715    psFree(object->label);
     10716}
     10717
     10718bool fakeMaskCreateTable(psDB *dbh)
     10719{
     10720    psMetadata *md = psMetadataAlloc();
     10721    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Primary Key", "64")) {
     10722        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     10723        psFree(md);
     10724        return false;
     10725    }
     10726
     10727    bool status = psDBCreateTable(dbh, FAKEMASK_TABLE_NAME, md);
     10728
     10729    psFree(md);
     10730
     10731    return status;
     10732}
     10733
     10734bool fakeMaskDropTable(psDB *dbh)
     10735{
     10736    return psDBDropTable(dbh, FAKEMASK_TABLE_NAME);
     10737}
     10738
     10739bool fakeMaskInsert(psDB * dbh, const char *label)
     10740{
     10741    psMetadata *md = psMetadataAlloc();
     10742    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) {
     10743        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     10744        psFree(md);
     10745        return false;
     10746    }
     10747
     10748    bool status = psDBInsertOneRow(dbh, FAKEMASK_TABLE_NAME, md);
     10749    psFree(md);
     10750
     10751    return status;
     10752}
     10753
     10754long long fakeMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     10755{
     10756    long long       deleted = 0;
     10757
     10758    long long count = psDBDeleteRows(dbh, FAKEMASK_TABLE_NAME, where, limit);
     10759    if (count < 0) {
     10760        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeMask");
     10761        return count;
     10762
     10763        deleted += count;
     10764    }
     10765
     10766    return deleted;
     10767}
     10768bool fakeMaskInsertObject(psDB *dbh, fakeMaskRow *object)
     10769{
     10770    return fakeMaskInsert(dbh, object->label);
     10771}
     10772
     10773bool fakeMaskInsertObjects(psDB *dbh, psArray *objects)
     10774{
     10775    for (long i = 0; i < psArrayLength(objects); i++) {
     10776        if (!fakeMaskInsertObject(dbh, objects->data[i])) {
     10777            return false;
     10778        }
     10779    }
     10780
     10781    return true;
     10782}
     10783
     10784bool fakeMaskInsertFits(psDB *dbh, const psFits *fits)
     10785{
     10786    psArray         *rowSet;
     10787
     10788    // move to (the first?) extension named  FAKEMASK_TABLE_NAME
     10789    if (!psFitsMoveExtName(fits, FAKEMASK_TABLE_NAME)) {
     10790        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", FAKEMASK_TABLE_NAME);
     10791        return false;
     10792    }
     10793
     10794    // check HDU type
     10795    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     10796        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     10797        return false;
     10798    }
     10799
     10800    // read fits table
     10801    rowSet = psFitsReadTable(fits);
     10802    if (!rowSet) {
     10803        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     10804        psFree(rowSet);
     10805        return false;
     10806    }
     10807
     10808    if (!psDBInsertRows(dbh, FAKEMASK_TABLE_NAME, rowSet)) {
     10809        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     10810        psFree(rowSet);
     10811        return false;
     10812    }
     10813
     10814    psFree(rowSet);
     10815
     10816    return true;
     10817}
     10818
     10819bool fakeMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     10820{
     10821    psArray         *rowSet;
     10822
     10823    rowSet = psDBSelectRows(dbh, FAKEMASK_TABLE_NAME, where, limit);
     10824    if (!rowSet) {
     10825        return false;
     10826    }
     10827
     10828    // output to fits
     10829    if (!psFitsWriteTable(fits, NULL, rowSet, FAKEMASK_TABLE_NAME)) {
     10830        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     10831        psFree(rowSet);
     10832        return false;
     10833    }
     10834
     10835    psFree(rowSet);
     10836
     10837    return true;
     10838}
     10839
     10840psMetadata *fakeMaskMetadataFromObject(const fakeMaskRow *object)
     10841{
     10842    psMetadata *md = psMetadataAlloc();
     10843    if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) {
     10844        psError(PS_ERR_UNKNOWN, false, "failed to add item label");
     10845        psFree(md);
     10846        return false;
     10847    }
     10848
     10849
     10850    return md;
     10851}
     10852
     10853fakeMaskRow *fakeMaskObjectFromMetadata(psMetadata *md)
     10854{
     10855
     10856bool status = false;
     10857    char* label = psMetadataLookupPtr(&status, md, "label");
     10858    if (!status) {
     10859        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label");
     10860        return false;
     10861    }
     10862
     10863    return fakeMaskRowAlloc(label);
     10864}
     10865psArray *fakeMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     10866{
     10867    psArray         *rowSet;
     10868    psArray         *returnSet;
     10869    psU64           i;
     10870
     10871    rowSet = psDBSelectRows(dbh, FAKEMASK_TABLE_NAME, where, limit);
     10872    if (!rowSet) {
     10873        return NULL;
     10874    }
     10875
     10876    // convert psMetadata rows to row objects
     10877
     10878    returnSet = psArrayAllocEmpty(rowSet->n);
     10879
     10880    for (i = 0; i < rowSet->n; i++) {
     10881        fakeMaskRow *object = fakeMaskObjectFromMetadata(rowSet->data[i]);
     10882        if (!object) {
     10883            psFree(object);
     10884            psFree(returnSet);
     10885            psError(PS_ERR_UNKNOWN, false, "database error");
     10886            return NULL;
     10887        }
     10888        psArrayAdd(returnSet, 0, object);
     10889        psFree(object);
     10890    }
     10891
     10892    psFree(rowSet);
     10893
     10894    return returnSet;
     10895}
     10896bool fakeMaskDeleteObject(psDB *dbh, const fakeMaskRow *object)
     10897{
     10898    psMetadata *where = fakeMaskMetadataFromObject(object);
     10899    long long count = psDBDeleteRows(dbh, FAKEMASK_TABLE_NAME, where, 0);
     10900    psFree(where);
     10901    if (count < 0) {
     10902        psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeMask");
     10903        return false;
     10904    }
     10905    if (count > 1) {
     10906        // XXX should this be a psAbort() instead?  It is possible that
     10907        // having an object match multiple rows was by design.
     10908        psError(PS_ERR_UNKNOWN, true, "fakeMaskRow object matched more then one row.  Check your database schema");
     10909        return false;
     10910    }
     10911
     10912    return true;
     10913}
     10914long long fakeMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     10915{
     10916    long long       deleted = 0;
     10917
     10918    for (long long i = 0; i < objects->n; i++) {
     10919        fakeMaskRow *object = objects->data[i];
     10920        psMetadata *where = fakeMaskMetadataFromObject(object);
     10921        long long count = psDBDeleteRows(dbh, FAKEMASK_TABLE_NAME, where, limit);
     10922        psFree(where);
     10923        if (count < 0) {
     10924            psError(PS_ERR_UNKNOWN, true, "failed to delete row from fakeMask");
     10925            return count;
     10926        }
     10927
     10928        deleted += count;
     10929    }
     10930
     10931    return deleted;
     10932}
     10933bool fakeMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     10934{
     10935    PS_ASSERT_PTR_NON_NULL(objects, false);
     10936
     10937    psMetadata *output = psMetadataAlloc();
     10938    for (long i = 0; i < psArrayLength(objects); i++) {
     10939        psMetadata *md = fakeMaskMetadataFromObject(objects->data[i]);
     10940        if (!psMetadataAddMetadata(
     10941            output,
     10942            PS_LIST_TAIL,
     10943            FAKEMASK_TABLE_NAME,
     10944            PS_META_DUPLICATE_OK,
     10945            NULL,
     10946            md
     10947        )) {
     10948            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     10949            psFree(md);
     10950            psFree(output);
     10951            return false;
     10952        }
     10953        psFree(md);
     10954    }
     10955
     10956    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     10957        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10958        psFree(output);
     10959    }
     10960    psFree(output);
     10961
     10962    return true;
     10963}
     10964bool fakeMaskPrintObject(FILE *stream, fakeMaskRow *object, bool mdcf)
     10965{
     10966    PS_ASSERT_PTR_NON_NULL(object, false);
     10967
     10968    psMetadata *md = fakeMaskMetadataFromObject(object);
     10969
     10970    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     10971        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     10972        psFree(md);
     10973    }
     10974
     10975    psFree(md);
     10976
     10977    return true;
     10978}
    976710979static void warpRunRowFree(warpRunRow *object);
    976810980
    9769 warpRunRow *warpRunRowAlloc(psS64 warp_id, psS64 cam_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
     10981warpRunRow *warpRunRowAlloc(psS64 warp_id, psS64 fake_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
    977010982{
    977110983    warpRunRow      *_object;
    … …  
    977510987
    977610988    _object->warp_id = warp_id;
    9777     _object->cam_id = cam_id;
     10989    _object->fake_id = fake_id;
    977810990    _object->mode = psStringCopy(mode);
    977910991    _object->state = psStringCopy(state);
    … …  
    981111023        return false;
    981211024    }
    9813     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Key INDEX(warp_id, cam_id) fkey(cam_id) ref camProcessedExp(cam_id)", 0)) {
    9814         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     11025    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, "Key INDEX(warp_id, fake_id) fkey(fake_id) ref camProcessedExp(fake_id)", 0)) {
     11026        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    981511027        psFree(md);
    981611028        return false;
    … …  
    987911091}
    988011092
    9881 bool warpRunInsert(psDB * dbh, psS64 warp_id, psS64 cam_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
     11093bool warpRunInsert(psDB * dbh, psS64 warp_id, psS64 fake_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
    988211094{
    988311095    psMetadata *md = psMetadataAlloc();
    … …  
    988711099        return false;
    988811100    }
    9889     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
    9890         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     11101    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, fake_id)) {
     11102        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    989111103        psFree(md);
    989211104        return false;
    … …  
    996511177bool warpRunInsertObject(psDB *dbh, warpRunRow *object)
    996611178{
    9967     return warpRunInsert(dbh, object->warp_id, object->cam_id, object->mode, object->state, object->workdir, object->workdir_state, object->label, object->dvodb, object->tess_id, object->end_stage, object->registered, object->magiced);
     11179    return warpRunInsert(dbh, object->warp_id, object->fake_id, object->mode, object->state, object->workdir, object->workdir_state, object->label, object->dvodb, object->tess_id, object->end_stage, object->registered, object->magiced);
    996811180}
    996911181
    … …  
    1004311255        return false;
    1004411256    }
    10045     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
    10046         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     11257    if (!psMetadataAdd(md, PS_LIST_TAIL, "fake_id", PS_DATA_S64, NULL, object->fake_id)) {
     11258        psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    1004711259        psFree(md);
    1004811260        return false;
    … …  
    1011211324        return false;
    1011311325    }
    10114     psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
    10115     if (!status) {
    10116         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
     11326    psS64 fake_id = psMetadataLookupS64(&status, md, "fake_id");
     11327    if (!status) {
     11328        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fake_id");
    1011711329        return false;
    1011811330    }
    … …  
    1016811380    }
    1016911381
    10170     return warpRunRowAlloc(warp_id, cam_id, mode, state, workdir, workdir_state, label, dvodb, tess_id, end_stage, registered, magiced);
     11382    return warpRunRowAlloc(warp_id, fake_id, mode, state, workdir, workdir_state, label, dvodb, tess_id, end_stage, registered, magiced);
    1017111383}
    1017211384psArray *warpRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1028611498static void warpSkyCellMapRowFree(warpSkyCellMapRow *object);
    1028711499
    10288 warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault)
     11500warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, const char *class_id, psS16 fault)
    1028911501{
    1029011502    warpSkyCellMapRow *_object;
    … …  
    1029611508    _object->skycell_id = psStringCopy(skycell_id);
    1029711509    _object->tess_id = psStringCopy(tess_id);
    10298     _object->cam_id = cam_id;
    1029911510    _object->class_id = psStringCopy(class_id);
    1030011511    _object->fault = fault;
    … …  
    1031311524{
    1031411525    psMetadata *md = psMetadataAlloc();
    10315     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id, cam_id) ref warpRun(warp_id, cam_id)", 0)) {
     11526    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id) ref warpRun(warp_id)", 0)) {
    1031611527        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1031711528        psFree(md);
    … …  
    1032811539        return false;
    1032911540    }
    10330     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) {
    10331         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    10332         psFree(md);
    10333         return false;
    10334     }
    1033511541    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    1033611542        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    … …  
    1035611562}
    1035711563
    10358 bool warpSkyCellMapInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault)
     11564bool warpSkyCellMapInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *class_id, psS16 fault)
    1035911565{
    1036011566    psMetadata *md = psMetadataAlloc();
    … …  
    1037111577    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    1037211578        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    10373         psFree(md);
    10374         return false;
    10375     }
    10376     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
    10377         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1037811579        psFree(md);
    1037911580        return false;
    … …  
    1041211613bool warpSkyCellMapInsertObject(psDB *dbh, warpSkyCellMapRow *object)
    1041311614{
    10414     return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->cam_id, object->class_id, object->fault);
     11615    return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->class_id, object->fault);
    1041511616}
    1041611617
    … …  
    1050011701        return false;
    1050111702    }
    10502     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
    10503         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    10504         psFree(md);
    10505         return false;
    10506     }
    1050711703    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    1050811704        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    … …  
    1053911735        return false;
    1054011736    }
    10541     psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
    10542     if (!status) {
    10543         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
    10544         return false;
    10545     }
    1054611737    char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    1054711738    if (!status) {
    … …  
    1055511746    }
    1055611747
    10557     return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, cam_id, class_id, fault);
     11748    return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, class_id, fault);
    1055811749}
    1055911750psArray *warpSkyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
Note: See TracChangeset for help on using the changeset viewer.