IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 16731 for trunk/ippdb/src


Ignore:
Timestamp:
Feb 28, 2008, 3:04:07 PM (18 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.31

Location:
trunk/ippdb/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r16616 r16731  
    4848#define CAMMASK_TABLE_NAME "camMask"
    4949#define WARPRUN_TABLE_NAME "warpRun"
    50 #define WARPINPUTEXP_TABLE_NAME "warpInputExp"
    5150#define WARPSKYCELLMAP_TABLE_NAME "warpSkyCellMap"
    5251#define WARPSKYFILE_TABLE_NAME "warpSkyfile"
    … …  
    95049503static void warpRunRowFree(warpRunRow *object);
    95059504
    9506 warpRunRow *warpRunRowAlloc(psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered)
     9505warpRunRow *warpRunRowAlloc(psS64 warp_id, psS64 cam_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
    95079506{
    95089507    warpRunRow      *_object;
    … …  
    95129511
    95139512    _object->warp_id = warp_id;
     9513    _object->cam_id = cam_id;
    95149514    _object->mode = psStringCopy(mode);
    95159515    _object->state = psStringCopy(state);
    … …  
    95209520    _object->end_stage = psStringCopy(end_stage);
    95219521    _object->registered = psTimeCopy(registered);
     9522    _object->magiced = magiced;
    95229523
    95239524    return _object;
    … …  
    95449545        return false;
    95459546    }
     9547    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)) {
     9548        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     9549        psFree(md);
     9550        return false;
     9551    }
    95469552    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, "Key", "64")) {
    95479553        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
    … …  
    95849590        return false;
    95859591    }
     9592    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, "Key", 0)) {
     9593        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
     9594        psFree(md);
     9595        return false;
     9596    }
    95869597
    95879598    bool status = psDBCreateTable(dbh, WARPRUN_TABLE_NAME, md);
    … …  
    95979608}
    95989609
    9599 bool warpRunInsert(psDB * dbh, psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered)
     9610bool warpRunInsert(psDB * dbh, psS64 warp_id, psS64 cam_id, const char *mode, const char *state, const char *workdir, const char *workdir_state, const char *dvodb, const char *tess_id, const char *end_stage, psTime* registered, bool magiced)
    96009611{
    96019612    psMetadata *md = psMetadataAlloc();
    … …  
    96059616        return false;
    96069617    }
     9618    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     9619        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     9620        psFree(md);
     9621        return false;
     9622    }
    96079623    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, mode)) {
    96089624        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
    … …  
    96429658    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
    96439659        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
     9660        psFree(md);
     9661        return false;
     9662    }
     9663    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, magiced)) {
     9664        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
    96449665        psFree(md);
    96459666        return false;
    … …  
    96689689bool warpRunInsertObject(psDB *dbh, warpRunRow *object)
    96699690{
    9670     return warpRunInsert(dbh, object->warp_id, object->mode, object->state, object->workdir, object->workdir_state, object->dvodb, object->tess_id, object->end_stage, object->registered);
     9691    return warpRunInsert(dbh, object->warp_id, object->cam_id, object->mode, object->state, object->workdir, object->workdir_state, object->dvodb, object->tess_id, object->end_stage, object->registered, object->magiced);
    96719692}
    96729693
    … …  
    97469767        return false;
    97479768    }
     9769    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     9770        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     9771        psFree(md);
     9772        return false;
     9773    }
    97489774    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, object->mode)) {
    97499775        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
    … …  
    97869812        return false;
    97879813    }
     9814    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, object->magiced)) {
     9815        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
     9816        psFree(md);
     9817        return false;
     9818    }
    97889819
    97899820
    … …  
    98009831        return false;
    98019832    }
     9833    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     9834    if (!status) {
     9835        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
     9836        return false;
     9837    }
    98029838    char* mode = psMetadataLookupPtr(&status, md, "mode");
    98039839    if (!status) {
    … …  
    98409876        return false;
    98419877    }
    9842 
    9843     return warpRunRowAlloc(warp_id, mode, state, workdir, workdir_state, dvodb, tess_id, end_stage, registered);
     9878    bool magiced = psMetadataLookupBool(&status, md, "magiced");
     9879    if (!status) {
     9880        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magiced");
     9881        return false;
     9882    }
     9883
     9884    return warpRunRowAlloc(warp_id, cam_id, mode, state, workdir, workdir_state, dvodb, tess_id, end_stage, registered, magiced);
    98449885}
    98459886psArray *warpRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    99579998    return true;
    99589999}
    9959 static void warpInputExpRowFree(warpInputExpRow *object);
    9960 
    9961 warpInputExpRow *warpInputExpRowAlloc(psS64 warp_id, psS64 cam_id, bool magiced)
    9962 {
    9963     warpInputExpRow *_object;
    9964 
    9965     _object = psAlloc(sizeof(warpInputExpRow));
    9966     psMemSetDeallocator(_object, (psFreeFunc)warpInputExpRowFree);
    9967 
    9968     _object->warp_id = warp_id;
    9969     _object->cam_id = cam_id;
    9970     _object->magiced = magiced;
    9971 
    9972     return _object;
    9973 }
    9974 
    9975 static void warpInputExpRowFree(warpInputExpRow *object)
    9976 {
    9977 }
    9978 
    9979 bool warpInputExpCreateTable(psDB *dbh)
    9980 {
    9981     psMetadata *md = psMetadataAlloc();
    9982     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id) ref warpRun(warp_id)", 0)) {
    9983         psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    9984         psFree(md);
    9985         return false;
    9986     }
    9987     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key fkey(cam_id) ref camProcessedExp(cam_id)", 0)) {
    9988         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    9989         psFree(md);
    9990         return false;
    9991     }
    9992     if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, "Key", 0)) {
    9993         psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
    9994         psFree(md);
    9995         return false;
    9996     }
    9997 
    9998     bool status = psDBCreateTable(dbh, WARPINPUTEXP_TABLE_NAME, md);
    9999 
    10000     psFree(md);
    10001 
    10002     return status;
    10003 }
    10004 
    10005 bool warpInputExpDropTable(psDB *dbh)
    10006 {
    10007     return psDBDropTable(dbh, WARPINPUTEXP_TABLE_NAME);
    10008 }
    10009 
    10010 bool warpInputExpInsert(psDB * dbh, psS64 warp_id, psS64 cam_id, bool magiced)
    10011 {
    10012     psMetadata *md = psMetadataAlloc();
    10013     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    10014         psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    10015         psFree(md);
    10016         return false;
    10017     }
    10018     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
    10019         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    10020         psFree(md);
    10021         return false;
    10022     }
    10023     if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, magiced)) {
    10024         psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
    10025         psFree(md);
    10026         return false;
    10027     }
    10028 
    10029     bool status = psDBInsertOneRow(dbh, WARPINPUTEXP_TABLE_NAME, md);
    10030     psFree(md);
    10031 
    10032     return status;
    10033 }
    10034 
    10035 long long warpInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    10036 {
    10037     long long       deleted = 0;
    10038 
    10039     long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    10040     if (count < 0) {
    10041         psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    10042         return count;
    10043 
    10044         deleted += count;
    10045     }
    10046 
    10047     return deleted;
    10048 }
    10049 bool warpInputExpInsertObject(psDB *dbh, warpInputExpRow *object)
    10050 {
    10051     return warpInputExpInsert(dbh, object->warp_id, object->cam_id, object->magiced);
    10052 }
    10053 
    10054 bool warpInputExpInsertObjects(psDB *dbh, psArray *objects)
    10055 {
    10056     for (long i = 0; i < psArrayLength(objects); i++) {
    10057         if (!warpInputExpInsertObject(dbh, objects->data[i])) {
    10058             return false;
    10059         }
    10060     }
    10061 
    10062     return true;
    10063 }
    10064 
    10065 bool warpInputExpInsertFits(psDB *dbh, const psFits *fits)
    10066 {
    10067     psArray         *rowSet;
    10068 
    10069     // move to (the first?) extension named  WARPINPUTEXP_TABLE_NAME
    10070     if (!psFitsMoveExtName(fits, WARPINPUTEXP_TABLE_NAME)) {
    10071         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPINPUTEXP_TABLE_NAME);
    10072         return false;
    10073     }
    10074 
    10075     // check HDU type
    10076     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    10077         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    10078         return false;
    10079     }
    10080 
    10081     // read fits table
    10082     rowSet = psFitsReadTable(fits);
    10083     if (!rowSet) {
    10084         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    10085         psFree(rowSet);
    10086         return false;
    10087     }
    10088 
    10089     if (!psDBInsertRows(dbh, WARPINPUTEXP_TABLE_NAME, rowSet)) {
    10090         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    10091         psFree(rowSet);
    10092         return false;
    10093     }
    10094 
    10095     psFree(rowSet);
    10096 
    10097     return true;
    10098 }
    10099 
    10100 bool warpInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    10101 {
    10102     psArray         *rowSet;
    10103 
    10104     rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    10105     if (!rowSet) {
    10106         return false;
    10107     }
    10108 
    10109     // output to fits
    10110     if (!psFitsWriteTable(fits, NULL, rowSet, WARPINPUTEXP_TABLE_NAME)) {
    10111         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    10112         psFree(rowSet);
    10113         return false;
    10114     }
    10115 
    10116     psFree(rowSet);
    10117 
    10118     return true;
    10119 }
    10120 
    10121 psMetadata *warpInputExpMetadataFromObject(const warpInputExpRow *object)
    10122 {
    10123     psMetadata *md = psMetadataAlloc();
    10124     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    10125         psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    10126         psFree(md);
    10127         return false;
    10128     }
    10129     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
    10130         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    10131         psFree(md);
    10132         return false;
    10133     }
    10134     if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, object->magiced)) {
    10135         psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
    10136         psFree(md);
    10137         return false;
    10138     }
    10139 
    10140 
    10141     return md;
    10142 }
    10143 
    10144 warpInputExpRow *warpInputExpObjectFromMetadata(psMetadata *md)
    10145 {
    10146 
    10147 bool status = false;
    10148     psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    10149     if (!status) {
    10150         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    10151         return false;
    10152     }
    10153     psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
    10154     if (!status) {
    10155         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
    10156         return false;
    10157     }
    10158     bool magiced = psMetadataLookupBool(&status, md, "magiced");
    10159     if (!status) {
    10160         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magiced");
    10161         return false;
    10162     }
    10163 
    10164     return warpInputExpRowAlloc(warp_id, cam_id, magiced);
    10165 }
    10166 psArray *warpInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    10167 {
    10168     psArray         *rowSet;
    10169     psArray         *returnSet;
    10170     psU64           i;
    10171 
    10172     rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    10173     if (!rowSet) {
    10174         return NULL;
    10175     }
    10176 
    10177     // convert psMetadata rows to row objects
    10178 
    10179     returnSet = psArrayAllocEmpty(rowSet->n);
    10180 
    10181     for (i = 0; i < rowSet->n; i++) {
    10182         warpInputExpRow *object = warpInputExpObjectFromMetadata(rowSet->data[i]);
    10183         if (!object) {
    10184             psFree(object);
    10185             psFree(returnSet);
    10186             psError(PS_ERR_UNKNOWN, false, "database error");
    10187             return NULL;
    10188         }
    10189         psArrayAdd(returnSet, 0, object);
    10190         psFree(object);
    10191     }
    10192 
    10193     psFree(rowSet);
    10194 
    10195     return returnSet;
    10196 }
    10197 bool warpInputExpDeleteObject(psDB *dbh, const warpInputExpRow *object)
    10198 {
    10199     psMetadata *where = warpInputExpMetadataFromObject(object);
    10200     long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, 0);
    10201     psFree(where);
    10202     if (count < 0) {
    10203         psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    10204         return false;
    10205     }
    10206     if (count > 1) {
    10207         // XXX should this be a psAbort() instead?  It is possible that
    10208         // having an object match multiple rows was by design.
    10209         psError(PS_ERR_UNKNOWN, true, "warpInputExpRow object matched more then one row.  Check your database schema");
    10210         return false;
    10211     }
    10212 
    10213     return true;
    10214 }
    10215 long long warpInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    10216 {
    10217     long long       deleted = 0;
    10218 
    10219     for (long long i = 0; i < objects->n; i++) {
    10220         warpInputExpRow *object = objects->data[i];
    10221         psMetadata *where = warpInputExpMetadataFromObject(object);
    10222         long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit);
    10223         psFree(where);
    10224         if (count < 0) {
    10225             psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp");
    10226             return count;
    10227         }
    10228 
    10229         deleted += count;
    10230     }
    10231 
    10232     return deleted;
    10233 }
    10234 bool warpInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    10235 {
    10236     PS_ASSERT_PTR_NON_NULL(objects, false);
    10237 
    10238     psMetadata *output = psMetadataAlloc();
    10239     for (long i = 0; i < psArrayLength(objects); i++) {
    10240         psMetadata *md = warpInputExpMetadataFromObject(objects->data[i]);
    10241         if (!psMetadataAddMetadata(
    10242             output,
    10243             PS_LIST_TAIL,
    10244             WARPINPUTEXP_TABLE_NAME,
    10245             PS_META_DUPLICATE_OK,
    10246             NULL,
    10247             md
    10248         )) {
    10249             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    10250             psFree(md);
    10251             psFree(output);
    10252             return false;
    10253         }
    10254         psFree(md);
    10255     }
    10256 
    10257     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    10258         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    10259         psFree(output);
    10260     }
    10261     psFree(output);
    10262 
    10263     return true;
    10264 }
    10265 bool warpInputExpPrintObject(FILE *stream, warpInputExpRow *object, bool mdcf)
    10266 {
    10267     PS_ASSERT_PTR_NON_NULL(object, false);
    10268 
    10269     psMetadata *md = warpInputExpMetadataFromObject(object);
    10270 
    10271     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    10272         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    10273         psFree(md);
    10274     }
    10275 
    10276     psFree(md);
    10277 
    10278     return true;
    10279 }
    1028010000static void warpSkyCellMapRowFree(warpSkyCellMapRow *object);
    1028110001
    … …  
    1030710027{
    1030810028    psMetadata *md = psMetadataAlloc();
    10309     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id, cam_id) ref warpInputExp(warp_id, cam_id)", 0)) {
     10029    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)) {
    1031010030        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1031110031        psFree(md);
    … …  
    2407823798static void flatcorrRunRowFree(flatcorrRunRow *object);
    2407923799
    24080 flatcorrRunRow *flatcorrRunRowAlloc(psS64 corr_id, const char *dvodb, const char *filter, const char *state, const char *workdir, const char *label, const char *stats)
     23800flatcorrRunRow *flatcorrRunRowAlloc(psS64 corr_id, const char *dvodb, const char *filter, const char *state, const char *workdir, const char *label, const char *stats, const char *region)
    2408123801{
    2408223802    flatcorrRunRow  *_object;
    … …  
    2409223812    _object->label = psStringCopy(label);
    2409323813    _object->stats = psStringCopy(stats);
     23814    _object->region = psStringCopy(region);
    2409423815
    2409523816    return _object;
    … …  
    2410423825    psFree(object->label);
    2410523826    psFree(object->stats);
     23827    psFree(object->region);
    2410623828}
    2410723829
    … …  
    2414423866        return false;
    2414523867    }
     23868    if (!psMetadataAdd(md, PS_LIST_TAIL, "region", PS_DATA_STRING, NULL, "255")) {
     23869        psError(PS_ERR_UNKNOWN, false, "failed to add item region");
     23870        psFree(md);
     23871        return false;
     23872    }
    2414623873
    2414723874    bool status = psDBCreateTable(dbh, FLATCORRRUN_TABLE_NAME, md);
    … …  
    2415723884}
    2415823885
    24159 bool flatcorrRunInsert(psDB * dbh, psS64 corr_id, const char *dvodb, const char *filter, const char *state, const char *workdir, const char *label, const char *stats)
     23886bool flatcorrRunInsert(psDB * dbh, psS64 corr_id, const char *dvodb, const char *filter, const char *state, const char *workdir, const char *label, const char *stats, const char *region)
    2416023887{
    2416123888    psMetadata *md = psMetadataAlloc();
    … …  
    2419223919    if (!psMetadataAdd(md, PS_LIST_TAIL, "stats", PS_DATA_STRING, NULL, stats)) {
    2419323920        psError(PS_ERR_UNKNOWN, false, "failed to add item stats");
     23921        psFree(md);
     23922        return false;
     23923    }
     23924    if (!psMetadataAdd(md, PS_LIST_TAIL, "region", PS_DATA_STRING, NULL, region)) {
     23925        psError(PS_ERR_UNKNOWN, false, "failed to add item region");
    2419423926        psFree(md);
    2419523927        return false;
    … …  
    2421823950bool flatcorrRunInsertObject(psDB *dbh, flatcorrRunRow *object)
    2421923951{
    24220     return flatcorrRunInsert(dbh, object->corr_id, object->dvodb, object->filter, object->state, object->workdir, object->label, object->stats);
     23952    return flatcorrRunInsert(dbh, object->corr_id, object->dvodb, object->filter, object->state, object->workdir, object->label, object->stats, object->region);
    2422123953}
    2422223954
    … …  
    2432624058        return false;
    2432724059    }
     24060    if (!psMetadataAdd(md, PS_LIST_TAIL, "region", PS_DATA_STRING, NULL, object->region)) {
     24061        psError(PS_ERR_UNKNOWN, false, "failed to add item region");
     24062        psFree(md);
     24063        return false;
     24064    }
    2432824065
    2432924066
    … …  
    2437024107        return false;
    2437124108    }
    24372 
    24373     return flatcorrRunRowAlloc(corr_id, dvodb, filter, state, workdir, label, stats);
     24109    char* region = psMetadataLookupPtr(&status, md, "region");
     24110    if (!status) {
     24111        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item region");
     24112        return false;
     24113    }
     24114
     24115    return flatcorrRunRowAlloc(corr_id, dvodb, filter, state, workdir, label, stats, region);
    2437424116}
    2437524117psArray *flatcorrRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)

  • trunk/ippdb/src/ippdb.h

    r16616 r16731  
    39213921typedef struct {
    39223922    psS64           warp_id;
     3923    psS64           cam_id;
    39233924    char            *mode;
    39243925    char            *state;
    … …  
    39293930    char            *end_stage;
    39303931    psTime*         registered;
     3932    bool            magiced;
    39313933} warpRunRow;
    39323934
    … …  
    39383940warpRunRow *warpRunRowAlloc(
    39393941    psS64           warp_id,
     3942    psS64           cam_id,
    39403943    const char      *mode,
    39413944    const char      *state,
    … …  
    39453948    const char      *tess_id,
    39463949    const char      *end_stage,
    3947     psTime*         registered
     3950    psTime*         registered,
     3951    bool            magiced
    39483952);
    39493953
    … …  
    39763980    psDB            *dbh,               ///< Database handle
    39773981    psS64           warp_id,
     3982    psS64           cam_id,
    39783983    const char      *mode,
    39793984    const char      *state,
    … …  
    39833988    const char      *tess_id,
    39843989    const char      *end_stage,
    3985     psTime*         registered
     3990    psTime*         registered,
     3991    bool            magiced
    39863992);
    39873993
    … …  
    41314137    FILE            *stream,            ///< a stream
    41324138    warpRunRow *object,    ///< an warpRunRow object
    4133     bool            mdcf                ///< format as mdconfig or simple
    4134 );
    4135 /** warpInputExpRow data structure
    4136  *
    4137  * Structure for representing a single row of warpInputExp table data.
    4138  */
    4139 
    4140 typedef struct {
    4141     psS64           warp_id;
    4142     psS64           cam_id;
    4143     bool            magiced;
    4144 } warpInputExpRow;
    4145 
    4146 /** Creates a new warpInputExpRow object
    4147  *
    4148  *  @return A new warpInputExpRow object or NULL on failure.
    4149  */
    4150 
    4151 warpInputExpRow *warpInputExpRowAlloc(
    4152     psS64           warp_id,
    4153     psS64           cam_id,
    4154     bool            magiced
    4155 );
    4156 
    4157 /** Creates a new warpInputExp table
    4158  *
    4159  * @return true on success
    4160  */
    4161 
    4162 bool warpInputExpCreateTable(
    4163     psDB            *dbh                ///< Database handle
    4164 );
    4165 
    4166 /** Deletes a warpInputExp table
    4167  *
    4168  * @return true on success
    4169  */
    4170 
    4171 bool warpInputExpDropTable(
    4172     psDB            *dbh                ///< Database handle
    4173 );
    4174 
    4175 /** Insert a single row into a table
    4176  *
    4177  * This function constructs and inserts a single row based on it's parameters.
    4178  *
    4179  * @return true on success
    4180  */
    4181 
    4182 bool warpInputExpInsert(
    4183     psDB            *dbh,               ///< Database handle
    4184     psS64           warp_id,
    4185     psS64           cam_id,
    4186     bool            magiced
    4187 );
    4188 
    4189 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    4190  *
    4191  * @return A The number of rows removed or a negative value on error
    4192  */
    4193 
    4194 long long warpInputExpDelete(
    4195     psDB            *dbh,               ///< Database handle
    4196     const psMetadata *where,            ///< Row match criteria
    4197     unsigned long long limit            ///< Maximum number of elements to delete
    4198 );
    4199 
    4200 /** Insert a single warpInputExpRow object into a table
    4201  *
    4202  * This function constructs and inserts a single row based on it's parameters.
    4203  *
    4204  * @return true on success
    4205  */
    4206 
    4207 bool warpInputExpInsertObject(
    4208     psDB            *dbh,               ///< Database handle
    4209     warpInputExpRow *object             ///< warpInputExpRow object
    4210 );
    4211 
    4212 /** Insert an array of warpInputExpRow object into a table
    4213  *
    4214  * This function constructs and inserts multiple rows based on it's parameters.
    4215  *
    4216  * @return true on success
    4217  */
    4218 
    4219 bool warpInputExpInsertObjects(
    4220     psDB            *dbh,               ///< Database handle
    4221     psArray         *objects            ///< array of warpInputExpRow objects
    4222 );
    4223 
    4224 /** Insert data from a binary FITS table warpInputExpRow into the database
    4225  *
    4226  * This function expects a psFits object with a FITS table as the first
    4227  * extension.  The table must have at least one row of data in it, that is of
    4228  * the appropriate format (number of columns and their type).  All other
    4229  * extensions are ignored.
    4230  *
    4231  * @return true on success
    4232  */
    4233 
    4234 bool warpInputExpInsertFits(
    4235     psDB            *dbh,               ///< Database handle
    4236     const psFits    *fits               ///< psFits object
    4237 );
    4238 
    4239 /** Selects up to limit from the database and returns them in a binary FITS table
    4240  *
    4241  * This function assumes an empty psFits object and will create a FITS table
    4242  * as the first extension.
    4243  *
    4244  *  See psDBSelectRows() for documentation on the format of where.
    4245  *
    4246  * @return true on success
    4247  */
    4248 
    4249 bool warpInputExpSelectRowsFits(
    4250     psDB            *dbh,               ///< Database handle
    4251     psFits          *fits,              ///< psFits object
    4252     const psMetadata *where,            ///< Row match criteria
    4253     unsigned long long limit            ///< Maximum number of elements to return
    4254 );
    4255 
    4256 /** Convert a warpInputExpRow into an equivalent psMetadata
    4257  *
    4258  * @return A psMetadata pointer or NULL on error
    4259  */
    4260 
    4261 psMetadata *warpInputExpMetadataFromObject(
    4262     const warpInputExpRow *object             ///< fooRow to convert into a psMetadata
    4263 );
    4264 
    4265 /** Convert a psMetadata into an equivalent fooRow
    4266  *
    4267  * @return A warpInputExpRow pointer or NULL on error
    4268  */
    4269 
    4270 warpInputExpRow *warpInputExpObjectFromMetadata(
    4271     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    4272 );
    4273 /** Selects up to limit rows from the database and returns as warpInputExpRow objects in a psArray
    4274  *
    4275  *  See psDBSelectRows() for documentation on the format of where.
    4276  *
    4277  * @return A psArray pointer or NULL on error
    4278  */
    4279 
    4280 psArray *warpInputExpSelectRowObjects(
    4281     psDB            *dbh,               ///< Database handle
    4282     const psMetadata *where,            ///< Row match criteria
    4283     unsigned long long limit            ///< Maximum number of elements to return
    4284 );
    4285 /** Deletes a row from the database coresponding to an warpInputExp
    4286  *
    4287  *  Note that a 'where' search psMetadata is constructed from each object and
    4288  *  used to find rows to delete.
    4289  *
    4290  * @return A The number of rows removed or a negative value on error
    4291  */
    4292 
    4293 bool warpInputExpDeleteObject(
    4294     psDB            *dbh,               ///< Database handle
    4295     const warpInputExpRow *object    ///< Object to delete
    4296 );
    4297 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    4298  *
    4299  *  Note that a 'where' search psMetadata is constructed from each object and
    4300  *  used to find rows to delete.
    4301  *
    4302  * @return A The number of rows removed or a negative value on error
    4303  */
    4304 
    4305 long long warpInputExpDeleteRowObjects(
    4306     psDB            *dbh,               ///< Database handle
    4307     const psArray   *objects,           ///< Array of objects to delete
    4308     unsigned long long limit            ///< Maximum number of elements to delete
    4309 );
    4310 /** Formats and prints an array of warpInputExpRow objects
    4311  *
    4312  * When mdcf is set the formated output is in psMetadataConfig
    4313  * format, otherwise it is in a simple tabular format.
    4314  *
    4315  * @return true on success
    4316  */
    4317 
    4318 bool warpInputExpPrintObjects(
    4319     FILE            *stream,            ///< a stream
    4320     psArray         *objects,           ///< An array of warpInputExpRow objects
    4321     bool            mdcf                ///< format as mdconfig or simple
    4322 );
    4323 /** Formats and prints an warpInputExpRow object
    4324  *
    4325  * When mdcf is set the formated output is in psMetadataConfig
    4326  * format, otherwise it is in a simple tabular format.
    4327  *
    4328  * @return true on success
    4329  */
    4330 
    4331 bool warpInputExpPrintObject(
    4332     FILE            *stream,            ///< a stream
    4333     warpInputExpRow *object,    ///< an warpInputExpRow object
    43344139    bool            mdcf                ///< format as mdconfig or simple
    43354140);
    … …  
    1095910764    char            *label;
    1096010765    char            *stats;
     10766    char            *region;
    1096110767} flatcorrRunRow;
    1096210768
    … …  
    1097310779    const char      *workdir,
    1097410780    const char      *label,
    10975     const char      *stats
     10781    const char      *stats,
     10782    const char      *region
    1097610783);
    1097710784
    … …  
    1100910816    const char      *workdir,
    1101010817    const char      *label,
    11011     const char      *stats
     10818    const char      *stats,
     10819    const char      *region
    1101210820);
    1101310821
Note: See TracChangeset for help on using the changeset viewer.