IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jan 11, 2007, 3:35:04 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.73

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r11030 r11045  
    4040#define NEWEXP_TABLE_NAME "newExp"
    4141#define NEWIMFILE_TABLE_NAME "newImfile"
    42 #define RAWDETRENDEXP_TABLE_NAME "rawDetrendExp"
    43 #define RAWSCIENCEEXP_TABLE_NAME "rawScienceExp"
     42#define RAWEXP_TABLE_NAME "rawExp"
    4443#define RAWIMFILE_TABLE_NAME "rawImfile"
    4544#define P1PENDINGEXP_TABLE_NAME "p1PendingExp"
    … …  
    28002799static void newExpRowFree(newExpRow *object);
    28012800
    2802 newExpRow *newExpRowAlloc(const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles, psS16 fault)
     2801newExpRow *newExpRowAlloc(const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles)
    28032802{
    28042803    newExpRow       *_object;
    … …  
    28142813    _object->exp_type = psStringCopy(exp_type);
    28152814    _object->imfiles = imfiles;
    2816     _object->fault = fault;
    28172815
    28182816    return _object;
    … …  
    28672865        return false;
    28682866    }
    2869     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "NOT NULL", 0)) {
    2870         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    2871         psFree(md);
    2872         return false;
    2873     }
    28742867
    28752868    bool status = psDBCreateTable(dbh, NEWEXP_TABLE_NAME, md);
    … …  
    28852878}
    28862879
    2887 bool newExpInsert(psDB * dbh, const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles, psS16 fault)
     2880bool newExpInsert(psDB * dbh, const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles)
    28882881{
    28892882    psMetadata *md = psMetadataAlloc();
    … …  
    29202913    if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
    29212914        psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    2922         psFree(md);
    2923         return false;
    2924     }
    2925     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
    2926         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    29272915        psFree(md);
    29282916        return false;
    … …  
    29512939bool newExpInsertObject(psDB *dbh, newExpRow *object)
    29522940{
    2953     return newExpInsert(dbh, object->exp_tag, object->exp_id, object->camera, object->telescope, object->dateobs, object->exp_type, object->imfiles, object->fault);
     2941    return newExpInsert(dbh, object->exp_tag, object->exp_id, object->camera, object->telescope, object->dateobs, object->exp_type, object->imfiles);
    29542942}
    29552943
    … …  
    30593047        return false;
    30603048    }
    3061     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
    3062         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    3063         psFree(md);
    3064         return false;
    3065     }
    30663049
    30673050
    … …  
    31083091        return false;
    31093092    }
    3110     psS16 fault = psMetadataLookupS16(&status, md, "fault");
    3111     if (!status) {
    3112         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
    3113         return false;
    3114     }
    3115 
    3116     return newExpRowAlloc(exp_tag, exp_id, camera, telescope, dateobs, exp_type, imfiles, fault);
     3093
     3094    return newExpRowAlloc(exp_tag, exp_id, camera, telescope, dateobs, exp_type, imfiles);
    31173095}
    31183096psArray *newExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    32263204static void newImfileRowFree(newImfileRow *object);
    32273205
    3228 newImfileRow *newImfileRowAlloc(const char *exp_tag, const char *class, const char *class_id, const char *uri, psS16 fault)
     3206newImfileRow *newImfileRowAlloc(const char *exp_tag, const char *class, const char *class_id, const char *uri)
    32293207{
    32303208    newImfileRow    *_object;
    … …  
    32373215    _object->class_id = psStringCopy(class_id);
    32383216    _object->uri = psStringCopy(uri);
    3239     _object->fault = fault;
    32403217
    32413218    return _object;
    … …  
    32733250        return false;
    32743251    }
    3275     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "NOT NULL", 0)) {
    3276         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    3277         psFree(md);
    3278         return false;
    3279     }
    32803252
    32813253    bool status = psDBCreateTable(dbh, NEWIMFILE_TABLE_NAME, md);
    … …  
    32913263}
    32923264
    3293 bool newImfileInsert(psDB * dbh, const char *exp_tag, const char *class, const char *class_id, const char *uri, psS16 fault)
     3265bool newImfileInsert(psDB * dbh, const char *exp_tag, const char *class, const char *class_id, const char *uri)
    32943266{
    32953267    psMetadata *md = psMetadataAlloc();
    … …  
    33113283    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    33123284        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    3313         psFree(md);
    3314         return false;
    3315     }
    3316     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
    3317         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    33183285        psFree(md);
    33193286        return false;
    … …  
    33423309bool newImfileInsertObject(psDB *dbh, newImfileRow *object)
    33433310{
    3344     return newImfileInsert(dbh, object->exp_tag, object->class, object->class_id, object->uri, object->fault);
     3311    return newImfileInsert(dbh, object->exp_tag, object->class, object->class_id, object->uri);
    33453312}
    33463313
    … …  
    34353402        return false;
    34363403    }
    3437     if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
    3438         psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    3439         psFree(md);
    3440         return false;
    3441     }
    34423404
    34433405
    … …  
    34693431        return false;
    34703432    }
    3471     psS16 fault = psMetadataLookupS16(&status, md, "fault");
    3472     if (!status) {
    3473         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
    3474         return false;
    3475     }
    3476 
    3477     return newImfileRowAlloc(exp_tag, class, class_id, uri, fault);
     3433
     3434    return newImfileRowAlloc(exp_tag, class, class_id, uri);
    34783435}
    34793436psArray *newImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    35853542    return true;
    35863543}
    3587 static void rawDetrendExpRowFree(rawDetrendExpRow *object);
    3588 
    3589 rawDetrendExpRow *rawDetrendExpRowAlloc(const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
    3590 {
    3591     rawDetrendExpRow *_object;
    3592 
    3593     _object = psAlloc(sizeof(rawDetrendExpRow));
    3594     psMemSetDeallocator(_object, (psFreeFunc)rawDetrendExpRowFree);
     3544static void rawExpRowFree(rawExpRow *object);
     3545
     3546rawExpRow *rawExpRowAlloc(const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault)
     3547{
     3548    rawExpRow      *_object;
     3549
     3550    _object = psAlloc(sizeof(rawExpRow));
     3551    psMemSetDeallocator(_object, (psFreeFunc)rawExpRowFree);
    35953552
    35963553    _object->exp_tag = psStringCopy(exp_tag);
    … …  
    36133570    _object->object = psStringCopy(object);
    36143571    _object->dateobs = psTimeCopy(dateobs);
     3572    _object->fault = fault;
    36153573
    36163574    return _object;
    36173575}
    36183576
    3619 static void rawDetrendExpRowFree(rawDetrendExpRow *object)
     3577static void rawExpRowFree(rawExpRow *object)
    36203578{
    36213579    psFree(object->exp_tag);
    … …  
    36283586}
    36293587
    3630 bool rawDetrendExpCreateTable(psDB *dbh)
     3588bool rawExpCreateTable(psDB *dbh)
    36313589{
    36323590    psMetadata *md = psMetadataAlloc();
    … …  
    37263684        return false;
    37273685    }
    3728 
    3729     bool status = psDBCreateTable(dbh, RAWDETRENDEXP_TABLE_NAME, md);
     3686    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "NOT NULL", 0)) {
     3687        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     3688        psFree(md);
     3689        return false;
     3690    }
     3691
     3692    bool status = psDBCreateTable(dbh, RAWEXP_TABLE_NAME, md);
    37303693
    37313694    psFree(md);
    … …  
    37343697}
    37353698
    3736 bool rawDetrendExpDropTable(psDB *dbh)
    3737 {
    3738     return psDBDropTable(dbh, RAWDETRENDEXP_TABLE_NAME);
    3739 }
    3740 
    3741 bool rawDetrendExpInsert(psDB * dbh, const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
     3699bool rawExpDropTable(psDB *dbh)
     3700{
     3701    return psDBDropTable(dbh, RAWEXP_TABLE_NAME);
     3702}
     3703
     3704bool rawExpInsert(psDB * dbh, const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault)
    37423705{
    37433706    psMetadata *md = psMetadataAlloc();
    … …  
    38373800        return false;
    38383801    }
    3839 
    3840     bool status = psDBInsertOneRow(dbh, RAWDETRENDEXP_TABLE_NAME, md);
     3802    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     3803        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     3804        psFree(md);
     3805        return false;
     3806    }
     3807
     3808    bool status = psDBInsertOneRow(dbh, RAWEXP_TABLE_NAME, md);
    38413809    psFree(md);
    38423810
    … …  
    38443812}
    38453813
    3846 long long rawDetrendExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     3814long long rawExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    38473815{
    38483816    long long       deleted = 0;
    38493817
    3850     long long count = psDBDeleteRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, limit);
     3818    long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, limit);
    38513819    if (count < 0) {
    3852         psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawDetrendExp");
     3820        psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp");
    38533821        return count;
    38543822
    … …  
    38583826    return deleted;
    38593827}
    3860 bool rawDetrendExpInsertObject(psDB *dbh, rawDetrendExpRow *object)
    3861 {
    3862     return rawDetrendExpInsert(dbh, object->exp_tag, object->camera, object->telescope, object->exp_type, object->imfiles, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs);
    3863 }
    3864 
    3865 bool rawDetrendExpInsertObjects(psDB *dbh, psArray *objects)
     3828bool rawExpInsertObject(psDB *dbh, rawExpRow *object)
     3829{
     3830    return rawExpInsert(dbh, object->exp_tag, object->camera, object->telescope, object->exp_type, object->imfiles, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs, object->fault);
     3831}
     3832
     3833bool rawExpInsertObjects(psDB *dbh, psArray *objects)
    38663834{
    38673835    for (long i = 0; i < psArrayLength(objects); i++) {
    3868         if (!rawDetrendExpInsertObject(dbh, objects->data[i])) {
     3836        if (!rawExpInsertObject(dbh, objects->data[i])) {
    38693837            return false;
    38703838        }
    … …  
    38743842}
    38753843
    3876 bool rawDetrendExpInsertFits(psDB *dbh, const psFits *fits)
     3844bool rawExpInsertFits(psDB *dbh, const psFits *fits)
    38773845{
    38783846    psArray         *rowSet;
    38793847
    3880     // move to (the first?) extension named  RAWDETRENDEXP_TABLE_NAME
    3881     if (!psFitsMoveExtName(fits, RAWDETRENDEXP_TABLE_NAME)) {
    3882         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", RAWDETRENDEXP_TABLE_NAME);
     3848    // move to (the first?) extension named  RAWEXP_TABLE_NAME
     3849    if (!psFitsMoveExtName(fits, RAWEXP_TABLE_NAME)) {
     3850        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", RAWEXP_TABLE_NAME);
    38833851        return false;
    38843852    }
    … …  
    38983866    }
    38993867
    3900     if (!psDBInsertRows(dbh, RAWDETRENDEXP_TABLE_NAME, rowSet)) {
     3868    if (!psDBInsertRows(dbh, RAWEXP_TABLE_NAME, rowSet)) {
    39013869        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    39023870        psFree(rowSet);
    … …  
    39093877}
    39103878
    3911 bool rawDetrendExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     3879bool rawExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    39123880{
    39133881    psArray         *rowSet;
    39143882
    3915     rowSet = psDBSelectRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, limit);
     3883    rowSet = psDBSelectRows(dbh, RAWEXP_TABLE_NAME, where, limit);
    39163884    if (!rowSet) {
    39173885        return false;
    … …  
    39193887
    39203888    // output to fits
    3921     if (!psFitsWriteTable(fits, NULL, rowSet, RAWDETRENDEXP_TABLE_NAME)) {
     3889    if (!psFitsWriteTable(fits, NULL, rowSet, RAWEXP_TABLE_NAME)) {
    39223890        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    39233891        psFree(rowSet);
    … …  
    39303898}
    39313899
    3932 psMetadata *rawDetrendExpMetadataFromObject(const rawDetrendExpRow *object)
     3900psMetadata *rawExpMetadataFromObject(const rawExpRow *object)
    39333901{
    39343902    psMetadata *md = psMetadataAlloc();
    … …  
    40283996        return false;
    40293997    }
     3998    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     3999        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     4000        psFree(md);
     4001        return false;
     4002    }
    40304003
    40314004
    … …  
    40334006}
    40344007
    4035 rawDetrendExpRow *rawDetrendExpObjectFromMetadata(psMetadata *md)
     4008rawExpRow *rawExpObjectFromMetadata(psMetadata *md)
    40364009{
    40374010
    … …  
    41324105        return false;
    41334106    }
    4134 
    4135     return rawDetrendExpRowAlloc(exp_tag, camera, telescope, exp_type, imfiles, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs);
    4136 }
    4137 psArray *rawDetrendExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     4107    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     4108    if (!status) {
     4109        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     4110        return false;
     4111    }
     4112
     4113    return rawExpRowAlloc(exp_tag, camera, telescope, exp_type, imfiles, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs, fault);
     4114}
     4115psArray *rawExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    41384116{
    41394117    psArray         *rowSet;
    … …  
    41414119    psU64           i;
    41424120
    4143     rowSet = psDBSelectRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, limit);
     4121    rowSet = psDBSelectRows(dbh, RAWEXP_TABLE_NAME, where, limit);
    41444122    if (!rowSet) {
    41454123        return NULL;
    … …  
    41514129
    41524130    for (i = 0; i < rowSet->n; i++) {
    4153         rawDetrendExpRow *object = rawDetrendExpObjectFromMetadata(rowSet->data[i]);
     4131        rawExpRow *object = rawExpObjectFromMetadata(rowSet->data[i]);
    41544132        psArrayAdd(returnSet, 0, object);
    41554133        psFree(object);
    … …  
    41604138    return returnSet;
    41614139}
    4162 bool rawDetrendExpDeleteObject(psDB *dbh, const rawDetrendExpRow *object)
    4163 {
    4164     psMetadata *where = rawDetrendExpMetadataFromObject(object);
    4165     long long count = psDBDeleteRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, 0);
     4140bool rawExpDeleteObject(psDB *dbh, const rawExpRow *object)
     4141{
     4142    psMetadata *where = rawExpMetadataFromObject(object);
     4143    long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, 0);
    41664144    psFree(where)
    41674145    if (count < 0) {
    4168         psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawDetrendExp");
     4146        psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp");
    41694147        return false;
    41704148    }
    … …  
    41724150        // XXX should this be a psAbort() instead?  It is possible that
    41734151        // having an object match multiple rows was by design.
    4174         psError(PS_ERR_UNKNOWN, true, "rawDetrendExpRow object matched more then one row.  Check your database schema");
    4175         return false;
    4176     }
    4177 
    4178     return true;
    4179 }
    4180 long long rawDetrendExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     4152        psError(PS_ERR_UNKNOWN, true, "rawExpRow object matched more then one row.  Check your database schema");
     4153        return false;
     4154    }
     4155
     4156    return true;
     4157}
     4158long long rawExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    41814159{
    41824160    long long       deleted = 0;
    41834161
    41844162    for (long long i = 0; i < objects->n; i++) {
    4185         rawDetrendExpRow *object = objects->data[i];
    4186         psMetadata *where = rawDetrendExpMetadataFromObject(object);
    4187         long long count = psDBDeleteRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, limit);
     4163        rawExpRow *object = objects->data[i];
     4164        psMetadata *where = rawExpMetadataFromObject(object);
     4165        long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, limit);
    41884166        psFree(where)
    41894167        if (count < 0) {
    4190             psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawDetrendExp");
     4168            psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp");
    41914169            return count;
    41924170        }
    … …  
    41974175    return deleted;
    41984176}
    4199 bool rawDetrendExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     4177bool rawExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    42004178{
    42014179    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    42034181    psMetadata *output = psMetadataAlloc();
    42044182    for (long i = 0; i < psArrayLength(objects); i++) {
    4205         psMetadata *md = rawDetrendExpMetadataFromObject(objects->data[i]);
     4183        psMetadata *md = rawExpMetadataFromObject(objects->data[i]);
    42064184        if (!psMetadataAddMetadata(
    42074185            output,
    42084186            PS_LIST_TAIL,
    4209             RAWDETRENDEXP_TABLE_NAME,
     4187            RAWEXP_TABLE_NAME,
    42104188            PS_META_DUPLICATE_OK,
    42114189            NULL,
    … …  
    42284206    return true;
    42294207}
    4230 bool rawDetrendExpPrintObject(FILE *stream, rawDetrendExpRow *object, bool mdcf)
     4208bool rawExpPrintObject(FILE *stream, rawExpRow *object, bool mdcf)
    42314209{
    42324210    PS_ASSERT_PTR_NON_NULL(object, false);
    42334211
    4234     psMetadata *md = rawDetrendExpMetadataFromObject(object);
     4212    psMetadata *md = rawExpMetadataFromObject(object);
    42354213
    42364214    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    42434221    return true;
    42444222}
    4245 static void rawScienceExpRowFree(rawScienceExpRow *object);
    4246 
    4247 rawScienceExpRow *rawScienceExpRowAlloc(const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
    4248 {
    4249     rawScienceExpRow *_object;
    4250 
    4251     _object = psAlloc(sizeof(rawScienceExpRow));
    4252     psMemSetDeallocator(_object, (psFreeFunc)rawScienceExpRowFree);
    4253 
    4254     _object->exp_tag = psStringCopy(exp_tag);
    4255     _object->camera = psStringCopy(camera);
    4256     _object->telescope = psStringCopy(telescope);
    4257     _object->exp_type = psStringCopy(exp_type);
    4258     _object->imfiles = imfiles;
    4259     _object->filter = psStringCopy(filter);
    4260     _object->airmass = airmass;
    4261     _object->ra = ra;
    4262     _object->decl = decl;
    4263     _object->exp_time = exp_time;
    4264     _object->bg = bg;
    4265     _object->bg_stdev = bg_stdev;
    4266     _object->bg_mean_stdev = bg_mean_stdev;
    4267     _object->alt = alt;
    4268     _object->az = az;
    4269     _object->ccd_temp = ccd_temp;
    4270     _object->posang = posang;
    4271     _object->object = psStringCopy(object);
    4272     _object->dateobs = psTimeCopy(dateobs);
    4273 
    4274     return _object;
    4275 }
    4276 
    4277 static void rawScienceExpRowFree(rawScienceExpRow *object)
    4278 {
    4279     psFree(object->exp_tag);
    4280     psFree(object->camera);
    4281     psFree(object->telescope);
    4282     psFree(object->exp_type);
    4283     psFree(object->filter);
    4284     psFree(object->object);
    4285     psFree(object->dateobs);
    4286 }
    4287 
    4288 bool rawScienceExpCreateTable(psDB *dbh)
    4289 {
    4290     psMetadata *md = psMetadataAlloc();
    4291     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    4292         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    4293         psFree(md);
    4294         return false;
    4295     }
    4296     if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, "64")) {
    4297         psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    4298         psFree(md);
    4299         return false;
    4300     }
    4301     if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, "64")) {
    4302         psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
    4303         psFree(md);
    4304         return false;
    4305     }
    4306     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) {
    4307         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    4308         psFree(md);
    4309         return false;
    4310     }
    4311     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) {
    4312         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    4313         psFree(md);
    4314         return false;
    4315     }
    4316     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) {
    4317         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    4318         psFree(md);
    4319         return false;
    4320     }
    4321     if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, 0.0)) {
    4322         psError(PS_ERR_UNKNOWN, false, "failed to add item airmass");
    4323         psFree(md);
    4324         return false;
    4325     }
    4326     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, 0.0)) {
    4327         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    4328         psFree(md);
    4329         return false;
    4330     }
    4331     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, 0.0)) {
    4332         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    4333         psFree(md);
    4334         return false;
    4335     }
    4336     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, 0.0)) {
    4337         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time");
    4338         psFree(md);
    4339         return false;
    4340     }
    4341     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
    4342         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    4343         psFree(md);
    4344         return false;
    4345     }
    4346     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) {
    4347         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    4348         psFree(md);
    4349         return false;
    4350     }
    4351     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
    4352         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    4353         psFree(md);
    4354         return false;
    4355     }
    4356     if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, 0.0)) {
    4357         psError(PS_ERR_UNKNOWN, false, "failed to add item alt");
    4358         psFree(md);
    4359         return false;
    4360     }
    4361     if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, 0.0)) {
    4362         psError(PS_ERR_UNKNOWN, false, "failed to add item az");
    4363         psFree(md);
    4364         return false;
    4365     }
    4366     if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, 0.0)) {
    4367         psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp");
    4368         psFree(md);
    4369         return false;
    4370     }
    4371     if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, 0.0)) {
    4372         psError(PS_ERR_UNKNOWN, false, "failed to add item posang");
    4373         psFree(md);
    4374         return false;
    4375     }
    4376     if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, "64")) {
    4377         psError(PS_ERR_UNKNOWN, false, "failed to add item object");
    4378         psFree(md);
    4379         return false;
    4380     }
    4381     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) {
    4382         psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    4383         psFree(md);
    4384         return false;
    4385     }
    4386 
    4387     bool status = psDBCreateTable(dbh, RAWSCIENCEEXP_TABLE_NAME, md);
    4388 
    4389     psFree(md);
    4390 
    4391     return status;
    4392 }
    4393 
    4394 bool rawScienceExpDropTable(psDB *dbh)
    4395 {
    4396     return psDBDropTable(dbh, RAWSCIENCEEXP_TABLE_NAME);
    4397 }
    4398 
    4399 bool rawScienceExpInsert(psDB * dbh, const char *exp_tag, const char *camera, const char *telescope, const char *exp_type, psS32 imfiles, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
    4400 {
    4401     psMetadata *md = psMetadataAlloc();
    4402     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    4403         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    4404         psFree(md);
    4405         return false;
    4406     }
    4407     if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) {
    4408         psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    4409         psFree(md);
    4410         return false;
    4411     }
    4412     if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) {
    4413         psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
    4414         psFree(md);
    4415         return false;
    4416     }
    4417     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) {
    4418         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    4419         psFree(md);
    4420         return false;
    4421     }
    4422     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) {
    4423         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    4424         psFree(md);
    4425         return false;
    4426     }
    4427     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, filter)) {
    4428         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    4429         psFree(md);
    4430         return false;
    4431     }
    4432     if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, airmass)) {
    4433         psError(PS_ERR_UNKNOWN, false, "failed to add item airmass");
    4434         psFree(md);
    4435         return false;
    4436     }
    4437     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, ra)) {
    4438         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    4439         psFree(md);
    4440         return false;
    4441     }
    4442     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, decl)) {
    4443         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    4444         psFree(md);
    4445         return false;
    4446     }
    4447     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, exp_time)) {
    4448         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time");
    4449         psFree(md);
    4450         return false;
    4451     }
    4452     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
    4453         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    4454         psFree(md);
    4455         return false;
    4456     }
    4457     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) {
    4458         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    4459         psFree(md);
    4460         return false;
    4461     }
    4462     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
    4463         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    4464         psFree(md);
    4465         return false;
    4466     }
    4467     if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, alt)) {
    4468         psError(PS_ERR_UNKNOWN, false, "failed to add item alt");
    4469         psFree(md);
    4470         return false;
    4471     }
    4472     if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, az)) {
    4473         psError(PS_ERR_UNKNOWN, false, "failed to add item az");
    4474         psFree(md);
    4475         return false;
    4476     }
    4477     if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, ccd_temp)) {
    4478         psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp");
    4479         psFree(md);
    4480         return false;
    4481     }
    4482     if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, posang)) {
    4483         psError(PS_ERR_UNKNOWN, false, "failed to add item posang");
    4484         psFree(md);
    4485         return false;
    4486     }
    4487     if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object)) {
    4488         psError(PS_ERR_UNKNOWN, false, "failed to add item object");
    4489         psFree(md);
    4490         return false;
    4491     }
    4492     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    4493         psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    4494         psFree(md);
    4495         return false;
    4496     }
    4497 
    4498     bool status = psDBInsertOneRow(dbh, RAWSCIENCEEXP_TABLE_NAME, md);
    4499     psFree(md);
    4500 
    4501     return status;
    4502 }
    4503 
    4504 long long rawScienceExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    4505 {
    4506     long long       deleted = 0;
    4507 
    4508     long long count = psDBDeleteRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, limit);
    4509     if (count < 0) {
    4510         psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawScienceExp");
    4511         return count;
    4512 
    4513         deleted += count;
    4514     }
    4515 
    4516     return deleted;
    4517 }
    4518 bool rawScienceExpInsertObject(psDB *dbh, rawScienceExpRow *object)
    4519 {
    4520     return rawScienceExpInsert(dbh, object->exp_tag, object->camera, object->telescope, object->exp_type, object->imfiles, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs);
    4521 }
    4522 
    4523 bool rawScienceExpInsertObjects(psDB *dbh, psArray *objects)
    4524 {
    4525     for (long i = 0; i < psArrayLength(objects); i++) {
    4526         if (!rawScienceExpInsertObject(dbh, objects->data[i])) {
    4527             return false;
    4528         }
    4529     }
    4530 
    4531     return true;
    4532 }
    4533 
    4534 bool rawScienceExpInsertFits(psDB *dbh, const psFits *fits)
    4535 {
    4536     psArray         *rowSet;
    4537 
    4538     // move to (the first?) extension named  RAWSCIENCEEXP_TABLE_NAME
    4539     if (!psFitsMoveExtName(fits, RAWSCIENCEEXP_TABLE_NAME)) {
    4540         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", RAWSCIENCEEXP_TABLE_NAME);
    4541         return false;
    4542     }
    4543 
    4544     // check HDU type
    4545     if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
    4546         psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
    4547         return false;
    4548     }
    4549 
    4550     // read fits table
    4551     rowSet = psFitsReadTable(fits);
    4552     if (!rowSet) {
    4553         psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
    4554         psFree(rowSet);
    4555         return false;
    4556     }
    4557 
    4558     if (!psDBInsertRows(dbh, RAWSCIENCEEXP_TABLE_NAME, rowSet)) {
    4559         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    4560         psFree(rowSet);
    4561         return false;
    4562     }
    4563 
    4564     psFree(rowSet);
    4565 
    4566     return true;
    4567 }
    4568 
    4569 bool rawScienceExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    4570 {
    4571     psArray         *rowSet;
    4572 
    4573     rowSet = psDBSelectRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, limit);
    4574     if (!rowSet) {
    4575         return false;
    4576     }
    4577 
    4578     // output to fits
    4579     if (!psFitsWriteTable(fits, NULL, rowSet, RAWSCIENCEEXP_TABLE_NAME)) {
    4580         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    4581         psFree(rowSet);
    4582         return false;
    4583     }
    4584 
    4585     psFree(rowSet);
    4586 
    4587     return true;
    4588 }
    4589 
    4590 psMetadata *rawScienceExpMetadataFromObject(const rawScienceExpRow *object)
    4591 {
    4592     psMetadata *md = psMetadataAlloc();
    4593     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    4594         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    4595         psFree(md);
    4596         return false;
    4597     }
    4598     if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) {
    4599         psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    4600         psFree(md);
    4601         return false;
    4602     }
    4603     if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) {
    4604         psError(PS_ERR_UNKNOWN, false, "failed to add item telescope");
    4605         psFree(md);
    4606         return false;
    4607     }
    4608     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) {
    4609         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type");
    4610         psFree(md);
    4611         return false;
    4612     }
    4613     if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, object->imfiles)) {
    4614         psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    4615         psFree(md);
    4616         return false;
    4617     }
    4618     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) {
    4619         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    4620         psFree(md);
    4621         return false;
    4622     }
    4623     if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, object->airmass)) {
    4624         psError(PS_ERR_UNKNOWN, false, "failed to add item airmass");
    4625         psFree(md);
    4626         return false;
    4627     }
    4628     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, object->ra)) {
    4629         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    4630         psFree(md);
    4631         return false;
    4632     }
    4633     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, object->decl)) {
    4634         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    4635         psFree(md);
    4636         return false;
    4637     }
    4638     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, object->exp_time)) {
    4639         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time");
    4640         psFree(md);
    4641         return false;
    4642     }
    4643     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
    4644         psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
    4645         psFree(md);
    4646         return false;
    4647     }
    4648     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) {
    4649         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev");
    4650         psFree(md);
    4651         return false;
    4652     }
    4653     if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
    4654         psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    4655         psFree(md);
    4656         return false;
    4657     }
    4658     if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, object->alt)) {
    4659         psError(PS_ERR_UNKNOWN, false, "failed to add item alt");
    4660         psFree(md);
    4661         return false;
    4662     }
    4663     if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, object->az)) {
    4664         psError(PS_ERR_UNKNOWN, false, "failed to add item az");
    4665         psFree(md);
    4666         return false;
    4667     }
    4668     if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, object->ccd_temp)) {
    4669         psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp");
    4670         psFree(md);
    4671         return false;
    4672     }
    4673     if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, object->posang)) {
    4674         psError(PS_ERR_UNKNOWN, false, "failed to add item posang");
    4675         psFree(md);
    4676         return false;
    4677     }
    4678     if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object->object)) {
    4679         psError(PS_ERR_UNKNOWN, false, "failed to add item object");
    4680         psFree(md);
    4681         return false;
    4682     }
    4683     if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) {
    4684         psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
    4685         psFree(md);
    4686         return false;
    4687     }
    4688 
    4689 
    4690     return md;
    4691 }
    4692 
    4693 rawScienceExpRow *rawScienceExpObjectFromMetadata(psMetadata *md)
    4694 {
    4695 
    4696 bool status = false;
    4697     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    4698     if (!status) {
    4699         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    4700         return false;
    4701     }
    4702     char* camera = psMetadataLookupPtr(&status, md, "camera");
    4703     if (!status) {
    4704         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    4705         return false;
    4706     }
    4707     char* telescope = psMetadataLookupPtr(&status, md, "telescope");
    4708     if (!status) {
    4709         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    4710         return false;
    4711     }
    4712     char* exp_type = psMetadataLookupPtr(&status, md, "exp_type");
    4713     if (!status) {
    4714         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    4715         return false;
    4716     }
    4717     psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles");
    4718     if (!status) {
    4719         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    4720         return false;
    4721     }
    4722     char* filter = psMetadataLookupPtr(&status, md, "filter");
    4723     if (!status) {
    4724         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    4725         return false;
    4726     }
    4727     psF32 airmass = psMetadataLookupF32(&status, md, "airmass");
    4728     if (!status) {
    4729         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass");
    4730         return false;
    4731     }
    4732     psF64 ra = psMetadataLookupF64(&status, md, "ra");
    4733     if (!status) {
    4734         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    4735         return false;
    4736     }
    4737     psF64 decl = psMetadataLookupF64(&status, md, "decl");
    4738     if (!status) {
    4739         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    4740         return false;
    4741     }
    4742     psF32 exp_time = psMetadataLookupF32(&status, md, "exp_time");
    4743     if (!status) {
    4744         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time");
    4745         return false;
    4746     }
    4747     psF64 bg = psMetadataLookupF64(&status, md, "bg");
    4748     if (!status) {
    4749         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    4750         return false;
    4751     }
    4752     psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev");
    4753     if (!status) {
    4754         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    4755         return false;
    4756     }
    4757     psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
    4758     if (!status) {
    4759         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    4760         return false;
    4761     }
    4762     psF64 alt = psMetadataLookupF64(&status, md, "alt");
    4763     if (!status) {
    4764         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt");
    4765         return false;
    4766     }
    4767     psF64 az = psMetadataLookupF64(&status, md, "az");
    4768     if (!status) {
    4769         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    4770         return false;
    4771     }
    4772     psF32 ccd_temp = psMetadataLookupF32(&status, md, "ccd_temp");
    4773     if (!status) {
    4774         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp");
    4775         return false;
    4776     }
    4777     psF64 posang = psMetadataLookupF64(&status, md, "posang");
    4778     if (!status) {
    4779         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang");
    4780         return false;
    4781     }
    4782     char* object = psMetadataLookupPtr(&status, md, "object");
    4783     if (!status) {
    4784         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object");
    4785         return false;
    4786     }
    4787     psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs");
    4788     if (!status) {
    4789         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs");
    4790         return false;
    4791     }
    4792 
    4793     return rawScienceExpRowAlloc(exp_tag, camera, telescope, exp_type, imfiles, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs);
    4794 }
    4795 psArray *rawScienceExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    4796 {
    4797     psArray         *rowSet;
    4798     psArray         *returnSet;
    4799     psU64           i;
    4800 
    4801     rowSet = psDBSelectRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, limit);
    4802     if (!rowSet) {
    4803         return NULL;
    4804     }
    4805 
    4806     // convert psMetadata rows to row objects
    4807 
    4808     returnSet = psArrayAllocEmpty(rowSet->n);
    4809 
    4810     for (i = 0; i < rowSet->n; i++) {
    4811         rawScienceExpRow *object = rawScienceExpObjectFromMetadata(rowSet->data[i]);
    4812         psArrayAdd(returnSet, 0, object);
    4813         psFree(object);
    4814     }
    4815 
    4816     psFree(rowSet);
    4817 
    4818     return returnSet;
    4819 }
    4820 bool rawScienceExpDeleteObject(psDB *dbh, const rawScienceExpRow *object)
    4821 {
    4822     psMetadata *where = rawScienceExpMetadataFromObject(object);
    4823     long long count = psDBDeleteRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, 0);
    4824     psFree(where)
    4825     if (count < 0) {
    4826         psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawScienceExp");
    4827         return false;
    4828     }
    4829     if (count > 1) {
    4830         // XXX should this be a psAbort() instead?  It is possible that
    4831         // having an object match multiple rows was by design.
    4832         psError(PS_ERR_UNKNOWN, true, "rawScienceExpRow object matched more then one row.  Check your database schema");
    4833         return false;
    4834     }
    4835 
    4836     return true;
    4837 }
    4838 long long rawScienceExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    4839 {
    4840     long long       deleted = 0;
    4841 
    4842     for (long long i = 0; i < objects->n; i++) {
    4843         rawScienceExpRow *object = objects->data[i];
    4844         psMetadata *where = rawScienceExpMetadataFromObject(object);
    4845         long long count = psDBDeleteRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, limit);
    4846         psFree(where)
    4847         if (count < 0) {
    4848             psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawScienceExp");
    4849             return count;
    4850         }
    4851 
    4852         deleted += count;
    4853     }
    4854 
    4855     return deleted;
    4856 }
    4857 bool rawScienceExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    4858 {
    4859     PS_ASSERT_PTR_NON_NULL(objects, false);
    4860 
    4861     psMetadata *output = psMetadataAlloc();
    4862     for (long i = 0; i < psArrayLength(objects); i++) {
    4863         psMetadata *md = rawScienceExpMetadataFromObject(objects->data[i]);
    4864         if (!psMetadataAddMetadata(
    4865             output,
    4866             PS_LIST_TAIL,
    4867             RAWSCIENCEEXP_TABLE_NAME,
    4868             PS_META_DUPLICATE_OK,
    4869             NULL,
    4870             md
    4871         )) {
    4872             psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
    4873             psFree(md);
    4874             psFree(output);
    4875             return false;
    4876         }
    4877         psFree(md);
    4878     }
    4879 
    4880     if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
    4881         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    4882         psFree(output);
    4883     }
    4884     psFree(output);
    4885 
    4886     return true;
    4887 }
    4888 bool rawScienceExpPrintObject(FILE *stream, rawScienceExpRow *object, bool mdcf)
    4889 {
    4890     PS_ASSERT_PTR_NON_NULL(object, false);
    4891 
    4892     psMetadata *md = rawScienceExpMetadataFromObject(object);
    4893 
    4894     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    4895         psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    4896         psFree(md);
    4897     }
    4898 
    4899     psFree(md);
    4900 
    4901     return true;
    4902 }
    49034223static void rawImfileRowFree(rawImfileRow *object);
    49044224
    4905 rawImfileRow *rawImfileRowAlloc(const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
     4225rawImfileRow *rawImfileRowAlloc(const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault)
    49064226{
    49074227    rawImfileRow    *_object;
    … …  
    49294249    _object->object = psStringCopy(object);
    49304250    _object->dateobs = psTimeCopy(dateobs);
     4251    _object->fault = fault;
    49314252
    49324253    return _object;
    … …  
    50434364        return false;
    50444365    }
     4366    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "NOT NULL", 0)) {
     4367        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     4368        psFree(md);
     4369        return false;
     4370    }
    50454371
    50464372    bool status = psDBCreateTable(dbh, RAWIMFILE_TABLE_NAME, md);
    … …  
    50564382}
    50574383
    5058 bool rawImfileInsert(psDB * dbh, const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs)
     4384bool rawImfileInsert(psDB * dbh, const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault)
    50594385{
    50604386    psMetadata *md = psMetadataAlloc();
    … …  
    51514477    if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) {
    51524478        psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs");
     4479        psFree(md);
     4480        return false;
     4481    }
     4482    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) {
     4483        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    51534484        psFree(md);
    51544485        return false;
    … …  
    51774508bool rawImfileInsertObject(psDB *dbh, rawImfileRow *object)
    51784509{
    5179     return rawImfileInsert(dbh, object->exp_tag, object->class, object->class_id, object->uri, object->exp_type, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs);
     4510    return rawImfileInsert(dbh, object->exp_tag, object->class, object->class_id, object->uri, object->exp_type, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs, object->fault);
    51804511}
    51814512
    … …  
    53454676        return false;
    53464677    }
     4678    if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) {
     4679        psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
     4680        psFree(md);
     4681        return false;
     4682    }
    53474683
    53484684
    … …  
    54494785        return false;
    54504786    }
    5451 
    5452     return rawImfileRowAlloc(exp_tag, class, class_id, uri, exp_type, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs);
     4787    psS16 fault = psMetadataLookupS16(&status, md, "fault");
     4788    if (!status) {
     4789        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault");
     4790        return false;
     4791    }
     4792
     4793    return rawImfileRowAlloc(exp_tag, class, class_id, uri, exp_type, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs, fault);
    54534794}
    54544795psArray *rawImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
Note: See TracChangeset for help on using the changeset viewer.