IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11045 for trunk/ippdb/src


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

VERSION 0.0.73

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

  • trunk/ippdb/src/ippdb.h

    r11030 r11045  
    15901590    char            *exp_type;
    15911591    psS32           imfiles;
    1592     psS16           fault;
    15931592} newExpRow;
    15941593
    … …  
    16051604    psTime*         dateobs,
    16061605    const char      *exp_type,
    1607     psS32           imfiles,
    1608     psS16           fault
     1606    psS32           imfiles
    16091607);
    16101608
    … …  
    16421640    psTime*         dateobs,
    16431641    const char      *exp_type,
    1644     psS32           imfiles,
    1645     psS16           fault
     1642    psS32           imfiles
    16461643);
    16471644
    … …  
    18031800    char            *class_id;
    18041801    char            *uri;
    1805     psS16           fault;
    18061802} newImfileRow;
    18071803
    … …  
    18151811    const char      *class,
    18161812    const char      *class_id,
    1817     const char      *uri,
    1818     psS16           fault
     1813    const char      *uri
    18191814);
    18201815
    … …  
    18491844    const char      *class,
    18501845    const char      *class_id,
    1851     const char      *uri,
    1852     psS16           fault
     1846    const char      *uri
    18531847);
    18541848
    … …  
    20001994    bool            mdcf                ///< format as mdconfig or simple
    20011995);
    2002 /** rawDetrendExpRow data structure
    2003  *
    2004  * Structure for representing a single row of rawDetrendExp table data.
     1996/** rawExpRow data structure
     1997 *
     1998 * Structure for representing a single row of rawExp table data.
    20051999 */
    20062000
    … …  
    20252019    char            *object;
    20262020    psTime*         dateobs;
    2027 } rawDetrendExpRow;
    2028 
    2029 /** Creates a new rawDetrendExpRow object
    2030  *
    2031  *  @return A new rawDetrendExpRow object or NULL on failure.
    2032  */
    2033 
    2034 rawDetrendExpRow *rawDetrendExpRowAlloc(
     2021    psS16           fault;
     2022} rawExpRow;
     2023
     2024/** Creates a new rawExpRow object
     2025 *
     2026 *  @return A new rawExpRow object or NULL on failure.
     2027 */
     2028
     2029rawExpRow *rawExpRowAlloc(
    20352030    const char      *exp_tag,
    20362031    const char      *camera,
    … …  
    20512046    psF64           posang,
    20522047    const char      *object,
    2053     psTime*         dateobs
    2054 );
    2055 
    2056 /** Creates a new rawDetrendExp table
    2057  *
    2058  * @return true on success
    2059  */
    2060 
    2061 bool rawDetrendExpCreateTable(
     2048    psTime*         dateobs,
     2049    psS16           fault
     2050);
     2051
     2052/** Creates a new rawExp table
     2053 *
     2054 * @return true on success
     2055 */
     2056
     2057bool rawExpCreateTable(
    20622058    psDB            *dbh                ///< Database handle
    20632059);
    20642060
    2065 /** Deletes a rawDetrendExp table
    2066  *
    2067  * @return true on success
    2068  */
    2069 
    2070 bool rawDetrendExpDropTable(
     2061/** Deletes a rawExp table
     2062 *
     2063 * @return true on success
     2064 */
     2065
     2066bool rawExpDropTable(
    20712067    psDB            *dbh                ///< Database handle
    20722068);
    … …  
    20792075 */
    20802076
    2081 bool rawDetrendExpInsert(
     2077bool rawExpInsert(
    20822078    psDB            *dbh,               ///< Database handle
    20832079    const char      *exp_tag,
    … …  
    20992095    psF64           posang,
    21002096    const char      *object,
    2101     psTime*         dateobs
     2097    psTime*         dateobs,
     2098    psS16           fault
    21022099);
    21032100
    … …  
    21072104 */
    21082105
    2109 long long rawDetrendExpDelete(
     2106long long rawExpDelete(
    21102107    psDB            *dbh,               ///< Database handle
    21112108    const psMetadata *where,            ///< Row match criteria
    … …  
    21132110);
    21142111
    2115 /** Insert a single rawDetrendExpRow object into a table
     2112/** Insert a single rawExpRow object into a table
    21162113 *
    21172114 * This function constructs and inserts a single row based on it's parameters.
    … …  
    21202117 */
    21212118
    2122 bool rawDetrendExpInsertObject(
    2123     psDB            *dbh,               ///< Database handle
    2124     rawDetrendExpRow *object             ///< rawDetrendExpRow object
    2125 );
    2126 
    2127 /** Insert an array of rawDetrendExpRow object into a table
     2119bool rawExpInsertObject(
     2120    psDB            *dbh,               ///< Database handle
     2121    rawExpRow       *object             ///< rawExpRow object
     2122);
     2123
     2124/** Insert an array of rawExpRow object into a table
    21282125 *
    21292126 * This function constructs and inserts multiple rows based on it's parameters.
    … …  
    21322129 */
    21332130
    2134 bool rawDetrendExpInsertObjects(
    2135     psDB            *dbh,               ///< Database handle
    2136     psArray         *objects            ///< array of rawDetrendExpRow objects
    2137 );
    2138 
    2139 /** Insert data from a binary FITS table rawDetrendExpRow into the database
     2131bool rawExpInsertObjects(
     2132    psDB            *dbh,               ///< Database handle
     2133    psArray         *objects            ///< array of rawExpRow objects
     2134);
     2135
     2136/** Insert data from a binary FITS table rawExpRow into the database
    21402137 *
    21412138 * This function expects a psFits object with a FITS table as the first
    … …  
    21472144 */
    21482145
    2149 bool rawDetrendExpInsertFits(
     2146bool rawExpInsertFits(
    21502147    psDB            *dbh,               ///< Database handle
    21512148    const psFits    *fits               ///< psFits object
    … …  
    21622159 */
    21632160
    2164 bool rawDetrendExpSelectRowsFits(
     2161bool rawExpSelectRowsFits(
    21652162    psDB            *dbh,               ///< Database handle
    21662163    psFits          *fits,              ///< psFits object
    … …  
    21692166);
    21702167
    2171 /** Convert a rawDetrendExpRow into an equivalent psMetadata
     2168/** Convert a rawExpRow into an equivalent psMetadata
    21722169 *
    21732170 * @return A psMetadata pointer or NULL on error
    21742171 */
    21752172
    2176 psMetadata *rawDetrendExpMetadataFromObject(
    2177     const rawDetrendExpRow *object             ///< fooRow to convert into a psMetadata
     2173psMetadata *rawExpMetadataFromObject(
     2174    const rawExpRow *object             ///< fooRow to convert into a psMetadata
    21782175);
    21792176
    21802177/** Convert a psMetadata into an equivalent fooRow
    21812178 *
    2182  * @return A rawDetrendExpRow pointer or NULL on error
    2183  */
    2184 
    2185 rawDetrendExpRow *rawDetrendExpObjectFromMetadata(
     2179 * @return A rawExpRow pointer or NULL on error
     2180 */
     2181
     2182rawExpRow *rawExpObjectFromMetadata(
    21862183    psMetadata      *md                 ///< psMetadata to convert into a fooRow
    21872184);
    2188 /** Selects up to limit rows from the database and returns as rawDetrendExpRow objects in a psArray
     2185/** Selects up to limit rows from the database and returns as rawExpRow objects in a psArray
    21892186 *
    21902187 *  See psDBSelectRows() for documentation on the format of where.
    … …  
    21932190 */
    21942191
    2195 psArray *rawDetrendExpSelectRowObjects(
     2192psArray *rawExpSelectRowObjects(
    21962193    psDB            *dbh,               ///< Database handle
    21972194    const psMetadata *where,            ///< Row match criteria
    21982195    unsigned long long limit            ///< Maximum number of elements to return
    21992196);
    2200 /** Deletes a row from the database coresponding to an rawDetrendExp
     2197/** Deletes a row from the database coresponding to an rawExp
    22012198 *
    22022199 *  Note that a 'where' search psMetadata is constructed from each object and
    … …  
    22062203 */
    22072204
    2208 bool rawDetrendExpDeleteObject(
    2209     psDB            *dbh,               ///< Database handle
    2210     const rawDetrendExpRow *object    ///< Object to delete
     2205bool rawExpDeleteObject(
     2206    psDB            *dbh,               ///< Database handle
     2207    const rawExpRow *object    ///< Object to delete
    22112208);
    22122209/** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    … …  
    22182215 */
    22192216
    2220 long long rawDetrendExpDeleteRowObjects(
     2217long long rawExpDeleteRowObjects(
    22212218    psDB            *dbh,               ///< Database handle
    22222219    const psArray   *objects,           ///< Array of objects to delete
    22232220    unsigned long long limit            ///< Maximum number of elements to delete
    22242221);
    2225 /** Formats and prints an array of rawDetrendExpRow objects
     2222/** Formats and prints an array of rawExpRow objects
    22262223 *
    22272224 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    22312228 */
    22322229
    2233 bool rawDetrendExpPrintObjects(
     2230bool rawExpPrintObjects(
    22342231    FILE            *stream,            ///< a stream
    2235     psArray         *objects,           ///< An array of rawDetrendExpRow objects
     2232    psArray         *objects,           ///< An array of rawExpRow objects
    22362233    bool            mdcf                ///< format as mdconfig or simple
    22372234);
    2238 /** Formats and prints an rawDetrendExpRow object
     2235/** Formats and prints an rawExpRow object
    22392236 *
    22402237 * When mdcf is set the formated output is in psMetadataConfig
    … …  
    22442241 */
    22452242
    2246 bool rawDetrendExpPrintObject(
     2243bool rawExpPrintObject(
    22472244    FILE            *stream,            ///< a stream
    2248     rawDetrendExpRow *object,    ///< an rawDetrendExpRow object
    2249     bool            mdcf                ///< format as mdconfig or simple
    2250 );
    2251 /** rawScienceExpRow data structure
    2252  *
    2253  * Structure for representing a single row of rawScienceExp table data.
    2254  */
    2255 
    2256 typedef struct {
    2257     char            *exp_tag;
    2258     char            *camera;
    2259     char            *telescope;
    2260     char            *exp_type;
    2261     psS32           imfiles;
    2262     char            *filter;
    2263     psF32           airmass;
    2264     psF64           ra;
    2265     psF64           decl;
    2266     psF32           exp_time;
    2267     psF64           bg;
    2268     psF64           bg_stdev;
    2269     psF64           bg_mean_stdev;
    2270     psF64           alt;
    2271     psF64           az;
    2272     psF32           ccd_temp;
    2273     psF64           posang;
    2274     char            *object;
    2275     psTime*         dateobs;
    2276 } rawScienceExpRow;
    2277 
    2278 /** Creates a new rawScienceExpRow object
    2279  *
    2280  *  @return A new rawScienceExpRow object or NULL on failure.
    2281  */
    2282 
    2283 rawScienceExpRow *rawScienceExpRowAlloc(
    2284     const char      *exp_tag,
    2285     const char      *camera,
    2286     const char      *telescope,
    2287     const char      *exp_type,
    2288     psS32           imfiles,
    2289     const char      *filter,
    2290     psF32           airmass,
    2291     psF64           ra,
    2292     psF64           decl,
    2293     psF32           exp_time,
    2294     psF64           bg,
    2295     psF64           bg_stdev,
    2296     psF64           bg_mean_stdev,
    2297     psF64           alt,
    2298     psF64           az,
    2299     psF32           ccd_temp,
    2300     psF64           posang,
    2301     const char      *object,
    2302     psTime*         dateobs
    2303 );
    2304 
    2305 /** Creates a new rawScienceExp table
    2306  *
    2307  * @return true on success
    2308  */
    2309 
    2310 bool rawScienceExpCreateTable(
    2311     psDB            *dbh                ///< Database handle
    2312 );
    2313 
    2314 /** Deletes a rawScienceExp table
    2315  *
    2316  * @return true on success
    2317  */
    2318 
    2319 bool rawScienceExpDropTable(
    2320     psDB            *dbh                ///< Database handle
    2321 );
    2322 
    2323 /** Insert a single row into a table
    2324  *
    2325  * This function constructs and inserts a single row based on it's parameters.
    2326  *
    2327  * @return true on success
    2328  */
    2329 
    2330 bool rawScienceExpInsert(
    2331     psDB            *dbh,               ///< Database handle
    2332     const char      *exp_tag,
    2333     const char      *camera,
    2334     const char      *telescope,
    2335     const char      *exp_type,
    2336     psS32           imfiles,
    2337     const char      *filter,
    2338     psF32           airmass,
    2339     psF64           ra,
    2340     psF64           decl,
    2341     psF32           exp_time,
    2342     psF64           bg,
    2343     psF64           bg_stdev,
    2344     psF64           bg_mean_stdev,
    2345     psF64           alt,
    2346     psF64           az,
    2347     psF32           ccd_temp,
    2348     psF64           posang,
    2349     const char      *object,
    2350     psTime*         dateobs
    2351 );
    2352 
    2353 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    2354  *
    2355  * @return A The number of rows removed or a negative value on error
    2356  */
    2357 
    2358 long long rawScienceExpDelete(
    2359     psDB            *dbh,               ///< Database handle
    2360     const psMetadata *where,            ///< Row match criteria
    2361     unsigned long long limit            ///< Maximum number of elements to delete
    2362 );
    2363 
    2364 /** Insert a single rawScienceExpRow object into a table
    2365  *
    2366  * This function constructs and inserts a single row based on it's parameters.
    2367  *
    2368  * @return true on success
    2369  */
    2370 
    2371 bool rawScienceExpInsertObject(
    2372     psDB            *dbh,               ///< Database handle
    2373     rawScienceExpRow *object             ///< rawScienceExpRow object
    2374 );
    2375 
    2376 /** Insert an array of rawScienceExpRow object into a table
    2377  *
    2378  * This function constructs and inserts multiple rows based on it's parameters.
    2379  *
    2380  * @return true on success
    2381  */
    2382 
    2383 bool rawScienceExpInsertObjects(
    2384     psDB            *dbh,               ///< Database handle
    2385     psArray         *objects            ///< array of rawScienceExpRow objects
    2386 );
    2387 
    2388 /** Insert data from a binary FITS table rawScienceExpRow into the database
    2389  *
    2390  * This function expects a psFits object with a FITS table as the first
    2391  * extension.  The table must have at least one row of data in it, that is of
    2392  * the appropriate format (number of columns and their type).  All other
    2393  * extensions are ignored.
    2394  *
    2395  * @return true on success
    2396  */
    2397 
    2398 bool rawScienceExpInsertFits(
    2399     psDB            *dbh,               ///< Database handle
    2400     const psFits    *fits               ///< psFits object
    2401 );
    2402 
    2403 /** Selects up to limit from the database and returns them in a binary FITS table
    2404  *
    2405  * This function assumes an empty psFits object and will create a FITS table
    2406  * as the first extension.
    2407  *
    2408  *  See psDBSelectRows() for documentation on the format of where.
    2409  *
    2410  * @return true on success
    2411  */
    2412 
    2413 bool rawScienceExpSelectRowsFits(
    2414     psDB            *dbh,               ///< Database handle
    2415     psFits          *fits,              ///< psFits object
    2416     const psMetadata *where,            ///< Row match criteria
    2417     unsigned long long limit            ///< Maximum number of elements to return
    2418 );
    2419 
    2420 /** Convert a rawScienceExpRow into an equivalent psMetadata
    2421  *
    2422  * @return A psMetadata pointer or NULL on error
    2423  */
    2424 
    2425 psMetadata *rawScienceExpMetadataFromObject(
    2426     const rawScienceExpRow *object             ///< fooRow to convert into a psMetadata
    2427 );
    2428 
    2429 /** Convert a psMetadata into an equivalent fooRow
    2430  *
    2431  * @return A rawScienceExpRow pointer or NULL on error
    2432  */
    2433 
    2434 rawScienceExpRow *rawScienceExpObjectFromMetadata(
    2435     psMetadata      *md                 ///< psMetadata to convert into a fooRow
    2436 );
    2437 /** Selects up to limit rows from the database and returns as rawScienceExpRow objects in a psArray
    2438  *
    2439  *  See psDBSelectRows() for documentation on the format of where.
    2440  *
    2441  * @return A psArray pointer or NULL on error
    2442  */
    2443 
    2444 psArray *rawScienceExpSelectRowObjects(
    2445     psDB            *dbh,               ///< Database handle
    2446     const psMetadata *where,            ///< Row match criteria
    2447     unsigned long long limit            ///< Maximum number of elements to return
    2448 );
    2449 /** Deletes a row from the database coresponding to an rawScienceExp
    2450  *
    2451  *  Note that a 'where' search psMetadata is constructed from each object and
    2452  *  used to find rows to delete.
    2453  *
    2454  * @return A The number of rows removed or a negative value on error
    2455  */
    2456 
    2457 bool rawScienceExpDeleteObject(
    2458     psDB            *dbh,               ///< Database handle
    2459     const rawScienceExpRow *object    ///< Object to delete
    2460 );
    2461 /** Deletes up to limit rows from the database and returns the number of rows actually deleted.
    2462  *
    2463  *  Note that a 'where' search psMetadata is constructed from each object and
    2464  *  used to find rows to delete.
    2465  *
    2466  * @return A The number of rows removed or a negative value on error
    2467  */
    2468 
    2469 long long rawScienceExpDeleteRowObjects(
    2470     psDB            *dbh,               ///< Database handle
    2471     const psArray   *objects,           ///< Array of objects to delete
    2472     unsigned long long limit            ///< Maximum number of elements to delete
    2473 );
    2474 /** Formats and prints an array of rawScienceExpRow objects
    2475  *
    2476  * When mdcf is set the formated output is in psMetadataConfig
    2477  * format, otherwise it is in a simple tabular format.
    2478  *
    2479  * @return true on success
    2480  */
    2481 
    2482 bool rawScienceExpPrintObjects(
    2483     FILE            *stream,            ///< a stream
    2484     psArray         *objects,           ///< An array of rawScienceExpRow objects
    2485     bool            mdcf                ///< format as mdconfig or simple
    2486 );
    2487 /** Formats and prints an rawScienceExpRow object
    2488  *
    2489  * When mdcf is set the formated output is in psMetadataConfig
    2490  * format, otherwise it is in a simple tabular format.
    2491  *
    2492  * @return true on success
    2493  */
    2494 
    2495 bool rawScienceExpPrintObject(
    2496     FILE            *stream,            ///< a stream
    2497     rawScienceExpRow *object,    ///< an rawScienceExpRow object
     2245    rawExpRow *object,    ///< an rawExpRow object
    24982246    bool            mdcf                ///< format as mdconfig or simple
    24992247);
    … …  
    25232271    char            *object;
    25242272    psTime*         dateobs;
     2273    psS16           fault;
    25252274} rawImfileRow;
    25262275
    … …  
    25492298    psF64           posang,
    25502299    const char      *object,
    2551     psTime*         dateobs
     2300    psTime*         dateobs,
     2301    psS16           fault
    25522302);
    25532303
    … …  
    25972347    psF64           posang,
    25982348    const char      *object,
    2599     psTime*         dateobs
     2349    psTime*         dateobs,
     2350    psS16           fault
    26002351);
    26012352
Note: See TracChangeset for help on using the changeset viewer.