IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Nov 28, 2006, 12:23:25 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.60

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r10155 r10238  
    2020/*
    2121 *
    22  * This file was generated by glueforge 0.31
     22 * This file was generated by glueforge 0.32
    2323 *
    2424 * Do NOT directly edit this file.
    … …  
    6060#define DETNORMALIZEDIMFILE_TABLE_NAME "detNormalizedImfile"
    6161#define DETNORMALIZEDEXP_TABLE_NAME "detNormalizedExp"
    62 #define DETMASTERFRAME_TABLE_NAME "detMasterFrame"
    63 #define DETMASTERIMFILE_TABLE_NAME "detMasterImfile"
    6462#define DETRESIDIMFILE_TABLE_NAME "detResidImfile"
    6563#define DETRESIDEXP_TABLE_NAME "detResidExp"
    … …  
    542540        return false;
    543541    }
    544     psTime* dateobs = psTimeFromISO("", PS_TIME_UTC);
    545     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    546         psFree(dateobs);
     542    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    547543        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    548544        psFree(md);
    549545        return false;
    550546    }
    551     psFree(dateobs);
    552547    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    553548        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    … …  
    27182713        return false;
    27192714    }
    2720     psTime* dateobs = psTimeFromISO("", PS_TIME_UTC);
    2721     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    2722         psFree(dateobs);
     2715    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    27232716        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    27242717        psFree(md);
    27252718        return false;
    27262719    }
    2727     psFree(dateobs);
    27282720    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    27292721        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    … …  
    35193511        return false;
    35203512    }
    3521     psTime* dateobs = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_UTC);
    3522     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    3523         psFree(dateobs);
     3513    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    35243514        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    35253515        psFree(md);
    35263516        return false;
    35273517    }
    3528     psFree(dateobs);
    35293518
    35303519    bool status = psDBCreateTable(dbh, RAWDETRENDEXP_TABLE_NAME, md);
    … …  
    41654154        return false;
    41664155    }
    4167     psTime* dateobs = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_UTC);
    4168     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    4169         psFree(dateobs);
     4156    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    41704157        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    41714158        psFree(md);
    41724159        return false;
    41734160    }
    4174     psFree(dateobs);
    41754161
    41764162    bool status = psDBCreateTable(dbh, RAWSCIENCEEXP_TABLE_NAME, md);
    … …  
    48124798        return false;
    48134799    }
    4814     psTime* dateobs = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_UTC);
    4815     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    4816         psFree(dateobs);
     4800    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    48174801        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    48184802        psFree(md);
    48194803        return false;
    48204804    }
    4821     psFree(dateobs);
    48224805
    48234806    bool status = psDBCreateTable(dbh, RAWIMFILE_TABLE_NAME, md);
    … …  
    86578640        return false;
    86588641    }
    8659     psTime* registered = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_TAI);
    8660     if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
    8661         psFree(registered);
     8642    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) {
    86628643        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
    86638644        psFree(md);
    86648645        return false;
    86658646    }
    8666     psFree(registered);
    8667     psTime* use_begin = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_TAI);
    8668     if (!psMetadataAdd(md, PS_LIST_TAIL, "use_begin", PS_DATA_TIME, NULL, use_begin)) {
    8669         psFree(use_begin);
     8647    if (!psMetadataAdd(md, PS_LIST_TAIL, "use_begin", PS_DATA_TIME, NULL, NULL)) {
    86708648        psError(PS_ERR_UNKNOWN, false, "failed to add item use_begin");
    86718649        psFree(md);
    86728650        return false;
    86738651    }
    8674     psFree(use_begin);
    8675     psTime* use_end = psTimeFromISO("0001-01-01T00:00:00", PS_TIME_TAI);
    8676     if (!psMetadataAdd(md, PS_LIST_TAIL, "use_end", PS_DATA_TIME, NULL, use_end)) {
    8677         psFree(use_end);
     8652    if (!psMetadataAdd(md, PS_LIST_TAIL, "use_end", PS_DATA_TIME, NULL, NULL)) {
    86788653        psError(PS_ERR_UNKNOWN, false, "failed to add item use_end");
    86798654        psFree(md);
    86808655        return false;
    86818656    }
    8682     psFree(use_end);
    86838657
    86848658    bool status = psDBCreateTable(dbh, DETRUN_TABLE_NAME, md);
    … …  
    1187511849    return true;
    1187611850}
    11877 static void detMasterFrameRowFree(detMasterFrameRow *object);
    11878 
    11879 detMasterFrameRow *detMasterFrameRowAlloc(psS32 det_id, psS32 iteration, const char *comment)
    11880 {
    11881     detMasterFrameRow *_object;
    11882 
    11883     _object = psAlloc(sizeof(detMasterFrameRow));
    11884     psMemSetDeallocator(_object, (psFreeFunc)detMasterFrameRowFree);
    11885 
    11886     _object->det_id = det_id;
    11887     _object->iteration = iteration;
    11888     _object->comment = psStringCopy(comment);
    11889 
    11890     return _object;
    11891 }
    11892 
    11893 static void detMasterFrameRowFree(detMasterFrameRow *object)
    11894 {
    11895     psFree(object->comment);
    11896 }
    11897 
    11898 bool detMasterFrameCreateTable(psDB *dbh)
    11899 {
    11900     psMetadata *md = psMetadataAlloc();
    11901     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
    11902         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    11903         psFree(md);
    11904         return false;
    11905     }
    11906     if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key", 0)) {
    11907         psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    11908         psFree(md);
    11909         return false;
    11910     }
    11911     if (!psMetadataAdd(md, PS_LIST_TAIL, "comment", PS_DATA_STRING, NULL, "255")) {
    11912         psError(PS_ERR_UNKNOWN, false, "failed to add item comment");
    11913         psFree(md);
    11914         return false;
    11915     }
    11916 
    11917     bool status = psDBCreateTable(dbh, DETMASTERFRAME_TABLE_NAME, md);
    11918 
    11919     psFree(md);
    11920 
    11921     return status;
    11922 }
    11923 
    11924 bool detMasterFrameDropTable(psDB *dbh)
    11925 {
    11926     return psDBDropTable(dbh, DETMASTERFRAME_TABLE_NAME);
    11927 }
    11928 
    11929 bool detMasterFrameInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *comment)
    11930 {
    11931     psMetadata *md = psMetadataAlloc();
    11932     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
    11933         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    11934         psFree(md);
    11935         return false;
    11936     }
    11937     if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) {
    11938         psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    11939         psFree(md);
    11940         return false;
    11941     }
    11942     if (!psMetadataAdd(md, PS_LIST_TAIL, "comment", PS_DATA_STRING, NULL, comment)) {
    11943         psError(PS_ERR_UNKNOWN, false, "failed to add item comment");
    11944         psFree(md);
    11945         return false;
    11946     }
    11947 
    11948     bool status = psDBInsertOneRow(dbh, DETMASTERFRAME_TABLE_NAME, md);
    11949     psFree(md);
    11950 
    11951     return status;
    11952 }
    11953 
    11954 long long detMasterFrameDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    11955 {
    11956     long long       deleted = 0;
    11957 
    11958     long long count = psDBDeleteRows(dbh, DETMASTERFRAME_TABLE_NAME, where, limit);
    11959     if (count < 0) {
    11960         psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterFrame");
    11961         return count;
    11962 
    11963         deleted += count;
    11964     }
    11965 
    11966     return deleted;
    11967 }
    11968 bool detMasterFrameInsertObject(psDB *dbh, detMasterFrameRow *object)
    11969 {
    11970     return detMasterFrameInsert(dbh, object->det_id, object->iteration, object->comment);
    11971 }
    11972 
    11973 bool detMasterFrameInsertObjects(psDB *dbh, psArray *objects)
    11974 {
    11975     for (long i = 0; i < psArrayLength(objects); i++) {
    11976         if (!detMasterFrameInsertObject(dbh, objects->data[i])) {
    11977             return false;
    11978         }
    11979     }
    11980 
    11981     return true;
    11982 }
    11983 
    11984 bool detMasterFrameInsertFits(psDB *dbh, const psFits *fits)
    11985 {
    11986     psArray         *rowSet;
    11987 
    11988     // move to (the first?) extension named  DETMASTERFRAME_TABLE_NAME
    11989     if (!psFitsMoveExtName(fits, DETMASTERFRAME_TABLE_NAME)) {
    11990         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETMASTERFRAME_TABLE_NAME);
    11991         return false;
    11992     }
    11993 
    11994     // check HDU type
    11995     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    11996         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    11997         return false;
    11998     }
    11999 
    12000     // read fits table
    12001     rowSet = psFitsReadTable(fits);
    12002     if (!rowSet) {
    12003         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    12004         psFree(rowSet);
    12005         return false;
    12006     }
    12007 
    12008     if (!psDBInsertRows(dbh, DETMASTERFRAME_TABLE_NAME, rowSet)) {
    12009         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    12010         psFree(rowSet);
    12011         return false;
    12012     }
    12013 
    12014     psFree(rowSet);
    12015 
    12016     return true;
    12017 }
    12018 
    12019 bool detMasterFrameSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    12020 {
    12021     psArray         *rowSet;
    12022 
    12023     rowSet = psDBSelectRows(dbh, DETMASTERFRAME_TABLE_NAME, where, limit);
    12024     if (!rowSet) {
    12025         return false;
    12026     }
    12027 
    12028     // output to fits
    12029     if (!psFitsWriteTable(fits, NULL, rowSet, DETMASTERFRAME_TABLE_NAME)) {
    12030         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    12031         psFree(rowSet);
    12032         return false;
    12033     }
    12034 
    12035     psFree(rowSet);
    12036 
    12037     return true;
    12038 }
    12039 
    12040 psMetadata *detMasterFrameMetadataFromObject(const detMasterFrameRow *object)
    12041 {
    12042     psMetadata *md = psMetadataAlloc();
    12043     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
    12044         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    12045         psFree(md);
    12046         return false;
    12047     }
    12048     if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) {
    12049         psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    12050         psFree(md);
    12051         return false;
    12052     }
    12053     if (!psMetadataAdd(md, PS_LIST_TAIL, "comment", PS_DATA_STRING, NULL, object->comment)) {
    12054         psError(PS_ERR_UNKNOWN, false, "failed to add item comment");
    12055         psFree(md);
    12056         return false;
    12057     }
    12058 
    12059 
    12060     return md;
    12061 }
    12062 
    12063 detMasterFrameRow *detMasterFrameObjectFromMetadata(psMetadata *md)
    12064 {
    12065 
    12066 bool status = false;
    12067     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
    12068     if (!status) {
    12069         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    12070         return false;
    12071     }
    12072     psS32 iteration = psMetadataLookupS32(&status, md, "iteration");
    12073     if (!status) {
    12074         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    12075         return false;
    12076     }
    12077     char* comment = psMetadataLookupPtr(&status, md, "comment");
    12078     if (!status) {
    12079         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item comment");
    12080         return false;
    12081     }
    12082 
    12083     return detMasterFrameRowAlloc(det_id, iteration, comment);
    12084 }
    12085 psArray *detMasterFrameSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    12086 {
    12087     psArray         *rowSet;
    12088     psArray         *returnSet;
    12089     psU64           i;
    12090 
    12091     rowSet = psDBSelectRows(dbh, DETMASTERFRAME_TABLE_NAME, where, limit);
    12092     if (!rowSet) {
    12093         return NULL;
    12094     }
    12095 
    12096     // convert psMetadata rows to row objects
    12097 
    12098     returnSet = psArrayAllocEmpty(rowSet->n);
    12099 
    12100     for (i = 0; i < rowSet->n; i++) {
    12101         detMasterFrameRow *object = detMasterFrameObjectFromMetadata(rowSet->data[i]);
    12102         psArrayAdd(returnSet, 0, object);
    12103         psFree(object);
    12104     }
    12105 
    12106     psFree(rowSet);
    12107 
    12108     return returnSet;
    12109 }
    12110 bool detMasterFrameDeleteObject(psDB *dbh, const detMasterFrameRow *object)
    12111 {
    12112     psMetadata *where = detMasterFrameMetadataFromObject(object);
    12113     long long count = psDBDeleteRows(dbh, DETMASTERFRAME_TABLE_NAME, where, 0);
    12114     psFree(where)
    12115     if (count < 0) {
    12116         psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterFrame");
    12117         return false;
    12118     }
    12119     if (count > 1) {
    12120         // XXX should this be a psAbort() instead?  It is possible that
    12121         // having an object match multiple rows was by design.
    12122         psError(PS_ERR_UNKNOWN, true, "detMasterFrameRow object matched more then one row.  Check your database schema");
    12123         return false;
    12124     }
    12125 
    12126     return true;
    12127 }
    12128 long long detMasterFrameDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    12129 {
    12130     long long       deleted = 0;
    12131 
    12132     for (long long i = 0; i < objects->n; i++) {
    12133         detMasterFrameRow *object = objects->data[i];
    12134         psMetadata *where = detMasterFrameMetadataFromObject(object);
    12135         long long count = psDBDeleteRows(dbh, DETMASTERFRAME_TABLE_NAME, where, limit);
    12136         psFree(where)
    12137         if (count < 0) {
    12138             psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterFrame");
    12139             return count;
    12140         }
    12141 
    12142         deleted += count;
    12143     }
    12144 
    12145     return deleted;
    12146 }
    12147 bool detMasterFramePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    12148 {
    12149     PS_ASSERT_PTR_NON_NULL(objects, false);
    12150 
    12151     psMetadata *output = psMetadataAlloc();
    12152     for (long i = 0; i < psArrayLength(objects); i++) {
    12153         psMetadata *md = detMasterFrameMetadataFromObject(objects->data[i]);
    12154         if (!psMetadataAddMetadata(
    12155             output,
    12156             PS_LIST_TAIL,
    12157             DETMASTERFRAME_TABLE_NAME,
    12158             PS_META_DUPLICATE_OK,
    12159             NULL,
    12160             md
    12161         )) {
    12162             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    12163             psFree(md);
    12164             psFree(output);
    12165             return false;
    12166         }
    12167         psFree(md);
    12168     }
    12169 
    12170     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    12171         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    12172         psFree(output);
    12173     }
    12174     psFree(output);
    12175 
    12176     return true;
    12177 }
    12178 static void detMasterImfileRowFree(detMasterImfileRow *object);
    12179 
    12180 detMasterImfileRow *detMasterImfileRowAlloc(psS32 det_id, const char *class_id, const char *uri, const char *recipe)
    12181 {
    12182     detMasterImfileRow *_object;
    12183 
    12184     _object = psAlloc(sizeof(detMasterImfileRow));
    12185     psMemSetDeallocator(_object, (psFreeFunc)detMasterImfileRowFree);
    12186 
    12187     _object->det_id = det_id;
    12188     _object->class_id = psStringCopy(class_id);
    12189     _object->uri = psStringCopy(uri);
    12190     _object->recipe = psStringCopy(recipe);
    12191 
    12192     return _object;
    12193 }
    12194 
    12195 static void detMasterImfileRowFree(detMasterImfileRow *object)
    12196 {
    12197     psFree(object->class_id);
    12198     psFree(object->uri);
    12199     psFree(object->recipe);
    12200 }
    12201 
    12202 bool detMasterImfileCreateTable(psDB *dbh)
    12203 {
    12204     psMetadata *md = psMetadataAlloc();
    12205     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
    12206         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    12207         psFree(md);
    12208         return false;
    12209     }
    12210     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    12211         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    12212         psFree(md);
    12213         return false;
    12214     }
    12215     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    12216         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    12217         psFree(md);
    12218         return false;
    12219     }
    12220     if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) {
    12221         psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
    12222         psFree(md);
    12223         return false;
    12224     }
    12225 
    12226     bool status = psDBCreateTable(dbh, DETMASTERIMFILE_TABLE_NAME, md);
    12227 
    12228     psFree(md);
    12229 
    12230     return status;
    12231 }
    12232 
    12233 bool detMasterImfileDropTable(psDB *dbh)
    12234 {
    12235     return psDBDropTable(dbh, DETMASTERIMFILE_TABLE_NAME);
    12236 }
    12237 
    12238 bool detMasterImfileInsert(psDB * dbh, psS32 det_id, const char *class_id, const char *uri, const char *recipe)
    12239 {
    12240     psMetadata *md = psMetadataAlloc();
    12241     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
    12242         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    12243         psFree(md);
    12244         return false;
    12245     }
    12246     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    12247         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    12248         psFree(md);
    12249         return false;
    12250     }
    12251     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    12252         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    12253         psFree(md);
    12254         return false;
    12255     }
    12256     if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) {
    12257         psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
    12258         psFree(md);
    12259         return false;
    12260     }
    12261 
    12262     bool status = psDBInsertOneRow(dbh, DETMASTERIMFILE_TABLE_NAME, md);
    12263     psFree(md);
    12264 
    12265     return status;
    12266 }
    12267 
    12268 long long detMasterImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    12269 {
    12270     long long       deleted = 0;
    12271 
    12272     long long count = psDBDeleteRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, limit);
    12273     if (count < 0) {
    12274         psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterImfile");
    12275         return count;
    12276 
    12277         deleted += count;
    12278     }
    12279 
    12280     return deleted;
    12281 }
    12282 bool detMasterImfileInsertObject(psDB *dbh, detMasterImfileRow *object)
    12283 {
    12284     return detMasterImfileInsert(dbh, object->det_id, object->class_id, object->uri, object->recipe);
    12285 }
    12286 
    12287 bool detMasterImfileInsertObjects(psDB *dbh, psArray *objects)
    12288 {
    12289     for (long i = 0; i < psArrayLength(objects); i++) {
    12290         if (!detMasterImfileInsertObject(dbh, objects->data[i])) {
    12291             return false;
    12292         }
    12293     }
    12294 
    12295     return true;
    12296 }
    12297 
    12298 bool detMasterImfileInsertFits(psDB *dbh, const psFits *fits)
    12299 {
    12300     psArray         *rowSet;
    12301 
    12302     // move to (the first?) extension named  DETMASTERIMFILE_TABLE_NAME
    12303     if (!psFitsMoveExtName(fits, DETMASTERIMFILE_TABLE_NAME)) {
    12304         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETMASTERIMFILE_TABLE_NAME);
    12305         return false;
    12306     }
    12307 
    12308     // check HDU type
    12309     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    12310         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    12311         return false;
    12312     }
    12313 
    12314     // read fits table
    12315     rowSet = psFitsReadTable(fits);
    12316     if (!rowSet) {
    12317         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    12318         psFree(rowSet);
    12319         return false;
    12320     }
    12321 
    12322     if (!psDBInsertRows(dbh, DETMASTERIMFILE_TABLE_NAME, rowSet)) {
    12323         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    12324         psFree(rowSet);
    12325         return false;
    12326     }
    12327 
    12328     psFree(rowSet);
    12329 
    12330     return true;
    12331 }
    12332 
    12333 bool detMasterImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    12334 {
    12335     psArray         *rowSet;
    12336 
    12337     rowSet = psDBSelectRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, limit);
    12338     if (!rowSet) {
    12339         return false;
    12340     }
    12341 
    12342     // output to fits
    12343     if (!psFitsWriteTable(fits, NULL, rowSet, DETMASTERIMFILE_TABLE_NAME)) {
    12344         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    12345         psFree(rowSet);
    12346         return false;
    12347     }
    12348 
    12349     psFree(rowSet);
    12350 
    12351     return true;
    12352 }
    12353 
    12354 psMetadata *detMasterImfileMetadataFromObject(const detMasterImfileRow *object)
    12355 {
    12356     psMetadata *md = psMetadataAlloc();
    12357     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
    12358         psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    12359         psFree(md);
    12360         return false;
    12361     }
    12362     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    12363         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    12364         psFree(md);
    12365         return false;
    12366     }
    12367     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    12368         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    12369         psFree(md);
    12370         return false;
    12371     }
    12372     if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) {
    12373         psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
    12374         psFree(md);
    12375         return false;
    12376     }
    12377 
    12378 
    12379     return md;
    12380 }
    12381 
    12382 detMasterImfileRow *detMasterImfileObjectFromMetadata(psMetadata *md)
    12383 {
    12384 
    12385 bool status = false;
    12386     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
    12387     if (!status) {
    12388         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    12389         return false;
    12390     }
    12391     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    12392     if (!status) {
    12393         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    12394         return false;
    12395     }
    12396     char* uri = psMetadataLookupPtr(&status, md, "uri");
    12397     if (!status) {
    12398         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    12399         return false;
    12400     }
    12401     char* recipe = psMetadataLookupPtr(&status, md, "recipe");
    12402     if (!status) {
    12403         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    12404         return false;
    12405     }
    12406 
    12407     return detMasterImfileRowAlloc(det_id, class_id, uri, recipe);
    12408 }
    12409 psArray *detMasterImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    12410 {
    12411     psArray         *rowSet;
    12412     psArray         *returnSet;
    12413     psU64           i;
    12414 
    12415     rowSet = psDBSelectRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, limit);
    12416     if (!rowSet) {
    12417         return NULL;
    12418     }
    12419 
    12420     // convert psMetadata rows to row objects
    12421 
    12422     returnSet = psArrayAllocEmpty(rowSet->n);
    12423 
    12424     for (i = 0; i < rowSet->n; i++) {
    12425         detMasterImfileRow *object = detMasterImfileObjectFromMetadata(rowSet->data[i]);
    12426         psArrayAdd(returnSet, 0, object);
    12427         psFree(object);
    12428     }
    12429 
    12430     psFree(rowSet);
    12431 
    12432     return returnSet;
    12433 }
    12434 bool detMasterImfileDeleteObject(psDB *dbh, const detMasterImfileRow *object)
    12435 {
    12436     psMetadata *where = detMasterImfileMetadataFromObject(object);
    12437     long long count = psDBDeleteRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, 0);
    12438     psFree(where)
    12439     if (count < 0) {
    12440         psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterImfile");
    12441         return false;
    12442     }
    12443     if (count > 1) {
    12444         // XXX should this be a psAbort() instead?  It is possible that
    12445         // having an object match multiple rows was by design.
    12446         psError(PS_ERR_UNKNOWN, true, "detMasterImfileRow object matched more then one row.  Check your database schema");
    12447         return false;
    12448     }
    12449 
    12450     return true;
    12451 }
    12452 long long detMasterImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    12453 {
    12454     long long       deleted = 0;
    12455 
    12456     for (long long i = 0; i < objects->n; i++) {
    12457         detMasterImfileRow *object = objects->data[i];
    12458         psMetadata *where = detMasterImfileMetadataFromObject(object);
    12459         long long count = psDBDeleteRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, limit);
    12460         psFree(where)
    12461         if (count < 0) {
    12462             psError(PS_ERR_UNKNOWN, true, "failed to delete row from detMasterImfile");
    12463             return count;
    12464         }
    12465 
    12466         deleted += count;
    12467     }
    12468 
    12469     return deleted;
    12470 }
    12471 bool detMasterImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    12472 {
    12473     PS_ASSERT_PTR_NON_NULL(objects, false);
    12474 
    12475     psMetadata *output = psMetadataAlloc();
    12476     for (long i = 0; i < psArrayLength(objects); i++) {
    12477         psMetadata *md = detMasterImfileMetadataFromObject(objects->data[i]);
    12478         if (!psMetadataAddMetadata(
    12479             output,
    12480             PS_LIST_TAIL,
    12481             DETMASTERIMFILE_TABLE_NAME,
    12482             PS_META_DUPLICATE_OK,
    12483             NULL,
    12484             md
    12485         )) {
    12486             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    12487             psFree(md);
    12488             psFree(output);
    12489             return false;
    12490         }
    12491         psFree(md);
    12492     }
    12493 
    12494     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    12495         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    12496         psFree(output);
    12497     }
    12498     psFree(output);
    12499 
    12500     return true;
    12501 }
    1250211851static void detResidImfileRowFree(detResidImfileRow *object);
    1250311852
Note: See TracChangeset for help on using the changeset viewer.