IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 12130 for trunk/ippdb/src


Ignore:
Timestamp:
Feb 28, 2007, 6:43:37 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.4

Location:
trunk/ippdb/src
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r12061 r12130  
    49504950static void guidePendingExpRowFree(guidePendingExpRow *object);
    49514951
    4952 guidePendingExpRow *guidePendingExpRowAlloc(const char *exp_tag, psS32 guide_version, const char *recipe)
     4952guidePendingExpRow *guidePendingExpRowAlloc(psS64 guide_id, const char *exp_tag, const char *recipe)
    49534953{
    49544954    guidePendingExpRow *_object;
    … …  
    49574957    psMemSetDeallocator(_object, (psFreeFunc)guidePendingExpRowFree);
    49584958
     4959    _object->guide_id = guide_id;
    49594960    _object->exp_tag = psStringCopy(exp_tag);
    4960     _object->guide_version = guide_version;
    49614961    _object->recipe = psStringCopy(recipe);
    49624962
    … …  
    49734973{
    49744974    psMetadata *md = psMetadataAlloc();
    4975     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
     4975    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
     4976        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
     4977        psFree(md);
     4978        return false;
     4979    }
     4980    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Key", "64")) {
    49764981        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    4977         psFree(md);
    4978         return false;
    4979     }
    4980     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, "Primary Key", 0)) {
    4981         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    49824982        psFree(md);
    49834983        return false;
    … …  
    50015001}
    50025002
    5003 bool guidePendingExpInsert(psDB * dbh, const char *exp_tag, psS32 guide_version, const char *recipe)
     5003bool guidePendingExpInsert(psDB * dbh, psS64 guide_id, const char *exp_tag, const char *recipe)
    50045004{
    50055005    psMetadata *md = psMetadataAlloc();
     5006    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) {
     5007        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
     5008        psFree(md);
     5009        return false;
     5010    }
    50065011    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    50075012        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    5008         psFree(md);
    5009         return false;
    5010     }
    5011     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
    5012         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    50135013        psFree(md);
    50145014        return false;
    … …  
    50425042bool guidePendingExpInsertObject(psDB *dbh, guidePendingExpRow *object)
    50435043{
    5044     return guidePendingExpInsert(dbh, object->exp_tag, object->guide_version, object->recipe);
     5044    return guidePendingExpInsert(dbh, object->guide_id, object->exp_tag, object->recipe);
    50455045}
    50465046
    … …  
    51155115{
    51165116    psMetadata *md = psMetadataAlloc();
     5117    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) {
     5118        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
     5119        psFree(md);
     5120        return false;
     5121    }
    51175122    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    51185123        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    51205125        return false;
    51215126    }
    5122     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
    5123         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    5124         psFree(md);
    5125         return false;
    5126     }
    51275127    if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) {
    51285128        psError(PS_ERR_UNKNOWN, false, "failed to add item recipe");
    … …  
    51395139
    51405140bool status = false;
     5141    psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id");
     5142    if (!status) {
     5143        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id");
     5144        return false;
     5145    }
    51415146    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    51425147    if (!status) {
    … …  
    51445149        return false;
    51455150    }
    5146     psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
    5147     if (!status) {
    5148         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
    5149         return false;
    5150     }
    51515151    char* recipe = psMetadataLookupPtr(&status, md, "recipe");
    51525152    if (!status) {
    … …  
    51555155    }
    51565156
    5157     return guidePendingExpRowAlloc(exp_tag, guide_version, recipe);
     5157    return guidePendingExpRowAlloc(guide_id, exp_tag, recipe);
    51585158}
    51595159psArray *guidePendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    52675267static void chipPendingExpRowFree(chipPendingExpRow *object);
    52685268
    5269 chipPendingExpRow *chipPendingExpRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
     5269chipPendingExpRow *chipPendingExpRowAlloc(psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
    52705270{
    52715271    chipPendingExpRow *_object;
    … …  
    52745274    psMemSetDeallocator(_object, (psFreeFunc)chipPendingExpRowFree);
    52755275
     5276    _object->chip_id = chip_id;
    52765277    _object->exp_tag = psStringCopy(exp_tag);
    5277     _object->chip_version = chip_version;
    5278     _object->guide_version = guide_version;
     5278    _object->guide_id = guide_id;
    52795279    _object->label = psStringCopy(label);
    52805280    _object->recipe = psStringCopy(recipe);
    … …  
    52975297{
    52985298    psMetadata *md = psMetadataAlloc();
     5299    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
     5300        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5301        psFree(md);
     5302        return false;
     5303    }
    52995304    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    53005305        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    53025307        return false;
    53035308    }
    5304     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
    5305         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5306         psFree(md);
    5307         return false;
    5308     }
    5309     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
    5310         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5309    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Not NULL", 0)) {
     5310        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    53115311        psFree(md);
    53125312        return false;
    … …  
    53455345}
    53465346
    5347 bool chipPendingExpInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
     5347bool chipPendingExpInsert(psDB * dbh, psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *label, const char *recipe, const char *expgroup, const char *dvodb)
    53485348{
    53495349    psMetadata *md = psMetadataAlloc();
     5350    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     5351        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5352        psFree(md);
     5353        return false;
     5354    }
    53505355    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    53515356        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    53535358        return false;
    53545359    }
    5355     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    5356         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5357         psFree(md);
    5358         return false;
    5359     }
    5360     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
    5361         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5360    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) {
     5361        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    53625362        psFree(md);
    53635363        return false;
    … …  
    54065406bool chipPendingExpInsertObject(psDB *dbh, chipPendingExpRow *object)
    54075407{
    5408     return chipPendingExpInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->label, object->recipe, object->expgroup, object->dvodb);
     5408    return chipPendingExpInsert(dbh, object->chip_id, object->exp_tag, object->guide_id, object->label, object->recipe, object->expgroup, object->dvodb);
    54095409}
    54105410
    … …  
    54795479{
    54805480    psMetadata *md = psMetadataAlloc();
     5481    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     5482        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5483        psFree(md);
     5484        return false;
     5485    }
    54815486    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    54825487        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    54845489        return false;
    54855490    }
    5486     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    5487         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5488         psFree(md);
    5489         return false;
    5490     }
    5491     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
    5492         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5491    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) {
     5492        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    54935493        psFree(md);
    54945494        return false;
    … …  
    55235523
    55245524bool status = false;
     5525    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     5526    if (!status) {
     5527        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
     5528        return false;
     5529    }
    55255530    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    55265531    if (!status) {
    … …  
    55285533        return false;
    55295534    }
    5530     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    5531     if (!status) {
    5532         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    5533         return false;
    5534     }
    5535     psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
    5536     if (!status) {
    5537         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
     5535    psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id");
     5536    if (!status) {
     5537        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id");
    55385538        return false;
    55395539    }
    … …  
    55595559    }
    55605560
    5561     return chipPendingExpRowAlloc(exp_tag, chip_version, guide_version, label, recipe, expgroup, dvodb);
     5561    return chipPendingExpRowAlloc(chip_id, exp_tag, guide_id, label, recipe, expgroup, dvodb);
    55625562}
    55635563psArray *chipPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    56715671static void chipPendingImfileRowFree(chipPendingImfileRow *object);
    56725672
    5673 chipPendingImfileRow *chipPendingImfileRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri)
     5673chipPendingImfileRow *chipPendingImfileRowAlloc(psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *class_id, const char *recipe, const char *uri)
    56745674{
    56755675    chipPendingImfileRow *_object;
    … …  
    56785678    psMemSetDeallocator(_object, (psFreeFunc)chipPendingImfileRowFree);
    56795679
     5680    _object->chip_id = chip_id;
    56805681    _object->exp_tag = psStringCopy(exp_tag);
    5681     _object->chip_version = chip_version;
    5682     _object->guide_version = guide_version;
     5682    _object->guide_id = guide_id;
    56835683    _object->class_id = psStringCopy(class_id);
    56845684    _object->recipe = psStringCopy(recipe);
    … …  
    56995699{
    57005700    psMetadata *md = psMetadataAlloc();
     5701    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 0)) {
     5702        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5703        psFree(md);
     5704        return false;
     5705    }
    57015706    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    57025707        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    57045709        return false;
    57055710    }
    5706     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
    5707         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5708         psFree(md);
    5709         return false;
    5710     }
    5711     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
    5712         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5711    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Not NULL", 0)) {
     5712        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    57135713        psFree(md);
    57145714        return false;
    … …  
    57425742}
    57435743
    5744 bool chipPendingImfileInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri)
     5744bool chipPendingImfileInsert(psDB * dbh, psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *class_id, const char *recipe, const char *uri)
    57455745{
    57465746    psMetadata *md = psMetadataAlloc();
     5747    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     5748        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5749        psFree(md);
     5750        return false;
     5751    }
    57475752    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    57485753        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    57505755        return false;
    57515756    }
    5752     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    5753         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5754         psFree(md);
    5755         return false;
    5756     }
    5757     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
    5758         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5757    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) {
     5758        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    57595759        psFree(md);
    57605760        return false;
    … …  
    57985798bool chipPendingImfileInsertObject(psDB *dbh, chipPendingImfileRow *object)
    57995799{
    5800     return chipPendingImfileInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->class_id, object->recipe, object->uri);
     5800    return chipPendingImfileInsert(dbh, object->chip_id, object->exp_tag, object->guide_id, object->class_id, object->recipe, object->uri);
    58015801}
    58025802
    … …  
    58715871{
    58725872    psMetadata *md = psMetadataAlloc();
     5873    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     5874        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     5875        psFree(md);
     5876        return false;
     5877    }
    58735878    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    58745879        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    58765881        return false;
    58775882    }
    5878     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    5879         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    5880         psFree(md);
    5881         return false;
    5882     }
    5883     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
    5884         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     5883    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) {
     5884        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    58855885        psFree(md);
    58865886        return false;
    … …  
    59105910
    59115911bool status = false;
     5912    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     5913    if (!status) {
     5914        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
     5915        return false;
     5916    }
    59125917    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    59135918    if (!status) {
    … …  
    59155920        return false;
    59165921    }
    5917     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    5918     if (!status) {
    5919         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    5920         return false;
    5921     }
    5922     psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
    5923     if (!status) {
    5924         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
     5922    psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id");
     5923    if (!status) {
     5924        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id");
    59255925        return false;
    59265926    }
    … …  
    59415941    }
    59425942
    5943     return chipPendingImfileRowAlloc(exp_tag, chip_version, guide_version, class_id, recipe, uri);
     5943    return chipPendingImfileRowAlloc(chip_id, exp_tag, guide_id, class_id, recipe, uri);
    59445944}
    59455945psArray *chipPendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    60536053static void chipProcessedExpRowFree(chipProcessedExpRow *object);
    60546054
    6055 chipProcessedExpRow *chipProcessedExpRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *expgroup, const char *dvodb)
     6055chipProcessedExpRow *chipProcessedExpRowAlloc(psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *label, const char *expgroup, const char *dvodb)
    60566056{
    60576057    chipProcessedExpRow *_object;
    … …  
    60606060    psMemSetDeallocator(_object, (psFreeFunc)chipProcessedExpRowFree);
    60616061
     6062    _object->chip_id = chip_id;
    60626063    _object->exp_tag = psStringCopy(exp_tag);
    6063     _object->chip_version = chip_version;
    6064     _object->guide_version = guide_version;
     6064    _object->guide_id = guide_id;
    60656065    _object->label = psStringCopy(label);
    60666066    _object->expgroup = psStringCopy(expgroup);
    … …  
    60816081{
    60826082    psMetadata *md = psMetadataAlloc();
     6083    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 0)) {
     6084        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6085        psFree(md);
     6086        return false;
     6087    }
    60836088    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    60846089        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    60866091        return false;
    60876092    }
    6088     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
    6089         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6090         psFree(md);
    6091         return false;
    6092     }
    6093     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
    6094         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6093    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Not NULL", 0)) {
     6094        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    60956095        psFree(md);
    60966096        return false;
    … …  
    61246124}
    61256125
    6126 bool chipProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *label, const char *expgroup, const char *dvodb)
     6126bool chipProcessedExpInsert(psDB * dbh, psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *label, const char *expgroup, const char *dvodb)
    61276127{
    61286128    psMetadata *md = psMetadataAlloc();
     6129    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     6130        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6131        psFree(md);
     6132        return false;
     6133    }
    61296134    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    61306135        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    61326137        return false;
    61336138    }
    6134     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    6135         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6136         psFree(md);
    6137         return false;
    6138     }
    6139     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
    6140         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6139    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) {
     6140        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    61416141        psFree(md);
    61426142        return false;
    … …  
    61806180bool chipProcessedExpInsertObject(psDB *dbh, chipProcessedExpRow *object)
    61816181{
    6182     return chipProcessedExpInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->label, object->expgroup, object->dvodb);
     6182    return chipProcessedExpInsert(dbh, object->chip_id, object->exp_tag, object->guide_id, object->label, object->expgroup, object->dvodb);
    61836183}
    61846184
    … …  
    62536253{
    62546254    psMetadata *md = psMetadataAlloc();
     6255    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     6256        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6257        psFree(md);
     6258        return false;
     6259    }
    62556260    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    62566261        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    62586263        return false;
    62596264    }
    6260     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    6261         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6262         psFree(md);
    6263         return false;
    6264     }
    6265     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
    6266         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6265    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) {
     6266        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    62676267        psFree(md);
    62686268        return false;
    … …  
    62926292
    62936293bool status = false;
     6294    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     6295    if (!status) {
     6296        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
     6297        return false;
     6298    }
    62946299    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    62956300    if (!status) {
    … …  
    62976302        return false;
    62986303    }
    6299     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    6300     if (!status) {
    6301         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    6302         return false;
    6303     }
    6304     psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
    6305     if (!status) {
    6306         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
     6304    psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id");
     6305    if (!status) {
     6306        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id");
    63076307        return false;
    63086308    }
    … …  
    63236323    }
    63246324
    6325     return chipProcessedExpRowAlloc(exp_tag, chip_version, guide_version, label, expgroup, dvodb);
     6325    return chipProcessedExpRowAlloc(chip_id, exp_tag, guide_id, label, expgroup, dvodb);
    63266326}
    63276327psArray *chipProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    67096709static void chipProcessedImfileRowFree(chipProcessedImfileRow *object);
    67106710
    6711 chipProcessedImfileRow *chipProcessedImfileRowAlloc(const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     6711chipProcessedImfileRow *chipProcessedImfileRowAlloc(psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    67126712{
    67136713    chipProcessedImfileRow *_object;
    … …  
    67166716    psMemSetDeallocator(_object, (psFreeFunc)chipProcessedImfileRowFree);
    67176717
     6718    _object->chip_id = chip_id;
    67186719    _object->exp_tag = psStringCopy(exp_tag);
    6719     _object->chip_version = chip_version;
    6720     _object->guide_version = guide_version;
     6720    _object->guide_id = guide_id;
    67216721    _object->class_id = psStringCopy(class_id);
    67226722    _object->recipe = psStringCopy(recipe);
    … …  
    67436743{
    67446744    psMetadata *md = psMetadataAlloc();
     6745    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 0)) {
     6746        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6747        psFree(md);
     6748        return false;
     6749    }
    67456750    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    67466751        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    67486753        return false;
    67496754    }
    6750     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, "Primary Key", 0)) {
    6751         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6752         psFree(md);
    6753         return false;
    6754     }
    6755     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, 0)) {
    6756         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6755    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Not NULL", 0)) {
     6756        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    67576757        psFree(md);
    67586758        return false;
    … …  
    68116811}
    68126812
    6813 bool chipProcessedImfileInsert(psDB * dbh, const char *exp_tag, psS32 chip_version, psS32 guide_version, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     6813bool chipProcessedImfileInsert(psDB * dbh, psS64 chip_id, const char *exp_tag, psS64 guide_id, const char *class_id, const char *recipe, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    68146814{
    68156815    psMetadata *md = psMetadataAlloc();
     6816    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     6817        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6818        psFree(md);
     6819        return false;
     6820    }
    68166821    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    68176822        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    68196824        return false;
    68206825    }
    6821     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    6822         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6823         psFree(md);
    6824         return false;
    6825     }
    6826     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, guide_version)) {
    6827         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6826    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) {
     6827        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    68286828        psFree(md);
    68296829        return false;
    … …  
    68926892bool chipProcessedImfileInsertObject(psDB *dbh, chipProcessedImfileRow *object)
    68936893{
    6894     return chipProcessedImfileInsert(dbh, object->exp_tag, object->chip_version, object->guide_version, object->class_id, object->recipe, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->path_base, object->fault);
     6894    return chipProcessedImfileInsert(dbh, object->chip_id, object->exp_tag, object->guide_id, object->class_id, object->recipe, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->path_base, object->fault);
    68956895}
    68966896
    … …  
    69656965{
    69666966    psMetadata *md = psMetadataAlloc();
     6967    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     6968        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
     6969        psFree(md);
     6970        return false;
     6971    }
    69676972    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    69686973        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    69706975        return false;
    69716976    }
    6972     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    6973         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
    6974         psFree(md);
    6975         return false;
    6976     }
    6977     if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_version", PS_DATA_S32, NULL, object->guide_version)) {
    6978         psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
     6977    if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) {
     6978        psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id");
    69796979        psFree(md);
    69806980        return false;
    … …  
    70297029
    70307030bool status = false;
     7031    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     7032    if (!status) {
     7033        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
     7034        return false;
     7035    }
    70317036    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    70327037    if (!status) {
    … …  
    70347039        return false;
    70357040    }
    7036     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    7037     if (!status) {
    7038         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
    7039         return false;
    7040     }
    7041     psS32 guide_version = psMetadataLookupS32(&status, md, "guide_version");
    7042     if (!status) {
    7043         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_version");
     7041    psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id");
     7042    if (!status) {
     7043        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id");
    70447044        return false;
    70457045    }
    … …  
    70857085    }
    70867086
    7087     return chipProcessedImfileRowAlloc(exp_tag, chip_version, guide_version, class_id, recipe, uri, bg, bg_stdev, bg_mean_stdev, path_base, fault);
     7087    return chipProcessedImfileRowAlloc(chip_id, exp_tag, guide_id, class_id, recipe, uri, bg, bg_stdev, bg_mean_stdev, path_base, fault);
    70887088}
    70897089psArray *chipProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    71977197static void camPendingExpRowFree(camPendingExpRow *object);
    71987198
    7199 camPendingExpRow *camPendingExpRowAlloc(const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *expgroup, const char *dvodb)
     7199camPendingExpRow *camPendingExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *label, const char *expgroup, const char *dvodb)
    72007200{
    72017201    camPendingExpRow *_object;
    … …  
    72047204    psMemSetDeallocator(_object, (psFreeFunc)camPendingExpRowFree);
    72057205
    7206     _object->exp_tag = psStringCopy(exp_tag);
    7207     _object->cam_version = cam_version;
    7208     _object->chip_version = chip_version;
     7206    _object->cam_id = cam_id;
     7207    _object->chip_id = chip_id;
    72097208    _object->label = psStringCopy(label);
    72107209    _object->expgroup = psStringCopy(expgroup);
    … …  
    72167215static void camPendingExpRowFree(camPendingExpRow *object)
    72177216{
    7218     psFree(object->exp_tag);
    72197217    psFree(object->label);
    72207218    psFree(object->expgroup);
    … …  
    72257223{
    72267224    psMetadata *md = psMetadataAlloc();
    7227     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    7228         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7229         psFree(md);
    7230         return false;
    7231     }
    7232     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
    7233         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7234         psFree(md);
    7235         return false;
    7236     }
    7237     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, 0)) {
    7238         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7225    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
     7226        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7227        psFree(md);
     7228        return false;
     7229    }
     7230    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 0)) {
     7231        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    72397232        psFree(md);
    72407233        return false;
    … …  
    72687261}
    72697262
    7270 bool camPendingExpInsert(psDB * dbh, const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *expgroup, const char *dvodb)
     7263bool camPendingExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *label, const char *expgroup, const char *dvodb)
    72717264{
    72727265    psMetadata *md = psMetadataAlloc();
    7273     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    7274         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7275         psFree(md);
    7276         return false;
    7277     }
    7278     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
    7279         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7280         psFree(md);
    7281         return false;
    7282     }
    7283     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    7284         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7266    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     7267        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7268        psFree(md);
     7269        return false;
     7270    }
     7271    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     7272        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    72857273        psFree(md);
    72867274        return false;
    … …  
    73247312bool camPendingExpInsertObject(psDB *dbh, camPendingExpRow *object)
    73257313{
    7326     return camPendingExpInsert(dbh, object->exp_tag, object->cam_version, object->chip_version, object->label, object->expgroup, object->dvodb);
     7314    return camPendingExpInsert(dbh, object->cam_id, object->chip_id, object->label, object->expgroup, object->dvodb);
    73277315}
    73287316
    … …  
    73977385{
    73987386    psMetadata *md = psMetadataAlloc();
    7399     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    7400         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7401         psFree(md);
    7402         return false;
    7403     }
    7404     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
    7405         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7406         psFree(md);
    7407         return false;
    7408     }
    7409     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    7410         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7387    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     7388        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7389        psFree(md);
     7390        return false;
     7391    }
     7392    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     7393        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    74117394        psFree(md);
    74127395        return false;
    … …  
    74367419
    74377420bool status = false;
    7438     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    7439     if (!status) {
    7440         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    7441         return false;
    7442     }
    7443     psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
    7444     if (!status) {
    7445         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
    7446         return false;
    7447     }
    7448     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    7449     if (!status) {
    7450         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     7421    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     7422    if (!status) {
     7423        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
     7424        return false;
     7425    }
     7426    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     7427    if (!status) {
     7428        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
    74517429        return false;
    74527430    }
    … …  
    74677445    }
    74687446
    7469     return camPendingExpRowAlloc(exp_tag, cam_version, chip_version, label, expgroup, dvodb);
     7447    return camPendingExpRowAlloc(cam_id, chip_id, label, expgroup, dvodb);
    74707448}
    74717449psArray *camPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    75797557static void camProcessedExpRowFree(camProcessedExpRow *object);
    75807558
    7581 camProcessedExpRow *camProcessedExpRowAlloc(const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
     7559camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
    75827560{
    75837561    camProcessedExpRow *_object;
    … …  
    75867564    psMemSetDeallocator(_object, (psFreeFunc)camProcessedExpRowFree);
    75877565
    7588     _object->exp_tag = psStringCopy(exp_tag);
    7589     _object->cam_version = cam_version;
    7590     _object->chip_version = chip_version;
     7566    _object->cam_id = cam_id;
     7567    _object->chip_id = chip_id;
    75917568    _object->label = psStringCopy(label);
    75927569    _object->uri = psStringCopy(uri);
    … …  
    76107587static void camProcessedExpRowFree(camProcessedExpRow *object)
    76117588{
    7612     psFree(object->exp_tag);
    76137589    psFree(object->label);
    76147590    psFree(object->uri);
    … …  
    76227598{
    76237599    psMetadata *md = psMetadataAlloc();
    7624     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    7625         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7626         psFree(md);
    7627         return false;
    7628     }
    7629     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
    7630         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7631         psFree(md);
    7632         return false;
    7633     }
    7634     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, 0)) {
    7635         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7600    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) {
     7601        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7602        psFree(md);
     7603        return false;
     7604    }
     7605    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key", 0)) {
     7606        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    76367607        psFree(md);
    76377608        return false;
    … …  
    77257696}
    77267697
    7727 bool camProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 cam_version, psS32 chip_version, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
     7698bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *label, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *path_base, psF32 zp_mean, psF32 zp_stdev, psS16 fault, const char *expgroup, const char *dvodb)
    77287699{
    77297700    psMetadata *md = psMetadataAlloc();
    7730     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    7731         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7732         psFree(md);
    7733         return false;
    7734     }
    7735     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
    7736         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7737         psFree(md);
    7738         return false;
    7739     }
    7740     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, chip_version)) {
    7741         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7701    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     7702        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7703        psFree(md);
     7704        return false;
     7705    }
     7706    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) {
     7707        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    77427708        psFree(md);
    77437709        return false;
    … …  
    78417807bool camProcessedExpInsertObject(psDB *dbh, camProcessedExpRow *object)
    78427808{
    7843     return camProcessedExpInsert(dbh, object->exp_tag, object->cam_version, object->chip_version, object->label, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->path_base, object->zp_mean, object->zp_stdev, object->fault, object->expgroup, object->dvodb);
     7809    return camProcessedExpInsert(dbh, object->cam_id, object->chip_id, object->label, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->path_base, object->zp_mean, object->zp_stdev, object->fault, object->expgroup, object->dvodb);
    78447810}
    78457811
    … …  
    79147880{
    79157881    psMetadata *md = psMetadataAlloc();
    7916     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    7917         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    7918         psFree(md);
    7919         return false;
    7920     }
    7921     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
    7922         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
    7923         psFree(md);
    7924         return false;
    7925     }
    7926     if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_version", PS_DATA_S32, NULL, object->chip_version)) {
    7927         psError(PS_ERR_UNKNOWN, false, "failed to add item chip_version");
     7882    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     7883        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
     7884        psFree(md);
     7885        return false;
     7886    }
     7887    if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) {
     7888        psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    79287889        psFree(md);
    79297890        return false;
    … …  
    80137974
    80147975bool status = false;
    8015     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    8016     if (!status) {
    8017         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    8018         return false;
    8019     }
    8020     psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
    8021     if (!status) {
    8022         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
    8023         return false;
    8024     }
    8025     psS32 chip_version = psMetadataLookupS32(&status, md, "chip_version");
    8026     if (!status) {
    8027         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_version");
     7976    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     7977    if (!status) {
     7978        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
     7979        return false;
     7980    }
     7981    psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
     7982    if (!status) {
     7983        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id");
    80287984        return false;
    80297985    }
    … …  
    81048060    }
    81058061
    8106     return camProcessedExpRowAlloc(exp_tag, cam_version, chip_version, label, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, path_base, zp_mean, zp_stdev, fault, expgroup, dvodb);
     8062    return camProcessedExpRowAlloc(cam_id, chip_id, label, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, path_base, zp_mean, zp_stdev, fault, expgroup, dvodb);
    81078063}
    81088064psArray *camProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    84908446static void detRunRowFree(detRunRow *object);
    84918447
    8492 detRunRow *detRunRowAlloc(psS32 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent)
     8448detRunRow *detRunRowAlloc(psS64 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent)
    84938449{
    84948450    detRunRow       *_object;
    … …  
    85498505{
    85508506    psMetadata *md = psMetadataAlloc();
    8551     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     8507    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
    85528508        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    85538509        psFree(md);
    … …  
    86978653}
    86988654
    8699 bool detRunInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent)
     8655bool detRunInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent)
    87008656{
    87018657    psMetadata *md = psMetadataAlloc();
    8702     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     8658    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    87038659        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    87048660        psFree(md);
    … …  
    89318887{
    89328888    psMetadata *md = psMetadataAlloc();
    8933     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     8889    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    89348890        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    89358891        psFree(md);
    … …  
    90759031
    90769032bool status = false;
    9077     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     9033    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    90789034    if (!status) {
    90799035        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    93239279static void detInputExpRowFree(detInputExpRow *object);
    93249280
    9325 detInputExpRow *detInputExpRowAlloc(psS32 det_id, psS32 iteration, const char *exp_tag, bool include)
     9281detInputExpRow *detInputExpRowAlloc(psS64 det_id, psS32 iteration, const char *exp_tag, bool include)
    93269282{
    93279283    detInputExpRow  *_object;
    … …  
    93469302{
    93479303    psMetadata *md = psMetadataAlloc();
    9348     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     9304    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    93499305        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    93509306        psFree(md);
    … …  
    93799335}
    93809336
    9381 bool detInputExpInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *exp_tag, bool include)
     9337bool detInputExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *exp_tag, bool include)
    93829338{
    93839339    psMetadata *md = psMetadataAlloc();
    9384     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     9340    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    93859341        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    93869342        psFree(md);
    … …  
    94989454{
    94999455    psMetadata *md = psMetadataAlloc();
    9500     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     9456    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    95019457        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    95029458        psFree(md);
    … …  
    95279483
    95289484bool status = false;
    9529     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     9485    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    95309486    if (!status) {
    95319487        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    96609616static void detProcessedImfileRowFree(detProcessedImfileRow *object);
    96619617
    9662 detProcessedImfileRow *detProcessedImfileRowAlloc(psS32 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     9618detProcessedImfileRow *detProcessedImfileRowAlloc(psS64 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    96639619{
    96649620    detProcessedImfileRow *_object;
    … …  
    96939649{
    96949650    psMetadata *md = psMetadataAlloc();
    9695     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     9651    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    96969652        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    96979653        psFree(md);
    … …  
    97569712}
    97579713
    9758 bool detProcessedImfileInsert(psDB * dbh, psS32 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     9714bool detProcessedImfileInsert(psDB * dbh, psS64 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    97599715{
    97609716    psMetadata *md = psMetadataAlloc();
    9761     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     9717    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    97629718        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    97639719        psFree(md);
    … …  
    99059861{
    99069862    psMetadata *md = psMetadataAlloc();
    9907     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     9863    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    99089864        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    99099865        psFree(md);
    … …  
    99649920
    99659921bool status = false;
    9966     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     9922    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    99679923    if (!status) {
    99689924        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1012710083static void detProcessedExpRowFree(detProcessedExpRow *object);
    1012810084
    10129 detProcessedExpRow *detProcessedExpRowAlloc(psS32 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     10085detProcessedExpRow *detProcessedExpRowAlloc(psS64 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1013010086{
    1013110087    detProcessedExpRow *_object;
    … …  
    1015610112{
    1015710113    psMetadata *md = psMetadataAlloc();
    10158     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     10114    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1015910115        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1016010116        psFree(md);
    … …  
    1020910165}
    1021010166
    10211 bool detProcessedExpInsert(psDB * dbh, psS32 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     10167bool detProcessedExpInsert(psDB * dbh, psS64 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1021210168{
    1021310169    psMetadata *md = psMetadataAlloc();
    10214     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     10170    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1021510171        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1021610172        psFree(md);
    … …  
    1034810304{
    1034910305    psMetadata *md = psMetadataAlloc();
    10350     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     10306    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1035110307        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1035210308        psFree(md);
    … …  
    1039710353
    1039810354bool status = false;
    10399     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     10355    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1040010356    if (!status) {
    1040110357        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1055010506static void detStackedImfileRowFree(detStackedImfileRow *object);
    1055110507
    10552 detStackedImfileRow *detStackedImfileRowAlloc(psS32 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psS16 fault)
     10508detStackedImfileRow *detStackedImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psS16 fault)
    1055310509{
    1055410510    detStackedImfileRow *_object;
    … …  
    1058010536{
    1058110537    psMetadata *md = psMetadataAlloc();
    10582     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     10538    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1058310539        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1058410540        psFree(md);
    … …  
    1063810594}
    1063910595
    10640 bool detStackedImfileInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psS16 fault)
     10596bool detStackedImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psS16 fault)
    1064110597{
    1064210598    psMetadata *md = psMetadataAlloc();
    10643     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     10599    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1064410600        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1064510601        psFree(md);
    … …  
    1078210738{
    1078310739    psMetadata *md = psMetadataAlloc();
    10784     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     10740    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1078510741        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1078610742        psFree(md);
    … …  
    1083610792
    1083710793bool status = false;
    10838     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     10794    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1083910795    if (!status) {
    1084010796        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1099410950static void detNormalizedStatImfileRowFree(detNormalizedStatImfileRow *object);
    1099510951
    10996 detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc(psS32 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault)
     10952detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault)
    1099710953{
    1099810954    detNormalizedStatImfileRow *_object;
    … …  
    1101810974{
    1101910975    psMetadata *md = psMetadataAlloc();
    11020     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     10976    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1102110977        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1102210978        psFree(md);
    … …  
    1105611012}
    1105711013
    11058 bool detNormalizedStatImfileInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault)
     11014bool detNormalizedStatImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault)
    1105911015{
    1106011016    psMetadata *md = psMetadataAlloc();
    11061     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     11017    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1106211018        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1106311019        psFree(md);
    … …  
    1118011136{
    1118111137    psMetadata *md = psMetadataAlloc();
    11182     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     11138    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1118311139        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1118411140        psFree(md);
    … …  
    1121411170
    1121511171bool status = false;
    11216     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     11172    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1121711173    if (!status) {
    1121811174        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1135211308static void detNormalizedImfileRowFree(detNormalizedImfileRow *object);
    1135311309
    11354 detNormalizedImfileRow *detNormalizedImfileRowAlloc(psS32 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     11310detNormalizedImfileRow *detNormalizedImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1135511311{
    1135611312    detNormalizedImfileRow *_object;
    … …  
    1138211338{
    1138311339    psMetadata *md = psMetadataAlloc();
    11384     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     11340    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1138511341        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1138611342        psFree(md);
    … …  
    1144011396}
    1144111397
    11442 bool detNormalizedImfileInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     11398bool detNormalizedImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1144311399{
    1144411400    psMetadata *md = psMetadataAlloc();
    11445     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     11401    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1144611402        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1144711403        psFree(md);
    … …  
    1158411540{
    1158511541    psMetadata *md = psMetadataAlloc();
    11586     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     11542    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1158711543        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1158811544        psFree(md);
    … …  
    1163811594
    1163911595bool status = false;
    11640     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     11596    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1164111597    if (!status) {
    1164211598        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1179611752static void detNormalizedExpRowFree(detNormalizedExpRow *object);
    1179711753
    11798 detNormalizedExpRow *detNormalizedExpRowAlloc(psS32 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     11754detNormalizedExpRow *detNormalizedExpRowAlloc(psS64 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1179911755{
    1180011756    detNormalizedExpRow *_object;
    … …  
    1182411780{
    1182511781    psMetadata *md = psMetadataAlloc();
    11826     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     11782    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1182711783        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1182811784        psFree(md);
    … …  
    1187711833}
    1187811834
    11879 bool detNormalizedExpInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     11835bool detNormalizedExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1188011836{
    1188111837    psMetadata *md = psMetadataAlloc();
    11882     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     11838    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1188311839        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1188411840        psFree(md);
    … …  
    1201611972{
    1201711973    psMetadata *md = psMetadataAlloc();
    12018     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     11974    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1201911975        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1202011976        psFree(md);
    … …  
    1206512021
    1206612022bool status = false;
    12067     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     12023    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1206812024    if (!status) {
    1206912025        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1221812174static void detResidImfileRowFree(detResidImfileRow *object);
    1221912175
    12220 detResidImfileRow *detResidImfileRowAlloc(psS32 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     12176detResidImfileRow *detResidImfileRowAlloc(psS64 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1222112177{
    1222212178    detResidImfileRow *_object;
    … …  
    1225212208{
    1225312209    psMetadata *md = psMetadataAlloc();
    12254     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     12210    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1225512211        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1225612212        psFree(md);
    … …  
    1232012276}
    1232112277
    12322 bool detResidImfileInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
     12278bool detResidImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, psS16 fault)
    1232312279{
    1232412280    psMetadata *md = psMetadataAlloc();
    12325     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     12281    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1232612282        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1232712283        psFree(md);
    … …  
    1247412430{
    1247512431    psMetadata *md = psMetadataAlloc();
    12476     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     12432    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1247712433        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1247812434        psFree(md);
    … …  
    1253812494
    1253912495bool status = false;
    12540     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     12496    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1254112497    if (!status) {
    1254212498        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1270612662static void detResidExpRowFree(detResidExpRow *object);
    1270712663
    12708 detResidExpRow *detResidExpRowAlloc(psS32 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, bool accept, psS16 fault)
     12664detResidExpRow *detResidExpRowAlloc(psS64 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, bool accept, psS16 fault)
    1270912665{
    1271012666    detResidExpRow  *_object;
    … …  
    1273712693{
    1273812694    psMetadata *md = psMetadataAlloc();
    12739     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     12695    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1274012696        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1274112697        psFree(md);
    … …  
    1280012756}
    1280112757
    12802 bool detResidExpInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, bool accept, psS16 fault)
     12758bool detResidExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *path_base, bool accept, psS16 fault)
    1280312759{
    1280412760    psMetadata *md = psMetadataAlloc();
    12805     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     12761    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1280612762        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1280712763        psFree(md);
    … …  
    1294912905{
    1295012906    psMetadata *md = psMetadataAlloc();
    12951     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     12907    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1295212908        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1295312909        psFree(md);
    … …  
    1300812964
    1300912965bool status = false;
    13010     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     12966    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1301112967    if (!status) {
    1301212968        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1317113127static void detRunSummaryRowFree(detRunSummaryRow *object);
    1317213128
    13173 detRunSummaryRow *detRunSummaryRowAlloc(psS32 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault)
     13129detRunSummaryRow *detRunSummaryRowAlloc(psS64 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault)
    1317413130{
    1317513131    detRunSummaryRow *_object;
    … …  
    1319613152{
    1319713153    psMetadata *md = psMetadataAlloc();
    13198     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) {
     13154    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key", 0)) {
    1319913155        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1320013156        psFree(md);
    … …  
    1324413200}
    1324513201
    13246 bool detRunSummaryInsert(psDB * dbh, psS32 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault)
     13202bool detRunSummaryInsert(psDB * dbh, psS64 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault)
    1324713203{
    1324813204    psMetadata *md = psMetadataAlloc();
    13249     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, det_id)) {
     13205    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) {
    1325013206        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1325113207        psFree(md);
    … …  
    1337813334{
    1337913335    psMetadata *md = psMetadataAlloc();
    13380     if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, NULL, object->det_id)) {
     13336    if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) {
    1338113337        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    1338213338        psFree(md);
    … …  
    1342213378
    1342313379bool status = false;
    13424     psS32 det_id = psMetadataLookupS32(&status, md, "det_id");
     13380    psS64 det_id = psMetadataLookupS64(&status, md, "det_id");
    1342513381    if (!status) {
    1342613382        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    … …  
    1357013526static void warpRunRowFree(warpRunRow *object);
    1357113527
    13572 warpRunRow *warpRunRowAlloc(psS32 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     13528warpRunRow *warpRunRowAlloc(psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
    1357313529{
    1357413530    warpRunRow      *_object;
    … …  
    1359913555{
    1360013556    psMetadata *md = psMetadataAlloc();
    13601     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     13557    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
    1360213558        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1360313559        psFree(md);
    … …  
    1364213598}
    1364313599
    13644 bool warpRunInsert(psDB * dbh, psS32 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
     13600bool warpRunInsert(psDB * dbh, psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered)
    1364513601{
    1364613602    psMetadata *md = psMetadataAlloc();
    13647     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     13603    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1364813604        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1364913605        psFree(md);
    … …  
    1377113727{
    1377213728    psMetadata *md = psMetadataAlloc();
    13773     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     13729    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1377413730        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1377513731        psFree(md);
    … …  
    1381013766
    1381113767bool status = false;
    13812     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     13768    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1381313769    if (!status) {
    1381413770        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    … …  
    1395313909static void warpInputExpRowFree(warpInputExpRow *object);
    1395413910
    13955 warpInputExpRow *warpInputExpRowAlloc(psS32 warp_id, const char *exp_tag, psS32 cam_version, bool magiced)
     13911warpInputExpRow *warpInputExpRowAlloc(psS64 warp_id, psS64 cam_id, bool magiced)
    1395613912{
    1395713913    warpInputExpRow *_object;
    … …  
    1396113917
    1396213918    _object->warp_id = warp_id;
    13963     _object->exp_tag = psStringCopy(exp_tag);
    13964     _object->cam_version = cam_version;
     13919    _object->cam_id = cam_id;
    1396513920    _object->magiced = magiced;
    1396613921
    … …  
    1397013925static void warpInputExpRowFree(warpInputExpRow *object)
    1397113926{
    13972     psFree(object->exp_tag);
    1397313927}
    1397413928
    … …  
    1397613930{
    1397713931    psMetadata *md = psMetadataAlloc();
    13978     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     13932    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key", 0)) {
    1397913933        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1398013934        psFree(md);
    1398113935        return false;
    1398213936    }
    13983     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    13984         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    13985         psFree(md);
    13986         return false;
    13987     }
    13988     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Key", 0)) {
    13989         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     13937    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) {
     13938        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1399013939        psFree(md);
    1399113940        return false;
    … …  
    1400913958}
    1401013959
    14011 bool warpInputExpInsert(psDB * dbh, psS32 warp_id, const char *exp_tag, psS32 cam_version, bool magiced)
     13960bool warpInputExpInsert(psDB * dbh, psS64 warp_id, psS64 cam_id, bool magiced)
    1401213961{
    1401313962    psMetadata *md = psMetadataAlloc();
    14014     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     13963    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1401513964        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1401613965        psFree(md);
    1401713966        return false;
    1401813967    }
    14019     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    14020         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14021         psFree(md);
    14022         return false;
    14023     }
    14024     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
    14025         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     13968    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     13969        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1402613970        psFree(md);
    1402713971        return false;
    … …  
    1405513999bool warpInputExpInsertObject(psDB *dbh, warpInputExpRow *object)
    1405614000{
    14057     return warpInputExpInsert(dbh, object->warp_id, object->exp_tag, object->cam_version, object->magiced);
     14001    return warpInputExpInsert(dbh, object->warp_id, object->cam_id, object->magiced);
    1405814002}
    1405914003
    … …  
    1412814072{
    1412914073    psMetadata *md = psMetadataAlloc();
    14130     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     14074    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1413114075        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1413214076        psFree(md);
    1413314077        return false;
    1413414078    }
    14135     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    14136         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14137         psFree(md);
    14138         return false;
    14139     }
    14140     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
    14141         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     14079    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     14080        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1414214081        psFree(md);
    1414314082        return false;
    … …  
    1415714096
    1415814097bool status = false;
    14159     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     14098    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1416014099    if (!status) {
    1416114100        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    1416214101        return false;
    1416314102    }
    14164     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    14165     if (!status) {
    14166         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    14167         return false;
    14168     }
    14169     psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
    14170     if (!status) {
    14171         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
     14103    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     14104    if (!status) {
     14105        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
    1417214106        return false;
    1417314107    }
    … …  
    1417814112    }
    1417914113
    14180     return warpInputExpRowAlloc(warp_id, exp_tag, cam_version, magiced);
     14114    return warpInputExpRowAlloc(warp_id, cam_id, magiced);
    1418114115}
    1418214116psArray *warpInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1429014224static void warpSkyCellMapRowFree(warpSkyCellMapRow *object);
    1429114225
    14292 warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS32 warp_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 cam_version, const char *class_id, psS16 fault)
     14226warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault)
    1429314227{
    1429414228    warpSkyCellMapRow *_object;
    … …  
    1430014234    _object->skycell_id = psStringCopy(skycell_id);
    1430114235    _object->tess_id = psStringCopy(tess_id);
    14302     _object->exp_tag = psStringCopy(exp_tag);
    14303     _object->cam_version = cam_version;
     14236    _object->cam_id = cam_id;
    1430414237    _object->class_id = psStringCopy(class_id);
    1430514238    _object->fault = fault;
    … …  
    1431214245    psFree(object->skycell_id);
    1431314246    psFree(object->tess_id);
    14314     psFree(object->exp_tag);
    1431514247    psFree(object->class_id);
    1431614248}
    … …  
    1431914251{
    1432014252    psMetadata *md = psMetadataAlloc();
    14321     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     14253    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key", 0)) {
    1432214254        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1432314255        psFree(md);
    … …  
    1433414266        return false;
    1433514267    }
    14336     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
    14337         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14338         psFree(md);
    14339         return false;
    14340     }
    14341     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, "Primary Key", 0)) {
    14342         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     14268    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) {
     14269        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1434314270        psFree(md);
    1434414271        return false;
    … …  
    1436714294}
    1436814295
    14369 bool warpSkyCellMapInsert(psDB * dbh, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 cam_version, const char *class_id, psS16 fault)
     14296bool warpSkyCellMapInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault)
    1437014297{
    1437114298    psMetadata *md = psMetadataAlloc();
    14372     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     14299    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1437314300        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1437414301        psFree(md);
    … …  
    1438514312        return false;
    1438614313    }
    14387     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
    14388         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14389         psFree(md);
    14390         return false;
    14391     }
    14392     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, cam_version)) {
    14393         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     14314    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) {
     14315        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1439414316        psFree(md);
    1439514317        return false;
    … …  
    1442814350bool warpSkyCellMapInsertObject(psDB *dbh, warpSkyCellMapRow *object)
    1442914351{
    14430     return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->exp_tag, object->cam_version, object->class_id, object->fault);
     14352    return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->cam_id, object->class_id, object->fault);
    1443114353}
    1443214354
    … …  
    1450114423{
    1450214424    psMetadata *md = psMetadataAlloc();
    14503     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     14425    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1450414426        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1450514427        psFree(md);
    … …  
    1451614438        return false;
    1451714439    }
    14518     if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
    14519         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    14520         psFree(md);
    14521         return false;
    14522     }
    14523     if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_version", PS_DATA_S32, NULL, object->cam_version)) {
    14524         psError(PS_ERR_UNKNOWN, false, "failed to add item cam_version");
     14440    if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) {
     14441        psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    1452514442        psFree(md);
    1452614443        return false;
    … …  
    1454514462
    1454614463bool status = false;
    14547     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     14464    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1454814465    if (!status) {
    1454914466        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    … …  
    1456014477        return false;
    1456114478    }
    14562     char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
    14563     if (!status) {
    14564         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    14565         return false;
    14566     }
    14567     psS32 cam_version = psMetadataLookupS32(&status, md, "cam_version");
    14568     if (!status) {
    14569         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_version");
     14479    psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
     14480    if (!status) {
     14481        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id");
    1457014482        return false;
    1457114483    }
    … …  
    1458114493    }
    1458214494
    14583     return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, exp_tag, cam_version, class_id, fault);
     14495    return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, cam_id, class_id, fault);
    1458414496}
    1458514497psArray *warpSkyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1469314605static void warpSkyfileRowFree(warpSkyfileRow *object);
    1469414606
    14695 warpSkyfileRow *warpSkyfileRowAlloc(psS32 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_stdev)
     14607warpSkyfileRow *warpSkyfileRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1469614608{
    1469714609    warpSkyfileRow  *_object;
    … …  
    1472014632{
    1472114633    psMetadata *md = psMetadataAlloc();
    14722     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     14634    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key", 0)) {
    1472314635        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1472414636        psFree(md);
    … …  
    1476314675}
    1476414676
    14765 bool warpSkyfileInsert(psDB * dbh, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_stdev)
     14677bool warpSkyfileInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1476614678{
    1476714679    psMetadata *md = psMetadataAlloc();
    14768     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     14680    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1476914681        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1477014682        psFree(md);
    … …  
    1489214804{
    1489314805    psMetadata *md = psMetadataAlloc();
    14894     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     14806    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1489514807        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1489614808        psFree(md);
    … …  
    1493114843
    1493214844bool status = false;
    14933     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     14845    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1493414846    if (!status) {
    1493514847        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    … …  
    1507414986static void diffRunRowFree(diffRunRow *object);
    1507514987
    15076 diffRunRow *diffRunRowAlloc(psS32 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     14988diffRunRow *diffRunRowAlloc(psS64 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1507714989{
    1507814990    diffRunRow      *_object;
    … …  
    1510515017{
    1510615018    psMetadata *md = psMetadataAlloc();
    15107     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     15019    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
    1510815020        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1510915021        psFree(md);
    … …  
    1515315065}
    1515415066
    15155 bool diffRunInsert(psDB * dbh, psS32 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     15067bool diffRunInsert(psDB * dbh, psS64 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1515615068{
    1515715069    psMetadata *md = psMetadataAlloc();
    15158     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     15070    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) {
    1515915071        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1516015072        psFree(md);
    … …  
    1528715199{
    1528815200    psMetadata *md = psMetadataAlloc();
    15289     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     15201    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) {
    1529015202        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1529115203        psFree(md);
    … …  
    1533115243
    1533215244bool status = false;
    15333     psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     15245    psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id");
    1533415246    if (!status) {
    1533515247        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
    … …  
    1547915391static void diffInputSkyfileRowFree(diffInputSkyfileRow *object);
    1548015392
    15481 diffInputSkyfileRow *diffInputSkyfileRowAlloc(psS32 diff_id, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15393diffInputSkyfileRow *diffInputSkyfileRowAlloc(psS64 diff_id, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
    1548215394{
    1548315395    diffInputSkyfileRow *_object;
    … …  
    1550615418{
    1550715419    psMetadata *md = psMetadataAlloc();
    15508     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key", 0)) {
     15420    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key", 0)) {
    1550915421        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1551015422        psFree(md);
    1551115423        return false;
    1551215424    }
    15513     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     15425    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key", 0)) {
    1551415426        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1551515427        psFree(md);
    … …  
    1554915461}
    1555015462
    15551 bool diffInputSkyfileInsert(psDB * dbh, psS32 diff_id, psS32 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
     15463bool diffInputSkyfileInsert(psDB * dbh, psS64 diff_id, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *kind, bool template)
    1555215464{
    1555315465    psMetadata *md = psMetadataAlloc();
    15554     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     15466    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) {
    1555515467        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1555615468        psFree(md);
    1555715469        return false;
    1555815470    }
    15559     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     15471    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1556015472        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1556115473        psFree(md);
    … …  
    1567815590{
    1567915591    psMetadata *md = psMetadataAlloc();
    15680     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     15592    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) {
    1568115593        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1568215594        psFree(md);
    1568315595        return false;
    1568415596    }
    15685     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     15597    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1568615598        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1568715599        psFree(md);
    … …  
    1571715629
    1571815630bool status = false;
    15719     psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     15631    psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id");
    1572015632    if (!status) {
    1572115633        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
    1572215634        return false;
    1572315635    }
    15724     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     15636    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1572515637    if (!status) {
    1572615638        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    … …  
    1586015772static void diffSkyfileRowFree(diffSkyfileRow *object);
    1586115773
    15862 diffSkyfileRow *diffSkyfileRowAlloc(psS32 diff_id, const char *uri, psF64 bg, psF64 bg_stdev)
     15774diffSkyfileRow *diffSkyfileRowAlloc(psS64 diff_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1586315775{
    1586415776    diffSkyfileRow  *_object;
    … …  
    1588315795{
    1588415796    psMetadata *md = psMetadataAlloc();
    15885     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, "Primary Key", 0)) {
     15797    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key", 0)) {
    1588615798        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1588715799        psFree(md);
    … …  
    1591615828}
    1591715829
    15918 bool diffSkyfileInsert(psDB * dbh, psS32 diff_id, const char *uri, psF64 bg, psF64 bg_stdev)
     15830bool diffSkyfileInsert(psDB * dbh, psS64 diff_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1591915831{
    1592015832    psMetadata *md = psMetadataAlloc();
    15921     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, diff_id)) {
     15833    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) {
    1592215834        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1592315835        psFree(md);
    … …  
    1603515947{
    1603615948    psMetadata *md = psMetadataAlloc();
    16037     if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S32, NULL, object->diff_id)) {
     15949    if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) {
    1603815950        psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    1603915951        psFree(md);
    … …  
    1606415976
    1606515977bool status = false;
    16066     psS32 diff_id = psMetadataLookupS32(&status, md, "diff_id");
     15978    psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id");
    1606715979    if (!status) {
    1606815980        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id");
    … …  
    1619716109static void stackRunRowFree(stackRunRow *object);
    1619816110
    16199 stackRunRow *stackRunRowAlloc(psS32 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     16111stackRunRow *stackRunRowAlloc(psS64 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1620016112{
    1620116113    stackRunRow     *_object;
    … …  
    1622816140{
    1622916141    psMetadata *md = psMetadataAlloc();
    16230     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     16142    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) {
    1623116143        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1623216144        psFree(md);
    … …  
    1627616188}
    1627716189
    16278 bool stackRunInsert(psDB * dbh, psS32 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
     16190bool stackRunInsert(psDB * dbh, psS64 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id)
    1627916191{
    1628016192    psMetadata *md = psMetadataAlloc();
    16281     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     16193    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) {
    1628216194        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1628316195        psFree(md);
    … …  
    1641016322{
    1641116323    psMetadata *md = psMetadataAlloc();
    16412     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     16324    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) {
    1641316325        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1641416326        psFree(md);
    … …  
    1645416366
    1645516367bool status = false;
    16456     psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     16368    psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id");
    1645716369    if (!status) {
    1645816370        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");
    … …  
    1660216514static void stackInputSkyfileRowFree(stackInputSkyfileRow *object);
    1660316515
    16604 stackInputSkyfileRow *stackInputSkyfileRowAlloc(psS32 stack_id, psS32 warp_id)
     16516stackInputSkyfileRow *stackInputSkyfileRowAlloc(psS64 stack_id, psS64 warp_id)
    1660516517{
    1660616518    stackInputSkyfileRow *_object;
    … …  
    1662216534{
    1662316535    psMetadata *md = psMetadataAlloc();
    16624     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key", 0)) {
     16536    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key", 0)) {
    1662516537        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1662616538        psFree(md);
    1662716539        return false;
    1662816540    }
    16629     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, "Primary Key", 0)) {
     16541    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key", 0)) {
    1663016542        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1663116543        psFree(md);
    … …  
    1664516557}
    1664616558
    16647 bool stackInputSkyfileInsert(psDB * dbh, psS32 stack_id, psS32 warp_id)
     16559bool stackInputSkyfileInsert(psDB * dbh, psS64 stack_id, psS64 warp_id)
    1664816560{
    1664916561    psMetadata *md = psMetadataAlloc();
    16650     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     16562    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) {
    1665116563        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1665216564        psFree(md);
    1665316565        return false;
    1665416566    }
    16655     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, warp_id)) {
     16567    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) {
    1665616568        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1665716569        psFree(md);
    … …  
    1675416666{
    1675516667    psMetadata *md = psMetadataAlloc();
    16756     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     16668    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) {
    1675716669        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1675816670        psFree(md);
    1675916671        return false;
    1676016672    }
    16761     if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S32, NULL, object->warp_id)) {
     16673    if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) {
    1676216674        psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1676316675        psFree(md);
    … …  
    1677316685
    1677416686bool status = false;
    16775     psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     16687    psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id");
    1677616688    if (!status) {
    1677716689        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");
    1677816690        return false;
    1677916691    }
    16780     psS32 warp_id = psMetadataLookupS32(&status, md, "warp_id");
     16692    psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id");
    1678116693    if (!status) {
    1678216694        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id");
    … …  
    1689616808static void stackSumSkyfileRowFree(stackSumSkyfileRow *object);
    1689716809
    16898 stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS32 stack_id, const char *uri, psF64 bg, psF64 bg_stdev)
     16810stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS64 stack_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1689916811{
    1690016812    stackSumSkyfileRow *_object;
    … …  
    1691916831{
    1692016832    psMetadata *md = psMetadataAlloc();
    16921     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, "Primary Key", 0)) {
     16833    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key", 0)) {
    1692216834        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1692316835        psFree(md);
    … …  
    1695216864}
    1695316865
    16954 bool stackSumSkyfileInsert(psDB * dbh, psS32 stack_id, const char *uri, psF64 bg, psF64 bg_stdev)
     16866bool stackSumSkyfileInsert(psDB * dbh, psS64 stack_id, const char *uri, psF64 bg, psF64 bg_stdev)
    1695516867{
    1695616868    psMetadata *md = psMetadataAlloc();
    16957     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, stack_id)) {
     16869    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) {
    1695816870        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1695916871        psFree(md);
    … …  
    1707116983{
    1707216984    psMetadata *md = psMetadataAlloc();
    17073     if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S32, NULL, object->stack_id)) {
     16985    if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) {
    1707416986        psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    1707516987        psFree(md);
    … …  
    1710017012
    1710117013bool status = false;
    17102     psS32 stack_id = psMetadataLookupS32(&status, md, "stack_id");
     17014    psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id");
    1710317015    if (!status) {
    1710417016        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id");

  • trunk/ippdb/src/ippdb.h

    r12061 r12130  
    25102510
    25112511typedef struct {
     2512    psS64           guide_id;
    25122513    char            *exp_tag;
    2513     psS32           guide_version;
    25142514    char            *recipe;
    25152515} guidePendingExpRow;
    … …  
    25212521
    25222522guidePendingExpRow *guidePendingExpRowAlloc(
     2523    psS64           guide_id,
    25232524    const char      *exp_tag,
    2524     psS32           guide_version,
    25252525    const char      *recipe
    25262526);
    … …  
    25532553bool guidePendingExpInsert(
    25542554    psDB            *dbh,               ///< Database handle
     2555    psS64           guide_id,
    25552556    const char      *exp_tag,
    2556     psS32           guide_version,
    25572557    const char      *recipe
    25582558);
    … …  
    27112711
    27122712typedef struct {
     2713    psS64           chip_id;
    27132714    char            *exp_tag;
    2714     psS32           chip_version;
    2715     psS32           guide_version;
     2715    psS64           guide_id;
    27162716    char            *label;
    27172717    char            *recipe;
    … …  
    27262726
    27272727chipPendingExpRow *chipPendingExpRowAlloc(
     2728    psS64           chip_id,
    27282729    const char      *exp_tag,
    2729     psS32           chip_version,
    2730     psS32           guide_version,
     2730    psS64           guide_id,
    27312731    const char      *label,
    27322732    const char      *recipe,
    … …  
    27622762bool chipPendingExpInsert(
    27632763    psDB            *dbh,               ///< Database handle
     2764    psS64           chip_id,
    27642765    const char      *exp_tag,
    2765     psS32           chip_version,
    2766     psS32           guide_version,
     2766    psS64           guide_id,
    27672767    const char      *label,
    27682768    const char      *recipe,
    … …  
    29242924
    29252925typedef struct {
     2926    psS64           chip_id;
    29262927    char            *exp_tag;
    2927     psS32           chip_version;
    2928     psS32           guide_version;
     2928    psS64           guide_id;
    29292929    char            *class_id;
    29302930    char            *recipe;
    … …  
    29382938
    29392939chipPendingImfileRow *chipPendingImfileRowAlloc(
     2940    psS64           chip_id,
    29402941    const char      *exp_tag,
    2941     psS32           chip_version,
    2942     psS32           guide_version,
     2942    psS64           guide_id,
    29432943    const char      *class_id,
    29442944    const char      *recipe,
    … …  
    29732973bool chipPendingImfileInsert(
    29742974    psDB            *dbh,               ///< Database handle
     2975    psS64           chip_id,
    29752976    const char      *exp_tag,
    2976     psS32           chip_version,
    2977     psS32           guide_version,
     2977    psS64           guide_id,
    29782978    const char      *class_id,
    29792979    const char      *recipe,
    … …  
    31343134
    31353135typedef struct {
     3136    psS64           chip_id;
    31363137    char            *exp_tag;
    3137     psS32           chip_version;
    3138     psS32           guide_version;
     3138    psS64           guide_id;
    31393139    char            *label;
    31403140    char            *expgroup;
    … …  
    31483148
    31493149chipProcessedExpRow *chipProcessedExpRowAlloc(
     3150    psS64           chip_id,
    31503151    const char      *exp_tag,
    3151     psS32           chip_version,
    3152     psS32           guide_version,
     3152    psS64           guide_id,
    31533153    const char      *label,
    31543154    const char      *expgroup,
    … …  
    31833183bool chipProcessedExpInsert(
    31843184    psDB            *dbh,               ///< Database handle
     3185    psS64           chip_id,
    31853186    const char      *exp_tag,
    3186     psS32           chip_version,
    3187     psS32           guide_version,
     3187    psS64           guide_id,
    31883188    const char      *label,
    31893189    const char      *expgroup,
    … …  
    35393539
    35403540typedef struct {
     3541    psS64           chip_id;
    35413542    char            *exp_tag;
    3542     psS32           chip_version;
    3543     psS32           guide_version;
     3543    psS64           guide_id;
    35443544    char            *class_id;
    35453545    char            *recipe;
    … …  
    35583558
    35593559chipProcessedImfileRow *chipProcessedImfileRowAlloc(
     3560    psS64           chip_id,
    35603561    const char      *exp_tag,
    3561     psS32           chip_version,
    3562     psS32           guide_version,
     3562    psS64           guide_id,
    35633563    const char      *class_id,
    35643564    const char      *recipe,
    … …  
    35983598bool chipProcessedImfileInsert(
    35993599    psDB            *dbh,               ///< Database handle
     3600    psS64           chip_id,
    36003601    const char      *exp_tag,
    3601     psS32           chip_version,
    3602     psS32           guide_version,
     3602    psS64           guide_id,
    36033603    const char      *class_id,
    36043604    const char      *recipe,
    … …  
    37643764
    37653765typedef struct {
    3766     char            *exp_tag;
    3767     psS32           cam_version;
    3768     psS32           chip_version;
     3766    psS64           cam_id;
     3767    psS64           chip_id;
    37693768    char            *label;
    37703769    char            *expgroup;
    … …  
    37783777
    37793778camPendingExpRow *camPendingExpRowAlloc(
    3780     const char      *exp_tag,
    3781     psS32           cam_version,
    3782     psS32           chip_version,
     3779    psS64           cam_id,
     3780    psS64           chip_id,
    37833781    const char      *label,
    37843782    const char      *expgroup,
    … …  
    38133811bool camPendingExpInsert(
    38143812    psDB            *dbh,               ///< Database handle
    3815     const char      *exp_tag,
    3816     psS32           cam_version,
    3817     psS32           chip_version,
     3813    psS64           cam_id,
     3814    psS64           chip_id,
    38183815    const char      *label,
    38193816    const char      *expgroup,
    … …  
    39743971
    39753972typedef struct {
    3976     char            *exp_tag;
    3977     psS32           cam_version;
    3978     psS32           chip_version;
     3973    psS64           cam_id;
     3974    psS64           chip_id;
    39793975    char            *label;
    39803976    char            *uri;
    … …  
    40003996
    40013997camProcessedExpRow *camProcessedExpRowAlloc(
    4002     const char      *exp_tag,
    4003     psS32           cam_version,
    4004     psS32           chip_version,
     3998    psS64           cam_id,
     3999    psS64           chip_id,
    40054000    const char      *label,
    40064001    const char      *uri,
    … …  
    40474042bool camProcessedExpInsert(
    40484043    psDB            *dbh,               ///< Database handle
    4049     const char      *exp_tag,
    4050     psS32           cam_version,
    4051     psS32           chip_version,
     4044    psS64           cam_id,
     4045    psS64           chip_id,
    40524046    const char      *label,
    40534047    const char      *uri,
    … …  
    44154409
    44164410typedef struct {
    4417     psS32           det_id;
     4411    psS64           det_id;
    44184412    psS32           iteration;
    44194413    char            *det_type;
    … …  
    44504444
    44514445detRunRow *detRunRowAlloc(
    4452     psS32           det_id,
     4446    psS64           det_id,
    44534447    psS32           iteration,
    44544448    const char      *det_type,
    … …  
    45064500bool detRunInsert(
    45074501    psDB            *dbh,               ///< Database handle
    4508     psS32           det_id,
     4502    psS64           det_id,
    45094503    psS32           iteration,
    45104504    const char      *det_type,
    … …  
    46884682
    46894683typedef struct {
    4690     psS32           det_id;
     4684    psS64           det_id;
    46914685    psS32           iteration;
    46924686    char            *exp_tag;
    … …  
    47004694
    47014695detInputExpRow *detInputExpRowAlloc(
    4702     psS32           det_id,
     4696    psS64           det_id,
    47034697    psS32           iteration,
    47044698    const char      *exp_tag,
    … …  
    47334727bool detInputExpInsert(
    47344728    psDB            *dbh,               ///< Database handle
    4735     psS32           det_id,
     4729    psS64           det_id,
    47364730    psS32           iteration,
    47374731    const char      *exp_tag,
    … …  
    48924886
    48934887typedef struct {
    4894     psS32           det_id;
     4888    psS64           det_id;
    48954889    char            *exp_tag;
    48964890    char            *class_id;
    … …  
    49104904
    49114905detProcessedImfileRow *detProcessedImfileRowAlloc(
    4912     psS32           det_id,
     4906    psS64           det_id,
    49134907    const char      *exp_tag,
    49144908    const char      *class_id,
    … …  
    49494943bool detProcessedImfileInsert(
    49504944    psDB            *dbh,               ///< Database handle
    4951     psS32           det_id,
     4945    psS64           det_id,
    49524946    const char      *exp_tag,
    49534947    const char      *class_id,
    … …  
    51145108
    51155109typedef struct {
    5116     psS32           det_id;
     5110    psS64           det_id;
    51175111    char            *exp_tag;
    51185112    char            *recipe;
    … …  
    51305124
    51315125detProcessedExpRow *detProcessedExpRowAlloc(
    5132     psS32           det_id,
     5126    psS64           det_id,
    51335127    const char      *exp_tag,
    51345128    const char      *recipe,
    … …  
    51675161bool detProcessedExpInsert(
    51685162    psDB            *dbh,               ///< Database handle
    5169     psS32           det_id,
     5163    psS64           det_id,
    51705164    const char      *exp_tag,
    51715165    const char      *recipe,
    … …  
    53305324
    53315325typedef struct {
    5332     psS32           det_id;
     5326    psS64           det_id;
    53335327    psS32           iteration;
    53345328    char            *class_id;
    … …  
    53475341
    53485342detStackedImfileRow *detStackedImfileRowAlloc(
    5349     psS32           det_id,
     5343    psS64           det_id,
    53505344    psS32           iteration,
    53515345    const char      *class_id,
    … …  
    53855379bool detStackedImfileInsert(
    53865380    psDB            *dbh,               ///< Database handle
    5387     psS32           det_id,
     5381    psS64           det_id,
    53885382    psS32           iteration,
    53895383    const char      *class_id,
    … …  
    55495543
    55505544typedef struct {
    5551     psS32           det_id;
     5545    psS64           det_id;
    55525546    psS32           iteration;
    55535547    char            *class_id;
    … …  
    55625556
    55635557detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc(
    5564     psS32           det_id,
     5558    psS64           det_id,
    55655559    psS32           iteration,
    55665560    const char      *class_id,
    … …  
    55965590bool detNormalizedStatImfileInsert(
    55975591    psDB            *dbh,               ///< Database handle
    5598     psS32           det_id,
     5592    psS64           det_id,
    55995593    psS32           iteration,
    56005594    const char      *class_id,
    … …  
    57565750
    57575751typedef struct {
    5758     psS32           det_id;
     5752    psS64           det_id;
    57595753    psS32           iteration;
    57605754    char            *class_id;
    … …  
    57735767
    57745768detNormalizedImfileRow *detNormalizedImfileRowAlloc(
    5775     psS32           det_id,
     5769    psS64           det_id,
    57765770    psS32           iteration,
    57775771    const char      *class_id,
    … …  
    58115805bool detNormalizedImfileInsert(
    58125806    psDB            *dbh,               ///< Database handle
    5813     psS32           det_id,
     5807    psS64           det_id,
    58145808    psS32           iteration,
    58155809    const char      *class_id,
    … …  
    59755969
    59765970typedef struct {
    5977     psS32           det_id;
     5971    psS64           det_id;
    59785972    psS32           iteration;
    59795973    char            *recipe;
    … …  
    59915985
    59925986detNormalizedExpRow *detNormalizedExpRowAlloc(
    5993     psS32           det_id,
     5987    psS64           det_id,
    59945988    psS32           iteration,
    59955989    const char      *recipe,
    … …  
    60286022bool detNormalizedExpInsert(
    60296023    psDB            *dbh,               ///< Database handle
    6030     psS32           det_id,
     6024    psS64           det_id,
    60316025    psS32           iteration,
    60326026    const char      *recipe,
    … …  
    61916185
    61926186typedef struct {
    6193     psS32           det_id;
     6187    psS64           det_id;
    61946188    psS32           iteration;
    61956189    char            *exp_tag;
    … …  
    62106204
    62116205detResidImfileRow *detResidImfileRowAlloc(
    6212     psS32           det_id,
     6206    psS64           det_id,
    62136207    psS32           iteration,
    62146208    const char      *exp_tag,
    … …  
    62506244bool detResidImfileInsert(
    62516245    psDB            *dbh,               ///< Database handle
    6252     psS32           det_id,
     6246    psS64           det_id,
    62536247    psS32           iteration,
    62546248    const char      *exp_tag,
    … …  
    64166410
    64176411typedef struct {
    6418     psS32           det_id;
     6412    psS64           det_id;
    64196413    psS32           iteration;
    64206414    char            *exp_tag;
    … …  
    64346428
    64356429detResidExpRow *detResidExpRowAlloc(
    6436     psS32           det_id,
     6430    psS64           det_id,
    64376431    psS32           iteration,
    64386432    const char      *exp_tag,
    … …  
    64736467bool detResidExpInsert(
    64746468    psDB            *dbh,               ///< Database handle
    6475     psS32           det_id,
     6469    psS64           det_id,
    64766470    psS32           iteration,
    64776471    const char      *exp_tag,
    … …  
    66386632
    66396633typedef struct {
    6640     psS32           det_id;
     6634    psS64           det_id;
    66416635    psS32           iteration;
    66426636    psF64           bg;
    … …  
    66536647
    66546648detRunSummaryRow *detRunSummaryRowAlloc(
    6655     psS32           det_id,
     6649    psS64           det_id,
    66566650    psS32           iteration,
    66576651    psF64           bg,
    … …  
    66896683bool detRunSummaryInsert(
    66906684    psDB            *dbh,               ///< Database handle
    6691     psS32           det_id,
     6685    psS64           det_id,
    66926686    psS32           iteration,
    66936687    psF64           bg,
    … …  
    68516845
    68526846typedef struct {
    6853     psS32           warp_id;
     6847    psS64           warp_id;
    68546848    char            *mode;
    68556849    char            *state;
    … …  
    68656859
    68666860warpRunRow *warpRunRowAlloc(
    6867     psS32           warp_id,
     6861    psS64           warp_id,
    68686862    const char      *mode,
    68696863    const char      *state,
    … …  
    69006894bool warpRunInsert(
    69016895    psDB            *dbh,               ///< Database handle
    6902     psS32           warp_id,
     6896    psS64           warp_id,
    69036897    const char      *mode,
    69046898    const char      *state,
    … …  
    70617055
    70627056typedef struct {
    7063     psS32           warp_id;
    7064     char            *exp_tag;
    7065     psS32           cam_version;
     7057    psS64           warp_id;
     7058    psS64           cam_id;
    70667059    bool            magiced;
    70677060} warpInputExpRow;
    … …  
    70737066
    70747067warpInputExpRow *warpInputExpRowAlloc(
    7075     psS32           warp_id,
    7076     const char      *exp_tag,
    7077     psS32           cam_version,
     7068    psS64           warp_id,
     7069    psS64           cam_id,
    70787070    bool            magiced
    70797071);
    … …  
    71067098bool warpInputExpInsert(
    71077099    psDB            *dbh,               ///< Database handle
    7108     psS32           warp_id,
    7109     const char      *exp_tag,
    7110     psS32           cam_version,
     7100    psS64           warp_id,
     7101    psS64           cam_id,
    71117102    bool            magiced
    71127103);
    … …  
    72657256
    72667257typedef struct {
    7267     psS32           warp_id;
     7258    psS64           warp_id;
    72687259    char            *skycell_id;
    72697260    char            *tess_id;
    7270     char            *exp_tag;
    7271     psS32           cam_version;
     7261    psS64           cam_id;
    72727262    char            *class_id;
    72737263    psS16           fault;
    … …  
    72807270
    72817271warpSkyCellMapRow *warpSkyCellMapRowAlloc(
    7282     psS32           warp_id,
     7272    psS64           warp_id,
    72837273    const char      *skycell_id,
    72847274    const char      *tess_id,
    7285     const char      *exp_tag,
    7286     psS32           cam_version,
     7275    psS64           cam_id,
    72877276    const char      *class_id,
    72887277    psS16           fault
    … …  
    73167305bool warpSkyCellMapInsert(
    73177306    psDB            *dbh,               ///< Database handle
    7318     psS32           warp_id,
     7307    psS64           warp_id,
    73197308    const char      *skycell_id,
    73207309    const char      *tess_id,
    7321     const char      *exp_tag,
    7322     psS32           cam_version,
     7310    psS64           cam_id,
    73237311    const char      *class_id,
    73247312    psS16           fault
    … …  
    74787466
    74797467typedef struct {
    7480     psS32           warp_id;
     7468    psS64           warp_id;
    74817469    char            *skycell_id;
    74827470    char            *tess_id;
    … …  
    74927480
    74937481warpSkyfileRow *warpSkyfileRowAlloc(
    7494     psS32           warp_id,
     7482    psS64           warp_id,
    74957483    const char      *skycell_id,
    74967484    const char      *tess_id,
    … …  
    75277515bool warpSkyfileInsert(
    75287516    psDB            *dbh,               ///< Database handle
    7529     psS32           warp_id,
     7517    psS64           warp_id,
    75307518    const char      *skycell_id,
    75317519    const char      *tess_id,
    … …  
    76887676
    76897677typedef struct {
    7690     psS32           diff_id;
     7678    psS64           diff_id;
    76917679    char            *state;
    76927680    char            *workdir;
    … …  
    77037691
    77047692diffRunRow *diffRunRowAlloc(
    7705     psS32           diff_id,
     7693    psS64           diff_id,
    77067694    const char      *state,
    77077695    const char      *workdir,
    … …  
    77397727bool diffRunInsert(
    77407728    psDB            *dbh,               ///< Database handle
    7741     psS32           diff_id,
     7729    psS64           diff_id,
    77427730    const char      *state,
    77437731    const char      *workdir,
    … …  
    79017889
    79027890typedef struct {
    7903     psS32           diff_id;
    7904     psS32           warp_id;
     7891    psS64           diff_id;
     7892    psS64           warp_id;
    79057893    char            *skycell_id;
    79067894    char            *tess_id;
    … …  
    79157903
    79167904diffInputSkyfileRow *diffInputSkyfileRowAlloc(
    7917     psS32           diff_id,
    7918     psS32           warp_id,
     7905    psS64           diff_id,
     7906    psS64           warp_id,
    79197907    const char      *skycell_id,
    79207908    const char      *tess_id,
    … …  
    79507938bool diffInputSkyfileInsert(
    79517939    psDB            *dbh,               ///< Database handle
    7952     psS32           diff_id,
    7953     psS32           warp_id,
     7940    psS64           diff_id,
     7941    psS64           warp_id,
    79547942    const char      *skycell_id,
    79557943    const char      *tess_id,
    … …  
    81118099
    81128100typedef struct {
    8113     psS32           diff_id;
     8101    psS64           diff_id;
    81148102    char            *uri;
    81158103    psF64           bg;
    … …  
    81238111
    81248112diffSkyfileRow *diffSkyfileRowAlloc(
    8125     psS32           diff_id,
     8113    psS64           diff_id,
    81268114    const char      *uri,
    81278115    psF64           bg,
    … …  
    81568144bool diffSkyfileInsert(
    81578145    psDB            *dbh,               ///< Database handle
    8158     psS32           diff_id,
     8146    psS64           diff_id,
    81598147    const char      *uri,
    81608148    psF64           bg,
    … …  
    83158303
    83168304typedef struct {
    8317     psS32           stack_id;
     8305    psS64           stack_id;
    83188306    char            *state;
    83198307    char            *workdir;
    … …  
    83308318
    83318319stackRunRow *stackRunRowAlloc(
    8332     psS32           stack_id,
     8320    psS64           stack_id,
    83338321    const char      *state,
    83348322    const char      *workdir,
    … …  
    83668354bool stackRunInsert(
    83678355    psDB            *dbh,               ///< Database handle
    8368     psS32           stack_id,
     8356    psS64           stack_id,
    83698357    const char      *state,
    83708358    const char      *workdir,
    … …  
    85288516
    85298517typedef struct {
    8530     psS32           stack_id;
    8531     psS32           warp_id;
     8518    psS64           stack_id;
     8519    psS64           warp_id;
    85328520} stackInputSkyfileRow;
    85338521
    … …  
    85388526
    85398527stackInputSkyfileRow *stackInputSkyfileRowAlloc(
    8540     psS32           stack_id,
    8541     psS32           warp_id
     8528    psS64           stack_id,
     8529    psS64           warp_id
    85428530);
    85438531
    … …  
    85698557bool stackInputSkyfileInsert(
    85708558    psDB            *dbh,               ///< Database handle
    8571     psS32           stack_id,
    8572     psS32           warp_id
     8559    psS64           stack_id,
     8560    psS64           warp_id
    85738561);
    85748562
    … …  
    87268714
    87278715typedef struct {
    8728     psS32           stack_id;
     8716    psS64           stack_id;
    87298717    char            *uri;
    87308718    psF64           bg;
    … …  
    87388726
    87398727stackSumSkyfileRow *stackSumSkyfileRowAlloc(
    8740     psS32           stack_id,
     8728    psS64           stack_id,
    87418729    const char      *uri,
    87428730    psF64           bg,
    … …  
    87718759bool stackSumSkyfileInsert(
    87728760    psDB            *dbh,               ///< Database handle
    8773     psS32           stack_id,
     8761    psS64           stack_id,
    87748762    const char      *uri,
    87758763    psF64           bg,
Note: See TracChangeset for help on using the changeset viewer.