IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Oct 5, 2006, 11:32:26 AM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.47

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r9247 r9301  
    5757#define P3PENDINGEXP_TABLE_NAME "p3PendingExp"
    5858#define P3PENDINGEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
     59#define P3PROCESSEDEXP_TABLE_NAME "p3ProcessedExp"
     60#define P3PROCESSEDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5961#define DETRUN_TABLE_NAME "detRun"
    6062#define DETRUN_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    … …  
    1285812860    return true;
    1285912861}
     12862static void p3ProcessedExpRowFree(p3ProcessedExpRow *object);
     12863
     12864p3ProcessedExpRow *p3ProcessedExpRowAlloc(const char *exp_tag, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psS32 p2_version, psS32 p3_version)
     12865{
     12866    p3ProcessedExpRow *_object;
     12867
     12868    _object = psAlloc(sizeof(p3ProcessedExpRow));
     12869    psMemSetDeallocator(_object, (psFreeFunc)p3ProcessedExpRowFree);
     12870
     12871    _object->exp_tag = psStringCopy(exp_tag);
     12872    _object->uri = psStringCopy(uri);
     12873    _object->recipe = psStringCopy(recipe);
     12874    _object->bg = bg;
     12875    _object->bg_stdev = bg_stdev;
     12876    _object->bg_mean_stdev = bg_mean_stdev;
     12877    _object->sigma_ra = sigma_ra;
     12878    _object->sigma_dec = sigma_dec;
     12879    _object->nastro = nastro;
     12880    _object->b1_uri = psStringCopy(b1_uri);
     12881    _object->b2_uri = psStringCopy(b2_uri);
     12882    _object->p2_version = p2_version;
     12883    _object->p3_version = p3_version;
     12884
     12885    return _object;
     12886}
     12887
     12888static void p3ProcessedExpRowFree(p3ProcessedExpRow *object)
     12889{
     12890    psFree(object->exp_tag);
     12891    psFree(object->uri);
     12892    psFree(object->recipe);
     12893    psFree(object->b1_uri);
     12894    psFree(object->b2_uri);
     12895}
     12896
     12897bool p3ProcessedExpCreateTable(psDB *dbh)
     12898{
     12899    psMetadata      *md;
     12900    bool            status;
     12901
     12902    md = psMetadataAlloc();
     12903    if (!psMetadataAdd(md, PS_LIST_TAIL, P3PROCESSEDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
     12904        psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P3PROCESSEDEXP_INDEX_NAME);
     12905        psFree(md);
     12906        return false;
     12907    }
     12908    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
     12909        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     12910        psFree(md);
     12911        return false;
     12912    }
     12913    if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "255")) {
     12914        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     12915        psFree(md);
     12916        return false;
     12917    }
     12918    if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "64")) {
     12919        psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
     12920        psFree(md);
     12921        return false;
     12922    }
     12923    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 0.0)) {
     12924        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     12925        psFree(md);
     12926        return false;
     12927    }
     12928    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 0.0)) {
     12929        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     12930        psFree(md);
     12931        return false;
     12932    }
     12933    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 0.0)) {
     12934        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     12935        psFree(md);
     12936        return false;
     12937    }
     12938    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, 0.0)) {
     12939        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     12940        psFree(md);
     12941        return false;
     12942    }
     12943    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, 0.0)) {
     12944        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     12945        psFree(md);
     12946        return false;
     12947    }
     12948    if (!psMetadataAddS32(md, PS_LIST_TAIL, "nastro", 0, NULL, 0)) {
     12949        psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     12950        psFree(md);
     12951        return false;
     12952    }
     12953    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "255")) {
     12954        psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
     12955        psFree(md);
     12956        return false;
     12957    }
     12958    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "255")) {
     12959        psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     12960        psFree(md);
     12961        return false;
     12962    }
     12963    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, 0)) {
     12964        psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     12965        psFree(md);
     12966        return false;
     12967    }
     12968    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, 0)) {
     12969        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     12970        psFree(md);
     12971        return false;
     12972    }
     12973
     12974    status = psDBCreateTable(dbh, P3PROCESSEDEXP_TABLE_NAME, md);
     12975
     12976    psFree(md);
     12977
     12978    return status;
     12979}
     12980
     12981bool p3ProcessedExpDropTable(psDB *dbh)
     12982{
     12983    return psDBDropTable(dbh, P3PROCESSEDEXP_TABLE_NAME);
     12984}
     12985
     12986bool p3ProcessedExpInsert(psDB * dbh, const char *exp_tag, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psS32 p2_version, psS32 p3_version)
     12987{
     12988    psMetadata      *md;
     12989    bool            status;
     12990
     12991    md = psMetadataAlloc();
     12992    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, exp_tag)) {
     12993        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     12994        psFree(md);
     12995        return false;
     12996    }
     12997    if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, uri)) {
     12998        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     12999        psFree(md);
     13000        return false;
     13001    }
     13002    if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, recipe)) {
     13003        psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
     13004        psFree(md);
     13005        return false;
     13006    }
     13007    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, bg)) {
     13008        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     13009        psFree(md);
     13010        return false;
     13011    }
     13012    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, bg_stdev)) {
     13013        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     13014        psFree(md);
     13015        return false;
     13016    }
     13017    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, bg_mean_stdev)) {
     13018        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     13019        psFree(md);
     13020        return false;
     13021    }
     13022    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, sigma_ra)) {
     13023        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     13024        psFree(md);
     13025        return false;
     13026    }
     13027    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, sigma_dec)) {
     13028        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     13029        psFree(md);
     13030        return false;
     13031    }
     13032    if (!psMetadataAddS32(md, PS_LIST_TAIL, "nastro", 0, NULL, nastro)) {
     13033        psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     13034        psFree(md);
     13035        return false;
     13036    }
     13037    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, b1_uri)) {
     13038        psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
     13039        psFree(md);
     13040        return false;
     13041    }
     13042    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, b2_uri)) {
     13043        psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     13044        psFree(md);
     13045        return false;
     13046    }
     13047    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, p2_version)) {
     13048        psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     13049        psFree(md);
     13050        return false;
     13051    }
     13052    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, p3_version)) {
     13053        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     13054        psFree(md);
     13055        return false;
     13056    }
     13057
     13058    status = psDBInsertOneRow(dbh, P3PROCESSEDEXP_TABLE_NAME, md);
     13059    psFree(md);
     13060
     13061    return status;
     13062}
     13063
     13064long long p3ProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13065{
     13066    long long       deleted = 0;
     13067
     13068    long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     13069    if (count < 0) {
     13070        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     13071        return count;
     13072
     13073        deleted += count;
     13074    }
     13075
     13076    return deleted;
     13077}
     13078bool p3ProcessedExpPop(psDB *dbh, char **exp_tag, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, psF32 *sigma_ra, psF32 *sigma_dec, psS32 *nastro, char **b1_uri, char **b2_uri, psS32 *p2_version, psS32 *p3_version)
     13079{
     13080    psArray         *rowSet;
     13081    psMetadata      *row;
     13082    psMetadata      *popped;
     13083    long            deleted;
     13084    bool            status;
     13085    int             rowID;
     13086
     13087    rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, NULL, 1);
     13088    if (!rowSet) {
     13089        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PROCESSEDEXP_INDEX_NAME);
     13090        psFree(rowSet);
     13091        return NULL;
     13092    }
     13093
     13094    row = psArrayGet(rowSet, 0);
     13095    psMemIncrRefCounter(row);
     13096    if (!row) {
     13097        psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
     13098        return NULL;
     13099    }
     13100    psFree(rowSet);
     13101
     13102    rowID = psMetadataLookupS32(&status, row, P3PROCESSEDEXP_INDEX_NAME);
     13103    if (!status) {
     13104        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PROCESSEDEXP_INDEX_NAME);
     13105        psFree(row);
     13106        return NULL;
     13107    }
     13108
     13109    popped = psMetadataAlloc();
     13110    psMetadataAddS32(popped, PS_LIST_TAIL, P3PROCESSEDEXP_INDEX_NAME, 0, NULL, rowID);
     13111
     13112    deleted = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, popped, 0);
     13113    if (deleted != 1) {
     13114        psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
     13115        psFree(popped);
     13116        psFree(row);
     13117        return NULL;
     13118    }
     13119
     13120    psFree(popped);
     13121
     13122    *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
     13123    if (!status) {
     13124        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     13125        psFree(row);
     13126        return false;
     13127    }
     13128    *uri = psMetadataLookupPtr(&status, row, "uri");
     13129    if (!status) {
     13130        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     13131        psFree(row);
     13132        return false;
     13133    }
     13134    *recipe = psMetadataLookupPtr(&status, row, "recipe");
     13135    if (!status) {
     13136        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
     13137        psFree(row);
     13138        return false;
     13139    }
     13140    *bg = psMetadataLookupF64(&status, row, "bg");
     13141    if (!status) {
     13142        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
     13143        psFree(row);
     13144        return false;
     13145    }
     13146    *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
     13147    if (!status) {
     13148        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
     13149        psFree(row);
     13150        return false;
     13151    }
     13152    *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
     13153    if (!status) {
     13154        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
     13155        psFree(row);
     13156        return false;
     13157    }
     13158    *sigma_ra = psMetadataLookupF32(&status, row, "sigma_ra");
     13159    if (!status) {
     13160        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra");
     13161        psFree(row);
     13162        return false;
     13163    }
     13164    *sigma_dec = psMetadataLookupF32(&status, row, "sigma_dec");
     13165    if (!status) {
     13166        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec");
     13167        psFree(row);
     13168        return false;
     13169    }
     13170    *nastro = psMetadataLookupS32(&status, row, "nastro");
     13171    if (!status) {
     13172        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nastro");
     13173        psFree(row);
     13174        return false;
     13175    }
     13176    *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
     13177    if (!status) {
     13178        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
     13179        psFree(row);
     13180        return false;
     13181    }
     13182    *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
     13183    if (!status) {
     13184        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
     13185        psFree(row);
     13186        return false;
     13187    }
     13188    *p2_version = psMetadataLookupS32(&status, row, "p2_version");
     13189    if (!status) {
     13190        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
     13191        psFree(row);
     13192        return false;
     13193    }
     13194    *p3_version = psMetadataLookupS32(&status, row, "p3_version");
     13195    if (!status) {
     13196        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     13197        psFree(row);
     13198        return false;
     13199    }
     13200
     13201    psFree(row);
     13202
     13203    return true;
     13204}
     13205
     13206bool p3ProcessedExpInsertObject(psDB *dbh, p3ProcessedExpRow *object)
     13207{
     13208    return p3ProcessedExpInsert(dbh, object->exp_tag, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->b1_uri, object->b2_uri, object->p2_version, object->p3_version);
     13209}
     13210
     13211bool p3ProcessedExpInsertObjects(psDB *dbh, psArray *objects)
     13212{
     13213    for (long i = 0; i < psArrayLength(objects); i++) {
     13214        if (!p3ProcessedExpInsertObject(dbh, objects->data[i])) {
     13215            return false;
     13216        }
     13217    }
     13218
     13219    return true;
     13220}
     13221
     13222p3ProcessedExpRow *p3ProcessedExpPopObject(psDB *dbh)
     13223{
     13224    char            exp_tag[256];
     13225    char            uri[256];
     13226    char            recipe[256];
     13227    psF64           bg;
     13228    psF64           bg_stdev;
     13229    psF64           bg_mean_stdev;
     13230    psF32           sigma_ra;
     13231    psF32           sigma_dec;
     13232    psS32           nastro;
     13233    char            b1_uri[256];
     13234    char            b2_uri[256];
     13235    psS32           p2_version;
     13236    psS32           p3_version;
     13237
     13238    if (!p3ProcessedExpPop(dbh, (char **)&exp_tag, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, &sigma_ra, &sigma_dec, &nastro, (char **)&b1_uri, (char **)&b2_uri, &p2_version, &p3_version)) {
     13239        psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
     13240        return NULL;
     13241    }
     13242
     13243    return p3ProcessedExpRowAlloc(exp_tag, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, p2_version, p3_version);
     13244}
     13245
     13246bool p3ProcessedExpInsertFits(psDB *dbh, const psFits *fits)
     13247{
     13248    psArray         *rowSet;
     13249
     13250    // move to (the first?) extension named  P3PROCESSEDEXP_TABLE_NAME
     13251    if (!psFitsMoveExtName(fits, P3PROCESSEDEXP_TABLE_NAME)) {
     13252        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3PROCESSEDEXP_TABLE_NAME);
     13253        return false;
     13254    }
     13255
     13256    // check HDU type
     13257    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     13258        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     13259        return false;
     13260    }
     13261
     13262    // read fits table
     13263    rowSet = psFitsReadTable(fits);
     13264    if (!rowSet) {
     13265        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     13266        psFree(rowSet);
     13267        return false;
     13268    }
     13269
     13270    if (!psDBInsertRows(dbh, P3PROCESSEDEXP_TABLE_NAME, rowSet)) {
     13271        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     13272        psFree(rowSet);
     13273        return false;
     13274    }
     13275
     13276    psFree(rowSet);
     13277
     13278    return true;
     13279}
     13280
     13281bool p3ProcessedExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
     13282{
     13283    char            query[MAX_STRING_LENGTH];
     13284
     13285    if (!p3ProcessedExpSelectRowsFits(dbh, fits, NULL, limit)) {
     13286        psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
     13287        return false;
     13288    }
     13289
     13290    // remove limit rows from the end of the database
     13291    if (snprintf(query, MAX_STRING_LENGTH,
     13292                "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
     13293                P3PROCESSEDEXP_TABLE_NAME, P3PROCESSEDEXP_INDEX_NAME, limit) < 0) {
     13294        psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
     13295        return false;
     13296    }
     13297           
     13298    if (!p_psDBRunQuery(dbh, query)) {
     13299        psError(PS_ERR_UNKNOWN, false, "database query failed");
     13300        return false;
     13301    }
     13302
     13303    return true;
     13304}
     13305
     13306bool p3ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13307{
     13308    psArray         *rowSet;
     13309    psU64           i;
     13310
     13311    rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     13312    if (!rowSet) {
     13313        return false;
     13314    }
     13315
     13316    // strip index column
     13317    for (i = 0; i < rowSet->n; i++) {
     13318        if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P3PROCESSEDEXP_INDEX_NAME)) {
     13319            psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PROCESSEDEXP_INDEX_NAME);
     13320            psFree(rowSet);
     13321            return false;
     13322        }
     13323    }
     13324
     13325    // output to fits
     13326    if (!psFitsWriteTable(fits, NULL, rowSet, P3PROCESSEDEXP_TABLE_NAME)) {
     13327        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     13328        psFree(rowSet);
     13329        return false;
     13330    }
     13331
     13332    psFree(rowSet);
     13333
     13334    return true;
     13335}
     13336
     13337psMetadata *p3ProcessedExpMetadataFromObject(const p3ProcessedExpRow *object)
     13338{
     13339    psMetadata      *md;
     13340
     13341    md = psMetadataAlloc();
     13342    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, object->exp_tag)) {
     13343        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     13344        psFree(md);
     13345        return NULL;
     13346    }
     13347    if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, object->uri)) {
     13348        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     13349        psFree(md);
     13350        return NULL;
     13351    }
     13352    if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, object->recipe)) {
     13353        psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
     13354        psFree(md);
     13355        return NULL;
     13356    }
     13357    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, object->bg)) {
     13358        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     13359        psFree(md);
     13360        return NULL;
     13361    }
     13362    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, object->bg_stdev)) {
     13363        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
     13364        psFree(md);
     13365        return NULL;
     13366    }
     13367    if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, object->bg_mean_stdev)) {
     13368        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     13369        psFree(md);
     13370        return NULL;
     13371    }
     13372    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, object->sigma_ra)) {
     13373        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra");
     13374        psFree(md);
     13375        return NULL;
     13376    }
     13377    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, object->sigma_dec)) {
     13378        psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec");
     13379        psFree(md);
     13380        return NULL;
     13381    }
     13382    if (!psMetadataAddS32(md, PS_LIST_TAIL, "nastro", 0, NULL, object->nastro)) {
     13383        psError(PS_ERR_UNKNOWN, false, "failed to add item nastro");
     13384        psFree(md);
     13385        return NULL;
     13386    }
     13387    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, object->b1_uri)) {
     13388        psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
     13389        psFree(md);
     13390        return NULL;
     13391    }
     13392    if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, object->b2_uri)) {
     13393        psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     13394        psFree(md);
     13395        return NULL;
     13396    }
     13397    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, object->p2_version)) {
     13398        psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version");
     13399        psFree(md);
     13400        return NULL;
     13401    }
     13402    if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, object->p3_version)) {
     13403        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     13404        psFree(md);
     13405        return NULL;
     13406    }
     13407
     13408    return md;
     13409}
     13410
     13411p3ProcessedExpRow *p3ProcessedExpObjectFromMetadata(psMetadata *md)
     13412{
     13413    bool            status;
     13414    char            *exp_tag;
     13415    char            *uri;
     13416    char            *recipe;
     13417    psF64           bg;
     13418    psF64           bg_stdev;
     13419    psF64           bg_mean_stdev;
     13420    psF32           sigma_ra;
     13421    psF32           sigma_dec;
     13422    psS32           nastro;
     13423    char            *b1_uri;
     13424    char            *b2_uri;
     13425    psS32           p2_version;
     13426    psS32           p3_version;
     13427
     13428    exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     13429    if (!status) {
     13430        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     13431        return false;
     13432    }
     13433    uri = psMetadataLookupPtr(&status, md, "uri");
     13434    if (!status) {
     13435        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     13436        return false;
     13437    }
     13438    recipe = psMetadataLookupPtr(&status, md, "recipe");
     13439    if (!status) {
     13440        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
     13441        return false;
     13442    }
     13443    bg = psMetadataLookupF64(&status, md, "bg");
     13444    if (!status) {
     13445        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
     13446        return false;
     13447    }
     13448    bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev");
     13449    if (!status) {
     13450        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
     13451        return false;
     13452    }
     13453    bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     13454    if (!status) {
     13455        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
     13456        return false;
     13457    }
     13458    sigma_ra = psMetadataLookupF32(&status, md, "sigma_ra");
     13459    if (!status) {
     13460        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra");
     13461        return false;
     13462    }
     13463    sigma_dec = psMetadataLookupF32(&status, md, "sigma_dec");
     13464    if (!status) {
     13465        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec");
     13466        return false;
     13467    }
     13468    nastro = psMetadataLookupS32(&status, md, "nastro");
     13469    if (!status) {
     13470        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nastro");
     13471        return false;
     13472    }
     13473    b1_uri = psMetadataLookupPtr(&status, md, "b1_uri");
     13474    if (!status) {
     13475        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
     13476        return false;
     13477    }
     13478    b2_uri = psMetadataLookupPtr(&status, md, "b2_uri");
     13479    if (!status) {
     13480        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
     13481        return false;
     13482    }
     13483    p2_version = psMetadataLookupS32(&status, md, "p2_version");
     13484    if (!status) {
     13485        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
     13486        return false;
     13487    }
     13488    p3_version = psMetadataLookupS32(&status, md, "p3_version");
     13489    if (!status) {
     13490        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     13491        return false;
     13492    }
     13493
     13494    return p3ProcessedExpRowAlloc(exp_tag, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, p2_version, p3_version);
     13495}
     13496psArray *p3ProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13497{
     13498    psArray         *rowSet;
     13499    psArray         *returnSet;
     13500    psU64           i;
     13501
     13502    rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     13503    if (!rowSet) {
     13504        return NULL;
     13505    }
     13506
     13507    // strip index column
     13508    for (i = 0; i < rowSet->n; i++) {
     13509        if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P3PROCESSEDEXP_INDEX_NAME)) {
     13510            psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PROCESSEDEXP_INDEX_NAME);
     13511            psFree(rowSet);
     13512            return false;
     13513        }
     13514    }
     13515
     13516    // convert psMetadata rows to row objects
     13517
     13518    returnSet = psArrayAlloc(rowSet->n);
     13519    returnSet->n = 0;
     13520
     13521    for (i = 0; i < rowSet->n; i++) {
     13522        p3ProcessedExpRow *object = p3ProcessedExpObjectFromMetadata(rowSet->data[i]);
     13523        psArrayAdd(returnSet, 0, object);
     13524        psFree(object);
     13525    }
     13526
     13527    psFree(rowSet);
     13528
     13529    return returnSet;
     13530}
     13531bool p3ProcessedExpDeleteObject(psDB *dbh, const p3ProcessedExpRow *object)
     13532{
     13533    psMetadata *where = p3ProcessedExpMetadataFromObject(object);
     13534    long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, 0);
     13535    psFree(where)
     13536    if (count < 0) {
     13537        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     13538        return false;
     13539    }
     13540    if (count > 1) {
     13541        // XXX should this be a psAbort() instead?  It is possible that
     13542        // having an object match multiple rows was by design.
     13543        psError(PS_ERR_UNKNOWN, true, "p3ProcessedExpRow object matched more then one row.  Check your database schema");
     13544        return false;
     13545    }
     13546
     13547    return true;
     13548}
     13549long long p3ProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     13550{
     13551    long long       deleted = 0;
     13552
     13553    for (long long i = 0; i < objects->n; i++) {
     13554        p3ProcessedExpRow *object = objects->data[i];
     13555        psMetadata *where = p3ProcessedExpMetadataFromObject(object);
     13556        long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
     13557        psFree(where)
     13558        if (count < 0) {
     13559            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
     13560            return count;
     13561        }
     13562
     13563        deleted += count;
     13564    }
     13565
     13566    return deleted;
     13567}
     13568bool p3ProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     13569{
     13570    PS_ASSERT_PTR_NON_NULL(objects, false);
     13571
     13572    psMetadata *output = psMetadataAlloc();
     13573    for (long i = 0; i < psArrayLength(objects); i++) {
     13574        psMetadata *md = p3ProcessedExpMetadataFromObject(objects->data[i]);
     13575        if (!psMetadataAddMetadata(
     13576            output,
     13577            PS_LIST_TAIL,
     13578            P3PROCESSEDEXP_TABLE_NAME,
     13579            PS_META_DUPLICATE_OK,
     13580            NULL,
     13581            md
     13582        )) {
     13583            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     13584            psFree(md);
     13585            psFree(output);
     13586            return false;
     13587        }
     13588        psFree(md);
     13589    }
     13590
     13591    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     13592        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     13593        psFree(output);
     13594    }
     13595    psFree(output);
     13596
     13597    return true;
     13598}
    1286013599static void detRunRowFree(detRunRow *object);
    1286113600
Note: See TracChangeset for help on using the changeset viewer.