IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 10238 for trunk/ippdb/src


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

VERSION 0.0.60

Location:
trunk/ippdb/src
Files:
2 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

  • trunk/ippdb/src/ippdb.h

    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.
    … …  
    59765976    bool            mdcf                ///< format as mdconfig or simple
    59775977);
    5978 /** detMasterFrameRow data structure
    5979  *
    5980  * Structure for representing a single row of detMasterFrame table data.
    5981  */
    5982 
    5983 typedef struct {
    5984     psS32           det_id;
    5985     psS32           iteration;
    5986     char            *comment;
    5987 } detMasterFrameRow;
    5988 
    5989 /** Creates a new detMasterFrameRow object
    5990  *
    5991  *  @return A new detMasterFrameRow object or NULL on failure.
    5992  */
    5993 
    5994 detMasterFrameRow *detMasterFrameRowAlloc(
    5995     psS32           det_id,
    5996     psS32           iteration,
    5997     const char      *comment
    5998 );
    5999 
    6000 /** Creates a new detMasterFrame table
    6001  *
    6002  * @return true on success
    6003  */
    6004 
    6005 bool detMasterFrameCreateTable(
    6006     psDB            *dbh                ///< Database handle
    6007 );
    6008 
    6009 /** Deletes a detMasterFrame table
    6010  *
    6011  * @return true on success
    6012  */
    6013 
    6014 bool detMasterFrameDropTable(
    6015     psDB            *dbh                ///< Database handle
    6016 );
    6017 
    6018 /** Insert a single row into a table
    6019  *
    6020  * This function constructs and inserts a single row based on it's parameters.
    6021  *
    6022  * @return true on success
    6023  */
    6024 
    6025 bool detMasterFrameInsert(
    6026     psDB            *dbh,               ///< Database handle
    6027     psS32           det_id,
    6028     psS32           iteration,
    6029     const char      *comment
    6030 );
    6031 
    6032 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    6033  *
    6034  * @return A The number of rows removed or a negative value on error
    6035  */
    6036 
    6037 long long detMasterFrameDelete(
    6038     psDB            *dbh,               ///< Database handle
    6039     const psMetadata *where,            ///< Row match criteria
    6040     unsigned long long limit            ///< Maximum number of elements to delete
    6041 );
    6042 
    6043 /** Insert a single detMasterFrameRow object into a table
    6044  *
    6045  * This function constructs and inserts a single row based on it's parameters.
    6046  *
    6047  * @return true on success
    6048  */
    6049 
    6050 bool detMasterFrameInsertObject(
    6051     psDB            *dbh,               ///< Database handle
    6052     detMasterFrameRow *object             ///< detMasterFrameRow object
    6053 );
    6054 
    6055 /** Insert an array of detMasterFrameRow object into a table
    6056  *
    6057  * This function constructs and inserts multiple rows based on it's parameters.
    6058  *
    6059  * @return true on success
    6060  */
    6061 
    6062 bool detMasterFrameInsertObjects(
    6063     psDB            *dbh,               ///< Database handle
    6064     psArray         *objects            ///< array of detMasterFrameRow objects
    6065 );
    6066 
    6067 /** Insert data from a binary FITS table detMasterFrameRow into the database
    6068  *
    6069  * This function expects a psFits object with a FITS table as the first
    6070  * extension.  The table must have at least one row of data in it, that is of
    6071  * the appropriate format (number of columns and their type).  All other
    6072  * extensions are ignored.
    6073  *
    6074  * @return true on success
    6075  */
    6076 
    6077 bool detMasterFrameInsertFits(
    6078     psDB            *dbh,               ///< Database handle
    6079     const psFits    *fits               ///< psFits object
    6080 );
    6081 
    6082 /** Selects up to limit from the database and returns them in a binary FITS table
    6083  *
    6084  * This function assumes an empty psFits object and will create a FITS table
    6085  * as the first extension.
    6086  *
    6087  *  See psDBSelectRows() for documentation on the format of where.
    6088  *
    6089  * @return true on success
    6090  */
    6091 
    6092 bool detMasterFrameSelectRowsFits(
    6093     psDB            *dbh,               ///< Database handle
    6094     psFits          *fits,              ///< psFits object
    6095     const psMetadata *where,            ///< Row match criteria
    6096     unsigned long long limit            ///< Maximum number of elements to return
    6097 );
    6098 
    6099 /** Convert a detMasterFrameRow into an equivalent psMetadata
    6100  *
    6101  * @return A psMetadata pointer or NULL on error
    6102  */
    6103 
    6104 psMetadata *detMasterFrameMetadataFromObject(
    6105     const detMasterFrameRow *object             ///< fooRow to convert into a psMetadata
    6106 );
    6107 
    6108 /** Convert a psMetadata into an equivalent fooRow
    6109  *
    6110  * @return A detMasterFrameRow pointer or NULL on error
    6111  */
    6112 
    6113 detMasterFrameRow *detMasterFrameObjectFromMetadata(
    6114     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    6115 );
    6116 /** Selects up to limit rows from the database and returns as detMasterFrameRow objects in a psArray
    6117  *
    6118  *  See psDBSelectRows() for documentation on the format of where.
    6119  *
    6120  * @return A psArray pointer or NULL on error
    6121  */
    6122 
    6123 psArray *detMasterFrameSelectRowObjects(
    6124     psDB            *dbh,               ///< Database handle
    6125     const psMetadata *where,            ///< Row match criteria
    6126     unsigned long long limit            ///< Maximum number of elements to return
    6127 );
    6128 /** Deletes a row from the database coresponding to an detMasterFrame
    6129  *
    6130  *  Note that a 'where' search psMetadata is constructed from each object and
    6131  *  used to find rows to delete.
    6132  *
    6133  * @return A The number of rows removed or a negative value on error
    6134  */
    6135 
    6136 bool detMasterFrameDeleteObject(
    6137     psDB            *dbh,               ///< Database handle
    6138     const detMasterFrameRow *object    ///< Object to delete
    6139 );
    6140 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    6141  *
    6142  *  Note that a 'where' search psMetadata is constructed from each object and
    6143  *  used to find rows to delete.
    6144  *
    6145  * @return A The number of rows removed or a negative value on error
    6146  */
    6147 
    6148 long long detMasterFrameDeleteRowObjects(
    6149     psDB            *dbh,               ///< Database handle
    6150     const psArray   *objects,           ///< Array of objects to delete
    6151     unsigned long long limit            ///< Maximum number of elements to delete
    6152 );
    6153 /** Formats and prints an array of detMasterFrameRow objects
    6154  *
    6155  * When mdcf is set the formated output is in psMetadataConfig
    6156  * format, otherwise it is in a simple tabular format.
    6157  *
    6158  * @return true on success
    6159  */
    6160 
    6161 bool detMasterFramePrintObjects(
    6162     FILE            *stream,            ///< a stream
    6163     psArray         *objects,           ///< An array of detMasterFrameRow objects
    6164     bool            mdcf                ///< format as mdconfig or simple
    6165 );
    6166 /** detMasterImfileRow data structure
    6167  *
    6168  * Structure for representing a single row of detMasterImfile table data.
    6169  */
    6170 
    6171 typedef struct {
    6172     psS32           det_id;
    6173     char            *class_id;
    6174     char            *uri;
    6175     char            *recipe;
    6176 } detMasterImfileRow;
    6177 
    6178 /** Creates a new detMasterImfileRow object
    6179  *
    6180  *  @return A new detMasterImfileRow object or NULL on failure.
    6181  */
    6182 
    6183 detMasterImfileRow *detMasterImfileRowAlloc(
    6184     psS32           det_id,
    6185     const char      *class_id,
    6186     const char      *uri,
    6187     const char      *recipe
    6188 );
    6189 
    6190 /** Creates a new detMasterImfile table
    6191  *
    6192  * @return true on success
    6193  */
    6194 
    6195 bool detMasterImfileCreateTable(
    6196     psDB            *dbh                ///< Database handle
    6197 );
    6198 
    6199 /** Deletes a detMasterImfile table
    6200  *
    6201  * @return true on success
    6202  */
    6203 
    6204 bool detMasterImfileDropTable(
    6205     psDB            *dbh                ///< Database handle
    6206 );
    6207 
    6208 /** Insert a single row into a table
    6209  *
    6210  * This function constructs and inserts a single row based on it's parameters.
    6211  *
    6212  * @return true on success
    6213  */
    6214 
    6215 bool detMasterImfileInsert(
    6216     psDB            *dbh,               ///< Database handle
    6217     psS32           det_id,
    6218     const char      *class_id,
    6219     const char      *uri,
    6220     const char      *recipe
    6221 );
    6222 
    6223 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    6224  *
    6225  * @return A The number of rows removed or a negative value on error
    6226  */
    6227 
    6228 long long detMasterImfileDelete(
    6229     psDB            *dbh,               ///< Database handle
    6230     const psMetadata *where,            ///< Row match criteria
    6231     unsigned long long limit            ///< Maximum number of elements to delete
    6232 );
    6233 
    6234 /** Insert a single detMasterImfileRow object into a table
    6235  *
    6236  * This function constructs and inserts a single row based on it's parameters.
    6237  *
    6238  * @return true on success
    6239  */
    6240 
    6241 bool detMasterImfileInsertObject(
    6242     psDB            *dbh,               ///< Database handle
    6243     detMasterImfileRow *object             ///< detMasterImfileRow object
    6244 );
    6245 
    6246 /** Insert an array of detMasterImfileRow object into a table
    6247  *
    6248  * This function constructs and inserts multiple rows based on it's parameters.
    6249  *
    6250  * @return true on success
    6251  */
    6252 
    6253 bool detMasterImfileInsertObjects(
    6254     psDB            *dbh,               ///< Database handle
    6255     psArray         *objects            ///< array of detMasterImfileRow objects
    6256 );
    6257 
    6258 /** Insert data from a binary FITS table detMasterImfileRow into the database
    6259  *
    6260  * This function expects a psFits object with a FITS table as the first
    6261  * extension.  The table must have at least one row of data in it, that is of
    6262  * the appropriate format (number of columns and their type).  All other
    6263  * extensions are ignored.
    6264  *
    6265  * @return true on success
    6266  */
    6267 
    6268 bool detMasterImfileInsertFits(
    6269     psDB            *dbh,               ///< Database handle
    6270     const psFits    *fits               ///< psFits object
    6271 );
    6272 
    6273 /** Selects up to limit from the database and returns them in a binary FITS table
    6274  *
    6275  * This function assumes an empty psFits object and will create a FITS table
    6276  * as the first extension.
    6277  *
    6278  *  See psDBSelectRows() for documentation on the format of where.
    6279  *
    6280  * @return true on success
    6281  */
    6282 
    6283 bool detMasterImfileSelectRowsFits(
    6284     psDB            *dbh,               ///< Database handle
    6285     psFits          *fits,              ///< psFits object
    6286     const psMetadata *where,            ///< Row match criteria
    6287     unsigned long long limit            ///< Maximum number of elements to return
    6288 );
    6289 
    6290 /** Convert a detMasterImfileRow into an equivalent psMetadata
    6291  *
    6292  * @return A psMetadata pointer or NULL on error
    6293  */
    6294 
    6295 psMetadata *detMasterImfileMetadataFromObject(
    6296     const detMasterImfileRow *object             ///< fooRow to convert into a psMetadata
    6297 );
    6298 
    6299 /** Convert a psMetadata into an equivalent fooRow
    6300  *
    6301  * @return A detMasterImfileRow pointer or NULL on error
    6302  */
    6303 
    6304 detMasterImfileRow *detMasterImfileObjectFromMetadata(
    6305     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    6306 );
    6307 /** Selects up to limit rows from the database and returns as detMasterImfileRow objects in a psArray
    6308  *
    6309  *  See psDBSelectRows() for documentation on the format of where.
    6310  *
    6311  * @return A psArray pointer or NULL on error
    6312  */
    6313 
    6314 psArray *detMasterImfileSelectRowObjects(
    6315     psDB            *dbh,               ///< Database handle
    6316     const psMetadata *where,            ///< Row match criteria
    6317     unsigned long long limit            ///< Maximum number of elements to return
    6318 );
    6319 /** Deletes a row from the database coresponding to an detMasterImfile
    6320  *
    6321  *  Note that a 'where' search psMetadata is constructed from each object and
    6322  *  used to find rows to delete.
    6323  *
    6324  * @return A The number of rows removed or a negative value on error
    6325  */
    6326 
    6327 bool detMasterImfileDeleteObject(
    6328     psDB            *dbh,               ///< Database handle
    6329     const detMasterImfileRow *object    ///< Object to delete
    6330 );
    6331 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    6332  *
    6333  *  Note that a 'where' search psMetadata is constructed from each object and
    6334  *  used to find rows to delete.
    6335  *
    6336  * @return A The number of rows removed or a negative value on error
    6337  */
    6338 
    6339 long long detMasterImfileDeleteRowObjects(
    6340     psDB            *dbh,               ///< Database handle
    6341     const psArray   *objects,           ///< Array of objects to delete
    6342     unsigned long long limit            ///< Maximum number of elements to delete
    6343 );
    6344 /** Formats and prints an array of detMasterImfileRow objects
    6345  *
    6346  * When mdcf is set the formated output is in psMetadataConfig
    6347  * format, otherwise it is in a simple tabular format.
    6348  *
    6349  * @return true on success
    6350  */
    6351 
    6352 bool detMasterImfilePrintObjects(
    6353     FILE            *stream,            ///< a stream
    6354     psArray         *objects,           ///< An array of detMasterImfileRow objects
    6355     bool            mdcf                ///< format as mdconfig or simple
    6356 );
    63575978/** detResidImfileRow data structure
    63585979 *
Note: See TracChangeset for help on using the changeset viewer.