IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11045


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

VERSION 0.0.73

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/config.md

    r11030 r11045  
    22    pkg_name        STR     ippdb
    33    pkg_namespace   STR     ippdb
    4     pkg_version     STR     0.0.72
     4    pkg_version     STR     0.0.73
    55END

  • trunk/ippdb/Makefile.am

    r10753 r11045  
    1919    $(top_builddir)/docs/man/man3/newExpRow.3 \
    2020    $(top_builddir)/docs/man/man3/newImfileRow.3 \
    21     $(top_builddir)/docs/man/man3/rawDetrendExpRow.3 \
    22     $(top_builddir)/docs/man/man3/rawScienceExpRow.3 \
     21    $(top_builddir)/docs/man/man3/rawExpRow.3 \
    2322    $(top_builddir)/docs/man/man3/rawImfileRow.3 \
    2423    $(top_builddir)/docs/man/man3/p1PendingExpRow.3 \
    … …  
    5049
    5150
    52 docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawDetrendExpRow.3 docs/man/man3/rawScienceExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4RunRow.3 docs/man/man3/p4InputImfileRow.3 docs/man/man3/p4WarpedImfileRow.3 docs/man/man3/p4StackedImfileRow.3 docs/man/man3/p4DiffImfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3:
     51docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/p4RunRow.3 docs/man/man3/p4InputImfileRow.3 docs/man/man3/p4WarpedImfileRow.3 docs/man/man3/p4StackedImfileRow.3 docs/man/man3/p4DiffImfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3:
    5352        $(DOXYGEN)
    5453

  • trunk/ippdb/configure.ac

    r11030 r11045  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [0.0.72], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [0.0.73], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • 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

  • trunk/ippdb/tests/alloc.c

    r11030 r11045  
    244244        newExpRow       *object;
    245245
    246         object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, -16    );
     246        object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32    );
    247247
    248248        if (!object) {
    … …  
    277277            exit(EXIT_FAILURE);
    278278        }
    279             psFree(object);
    280             exit(EXIT_FAILURE);
    281         }
    282279
    283280        psFree(object);
    … …  
    287284        newImfileRow    *object;
    288285
    289         object = newImfileRowAlloc("a string", "a string", "a string", "a string", -16    );
     286        object = newImfileRowAlloc("a string", "a string", "a string", "a string"    );
    290287
    291288        if (!object) {
    … …  
    309306            exit(EXIT_FAILURE);
    310307        }
    311             psFree(object);
    312             exit(EXIT_FAILURE);
    313         }
    314 
    315         psFree(object);
    316     }
    317 
    318     {
    319         rawDetrendExpRow *object;
    320 
    321         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
     308
     309        psFree(object);
     310    }
     311
     312    {
     313        rawExpRow       *object;
     314
     315        object = rawExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16    );
    322316
    323317        if (!object) {
    … …  
    400394            exit(EXIT_FAILURE);
    401395        }
    402 
    403         psFree(object);
    404     }
    405 
    406     {
    407         rawScienceExpRow *object;
    408 
    409         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
    410 
    411         if (!object) {
    412             exit(EXIT_FAILURE);
    413         }
    414 
    415         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    416             psFree(object);
    417             exit(EXIT_FAILURE);
    418         }
    419         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    420             psFree(object);
    421             exit(EXIT_FAILURE);
    422         }
    423         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     396            psFree(object);
     397            exit(EXIT_FAILURE);
     398        }
     399
     400        psFree(object);
     401    }
     402
     403    {
     404        rawImfileRow    *object;
     405
     406        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16    );
     407
     408        if (!object) {
     409            exit(EXIT_FAILURE);
     410        }
     411
     412        if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
     413            psFree(object);
     414            exit(EXIT_FAILURE);
     415        }
     416        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     417            psFree(object);
     418            exit(EXIT_FAILURE);
     419        }
     420        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     421            psFree(object);
     422            exit(EXIT_FAILURE);
     423        }
     424        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    424425            psFree(object);
    425426            exit(EXIT_FAILURE);
    … …  
    429430            exit(EXIT_FAILURE);
    430431        }
    431         if (!object->imfiles == -32) {
    432             psFree(object);
    433             exit(EXIT_FAILURE);
    434         }
    435432        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    436433            psFree(object);
    … …  
    485482            exit(EXIT_FAILURE);
    486483        }
    487             psFree(object);
    488             exit(EXIT_FAILURE);
    489         }
    490 
    491         psFree(object);
    492     }
    493 
    494     {
    495         rawImfileRow    *object;
    496 
    497         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z"    );
    498 
    499         if (!object) {
    500             exit(EXIT_FAILURE);
    501         }
    502 
    503         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    504             psFree(object);
    505             exit(EXIT_FAILURE);
    506         }
    507         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    508             psFree(object);
    509             exit(EXIT_FAILURE);
    510         }
    511         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    512             psFree(object);
    513             exit(EXIT_FAILURE);
    514         }
    515         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    516             psFree(object);
    517             exit(EXIT_FAILURE);
    518         }
    519         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    520             psFree(object);
    521             exit(EXIT_FAILURE);
    522         }
    523         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    524             psFree(object);
    525             exit(EXIT_FAILURE);
    526         }
    527         if (!object->airmass == 32.32) {
    528             psFree(object);
    529             exit(EXIT_FAILURE);
    530         }
    531         if (!object->ra == 64.64) {
    532             psFree(object);
    533             exit(EXIT_FAILURE);
    534         }
    535         if (!object->decl == 64.64) {
    536             psFree(object);
    537             exit(EXIT_FAILURE);
    538         }
    539         if (!object->exp_time == 32.32) {
    540             psFree(object);
    541             exit(EXIT_FAILURE);
    542         }
    543         if (!object->bg == 64.64) {
    544             psFree(object);
    545             exit(EXIT_FAILURE);
    546         }
    547         if (!object->bg_stdev == 64.64) {
    548             psFree(object);
    549             exit(EXIT_FAILURE);
    550         }
    551         if (!object->bg_mean_stdev == 64.64) {
    552             psFree(object);
    553             exit(EXIT_FAILURE);
    554         }
    555         if (!object->alt == 64.64) {
    556             psFree(object);
    557             exit(EXIT_FAILURE);
    558         }
    559         if (!object->az == 64.64) {
    560             psFree(object);
    561             exit(EXIT_FAILURE);
    562         }
    563         if (!object->ccd_temp == 32.32) {
    564             psFree(object);
    565             exit(EXIT_FAILURE);
    566         }
    567         if (!object->posang == 64.64) {
    568             psFree(object);
    569             exit(EXIT_FAILURE);
    570         }
    571         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    572484            psFree(object);
    573485            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/createtable.c

    r10753 r11045  
    148148        }
    149149
    150         if(!rawDetrendExpCreateTable(dbh)) {
    151             exit(EXIT_FAILURE);
    152         }
    153 
    154         psDBCleanup(dbh);
    155     }
    156 
    157     {
    158         psDB            *dbh;
    159 
    160         dbh = psDBInit("localhost", "test", NULL, "test");
    161         if (!dbh) {
    162             exit(EXIT_FAILURE);
    163         }
    164 
    165         if(!rawScienceExpCreateTable(dbh)) {
     150        if(!rawExpCreateTable(dbh)) {
    166151            exit(EXIT_FAILURE);
    167152        }

  • trunk/ippdb/tests/dbcleanup.c

    r10753 r11045  
    2020    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newExp");
    2121    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newImfile");
    22     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawDetrendExp");
    23     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawScienceExp");
     22    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawExp");
    2423    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawImfile");
    2524    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p1PendingExp");

  • trunk/ippdb/tests/dbsetup.c

    r10753 r11045  
    4040    newImfileCreateTable(dbh);
    4141
    42     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawDetrendExp");
    43     rawDetrendExpCreateTable(dbh);
    44 
    45     p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawScienceExp");
    46     rawScienceExpCreateTable(dbh);
     42    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawExp");
     43    rawExpCreateTable(dbh);
    4744
    4845    p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawImfile");

  • trunk/ippdb/tests/droptable.c

    r10753 r11045  
    148148        }
    149149
    150         if (!rawDetrendExpDropTable(dbh)) {
    151             exit(EXIT_FAILURE);
    152         }
    153 
    154         psDBCleanup(dbh);
    155     }
    156 
    157     {
    158         psDB            *dbh;
    159 
    160         dbh = psDBInit("localhost", "test", NULL, "test");
    161         if (!dbh) {
    162             exit(EXIT_FAILURE);
    163         }
    164 
    165         if (!rawScienceExpDropTable(dbh)) {
     150        if (!rawExpDropTable(dbh)) {
    166151            exit(EXIT_FAILURE);
    167152        }

  • trunk/ippdb/tests/insert.c

    r11030 r11045  
    118118        }
    119119
    120         if (!newExpInsert(dbh, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, -16)) {
    121             exit(EXIT_FAILURE);
    122         }
    123 
    124         psDBCleanup(dbh);
    125     }
    126 
    127     {
    128         psDB            *dbh;
    129 
    130         dbh = psDBInit("localhost", "test", NULL, "test");
    131         if (!dbh) {
    132             exit(EXIT_FAILURE);
    133         }
    134 
    135         if (!newImfileInsert(dbh, "a string", "a string", "a string", "a string", -16)) {
    136             exit(EXIT_FAILURE);
    137         }
    138 
    139         psDBCleanup(dbh);
    140     }
    141 
    142     {
    143         psDB            *dbh;
    144 
    145         dbh = psDBInit("localhost", "test", NULL, "test");
    146         if (!dbh) {
    147             exit(EXIT_FAILURE);
    148         }
    149 
    150         if (!rawDetrendExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
    151             exit(EXIT_FAILURE);
    152         }
    153 
    154         psDBCleanup(dbh);
    155     }
    156 
    157     {
    158         psDB            *dbh;
    159 
    160         dbh = psDBInit("localhost", "test", NULL, "test");
    161         if (!dbh) {
    162             exit(EXIT_FAILURE);
    163         }
    164 
    165         if (!rawScienceExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
    166             exit(EXIT_FAILURE);
    167         }
    168 
    169         psDBCleanup(dbh);
    170     }
    171 
    172     {
    173         psDB            *dbh;
    174 
    175         dbh = psDBInit("localhost", "test", NULL, "test");
    176         if (!dbh) {
    177             exit(EXIT_FAILURE);
    178         }
    179 
    180         if (!rawImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z")) {
     120        if (!newExpInsert(dbh, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32)) {
     121            exit(EXIT_FAILURE);
     122        }
     123
     124        psDBCleanup(dbh);
     125    }
     126
     127    {
     128        psDB            *dbh;
     129
     130        dbh = psDBInit("localhost", "test", NULL, "test");
     131        if (!dbh) {
     132            exit(EXIT_FAILURE);
     133        }
     134
     135        if (!newImfileInsert(dbh, "a string", "a string", "a string", "a string")) {
     136            exit(EXIT_FAILURE);
     137        }
     138
     139        psDBCleanup(dbh);
     140    }
     141
     142    {
     143        psDB            *dbh;
     144
     145        dbh = psDBInit("localhost", "test", NULL, "test");
     146        if (!dbh) {
     147            exit(EXIT_FAILURE);
     148        }
     149
     150        if (!rawExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16)) {
     151            exit(EXIT_FAILURE);
     152        }
     153
     154        psDBCleanup(dbh);
     155    }
     156
     157    {
     158        psDB            *dbh;
     159
     160        dbh = psDBInit("localhost", "test", NULL, "test");
     161        if (!dbh) {
     162            exit(EXIT_FAILURE);
     163        }
     164
     165        if (!rawImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16)) {
    181166            exit(EXIT_FAILURE);
    182167        }

  • trunk/ippdb/tests/insertfits.c

    r10753 r11045  
    258258        }
    259259
    260         if (!rawDetrendExpInsertFits(dbh, fits)) {
    261             exit(EXIT_FAILURE);
    262         }
    263 
    264         if (!psFitsClose(fits)) {
    265             exit(EXIT_FAILURE);
    266         }
    267 
    268         psDBCleanup(dbh);
    269     }
    270 
    271     {
    272         psDB            *dbh;
    273         psFits          *fits;
    274 
    275         dbh = psDBInit("localhost", "test", NULL, "test");
    276         if (!dbh) {
    277             exit(EXIT_FAILURE);
    278         }
    279 
    280         // open a temp
    281         fits = psFitsOpen(TMP_FILENAME, "r");
    282         if (!fits) {
    283             exit(EXIT_FAILURE);
    284         }
    285 
    286         if (!rawScienceExpInsertFits(dbh, fits)) {
     260        if (!rawExpInsertFits(dbh, fits)) {
    287261            exit(EXIT_FAILURE);
    288262        }

  • trunk/ippdb/tests/insertobject.c

    r11030 r11045  
    168168        }
    169169
    170         object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, -16);
     170        object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32);
    171171        if (!object) {
    172172            exit(EXIT_FAILURE);
    … …  
    190190        }
    191191
    192         object = newImfileRowAlloc("a string", "a string", "a string", "a string", -16);
     192        object = newImfileRowAlloc("a string", "a string", "a string", "a string");
    193193        if (!object) {
    194194            exit(EXIT_FAILURE);
    … …  
    205205    {
    206206        psDB            *dbh;
    207         rawDetrendExpRow *object;
    208 
    209         dbh = psDBInit("localhost", "test", NULL, "test");
    210         if (!dbh) {
    211             exit(EXIT_FAILURE);
    212         }
    213 
    214         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    215         if (!object) {
    216             exit(EXIT_FAILURE);
    217         }
    218 
    219         if (!rawDetrendExpInsertObject(dbh, object)) {
    220             exit(EXIT_FAILURE);
    221         }
    222 
    223         psFree(object);
    224         psDBCleanup(dbh);
    225     }
    226 
    227     {
    228         psDB            *dbh;
    229         rawScienceExpRow *object;
    230 
    231         dbh = psDBInit("localhost", "test", NULL, "test");
    232         if (!dbh) {
    233             exit(EXIT_FAILURE);
    234         }
    235 
    236         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    237         if (!object) {
    238             exit(EXIT_FAILURE);
    239         }
    240 
    241         if (!rawScienceExpInsertObject(dbh, object)) {
     207        rawExpRow       *object;
     208
     209        dbh = psDBInit("localhost", "test", NULL, "test");
     210        if (!dbh) {
     211            exit(EXIT_FAILURE);
     212        }
     213
     214        object = rawExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16);
     215        if (!object) {
     216            exit(EXIT_FAILURE);
     217        }
     218
     219        if (!rawExpInsertObject(dbh, object)) {
    242220            exit(EXIT_FAILURE);
    243221        }
    … …  
    256234        }
    257235
    258         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
     236        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16);
    259237        if (!object) {
    260238            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/metadatafromobject.c

    r11030 r11045  
    302302        bool            status;
    303303
    304         object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, -16);
     304        object = newExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32);
    305305        if (!object) {
    306306            exit(EXIT_FAILURE);
    … …  
    341341            exit(EXIT_FAILURE);
    342342        }
    343             psFree(md);
    344             exit(EXIT_FAILURE);
    345         }
    346343
    347344        psFree(md);
    … …  
    353350        bool            status;
    354351
    355         object = newImfileRowAlloc("a string", "a string", "a string", "a string", -16);
     352        object = newImfileRowAlloc("a string", "a string", "a string", "a string");
    356353        if (!object) {
    357354            exit(EXIT_FAILURE);
    … …  
    381378            exit(EXIT_FAILURE);
    382379        }
    383             psFree(md);
    384             exit(EXIT_FAILURE);
    385         }
    386 
    387         psFree(md);
    388     }
    389 
    390     {
    391         psMetadata      *md;
    392         rawDetrendExpRow *object;
    393         bool            status;
    394 
    395         object = rawDetrendExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    396         if (!object) {
    397             exit(EXIT_FAILURE);
    398         }
    399 
    400         md = rawDetrendExpMetadataFromObject(object);
     380
     381        psFree(md);
     382    }
     383
     384    {
     385        psMetadata      *md;
     386        rawExpRow       *object;
     387        bool            status;
     388
     389        object = rawExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16);
     390        if (!object) {
     391            exit(EXIT_FAILURE);
     392        }
     393
     394        md = rawExpMetadataFromObject(object);
    401395        if (!md) {
    402396            exit(EXIT_FAILURE);
    … …  
    480474            exit(EXIT_FAILURE);
    481475        }
    482 
    483         psFree(md);
    484     }
    485 
    486     {
    487         psMetadata      *md;
    488         rawScienceExpRow *object;
    489         bool            status;
    490 
    491         object = rawScienceExpRowAlloc("a string", "a string", "a string", "a string", -32, "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    492         if (!object) {
    493             exit(EXIT_FAILURE);
    494         }
    495 
    496         md = rawScienceExpMetadataFromObject(object);
    497         if (!md) {
    498             exit(EXIT_FAILURE);
    499         }
    500 
    501         psFree(object);
    502 
    503         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    504             psFree(md);
    505             exit(EXIT_FAILURE);
    506         }
    507         if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) {
    508             psFree(md);
    509             exit(EXIT_FAILURE);
    510         }
    511         if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) {
     476            psFree(md);
     477            exit(EXIT_FAILURE);
     478        }
     479
     480        psFree(md);
     481    }
     482
     483    {
     484        psMetadata      *md;
     485        rawImfileRow    *object;
     486        bool            status;
     487
     488        object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16);
     489        if (!object) {
     490            exit(EXIT_FAILURE);
     491        }
     492
     493        md = rawImfileMetadataFromObject(object);
     494        if (!md) {
     495            exit(EXIT_FAILURE);
     496        }
     497
     498        psFree(object);
     499
     500        if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
     501            psFree(md);
     502            exit(EXIT_FAILURE);
     503        }
     504        if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
     505            psFree(md);
     506            exit(EXIT_FAILURE);
     507        }
     508        if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
     509            psFree(md);
     510            exit(EXIT_FAILURE);
     511        }
     512        if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    512513            psFree(md);
    513514            exit(EXIT_FAILURE);
    … …  
    517518            exit(EXIT_FAILURE);
    518519        }
    519         if (!psMetadataLookupS32(&status, md, "imfiles") == -32) {
    520             psFree(md);
    521             exit(EXIT_FAILURE);
    522         }
    523520        if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    524521            psFree(md);
    … …  
    573570            exit(EXIT_FAILURE);
    574571        }
    575             psFree(md);
    576             exit(EXIT_FAILURE);
    577         }
    578 
    579         psFree(md);
    580     }
    581 
    582     {
    583         psMetadata      *md;
    584         rawImfileRow    *object;
    585         bool            status;
    586 
    587         object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z");
    588         if (!object) {
    589             exit(EXIT_FAILURE);
    590         }
    591 
    592         md = rawImfileMetadataFromObject(object);
    593         if (!md) {
    594             exit(EXIT_FAILURE);
    595         }
    596 
    597         psFree(object);
    598 
    599         if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) {
    600             psFree(md);
    601             exit(EXIT_FAILURE);
    602         }
    603         if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) {
    604             psFree(md);
    605             exit(EXIT_FAILURE);
    606         }
    607         if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) {
    608             psFree(md);
    609             exit(EXIT_FAILURE);
    610         }
    611         if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) {
    612             psFree(md);
    613             exit(EXIT_FAILURE);
    614         }
    615         if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) {
    616             psFree(md);
    617             exit(EXIT_FAILURE);
    618         }
    619         if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) {
    620             psFree(md);
    621             exit(EXIT_FAILURE);
    622         }
    623         if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) {
    624             psFree(md);
    625             exit(EXIT_FAILURE);
    626         }
    627         if (!psMetadataLookupF64(&status, md, "ra") == 64.64) {
    628             psFree(md);
    629             exit(EXIT_FAILURE);
    630         }
    631         if (!psMetadataLookupF64(&status, md, "decl") == 64.64) {
    632             psFree(md);
    633             exit(EXIT_FAILURE);
    634         }
    635         if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) {
    636             psFree(md);
    637             exit(EXIT_FAILURE);
    638         }
    639         if (!psMetadataLookupF64(&status, md, "bg") == 64.64) {
    640             psFree(md);
    641             exit(EXIT_FAILURE);
    642         }
    643         if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) {
    644             psFree(md);
    645             exit(EXIT_FAILURE);
    646         }
    647         if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) {
    648             psFree(md);
    649             exit(EXIT_FAILURE);
    650         }
    651         if (!psMetadataLookupF64(&status, md, "alt") == 64.64) {
    652             psFree(md);
    653             exit(EXIT_FAILURE);
    654         }
    655         if (!psMetadataLookupF64(&status, md, "az") == 64.64) {
    656             psFree(md);
    657             exit(EXIT_FAILURE);
    658         }
    659         if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) {
    660             psFree(md);
    661             exit(EXIT_FAILURE);
    662         }
    663         if (!psMetadataLookupF64(&status, md, "posang") == 64.64) {
    664             psFree(md);
    665             exit(EXIT_FAILURE);
    666         }
    667         if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) {
    668572            psFree(md);
    669573            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/objectfrommetadata.c

    r11030 r11045  
    450450            exit(EXIT_FAILURE);
    451451        }
    452             psFree(md);
    453             exit(EXIT_FAILURE);
    454         }
    455452
    456453        object = newExpObjectFromMetadata(md);
    … …  
    489486            exit(EXIT_FAILURE);
    490487        }
    491             psFree(object);
    492             exit(EXIT_FAILURE);
    493         }
    494488
    495489        psFree(object);
    … …  
    517511            exit(EXIT_FAILURE);
    518512        }
    519             psFree(md);
    520             exit(EXIT_FAILURE);
    521         }
    522513
    523514        object = newImfileObjectFromMetadata(md);
    … …  
    545536            exit(EXIT_FAILURE);
    546537        }
    547             psFree(object);
    548             exit(EXIT_FAILURE);
    549         }
    550 
    551         psFree(object);
    552     }
    553 
    554     {
    555         psMetadata      *md;
    556         rawDetrendExpRow *object;
     538
     539        psFree(object);
     540    }
     541
     542    {
     543        psMetadata      *md;
     544        rawExpRow       *object;
    557545
    558546        md = psMetadataAlloc();
    … …  
    632620            exit(EXIT_FAILURE);
    633621        }
    634 
    635         object = rawDetrendExpObjectFromMetadata(md);
     622            psFree(md);
     623            exit(EXIT_FAILURE);
     624        }
     625
     626        object = rawExpObjectFromMetadata(md);
    636627        if (!object) {
    637628            psFree(md);
    … …  
    716707            exit(EXIT_FAILURE);
    717708        }
    718 
    719         psFree(object);
    720     }
    721 
    722     {
    723         psMetadata      *md;
    724         rawScienceExpRow *object;
     709            psFree(object);
     710            exit(EXIT_FAILURE);
     711        }
     712
     713        psFree(object);
     714    }
     715
     716    {
     717        psMetadata      *md;
     718        rawImfileRow    *object;
    725719
    726720        md = psMetadataAlloc();
    … …  
    729723            exit(EXIT_FAILURE);
    730724        }
    731         if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) {
    732             psFree(md);
    733             exit(EXIT_FAILURE);
    734         }
    735         if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) {
     725        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
     726            psFree(md);
     727            exit(EXIT_FAILURE);
     728        }
     729        if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
     730            psFree(md);
     731            exit(EXIT_FAILURE);
     732        }
     733        if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    736734            psFree(md);
    737735            exit(EXIT_FAILURE);
    … …  
    741739            exit(EXIT_FAILURE);
    742740        }
    743         if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) {
    744             psFree(md);
    745             exit(EXIT_FAILURE);
    746         }
    747741        if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    748742            psFree(md);
    … …  
    800794            exit(EXIT_FAILURE);
    801795        }
    802 
    803         object = rawScienceExpObjectFromMetadata(md);
     796            psFree(md);
     797            exit(EXIT_FAILURE);
     798        }
     799
     800        object = rawImfileObjectFromMetadata(md);
    804801        if (!object) {
    805802            psFree(md);
    … …  
    813810            exit(EXIT_FAILURE);
    814811        }
    815         if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) {
    816             psFree(object);
    817             exit(EXIT_FAILURE);
    818         }
    819         if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) {
     812        if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
     813            psFree(object);
     814            exit(EXIT_FAILURE);
     815        }
     816        if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
     817            psFree(object);
     818            exit(EXIT_FAILURE);
     819        }
     820        if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    820821            psFree(object);
    821822            exit(EXIT_FAILURE);
    … …  
    825826            exit(EXIT_FAILURE);
    826827        }
    827         if (!object->imfiles == -32) {
    828             psFree(object);
    829             exit(EXIT_FAILURE);
    830         }
    831828        if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    832829            psFree(object);
    … …  
    881878            exit(EXIT_FAILURE);
    882879        }
    883             psFree(object);
    884             exit(EXIT_FAILURE);
    885         }
    886 
    887         psFree(object);
    888     }
    889 
    890     {
    891         psMetadata      *md;
    892         rawImfileRow    *object;
    893 
    894         md = psMetadataAlloc();
    895         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) {
    896             psFree(md);
    897             exit(EXIT_FAILURE);
    898         }
    899         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) {
    900             psFree(md);
    901             exit(EXIT_FAILURE);
    902         }
    903         if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) {
    904             psFree(md);
    905             exit(EXIT_FAILURE);
    906         }
    907         if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) {
    908             psFree(md);
    909             exit(EXIT_FAILURE);
    910         }
    911         if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) {
    912             psFree(md);
    913             exit(EXIT_FAILURE);
    914         }
    915         if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) {
    916             psFree(md);
    917             exit(EXIT_FAILURE);
    918         }
    919         if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) {
    920             psFree(md);
    921             exit(EXIT_FAILURE);
    922         }
    923         if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) {
    924             psFree(md);
    925             exit(EXIT_FAILURE);
    926         }
    927         if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) {
    928             psFree(md);
    929             exit(EXIT_FAILURE);
    930         }
    931         if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) {
    932             psFree(md);
    933             exit(EXIT_FAILURE);
    934         }
    935         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) {
    936             psFree(md);
    937             exit(EXIT_FAILURE);
    938         }
    939         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) {
    940             psFree(md);
    941             exit(EXIT_FAILURE);
    942         }
    943         if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) {
    944             psFree(md);
    945             exit(EXIT_FAILURE);
    946         }
    947         if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) {
    948             psFree(md);
    949             exit(EXIT_FAILURE);
    950         }
    951         if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) {
    952             psFree(md);
    953             exit(EXIT_FAILURE);
    954         }
    955         if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) {
    956             psFree(md);
    957             exit(EXIT_FAILURE);
    958         }
    959         if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) {
    960             psFree(md);
    961             exit(EXIT_FAILURE);
    962         }
    963         if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) {
    964             psFree(md);
    965             exit(EXIT_FAILURE);
    966         }
    967             psFree(md);
    968             exit(EXIT_FAILURE);
    969         }
    970 
    971         object = rawImfileObjectFromMetadata(md);
    972         if (!object) {
    973             psFree(md);
    974             exit(EXIT_FAILURE);
    975         }
    976 
    977         psFree(md);
    978 
    979         if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) {
    980             psFree(object);
    981             exit(EXIT_FAILURE);
    982         }
    983         if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) {
    984             psFree(object);
    985             exit(EXIT_FAILURE);
    986         }
    987         if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) {
    988             psFree(object);
    989             exit(EXIT_FAILURE);
    990         }
    991         if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) {
    992             psFree(object);
    993             exit(EXIT_FAILURE);
    994         }
    995         if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) {
    996             psFree(object);
    997             exit(EXIT_FAILURE);
    998         }
    999         if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) {
    1000             psFree(object);
    1001             exit(EXIT_FAILURE);
    1002         }
    1003         if (!object->airmass == 32.32) {
    1004             psFree(object);
    1005             exit(EXIT_FAILURE);
    1006         }
    1007         if (!object->ra == 64.64) {
    1008             psFree(object);
    1009             exit(EXIT_FAILURE);
    1010         }
    1011         if (!object->decl == 64.64) {
    1012             psFree(object);
    1013             exit(EXIT_FAILURE);
    1014         }
    1015         if (!object->exp_time == 32.32) {
    1016             psFree(object);
    1017             exit(EXIT_FAILURE);
    1018         }
    1019         if (!object->bg == 64.64) {
    1020             psFree(object);
    1021             exit(EXIT_FAILURE);
    1022         }
    1023         if (!object->bg_stdev == 64.64) {
    1024             psFree(object);
    1025             exit(EXIT_FAILURE);
    1026         }
    1027         if (!object->bg_mean_stdev == 64.64) {
    1028             psFree(object);
    1029             exit(EXIT_FAILURE);
    1030         }
    1031         if (!object->alt == 64.64) {
    1032             psFree(object);
    1033             exit(EXIT_FAILURE);
    1034         }
    1035         if (!object->az == 64.64) {
    1036             psFree(object);
    1037             exit(EXIT_FAILURE);
    1038         }
    1039         if (!object->ccd_temp == 32.32) {
    1040             psFree(object);
    1041             exit(EXIT_FAILURE);
    1042         }
    1043         if (!object->posang == 64.64) {
    1044             psFree(object);
    1045             exit(EXIT_FAILURE);
    1046         }
    1047         if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) {
    1048880            psFree(object);
    1049881            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/selectrowsfits.c

    r10753 r11045  
    219219        }
    220220
    221         if (!rawDetrendExpSelectRowsFits(dbh, fits, NULL, 1)) {
    222             exit(EXIT_FAILURE);
    223         }
    224 
    225         psFree(fits);
    226         psDBCleanup(dbh);
    227     }
    228 
    229     {
    230         psDB            *dbh;
    231         psFits          *fits;
    232 
    233         dbh = psDBInit("localhost", "test", NULL, "test");
    234         if (!dbh) {
    235             exit(EXIT_FAILURE);
    236         }
    237 
    238         fits = psFitsOpen(TMP_FILENAME, "w");
    239         if (!fits) {
    240             exit(EXIT_FAILURE);
    241         }
    242 
    243         if (!rawScienceExpSelectRowsFits(dbh, fits, NULL, 1)) {
     221        if (!rawExpSelectRowsFits(dbh, fits, NULL, 1)) {
    244222            exit(EXIT_FAILURE);
    245223        }
Note: See TracChangeset for help on using the changeset viewer.