IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18357


Ignore:
Timestamp:
Jun 29, 2008, 2:44:04 PM (18 years ago)
Author:
eugene
Message:

merge cvs HEAD into cleanup branch

Location:
branches/cleanup/ippTools
Files:
4 added
2 deleted
46 edited

Legend:

Unmodified
Added
Removed

  • branches/cleanup/ippTools/scripts/regtest.sh

    r18076 r18357  
    99
    1010exp_id1=`$inject -newExp -tmp_exp_name t10 -tmp_inst gpc -tmp_telescope ps1 -workdir file::///some/path -reduction batman -simple` || exit 1
     11
     12echo $exp_id1
    1113
    1214for ID in `seq 0 3`; do
    … …  
    3436
    3537$regtool -addprocessedexp -exp_id $exp_id1 -exp_name t10 -inst gpc -telescope ps1 -exp_tag batman.t10 -filelevel OTA -filter r -airmass 10 -ra 1 -decl 2 -exp_type object -exp_time 0 -bg 10 -bg_stdev 1 -bg_mean_stdev 10 -alt 10 -az 10 -ccd_temp 45 -posang 10 -object dog -dateobs "2006-10-20T10:10:10Z" -label foobar -tess_id moldyshoe $* || exit 1
     38# use BIAS or OBJECT? $regtool -addprocessedexp -exp_id $exp_id1 -exp_name t10 -inst gpc -telescope ps1 -exp_tag batman.t10 -filelevel OTA -filter r -airmass 10 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 10 -bg_stdev 1 -bg_mean_stdev 10 -alt 10 -az 10 -ccd_temp 45 -posang 10 -object dog -dateobs "2006-10-20T10:10:10Z" -label foobar -tess_id moldyshoe $* || exit 1
    3639
    3740$regtool -pendingimfile || exit 1
    … …  
    4447
    4548$regtool -addprocessedexp -exp_id $exp_id2 -exp_name t11 -inst gpc -telescope ps1 -exp_tag batman.t11 -filelevel OTA -filter r -airmass 11 -ra 1 -decl 2 -exp_type object -exp_time 0 -bg 11 -bg_stdev 1 -bg_mean_stdev 11 -alt 11 -az 11 -ccd_temp 45 -posang 11 -object dog -dateobs 2006-10-20T10:10:10Z -label foobar -tess_id moldyshoe $* || exit 1
     49# BIAS or OBJECT? $regtool -addprocessedexp -exp_id $exp_id2 -exp_name t11 -inst gpc -telescope ps1 -exp_tag batman.t11 -filelevel OTA -filter r -airmass 11 -ra 1 -decl 2 -exp_type bias -exp_time 0 -bg 11 -bg_stdev 1 -bg_mean_stdev 11 -alt 11 -az 11 -ccd_temp 45 -posang 11 -object dog -dateobs 2006-10-20T10:10:10Z -label foobar -tess_id moldyshoe $* || exit 1

  • branches/cleanup/ippTools/share/Makefile.am

    r18154 r18357  
    7474        pztool_pendingimfile.sql \
    7575        pztool_revertcopied.sql \
     76        pztool_revert_downloadimfile_faults.sql \
     77        pztool_revert_fileset_faults.sql \
     78        regtool_create_dup_table.sql \
    7679        regtool_pendingexp.sql \
    7780        regtool_pendingimfile.sql \
     81        regtool_populate_dup_table.sql \
    7882        regtool_processedexp.sql \
    7983        regtool_processedimfile.sql \

  • branches/cleanup/ippTools/share/chiptool_pendingcleanuprun.sql

    r18154 r18357  
    11SELECT
    2     chipRun.*
     2    chipRun.chip_id,
     3    rawExp.camera,
     4    chipRun.state
    35FROM chipRun
     6JOIN rawExp
     7USING (exp_id)
    48WHERE
    59    chipRun.state = 'goto_cleaned'

  • branches/cleanup/ippTools/share/pztool_pendingimfile.sql

    r16627 r18357  
    1818        AND pzDownloadImfile.class IS NULL
    1919        AND pzDownloadImfile.class_id IS NULL
    20     ORDER BY
    21         summitExp.dateobs
    2220) as Foo

  • branches/cleanup/ippTools/src/Makefile.am

    r18076 r18357  
    3030        pxdata.h \
    3131        pxfake.h \
    32         pxio.h \
    3332        pxregister.h \
    3433        pxtag.h \
    … …  
    7069        pxfake.c \
    7170        pxfault.c \
    72         pxio.c \
    7371        pxregister.c \
    7472        pxtag.c \

  • branches/cleanup/ippTools/src/caltool.c

    r16170 r18357  
    152152
    153153    if (psArrayLength(output)) {
    154         if (!convertIdToStr(output)) {
    155             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    156             psFree(output);
    157             return false;
    158         }
    159 
    160154        // negative simple so the default is true
    161155        if (!ippdbPrintMetadatas(stdout, output, "calDB", !simple)) {
    … …  
    247241
    248242    if (psArrayLength(output)) {
    249         if (!convertIdToStr(output)) {
    250             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    251             psFree(output);
    252             return false;
    253         }
    254 
    255243        // negative simple so the default is true
    256244        if (!ippdbPrintMetadatas(stdout, output, "calRun", !simple)) {

  • branches/cleanup/ippTools/src/caltoolConfig.c

    r16170 r18357  
    159159    // do this last so we don't setup a connection before CLI options are
    160160    // validated
    161     config->dbh = pmConfigDB(config->modules);
     161    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    162162    if (!config->dbh) {
    163163        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/camtool.c

    r18153 r18357  
    9797    PS_ASSERT_PTR_NON_NULL(config, NULL);
    9898
    99     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    100     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    101 
    10299    psMetadata *where = psMetadataAlloc();
    103     // convert chip_id into a psS64
    104     if (chip_id) {
    105         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    106             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    107             psFree(where);
    108             return false;
    109         }
    110     }
    111 
    112     // convert exp_id into a psS64
    113     if (exp_id) {
    114         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    115             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    116             psFree(where);
    117             return false;
    118         }
    119     }
    120 
     100    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     101    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    121102    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    122103    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    165146    }
    166147
    167     PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    168     PXOPT_LOOKUP_STR(label, config->args, "-set_label", true, false);
    169     PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", true, false);
    170     PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", true, false);
    171     PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", true, false);
    172     PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", true, false);
    173     PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", true, false);
     148    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
     149    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     150    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     151    PXOPT_LOOKUP_STR(expgroup, config->args, "-set_expgroup", false, false);
     152    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
     153    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     154    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    174155
    175156    // find the exp_id of all the exposures that we want to queue up.
    … …  
    182163
    183164    if (where && psListLength(where->list)) {
    184         psString whereClause = psDBGenerateWhereConditionSQL(where, "");
    185         psStringAppend(&query, " AND %s", whereClause);
     165        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     166        psStringAppend(&query, "%s", whereClause);
    186167        psFree(whereClause);
    187168    }
    … …  
    236217                    workdir     ? workdir   : row->workdir,
    237218                    label       ? label     : row->label,
    238                     reduction      ? reduction    : row->reduction,
     219                    reduction   ? reduction : row->reduction,
    239220                    expgroup    ? expgroup  : row->expgroup,
    240221                    dvodb       ? dvodb     : row->dvodb,
    … …  
    268249    PS_ASSERT_PTR_NON_NULL(config, false);
    269250
    270     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", false, false);
    271     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    272     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    273 
    274251    psMetadata *where = psMetadataAlloc();
    275     // convert cam_id into a psS64
    276     if (cam_id) {
    277         if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
    278             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    279             psFree(where);
    280             return false;
    281         }
    282     }
    283 
    284     // convert chip_id into a psS64
    285     if (chip_id) {
    286         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    287             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    288             psFree(where);
    289             return false;
    290         }
    291     }
    292 
    293     // convert exp_id into a psS64
    294     if (exp_id) {
    295         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    296             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    297             psFree(where);
    298             return false;
    299         }
    300     }
    301 
     252    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     253    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     254    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    302255    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    303256    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    421374    }
    422375
    423     if (!convertIdToStr(output)) {
    424         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    425         psFree(output);
    426         return false;
    427     }
    428 
    429376    // negate simple so the default is true
    430377    if (!ippdbPrintMetadatas(stdout, output, "camPendingExp", !simple)) {
    … …  
    475422    }
    476423
    477     if (!convertIdToStr(output)) {
    478         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    479         psFree(output);
    480         return false;
    481     }
    482 
    483424    // negate simple so the default is true
    484425    if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
    … …  
    498439
    499440    // required
    500     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", true, false);
     441    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", true, false);
    501442    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    502443
    … …  
    554495        psMetadata *where = psMetadataAlloc();
    555496        if (cam_id) {
    556             if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
     497            if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    557498                psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    558499                psFree(where);
    … …  
    746687    }
    747688
    748     if (!convertIdToStr(output)) {
    749         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    750         psFree(output);
    751         return false;
    752     }
    753 
    754689    // negate simple so the default is true
    755690    if (!ippdbPrintMetadatas(stdout, output, "camProcessedExp", !simple)) {
    … …  
    769704    PS_ASSERT_PTR_NON_NULL(config, false);
    770705
    771     PXOPT_LOOKUP_STR(cam_id, config->args, "-cam_id", false, false);
    772     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    773     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    774 
    775706    psMetadata *where = psMetadataAlloc();
    776     // convert cam_id into a psS64
    777     if (cam_id) {
    778         if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", (psS64)atoll(cam_id))) {
    779             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    780             psFree(where);
    781             return false;
    782         }
    783     }
    784 
    785     // convert chip_id into a psS64
    786     if (chip_id) {
    787         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    788             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    789             psFree(where);
    790             return false;
    791         }
    792     }
    793 
    794     // convert exp_id into a psS64
    795     if (exp_id) {
    796         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    797             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    798             psFree(where);
    799             return false;
    800         }
    801     }
    802 
     707    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     708    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     709    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    803710    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    804711    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    977884    }
    978885
    979     if (!convertIdToStr(output)) {
    980         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    981         psFree(output);
    982         return false;
    983     }
    984 
    985886    // negative simple so the default is true
    986887    if (!ippdbPrintMetadatas(stdout, output, "camMask", !simple)) {

  • branches/cleanup/ippTools/src/camtoolConfig.c

    r18153 r18357  
    4949    psMetadata *definebydefinebyqueryArgs = psMetadataAlloc();
    5050    // XXX need to allow multiple chip_ids
    51     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
    52             "search by chip_id", NULL);
     51    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
     52            "search by chip_id", 0);
    5353    // XXX need to allow multiple exp_ids
    54     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
    55             "search by exp_id", NULL);
     54    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
     55            "search by exp_id", 0);
    5656    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,
    5757            "search by exp_name", NULL);
    … …  
    148148    psMetadata *updaterunArgs = psMetadataAlloc();
    149149    // XXX need to allow multiple cam_ids
    150     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
    151             "search by cam_id", NULL);
     150    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
     151            "search by cam_id", 0);
    152152    // XXX need to allow multiple chip_ids
    153     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    154             "search by chip_id", NULL);
     153    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
     154            "search by chip_id", 0);
    155155    // XXX need to allow multiple exp_ids
    156     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    157             "search by exp_id", NULL);
     156    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     157            "search by exp_id", 0);
    158158    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    159159            "search by exp_name", NULL);
    … …  
    241241    // -pendingexp
    242242    psMetadata *pendingexpArgs = psMetadataAlloc();
    243     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    244             "search by camtool ID", NULL);
    245     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    246             "search by chiptool ID", NULL);
     243    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     244            "search by camtool ID", 0);
     245    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     246            "search by chiptool ID", 0);
    247247    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    248248            "limit result set to N items", 0);
    … …  
    253253    // -pendingimfile
    254254    psMetadata *pendingimfileArgs = psMetadataAlloc();
    255     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,
    256             "search by camtool ID", NULL);
    257     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
    258             "search by chiptool ID", NULL);
     255    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,
     256            "search by camtool ID", 0);
     257    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
     258            "search by chiptool ID", 0);
    259259    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,
    260260            "search by class", NULL);
    … …  
    267267    // -addprocessedexp
    268268    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    269     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    270             "define camtool ID (required)", NULL);
     269    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     270            "define camtool ID (required)", 0);
    271271    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,
    272272            "define URI (required)", NULL);
    … …  
    328328    // -processedexp
    329329    psMetadata *processedexpArgs = psMetadataAlloc();
    330     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    331             "search by camtool ID", NULL);
    332     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    333             "search by chiptool ID", NULL);
     330    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     331            "search by camtool ID", 0);
     332    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     333            "search by chiptool ID", 0);
    334334    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    335335            "limit result set to N items", 0);
    … …  
    342342    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    343343    // XXX need to allow multiple cam_ids
    344     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
    345             "search by cam_id", NULL);
     344    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
     345            "search by cam_id", 0);
    346346    // XXX need to allow multiple chip_ids
    347     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    348             "search by chip_id", NULL);
     347    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
     348            "search by chip_id", 0);
    349349    // XXX need to allow multiple exp_ids
    350     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    351             "search by exp_id", NULL);
     350    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
     351            "search by exp_id", 0);
    352352    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,
    353353            "search by exp_name", NULL);
    … …  
    433433    // -updateprocessedexp
    434434    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    435     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    436             "search by camtool ID", NULL);
    437     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    438             "search by chiptool ID", NULL);
     435    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     436            "search by camtool ID", 0);
     437    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
     438            "search by chiptool ID", 0);
    439439    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,
    440440            "search by class", NULL);
    … …  
    574574
    575575    // define Database handle, if used
    576     config->dbh = pmConfigDB(config->modules);
     576    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    577577    if (!config->dbh) {
    578578        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/chiptool.c

    r18154 r18357  
    110110    PS_ASSERT_PTR_NON_NULL(config, NULL);
    111111
    112     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
     112    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    113113
    114114    psMetadata *where = psMetadataAlloc();
    115     // convert exp_id into a psS64
    116     if (exp_id) {
    117         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    118             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    119             psFree(where);
    120             return false;
    121         }
    122     }
    123 
     115    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    124116    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    125117    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    158150    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    159151    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     152    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
    160153
    161154    if (!psListLength(where->list)
    … …  
    266259
    267260    psMetadata *where = psMetadataAlloc();
    268     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    269     // convert chip_id into a psS64
    270     if (chip_id) {
    271         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    272             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    273             psFree(where);
    274             return false;
    275         }
    276     }
    277 
    278     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    279     // convert exp_id into a psS64
    280     if (exp_id) {
    281         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    282             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    283             psFree(where);
    284             return false;
    285         }
    286     }
    287 
    288     PXOPT_COPY_STR(config->args,  where, "-chip_id", "chip_id", "==");
    289     PXOPT_COPY_STR(config->args,  where, "-exp_id", "exp_id", "==");
     261    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chip_id", "==");
     262    PXOPT_COPY_S64(config->args,  where, "-exp_id", "exp_id", "==");
    290263    PXOPT_COPY_STR(config->args,  where, "-exp_name", "exp_name", "==");
    291264    PXOPT_COPY_STR(config->args,  where, "-inst", "camera", "==");
    … …  
    374347
    375348    psMetadata *where = psMetadataAlloc();
    376     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    377     // convert chip_id into a psS64
    378     if (chip_id) {
    379         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    380             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    381             psFree(where);
    382             return false;
    383         }
    384     }
    385 
    386     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    387     // convert exp_id into a psS64
    388     if (exp_id) {
    389         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    390             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    391             psFree(where);
    392             return false;
    393         }
    394     }
    395 
     349    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     350    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    396351    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    397352    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    436391    }
    437392
    438     if (!convertIdToStr(output)) {
    439         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    440         psFree(output);
    441         return false;
    442     }
    443 
    444393    // negative simple so the default is true
    445394    if (!ippdbPrintMetadatas(stdout, output, "chipPendingImfile", !simple)) {
    … …  
    460409
    461410    // chip_id, ext_tag, class_id are required
    462     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", true, false);
    463     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     411    PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true, false);
     412    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    464413    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    465414
    … …  
    501450
    502451    if (!chipProcessedImfileInsert(config->dbh,
    503                                    (psS64)atoll(chip_id),
    504                                    (psS64)atoll(exp_id),
     452                                   chip_id,
     453                                   exp_id,
    505454                                   class_id,
    506455                                   uri,
    … …  
    572521
    573522    psMetadata *where = psMetadataAlloc();
    574     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    575     // convert chip_id into a psS64
    576     if (chip_id) {
    577         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    578             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    579             psFree(where);
    580             return false;
    581         }
    582     }
    583 
    584     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    585     // convert exp_id into a psS64
    586     if (exp_id) {
    587         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    588             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    589             psFree(where);
    590             return false;
    591         }
    592     }
    593 
     523    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     524    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.chip_id", "==");
    594525    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    595526    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    642573    }
    643574
    644     if (!convertIdToStr(output)) {
    645         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    646         psFree(output);
    647         return false;
    648     }
    649 
    650575    // negative simple so the default is true
    651576    if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
    … …  
    665590
    666591    psMetadata *where = psMetadataAlloc();
    667     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    668     // convert chip_id into a psS64
    669     if (chip_id) {
    670         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    671             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    672             psFree(where);
    673             return false;
    674         }
    675     }
    676 
    677     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    678     // convert exp_id into a psS64
    679     if (exp_id) {
    680         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    681             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    682             psFree(where);
    683             return false;
    684         }
    685     }
    686 
     592    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     593    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    687594    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    688595    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    835742    }
    836743
    837     if (!convertIdToStr(output)) {
    838         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    839         psFree(output);
    840         return false;
    841     }
    842 
    843744    // negative simple so the default is true
    844745    if (!ippdbPrintMetadatas(stdout, output, "chipMask", !simple)) {
    … …  
    908809    }
    909810
    910     if (!convertIdToStr(output)) {
    911         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    912         psFree(output);
    913         return false;
    914     }
    915 
    916811    // negative simple so the default is true
    917812    if (!ippdbPrintMetadatas(stdout, output, "chipUnmask", !simple)) {
    … …  
    992887    }
    993888
    994     if (!convertIdToStr(output)) {
    995         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    996         psFree(output);
    997         return false;
    998     }
    999 
    1000889    // negative simple so the default is true
    1001890    if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanupRun", !simple)) {
    … …  
    1063952    }
    1064953
    1065     if (!convertIdToStr(output)) {
    1066         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1067         psFree(output);
    1068         return false;
    1069     }
    1070 
    1071954    // negative simple so the default is true
    1072955    if (!ippdbPrintMetadatas(stdout, output, "chipPendingCleanupImfile", !simple)) {
    … …  
    11301013    }
    11311014
    1132     if (!convertIdToStr(output)) {
    1133         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1134         psFree(output);
    1135         return false;
    1136     }
    1137 
    11381015    // negative simple so the default is true
    11391016    if (!ippdbPrintMetadatas(stdout, output, "chipDoneCleanup", !simple)) {
    … …  
    12031080        psFree(output);
    12041081        return true;
    1205     }
    1206 
    1207     if (!convertIdToStr(output)) {
    1208         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1209         psFree(output);
    1210         return false;
    12111082    }
    12121083

  • branches/cleanup/ippTools/src/chiptoolConfig.c

    r18154 r18357  
    22 * chiptoolConfig.c
    33 *
    4  * Copyright (C) 2006  Joshua Hoblitt
     4 * Copyright (C) 2006-2008  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    4747    psMetadata *definebyqueryArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", NULL);
     49    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    5050    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    5151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
    … …  
    8585    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    8686    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     87    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",     0,        "search by comment field (LIKE comparison)", NULL);
     88
    8789    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    8890    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
    … …  
    9597    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    9698
    97 
    9899    // -updaterun
    99100    psMetadata *updaterunArgs = psMetadataAlloc();
    100     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", NULL);
    101     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
     101    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
     102    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", 0);
    102103    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",             0,            "search by exp_name", NULL);
    103104    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",                 0,            "search for camera", NULL);
    … …  
    146147    // -pendingimfile
    147148    psMetadata *pendingimfileArgs = psMetadataAlloc();
    148     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", NULL);
    149     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     149    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
     150    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    150151    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    151152    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera of interest", NULL);
    … …  
    156157    // -addprocessedimfile
    157158    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    158     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID (required)", NULL);
    159     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID (required)", NULL);
     159    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID (required)", 0);
     160    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID (required)", 0);
    160161    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    161162    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URL", NULL);
    … …  
    190191    // -processedimfile
    191192    psMetadata *processedimfileArgs = psMetadataAlloc();
    192     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID", NULL);
    193     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", NULL);
     193    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "define chip ID", 0);
     194    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", 0);
    194195    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID", NULL);
    195196    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "define camera of interest", NULL);
    … …  
    201202    // -updateprocessedimfile
    202203    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    203     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", NULL);
    204     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     204    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
     205    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    205206    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    206207    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
    … …  
    208209    // -revertprocessedimfile
    209210    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    210     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", NULL);
    211     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", NULL);
     211    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chip ID", 0);
     212    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    212213    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    213214    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
    … …  
    282283    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
    283284        "search by chip ID", 0);
    284     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
     285    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
    285286    psMetadataAddBool(pendingcleanupimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    286287    psMetadataAddU64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    345346
    346347    // define Database handle, if used
    347     config->dbh = pmConfigDB(config->modules);
     348    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    348349    if (!config->dbh) {
    349350        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/detselect.h

    r9392 r18357  
    3131pxConfig *detselectConfig(pxConfig *config, int argc, char **argv);
    3232
     33#define addWhereStr(name) \
     34{ \
     35    psString str = NULL; \
     36    bool status = false; \
     37    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     38        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
     39            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     40            psFree(config); \
     41            return NULL; \
     42        } \
     43    } \
     44}
     45
     46#define addWhereStrAlias(name,realname) \
     47{ \
     48    psString str = NULL; \
     49    bool status = false; \
     50    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     51        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #realname, 0, "==", str)) {\
     52            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     53            psFree(config); \
     54            return NULL; \
     55        } \
     56    } \
     57}
     58
     59#define addWhereS32(name) \
     60{ \
     61    psS32 s32 = 0; \
     62    bool status = false; \
     63    if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
     64        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
     65            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     66            psFree(config); \
     67            return NULL; \
     68        } \
     69    } \
     70}
     71
     72#define addWhereF32(name) \
     73{ \
     74    psF32 var = 0; \
     75    bool status = false; \
     76    if ((var = psMetadataLookupF32(&status, config->args, "-" #name))) { \
     77        if (!isnan(var)) { \
     78            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     79                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     80                psFree(config); \
     81                return NULL; \
     82            } \
     83        } \
     84    } \
     85}
     86
     87#define addWhereF64(name) \
     88{ \
     89    psF64 var = 0; \
     90    bool status = false; \
     91    if ((var = psMetadataLookupF64(&status, config->args, "-" #name))) { \
     92        if (!isnan(var))  { \
     93            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     94                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     95                psFree(config); \
     96                return NULL; \
     97            } \
     98        } \
     99    } \
     100}
     101
     102#define addWhereTimeStr(name) \
     103{ \
     104    psString str = NULL; \
     105    bool status = false; \
     106    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     107        psTime *time = psTimeFromISO(str, PS_TIME_UTC); \
     108        if (!time) { \
     109            psError(PS_ERR_UNKNOWN, false, "failed to convert " #name " into a psTime object"); \
     110            psFree(config); \
     111            return NULL; \
     112        } \
     113        psMetadataItem *item = psMetadataLookup(config->args, "-" #name); \
     114        if (item) { \
     115            str = item->comment; \
     116        } else { \
     117            str = NULL; \
     118        } \
     119        if (!psMetadataAddTime(config->where, PS_LIST_TAIL, #name, 0, str, time)) {\
     120            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     121            psFree(config); \
     122            return NULL; \
     123        } \
     124        psFree(time); \
     125    } \
     126}
     127
    33128#endif // DETSELECT_H

  • branches/cleanup/ippTools/src/detselectConfig.c

    r16170 r18357  
    4747    psMetadata *searchArgs = psMetadataAlloc();
    4848    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-inst", 0,
    49             "search by camera", NULL);
     49                     "search by camera", NULL);
    5050    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-telescope", 0,
    51             "search by telescope", NULL);
     51                     "search by telescope", NULL);
    5252    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-det_type", 0,
    53             "search by detrend type", NULL);
     53                     "search by detrend type", NULL);
     54    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-type", 0,
     55                     "search by detrend type (alias for -det_type)", NULL);
    5456    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-filter", 0,
    55             "search by filter", NULL);
     57                     "search by filter", NULL);
    5658    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-airmass", 0,
    57             "define airmass", NAN);
     59                     "define airmass", NAN);
    5860    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-exp_time", 0,
    59             "search by exposure time", NAN);
     61                     "search by exposure time", NAN);
    6062    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-ccd_temp", 0,
    61             "search by ccd tempature", NAN);
     63                     "search by ccd tempature", NAN);
    6264    psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,
    63             "search by rotator position angle", NAN);
     65                     "search by rotator position angle", NAN);
    6466    psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,
    65             "define time for desired detrend data", NULL);
     67                      "define time for desired detrend data", NULL);
    6668    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,
    67             "use the simple output format", false);
     69                      "use the simple output format", false);
    6870    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-unlimit",  0,
    69             "list all possible detruns, not just the best match", false);
     71                      "list all possible detruns, not just the best match", false);
    7072 
    7173    // -select
    7274    psMetadata *selectArgs = psMetadataAlloc();
    7375    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-det_id", 0,
    74             "search by detrend ID", NULL);
     76                     "search by detrend ID", NULL);
    7577    psMetadataAddS32(selectArgs, PS_LIST_TAIL, "-iteration", 0,
    76             "search by iteration number", 0);
     78                     "search by iteration number", 0);
    7779    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-class_id", 0,
    78             "search by class ID", NULL);
     80                     "search by class ID", NULL);
    7981    psMetadataAddBool(selectArgs, PS_LIST_TAIL, "-simple",  0,
    80             "use the simple output format", false);
     82                      "use the simple output format", false);
    8183   
    8284    psMetadata *argSets = psMetadataAlloc();
    … …  
    98100
    99101    // setup search criterion
    100 #define addWhereStr(name) \
    101 { \
    102     psString str = NULL; \
    103     bool status = false; \
    104     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    105         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    106             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    107             psFree(config); \
    108             return NULL; \
    109         } \
    110     } \
    111 }
    112 
    113 #define addWhereS32(name) \
    114 { \
    115     psS32 s32 = 0; \
    116     bool status = false; \
    117     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    118         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    119             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    120             psFree(config); \
    121             return NULL; \
    122         } \
    123     } \
    124 }
    125 
    126 #define addWhereF32(name) \
    127 { \
    128     psF32 var = 0; \
    129     bool status = false; \
    130     if ((var = psMetadataLookupF32(&status, config->args, "-" #name))) { \
    131         if (!isnan(var)) { \
    132             if (!psMetadataAddF32(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
    133                 psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    134                 psFree(config); \
    135                 return NULL; \
    136             } \
    137         } \
    138     } \
    139 }
    140 
    141 #define addWhereF64(name) \
    142 { \
    143     psF64 var = 0; \
    144     bool status = false; \
    145     if ((var = psMetadataLookupF64(&status, config->args, "-" #name))) { \
    146         if (!isnan(var))  { \
    147             if (!psMetadataAddF64(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
    148                 psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    149                 psFree(config); \
    150                 return NULL; \
    151             } \
    152         } \
    153     } \
    154 }
    155 
    156 #define addWhereTimeStr(name) \
    157 { \
    158     psString str = NULL; \
    159     bool status = false; \
    160     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    161         psTime *time = psTimeFromISO(str, PS_TIME_UTC); \
    162         if (!time) { \
    163             psError(PS_ERR_UNKNOWN, false, "failed to convert " #name " into a psTime object"); \
    164             psFree(config); \
    165             return NULL; \
    166         } \
    167         psMetadataItem *item = psMetadataLookup(config->args, "-" #name); \
    168         if (item) { \
    169             str = item->comment; \
    170         } else { \
    171             str = NULL; \
    172         } \
    173         if (!psMetadataAddTime(config->where, PS_LIST_TAIL, #name, 0, str, time)) {\
    174             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    175             psFree(config); \
    176             return NULL; \
    177         } \
    178         psFree(time); \
    179     } \
    180 }
    181 
    182102    // generate SQL where clause
    183103    config->where = psMetadataAlloc();
    … …  
    186106    addWhereS32(iteration);
    187107    addWhereStr(exp_id);
    188     // convert '-inst' to 'camera'
    189     {
    190         psString str = NULL;
    191         bool status = false;
    192         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    193             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    194                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    195                 psFree(config);
    196                 return NULL;
    197             }
    198         }
    199     }
     108    addWhereStrAlias(inst,camera);
     109
    200110    addWhereStr(telescope);
    201111    addWhereStr(det_type);
     112    addWhereStrAlias(type,det_type);
     113
    202114    addWhereStr(exp_type);
    203115    addWhereS32(imfiles);
    … …  
    205117    addWhereStr(class_id);
    206118    addWhereStr(filter);
    207 //    addWhereF32(exp_time);
    208 //    addWhereF64(ccd_temp);
    209 //    addWhereF32(airmass);
    210 //    addWhereTimeStr(use_begin);
    211 //    addWhereTimeStr(use_end);
     119
     120    //    addWhereF32(exp_time);
     121    //    addWhereF64(ccd_temp);
     122    //    addWhereF32(airmass);
     123    //    addWhereTimeStr(use_begin);
     124    //    addWhereTimeStr(use_end);
    212125
    213126    if (config->where->list->n < 1) {
    … …  
    218131
    219132    // define Database handle, if used
    220     config->dbh = pmConfigDB(config->modules);
     133    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    221134    if (!config->dbh) {
    222135        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/dettool.c

    r18153 r18357  
    8787static bool detrunsummaryMode(pxConfig *config);
    8888static bool revertdetrunsummaryMode(pxConfig *config);
     89static bool updatedetrunsummaryMode(pxConfig *config);
     90// run
    8991static bool updatedetrunMode(pxConfig *config);
    9092static bool rerunMode(pxConfig *config);
    … …  
    179181        MODECASE(DETTOOL_MODE_DETRUNSUMMARY,    detrunsummaryMode);
    180182        MODECASE(DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryMode);
     183        MODECASE(DETTOOL_MODE_UPDATEDETRUNSUMMARY, updatedetrunsummaryMode);
    181184        MODECASE(DETTOOL_MODE_UPDATEDETRUN,     updatedetrunMode);
    182185        MODECASE(DETTOOL_MODE_RERUN,            rerunMode);
    … …  
    456459    }
    457460
    458     if (!convertIdToStr(detRuns)) {
    459         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    460         psFree(detRuns);
    461         return false;
    462     }
    463 
    464461    // negative simple so the default is true
    465462    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {
    … …  
    719716    }
    720717
    721     // convert det_id to a string externaly
    722     if (!convertIdToStr(detRuns)) {
    723         psError(PS_ERR_UNKNOWN, false, "failed to convert det_id to a string");
    724         psFree(detRuns);
    725         return false;
    726     }
    727 
    728718    // negative simple so the default is true
    729719    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {
    … …  
    10121002    }
    10131003
    1014     // convert det_id to a string externaly
    1015     if (!convertIdToStr(detRuns)) {
    1016         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1017         psFree(detRuns);
    1018         return false;
    1019     }
    1020 
    10211004    // negative simple so the default is true
    10221005    if (!ippdbPrintMetadatas(stdout, newDetRuns, "detRun", !simple)) {
    … …  
    11111094        psFree(runs);
    11121095        return true;
    1113     }
    1114 
    1115     // convert det_id to a string externaly
    1116     if (!convertIdToStr(runs)) {
    1117         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1118         psFree(runs);
    1119         return false;
    11201096    }
    11211097
    … …  
    11801156        psFree(output);
    11811157        return true;
    1182     }
    1183 
    1184     // convert det_id to a string externaly
    1185     if (!convertIdToStr(output)) {
    1186         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1187         psFree(output);
    1188         return false;
    11891158    }
    11901159
    … …  
    38513820
    38523821
     3822static bool updatedetrunsummaryMode(pxConfig *config)
     3823{
     3824    PS_ASSERT_PTR_NON_NULL(config, false);
     3825
     3826    // required
     3827    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     3828
     3829    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
     3830    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
     3831
     3832    if (accept && reject) {
     3833        psError(PS_ERR_UNKNOWN, true, "-accept and -reject are exclusive");
     3834        return false;
     3835    }
     3836
     3837    if (!(accept || reject)) {
     3838        psError(PS_ERR_UNKNOWN, true, "either -accept or -reject is required");
     3839        return false;
     3840    }
     3841
     3842    char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64;
     3843    if (!p_psDBRunQuery(config->dbh, query, accept, (psS64)atoll(det_id))) {
     3844        psError(PS_ERR_UNKNOWN, false, "database error");
     3845        return false;
     3846    }
     3847
     3848    return true;
     3849}
     3850
     3851
    38533852static bool updatedetrunMode(pxConfig *config)
    38543853{
    … …  
    42524251    }
    42534252
    4254     if (!convertIdToStr(detRuns)) {
    4255         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    4256         psFree(detRuns);
    4257         return false;
    4258     }
    4259 
    42604253    // negative simple so the default is true
    42614254    if (!ippdbPrintMetadatas(stdout, detRuns, "detRun", !simple)) {

  • branches/cleanup/ippTools/src/dettool.h

    r15830 r18357  
    7474    DETTOOL_MODE_REVERTDETRUNSUMMARY,
    7575    DETTOOL_MODE_UPDATERESIDEXP,
     76    DETTOOL_MODE_UPDATEDETRUNSUMMARY,
    7677    DETTOOL_MODE_UPDATEDETRUN,
    7778    DETTOOL_MODE_RERUN,

  • branches/cleanup/ippTools/src/dettoolConfig.c

    r18153 r18357  
    10341034            "search by fault code", 0);
    10351035
     1036    // -updatedetrunsummary
     1037    psMetadata *updatedetrunsummaryArgs = psMetadataAlloc();
     1038    psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
     1039            "search for detrend master for detrend ID (required)", NULL);
     1040    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
     1041            "declare that this detrun iteration is accepted as a master", false);
     1042    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
     1043            "reject this detrun iteration as a master", false);
     1044
    10361045    // -updatedetrun
    10371046    psMetadata *updatedetrunArgs = psMetadataAlloc();
    … …  
    11871196    PXOPT_ADD_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
    11881197    PXOPT_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
     1198    PXOPT_ADD_MODE("-updatedetrunsummary", "", DETTOOL_MODE_UPDATEDETRUNSUMMARY, updatedetrunsummaryArgs);
    11891199    PXOPT_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
    11901200    PXOPT_ADD_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);
    … …  
    13081318    // do this last so we don't setup a connection before CLI options are
    13091319    // validated
    1310     config->dbh = pmConfigDB(config->modules);
     1320    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    13111321    if (!config->dbh) {
    13121322        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/dettool_correction.c

    r15830 r18357  
    120120    }
    121121
    122     if (!convertIdToStr(detRuns)) {
    123         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    124         psFree(detRuns);
    125         return false;
    126     }
    127 
    128122    bool simple = false;
    129123    {

  • branches/cleanup/ippTools/src/difftool.c

    r18153 r18357  
    4242static bool definebyqueryMode(pxConfig *config);
    4343
    44 static bool setdiffRunState(pxConfig *config, const char *diff_id, const char *state);
     44static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state);
    4545
    4646# define MODECASE(caseName, func) \
    … …  
    146146
    147147    // required options
    148     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     148    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    149149    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    150150
    … …  
    163163
    164164    // required options
    165     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     165    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    166166
    167167    // optional
    168     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", false, false);
    169     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
     168    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
     169    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
    170170    PXOPT_LOOKUP_STR(kind, config->args, "-kind", false, false);
    171171
    … …  
    188188    psString tess_id = NULL;
    189189    if (warp_id) {
    190         if (!p_psDBRunQuery(config->dbh, "SELECT * from diffRun WHERE diff_id = %" PRId64, (psS64)atoll(diff_id))) {
     190        if (!p_psDBRunQuery(config->dbh, "SELECT * from diffRun WHERE diff_id = %" PRId64, diff_id)) {
    191191            psError(PS_ERR_UNKNOWN, false, "database error");
    192192            return false;
    … …  
    199199        }
    200200        if (!psArrayLength(output)) {
    201             psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", (psS64)atoll(diff_id));
     201            psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", diff_id);
    202202            psFree(output);
    203203            return false;
    … …  
    215215
    216216    if (!diffInputSkyfileInsert(config->dbh,
    217             (psS64)atoll(diff_id),
     217            diff_id,
    218218            template,
    219             stack_id ? (psS64)atoll(stack_id) : PS_MAX_S64, // defined or NULL
    220             warp_id ? (psS64)atoll(warp_id) : PS_MAX_S64, // defined or NULL
     219            stack_id ? stack_id : PS_MAX_S64, // defined or NULL
     220            warp_id ? warp_id : PS_MAX_S64, // defined or NULL
    221221            skycell_id,
    222222            tess_id,
    … …  
    230230    }
    231231
    232     if (!p_psDBRunQuery(config->dbh, "SELECT count(diff_id) FROM diffRun JOIN diffInputSkyfile USING(diff_id) WHERE diff_id = %" PRId64, (psS64)atoll(diff_id))) {
     232    if (!p_psDBRunQuery(config->dbh, "SELECT count(diff_id) FROM diffRun JOIN diffInputSkyfile USING(diff_id) WHERE diff_id = %" PRId64, diff_id)) {
    233233        if (!psDBRollback(config->dbh)) {
    234234            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    250250            psError(PS_ERR_UNKNOWN, false, "database error");
    251251        }
    252         psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", (psS64)atoll(diff_id));
     252        psError(PS_ERR_UNKNOWN, false, "diff_id %" PRId64 " not found", diff_id);
    253253        psFree(output);
    254254        return false;
    … …  
    333333
    334334    if (psArrayLength(output)) {
    335         if (!convertIdToStr(output)) {
    336             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    337             psFree(output);
    338             return false;
    339         }
    340 
    341335        // negative simple so the default is true
    342336        if (!ippdbPrintMetadatas(stdout, output, "diffInputSkyfile", !simple)) {
    … …  
    407401
    408402    if (psArrayLength(output)) {
    409         if (!convertIdToStr(output)) {
    410             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    411             psFree(output);
    412             return false;
    413         }
    414 
    415403        // negative simple so the default is true
    416404        if (!ippdbPrintMetadatas(stdout, output, "diffSkyfile", !simple)) {
    … …  
    432420
    433421    // required
    434     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     422    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    435423
    436424    // default to 0
    … …  
    465453
    466454    if (!diffSkyfileInsert(config->dbh,
    467                            (psS64)atoll(diff_id),
     455                           diff_id,
    468456                           uri,
    469457                           path_base,
    … …  
    557545
    558546    if (psArrayLength(output)) {
    559         if (!convertIdToStr(output)) {
    560             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    561             psFree(output);
    562             return false;
    563         }
    564 
    565547        // negative simple so the default is true
    566548        if (!ippdbPrintMetadatas(stdout, output, "diffSkyfile", !simple)) {
    … …  
    609591
    610592
    611 static bool setdiffRunState(pxConfig *config, const char *diff_id, const char *state)
    612 {
    613     PS_ASSERT_PTR_NON_NULL(diff_id, false);
     593static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state)
     594{
    614595    PS_ASSERT_PTR_NON_NULL(state, false);
    615596
    … …  
    626607    }
    627608
    628     char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = '%s'";
     609    char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
    629610    if (!p_psDBRunQuery(config->dbh, query, state, diff_id)) {
    630611        psError(PS_ERR_UNKNOWN, false,
    631                 "failed to change state for diff_id %s", diff_id);
     612                "failed to change state for diff_id %"PRId64, diff_id);
    632613        return false;
    633614    }
    … …  
    766747
    767748    // optional
    768     PXOPT_LOOKUP_STR(template_stack_id, config->args, "-template_stack_id", false, false);
    769     PXOPT_LOOKUP_STR(template_warp_id, config->args, "-template_warp_id", false, false);
     749    PXOPT_LOOKUP_S64(template_stack_id, config->args, "-template_stack_id", false, false);
     750    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    770751
    771752    if (template_stack_id && template_warp_id) {
    … …  
    779760    }
    780761
    781     PXOPT_LOOKUP_STR(input_stack_id, config->args, "-input_stack_id", false, false);
    782     PXOPT_LOOKUP_STR(input_warp_id, config->args, "-input_warp_id", false, false);
     762    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
     763    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
    783764    if (input_stack_id && input_warp_id) {
    784765        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one input can be defined.");
    … …  
    792773
    793774    return populatedrun(workdir, skycell_id, tess_id,
    794                         input_warp_id ? (psS64)atoll(input_warp_id) : PS_MAX_S64,
    795                         input_stack_id ? (psS64)atoll(input_stack_id) : PS_MAX_S64,
    796                         template_warp_id ? (psS64)atoll(template_warp_id) : PS_MAX_S64,
    797                         template_stack_id ? (psS64)atoll(template_stack_id) : PS_MAX_S64,
     775                        input_warp_id ? input_warp_id : PS_MAX_S64,
     776                        input_stack_id ? input_stack_id : PS_MAX_S64,
     777                        template_warp_id ? template_warp_id : PS_MAX_S64,
     778                        template_stack_id ? template_stack_id : PS_MAX_S64,
    798779                        config);
    799780

  • branches/cleanup/ippTools/src/difftoolConfig.c

    r18153 r18357  
    6060    // -updaterun
    6161    psMetadata *updaterunArgs = psMetadataAlloc();
    62     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
    63             "define diff ID (required)", NULL);
     62    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
     63            "define diff ID (required)", 0);
    6464    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    6565            "set state (required)", NULL);
    … …  
    7373    // -addinputskyfile
    7474    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    75     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    76             "define diff ID (required)", NULL);
    77     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    78             "define warp ID", NULL);
    79     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    80             "define stack ID", NULL);
     75    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     76            "define diff ID (required)", 0);
     77    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     78            "define warp ID", 0);
     79    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     80            "define stack ID", 0);
    8181    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    8282            "define kind", NULL);
    … …  
    8686    // -inputskyfile
    8787    psMetadata *inputskyfileArgs = psMetadataAlloc();
    88     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    89             "search by diff ID", NULL);
    90     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    91             "search by warp ID", NULL);
     88    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     89            "search by diff ID", 0);
     90    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     91            "search by warp ID", 0);
    9292    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,
    9393            "search by skycell ID", NULL);
    … …  
    105105    // -todiffskyfile
    106106    psMetadata *todiffskyfileArgs = psMetadataAlloc();
    107     psMetadataAddStr(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    108             "search by diff ID", NULL);
     107    psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     108            "search by diff ID", 0);
    109109    psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    110110            "limit result set to N items", 0);
    … …  
    114114    // -adddiffskyfile
    115115    psMetadata *adddiffskyfileArgs = psMetadataAlloc();
    116     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    117             "define warp ID (required)", NULL);
     116    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     117            "define warp ID (required)", 0);
    118118    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    119119            "define URI of file", 0);
    … …  
    141141    // -diffskyfile
    142142    psMetadata *diffskyfileArgs = psMetadataAlloc();
    143     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    144             "search by warp ID", NULL);
     143    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     144            "search by warp ID", 0);
    145145    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,
    146146            "define skycell ID", NULL);
    … …  
    154154    // -revertdiffskyfile
    155155    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    156     psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    157             "define warp ID (required)", NULL);
     156    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     157            "define warp ID (required)", 0);
    158158    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    159159            "search by fault code", 0);
    … …  
    171171    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,
    172172            "use the simple output format", false);
    173     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,
    174             "define warp ID for template", NULL);
    175     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,
    176             "define stack ID for template", NULL);
    177     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,
    178             "define warp ID for input", NULL);
    179     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,
    180             "define stack ID for input", NULL);
     173    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,
     174            "define warp ID for template", 0);
     175    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,
     176            "define stack ID for template", 0);
     177    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,
     178            "define warp ID for input", 0);
     179    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,
     180            "define stack ID for input", 0);
    181181
    182182    // -definebyquery
    … …  
    293293    // do this last so we don't setup a connection before CLI options are
    294294    // validated
    295     config->dbh = pmConfigDB(config->modules);
     295    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    296296    if (!config->dbh) {
    297297        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/faketool.c

    r18153 r18357  
    103103    PS_ASSERT_PTR_NON_NULL(config, NULL);
    104104
    105     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    106 
    107105    psMetadata *where = psMetadataAlloc();
    108     // convert exp_id into a psS64
    109     if (exp_id) {
    110         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    111             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    112             psFree(where);
    113             return false;
    114         }
    115     }
    116 
     106    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    117107    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    118108    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    259249
    260250    psMetadata *where = psMetadataAlloc();
    261     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    262     // convert fake_id into a psS64
    263     if (fake_id) {
    264         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    265             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    266             psFree(where);
    267             return false;
    268         }
    269     }
    270 
    271     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    272     // convert exp_id into a psS64
    273     if (exp_id) {
    274         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    275             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    276             psFree(where);
    277             return false;
    278         }
    279     }
    280 
     251    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     252    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    281253    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    282254    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    406378    }
    407379
    408     if (!convertIdToStr(output)) {
    409         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    410         psFree(output);
    411         return false;
    412     }
    413 
    414380    // negate simple so the default is true
    415381    if (!ippdbPrintMetadatas(stdout, output, "fakePendingExp", !simple)) {
    … …  
    433399
    434400    psMetadata *where = psMetadataAlloc();
    435     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    436     // convert fake_id into a psS64
    437     if (fake_id) {
    438         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    439             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    440             psFree(where);
    441             return false;
    442         }
    443     }
    444 
    445     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    446     // convert exp_id into a psS64
    447     if (exp_id) {
    448         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    449             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    450             psFree(where);
    451             return false;
    452         }
    453     }
    454 
     401    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     402    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    455403    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    456404    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    495443    }
    496444
    497     if (!convertIdToStr(output)) {
    498         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    499         psFree(output);
    500         return false;
    501     }
    502 
    503445    // negative simple so the default is true
    504446    if (!ippdbPrintMetadatas(stdout, output, "fakePendingImfile", !simple)) {
    … …  
    519461
    520462    // fake_id, ext_tag, class_id are required
    521     PXOPT_LOOKUP_STR(fake_id, config->args,     "-fake_id", true, false);
    522     PXOPT_LOOKUP_STR(exp_id, config->args,      "-exp_id", true, false);
     463    PXOPT_LOOKUP_S64(fake_id, config->args,     "-fake_id", true, false);
     464    PXOPT_LOOKUP_S64(exp_id, config->args,      "-exp_id", true, false);
    523465    PXOPT_LOOKUP_STR(class_id, config->args,    "-class_id", true, false);
    524466
    … …  
    539481
    540482    if (!fakeProcessedImfileInsert(config->dbh,
    541                                    (psS64)atoll(fake_id),
    542                                    (psS64)atoll(exp_id),
     483                                   fake_id,
     484                                   exp_id,
    543485                                   class_id,
    544486                                   uri,
    … …  
    589531
    590532    psMetadata *where = psMetadataAlloc();
    591     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    592     // convert fake_id into a psS64
    593     if (fake_id) {
    594         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    595             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    596             psFree(where);
    597             return false;
    598         }
    599     }
    600 
    601     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    602     // convert exp_id into a psS64
    603     if (exp_id) {
    604         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    605             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    606             psFree(where);
    607             return false;
    608         }
    609     }
    610 
     533    PXOPT_COPY_S64(config->args, where, "-fake_id", "fakeRun.fake_id", "==");
     534    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    611535    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    612536    PXOPT_COPY_STR(config->args, where, "-inst", "rawExp.telescope", "==");
    … …  
    659583    }
    660584
    661     if (!convertIdToStr(output)) {
    662         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    663         psFree(output);
    664         return false;
    665     }
    666 
    667585    // negative simple so the default is true
    668586    if (!ippdbPrintMetadatas(stdout, output, "fakeProcessedImfile", !simple)) {
    … …  
    682600
    683601    psMetadata *where = psMetadataAlloc();
    684     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    685     // convert fake_id into a psS64
    686     if (fake_id) {
    687         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    688             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    689             psFree(where);
    690             return false;
    691         }
    692     }
    693 
    694     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    695     // convert exp_id into a psS64
    696     if (exp_id) {
    697         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    698             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    699             psFree(where);
    700             return false;
    701         }
    702     }
    703 
     602    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     603    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    704604    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    705605    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    778678
    779679    psMetadata *where = psMetadataAlloc();
    780     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    781     // convert fake_id into a psS64
    782     if (fake_id) {
    783         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    784             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    785             psFree(where);
    786             return false;
    787         }
    788     }
     680    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    789681    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    790682
    … …  
    866758    }
    867759
    868     if (!convertIdToStr(output)) {
    869         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    870         psFree(output);
    871         return false;
    872     }
    873 
    874760    // negative simple so the default is true
    875761    if (!ippdbPrintMetadatas(stdout, output, "fakeMask", !simple)) {
    … …  
    937823        psFree(output);
    938824        return true;
    939     }
    940 
    941     if (!convertIdToStr(output)) {
    942         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    943         psFree(output);
    944         return false;
    945825    }
    946826

  • branches/cleanup/ippTools/src/faketoolConfig.c

    r18153 r18357  
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    49     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
    50             "search by exp_id", NULL);
     49    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
     50            "search by exp_id", 0);
    5151    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,
    5252            "search by exp_name", NULL);
    … …  
    145145    // -updaterun
    146146    psMetadata *updaterunArgs = psMetadataAlloc();
    147     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,
    148             "search by fake ID", NULL);
    149     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    150             "search by exp_id", NULL);
     147    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,
     148            "search by fake ID", 0);
     149    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     150            "search by exp_id", 0);
    151151    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    152152            "search by exp_name", NULL);
    … …  
    231231            "allow everything to be queued without search terms", false);
    232232
    233 
    234233    // -pendingexp
    235234    psMetadata *pendingexpArgs = psMetadataAlloc();
    236     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    237             "search by camtool ID", NULL);
    238     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    239             "search by chiptool ID", NULL);
     235    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
     236            "search by camtool ID", 0);
     237    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
     238            "search by chiptool ID", 0);
    240239    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    241240            "limit result set to N items", 0);
    … …  
    245244    // -pendingimfile
    246245    psMetadata *pendingimfileArgs = psMetadataAlloc();
    247     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    248             "search by fake ID", NULL);
    249     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    250             "search by exposure ID", NULL);
     246    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     247            "search by fake ID", 0);
     248    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     249            "search by exposure ID", 0);
    251250    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    252251            "search by class ID", NULL);
    … …  
    262261    // -addprocessedimfile
    263262    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    264     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    265             "define fake ID (required)", NULL);
    266     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    267             "define exposure ID (required)", NULL);
     263    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     264            "define fake ID (required)", 0);
     265    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     266            "define exposure ID (required)", 0);
    268267    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    269268            "define class ID (required)", NULL);
    … …  
    281280    // -processedimfile
    282281    psMetadata *processedimfileArgs = psMetadataAlloc();
    283     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    284             "define fake ID", NULL);
    285     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    286             "define exposure ID", NULL);
     282    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     283            "define fake ID", 0);
     284    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     285            "define exposure ID", 0);
    287286    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    288287            "define class ID", NULL);
    … …  
    300299    // -updateprocessedimfile
    301300    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    302     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    303             "search by fake ID", NULL);
    304     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exposure ID", NULL);
     301    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
     302            "search by fake ID", 0);
     303    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     304            "search by exposure ID", 0);
    306305    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    307306            "search by class ID", NULL);
    … …  
    311310    // -revertprocessedimfile
    312311    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    313     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    314             "search by fake ID", NULL);
    315     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    316             "search by exp_id", NULL);
     312    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,
     313            "search by fake ID", 0);
     314    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     315            "search by exp_id", 0);
    317316    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,
    318317            "search by exp_name", NULL);
    … …  
    458457
    459458    // define Database handle, if used
    460     config->dbh = pmConfigDB(config->modules);
     459    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    461460    if (!config->dbh) {
    462461        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/flatcorr.c

    r17611 r18357  
    463463
    464464    if (psArrayLength(output)) {
    465         if (!convertIdToStr(output)) {
    466             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    467             psFree(output);
    468             return false;
    469         }
    470 
    471465        // negative simple so the default is true
    472466        if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {

  • branches/cleanup/ippTools/src/flatcorrConfig.c

    r16674 r18357  
    251251    // do this last so we don't setup a connection before CLI options are
    252252    // validated
    253     config->dbh = pmConfigDB(config->modules);
     253    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    254254    if (!config->dbh) {
    255255        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/guidetoolConfig.c

    r14023 r18357  
    196196
    197197    // define Database handle, if used
    198     config->dbh = pmConfigDB(config->modules);
     198    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    199199    if (!config->dbh) {
    200200        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/magictool.c

    r18153 r18357  
    399399
    400400    if (psArrayLength(output)) {
    401         if (!convertIdToStr(output)) {
    402             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    403             psFree(output);
    404             return false;
    405         }
    406 
    407401        // negative simple so the default is true
    408402        if (!ippdbPrintMetadatas(stdout, output, "magicInputSkyfile", !simple)) {
    … …  
    627621
    628622    if (psArrayLength(output)) {
    629         if (!convertIdToStr(output)) {
    630             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    631             psFree(output);
    632             return false;
    633         }
    634 
    635623        // negative simple so the default is true
    636624        if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
    … …  
    718706
    719707    if (psArrayLength(output)) {
    720         if (!convertIdToStr(output)) {
    721             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    722             psFree(output);
    723             return false;
    724         }
    725 
    726708        // negative simple so the default is true
    727709        if (!ippdbPrintMetadatas(stdout, output, "toprocess", !simple)) {
    … …  
    806788
    807789    if (psArrayLength(output)) {
    808         if (!convertIdToStr(output)) {
    809             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    810             psFree(output);
    811             return false;
    812         }
    813 
    814790        // negative simple so the default is true
    815791        if (!ippdbPrintMetadatas(stdout, output, "toskyfilemask", !simple)) {

  • branches/cleanup/ippTools/src/magictoolConfig.c

    r18153 r18357  
    251251    // do this last so we don't setup a connection before CLI options are
    252252    // validated
    253     config->dbh = pmConfigDB(config->modules);
     253    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    254254    if (!config->dbh) {
    255255        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/pstamptool.c

    r16957 r18357  
    336336    char *query ="INSERT INTO pstampRequest"
    337337                 " (state, uri, ds_id, outFileset, resultsFile)"
    338                  " VALUES( 'new', '%s', %s, '%s', 1)";
     338                 " VALUES( 'new', '%s', %s, '%s', 0)";
    339339
    340340    if (!p_psDBRunQuery(config->dbh, query, uri, ds_id, outFileset)) {
    … …  
    567567    }
    568568    if (job_type) {
    569         if (!strcmp(job_type, "get_image")) {
     569        if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
    570570            stampJob = false;
    571571        } else if (!strcmp(job_type, "stamp")) {
    … …  
    622622    }
    623623
     624    psString stateString = psMetadataLookupStr(&status, config->args, "-state");
     625    if (!status) {
     626        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
     627        return false;
     628    }
     629    if (!stateString) {
     630        stateString = "run";
     631    }
     632    psString result = psMetadataLookupStr(&status, config->args, "-result");
     633    if (!status) {
     634        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -result");
     635        return false;
     636    }
     637    if (!result) {
     638        result = "0";
     639    }
     640
    624641    char *query;
    625642   
    626643    if (stampJob) {
    627644        query ="INSERT INTO pstampJob"
    628                  " (req_id, state, jobType, uri, outputBase, args)"
    629                  " VALUES( %s, 'run', '%s', '%s', '%s', '%s')";
     645                 " (req_id, state, jobType, uri, outputBase, result, args)"
     646                 " VALUES( %s, '%s', '%s', '%s', '%s', %s, '%s')";
    630647    } else {
    631648        query ="INSERT INTO pstampJob"
    632                  " (req_id, state, jobType, uri, outputBase)"
    633                  " VALUES( %s, 'run', '%s', '%s', '%s')";
    634     }
    635 
    636     if (!p_psDBRunQuery(config->dbh, query, req_id, job_type, uri, outputBase, argString)) {
     649                 " (req_id, state, jobType, uri, outputBase, result)"
     650                 " VALUES( %s, '%s', '%s', '%s', '%s', %s)";
     651    }
     652
     653    if (!p_psDBRunQuery(config->dbh, query, req_id, stateString, job_type, uri, outputBase, result, argString)) {
    637654        psError(PS_ERR_UNKNOWN, false, "database error");
    638655        return false;

  • branches/cleanup/ippTools/src/pstamptoolConfig.c

    r16957 r18357  
    119119    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,
    120120            "define job args", NULL);
     121    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,
     122            "new state", NULL);
     123    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-result", 0,
     124            "new result", NULL);
    121125
    122126    // -listjob
    … …  
    224228    // do this last so we don't setup a connection before CLI options are
    225229    // validated
    226     config->dbh = pmConfigDB(config->modules);
     230    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    227231    if (!config->dbh) {
    228232        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/pxadminConfig.c

    r17611 r18357  
    126126
    127127    // define Database handle, if used
    128     config->dbh = pmConfigDB(config->modules);
     128    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    129129    if (!config->dbh) {
    130130        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/pxinject.c

    r18076 r18357  
    9191
    9292    if (!newExpInsert(config->dbh,
    93                 0x0,    // exp_id
     93                0,    // exp_id
    9494                tmp_exp_name,
    9595                tmp_camera,
    … …  
    110110    }
    111111
    112     psS64 lastInsertID = psDBLastInsertID(config->dbh);
    113     psString exp_id = psDBIntToString(lastInsertID);
     112    psS64 exp_id = psDBLastInsertID(config->dbh);
    114113
    115114    psMetadata *md = psMetadataAlloc();
    116     if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, NULL, exp_id)) {
     115    if (!psMetadataAddS64(md, PS_LIST_TAIL, "exp_id", 0, NULL, exp_id)) {
    117116        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    118117        psFree(md);
    119         psFree(exp_id);
    120118    }
    121     psFree(exp_id);
    122119
    123120    // negate simple so the default is true
    … …  
    137134    PS_ASSERT_PTR_NON_NULL(config, false);
    138135
    139     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     136    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    140137    PXOPT_LOOKUP_STR(tmp_class_id, config->args, "-tmp_class_id", true, false);
    141138    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    142139
    143140    // insert with error flag state set to 0 (no errors)
    144     if (!newImfileInsert(config->dbh, (psS64)atoll(exp_id), tmp_class_id, uri, NULL)) {
     141    if (!newImfileInsert(config->dbh, exp_id, tmp_class_id, uri, NULL)) {
    145142        psError(PS_ERR_UNKNOWN, false, "database error");
    146143        return false;
    … …  
    155152    PS_ASSERT_PTR_NON_NULL(config, false);
    156153
    157     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     154    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    158155    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    159156

  • branches/cleanup/ippTools/src/pxinjectConfig.c

    r16509 r18357  
    6868    // -newImfile
    6969    psMetadata *newImfileArgs = psMetadataAlloc();
    70     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    71             "define the exp_id (required)", NULL);
     70    psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
     71            "define the exp_id (required)", 0);
    7272    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,
    7373            "define the class ID (required)", NULL);
    … …  
    7777    // -updatenewExp
    7878    psMetadata *updatenewExpArgs = psMetadataAlloc();
    79     psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
    80             "define the exp_id (required)", NULL);
     79    psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
     80            "define the exp_id (required)", 0);
    8181    psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,
    8282            "set state (required)", NULL);
    … …  
    192192    // do this last so we don't setup a connection before CLI options are
    193193    // validated
    194     config->dbh = pmConfigDB(config->modules);
     194    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    195195    if (!config->dbh) {
    196196        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/pxregister.c

    r14023 r18357  
    2929#include "pxregister.h"
    3030
    31 bool pxnewExpSetState(pxConfig *config, const char *exp_id, const char *state)
     31bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state)
    3232{
    33     PS_ASSERT_PTR_NON_NULL(exp_id, false);
     33    if (!exp_id) {
     34        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     35        return false;
     36    }
    3437    PS_ASSERT_PTR_NON_NULL(state, false);
    3538
    … …  
    4649    }
    4750
    48     char *query = "UPDATE newExp SET state = '%s' WHERE exp_id = '%s'";
     51    char *query = "UPDATE newExp SET state = '%s' WHERE exp_id = %"PRId64;
    4952    if (!p_psDBRunQuery(config->dbh, query, state, exp_id)) {
    5053        psError(PS_ERR_UNKNOWN, false,
    51                 "failed to change state for exp_id %s", exp_id);
     54                "failed to change state for exp_id %"PRId64, exp_id);
    5255        return false;
    5356    }

  • branches/cleanup/ippTools/src/pxregister.h

    r14023 r18357  
    2525#include "pxtools.h"
    2626
    27 bool pxnewExpSetState(pxConfig *config, const char *exp_id, const char *state);
     27bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state);
    2828
    2929#endif // PXREGISTER_H

  • branches/cleanup/ippTools/src/pxtools.h

    r18076 r18357  
    3636#include "pxfake.h"
    3737#include "pxwarp.h"
    38 #include "pxio.h"
    3938#include "pxregister.h"
    4039#include "pxtag.h"
    … …  
    108107type var; \
    109108{ \
    110     bool status; \
    111  \
    112     var = psMetadataLookup##suffix(&status, md, key); \
    113     if (!status) { \
    114         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
    115         return ret; \
    116     } \
    117  \
    118     if (required && (var == max)) { \
    119         psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
    120         return ret; \
    121     } \
     109    psMetadataItem *item = psMetadataLookup(md, key); \
     110    if (!item) { \
     111        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", key); \
     112        return ret; \
     113    } \
     114    psAssert(item->comment, "metadata item comment should be defined"); \
     115    if (required && (!psStrcasestr(item->comment, "(found)"))) { \
     116        psError(PS_ERR_UNKNOWN, true, "%s is required", key); \
     117        return ret; \
     118    } \
     119 \
     120    var = item->data.suffix; \
     121 \
    122122}
    123123
    … …  
    171171// XXX the PXOPT_COPY_* macros free 'to' on error
    172172
    173 #define PXOPT_COPY_PRIMITIVE(from, to, type, suffix, oldname, newname, comment) \
    174 { \
    175     bool status = false; \
    176     type var = psMetadataLookup##suffix(&status, from, oldname); \
    177     if (!status) { \
    178         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     173#define PXOPT_COPY_PRIMITIVE(from, to, type, suffix, oldname, newname, newcomment) \
     174{ \
     175    psMetadataItem *item = psMetadataLookup(from, oldname); \
     176    if (!item) { \
     177        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", oldname); \
    179178        return false; \
    180179    } \
    181     if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
    182         psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
    183         psFree(to); \
    184         return false; \
     180    psAssert(item->comment, "metadata item comment should be defined"); \
     181\
     182    if (psStrcasestr(item->comment, "(found)")) { \
     183        if (!psMetadataAdd##suffix(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, newcomment, item->data.suffix)) { \
     184            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     185            psFree(to); \
     186            return false; \
     187        } \
    185188    } \
    186189}

  • branches/cleanup/ippTools/src/pzgetexpConfig.c

    r14600 r18357  
    7373
    7474    // define Database handle, if used
    75     config->dbh = pmConfigDB(config->modules);
     75    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    7676    if(!config->dbh) {
    7777        psError(PS_ERR_UNKNOWN, false, "Can't connect to db\n");

  • branches/cleanup/ippTools/src/pzgetimfilesConfig.c

    r17741 r18357  
    7979
    8080    // define Database handle, if used
    81     config->dbh = pmConfigDB(config->modules);
     81    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    8282    if(!config->dbh) {
    8383        psError(PS_ERR_UNKNOWN, false, "Can't connect to db\n");

  • branches/cleanup/ippTools/src/pztool.c

    r18076 r18357  
    4242static bool updatecopiedMode(pxConfig *config);
    4343static bool revertcopiedMode(pxConfig *config);
     44
     45static bool clearcommonfaultsMode(pxConfig *config);
    4446static bool advanceMode(pxConfig *config);
    4547
    … …  
    7779        MODECASE(PZTOOL_MODE_UPDATECOPIED, updatecopiedMode);
    7880        MODECASE(PZTOOL_MODE_REVERTCOPIED, revertcopiedMode);
     81        MODECASE(PZTOOL_MODE_CLEARCOMMONFAULTS, clearcommonfaultsMode);
    7982        MODECASE(PZTOOL_MODE_ADVANCE, advanceMode);
    8083        default:
    … …  
    203206    PS_ASSERT_PTR_NON_NULL(config, false);
    204207
     208    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    205209    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    206210    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    225229    }
    226230
     231    psStringAppend(&query, " ORDER BY summitExp.dateobs");
     232    if (desc) {
     233        psStringAppend(&query, " DESC");
     234    }
     235
    227236    // treat limit == 0 as "no limit"
    228237    if (limit) {
    … …  
    266275    PS_ASSERT_PTR_NON_NULL(config, false);
    267276
     277    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    268278    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    269279    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    294304            psStringAppend(&query, " AND %s", whereClause);
    295305            psFree(whereClause);
     306        }
     307
     308        psStringAppend(&query, " ORDER BY dateobs");
     309        if (desc) {
     310            psStringAppend(&query, " DESC");
    296311        }
    297312
    … …  
    748763
    749764
     765static bool clearcommonfaultsMode(pxConfig *config)
     766{
     767    PS_ASSERT_PTR_NON_NULL(config, false);
     768
     769{
     770    psString query = pxDataGet("pztool_revert_downloadimfile_faults.sql");
     771    if (!query) {
     772        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     773        return false;
     774    }
     775
     776    if (!p_psDBRunQuery(config->dbh, query)) {
     777        psError(PS_ERR_UNKNOWN, false, "database error");
     778        psFree(query);
     779        return false;
     780    }
     781    psFree(query);
     782}
     783
     784{
     785    psString query = pxDataGet("pztool_revert_fileset_faults.sql");
     786    if (!query) {
     787        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     788        return false;
     789    }
     790
     791    if (!p_psDBRunQuery(config->dbh, query)) {
     792        psError(PS_ERR_UNKNOWN, false, "database error");
     793        psFree(query);
     794        return false;
     795    }
     796    psFree(query);
     797}
     798
     799    return true;
     800}
     801
    750802static bool advanceMode(pxConfig *config)
    751803{

  • branches/cleanup/ippTools/src/pztool.h

    r17655 r18357  
    3434    PZTOOL_MODE_UPDATECOPIED,
    3535    PZTOOL_MODE_REVERTCOPIED,
     36    PZTOOL_MODE_CLEARCOMMONFAULTS,
    3637    PZTOOL_MODE_ADVANCE
    3738} pztoolMode;

  • branches/cleanup/ippTools/src/pztoolConfig.c

    r17655 r18357  
    8080    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,
    8181            "define exposure type", NULL);
     82    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,
     83            "sort ouput in descending format", false);
    8284    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    8385            "limit result set to N items", 0);
    … …  
    9597    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_type", 0,
    9698            "define exposure type", NULL);
     99    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,
     100            "sort ouput in descending format", false);
    97101    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
    98102            "limit result set to N items", 0);
    … …  
    176180            "search by fault code", 0);
    177181
     182    // -clearcommonfaults
     183    psMetadata *clearcommonfaultsArgs = psMetadataAlloc();
     184
    178185    // -advance
    179186    psMetadata *advanceArgs = psMetadataAlloc();
    … …  
    201208    PXOPT_ADD_MODE("-updatecopied",    "", PZTOOL_MODE_UPDATECOPIED,updatecopiedArgs);
    202209    PXOPT_ADD_MODE("-revertcopied",    "", PZTOOL_MODE_REVERTCOPIED,revertcopiedArgs);
     210    PXOPT_ADD_MODE("-clearcommonfaults","", PZTOOL_MODE_CLEARCOMMONFAULTS,clearcommonfaultsArgs);
    203211    PXOPT_ADD_MODE("-advance",          "", PZTOOL_MODE_ADVANCE,    advanceArgs);
    204212
    … …  
    257265    // do this last so we don't setup a connection before CLI options are
    258266    // validated
    259     config->dbh = pmConfigDB(config->modules);
     267    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    260268    if (!config->dbh) {
    261269        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/regtool.c

    r18076 r18357  
    4343static bool revertprocessedexpMode(pxConfig *config);
    4444static bool updateprocessedexpMode(pxConfig *config);
     45static bool cleardupexpMode(pxConfig *config);
    4546
    4647# define MODECASE(caseName, func) \
    … …  
    7475        MODECASE(REGTOOL_MODE_REVERTPROCESSEDEXP,    revertprocessedexpMode);
    7576        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
     77        MODECASE(REGTOOL_MODE_CLEARDUPEXP,           cleardupexpMode);
    7678        default:
    7779            psAbort("invalid option (this should not happen)");
    … …  
    168170
    169171    // required
    170     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     172    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    171173    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
    172174    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    228230    if (!rawImfileInsert(
    229231        config->dbh,
    230         (psS64)atoll(exp_id),
     232        exp_id,
    231233        exp_name,
    232234        camera,
    … …  
    494496
    495497    // required
    496     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
     498    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false);
    497499    PXOPT_LOOKUP_STR(exp_name, config->args, "-exp_name", true, false);
    498500    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    567569        // build a query to search by exp_id
    568570        psMetadata *where = psMetadataAlloc();
    569         if (!psMetadataAddStr(where, PS_LIST_TAIL, "newExp.exp_id", 0, "==", exp_id)) {
     571        if (!psMetadataAddS64(where, PS_LIST_TAIL, "newExp.exp_id", 0, "==", exp_id)) {
    570572            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    571573            psFree(where);
    … …  
    650652
    651653    if (!rawExpInsert(config->dbh,
    652         (psS64)atoll(exp_id),
     654        exp_id,
    653655        exp_name,
    654656        camera,
    … …  
    724726            psError(PS_ERR_UNKNOWN, false, "database error");
    725727        }
    726         psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
     728        psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %"PRId64, exp_id);
    727729    psFree(newExp);
    728730        return false;
    … …  
    747749    // this can only be run as the newExp's state has been set to stop
    748750    if (!pxchipQueueByExpTag(config,
    749                 (psS64)atoll(exp_id),
     751                exp_id,
    750752                workdir,
    751753            label,
    … …  
    795797
    796798    // XX test this out; need to make this consistent with the list in regtoolConfig.c
    797     PXOPT_COPY_STR(config->args, config->where,  "-exp_id", "exp_id", "==");
     799    PXOPT_COPY_S64(config->args, config->where,  "-exp_id", "exp_id", "==");
    798800    PXOPT_COPY_STR(config->args, config->where,  "-exp_name", "exp_name", "==");
    799801    PXOPT_COPY_STR(config->args, config->where,  "-inst", "camera", "==");
    … …  
    941943    return true;
    942944}
     945
     946
     947static bool cleardupexpMode(pxConfig *config)
     948{
     949    PS_ASSERT_PTR_NON_NULL(config, false);
     950
     951    if (!psDBTransaction(config->dbh)) {
     952        psError(PS_ERR_UNKNOWN, false, "database error");
     953        return false;
     954    }
     955
     956// create temp table of exp_ids to be removed
     957{
     958    psString query = pxDataGet("regtool_create_dup_table.sql");
     959    if (!query) {
     960        // rollback
     961        if (!psDBRollback(config->dbh)) {
     962            psError(PS_ERR_UNKNOWN, false, "database error");
     963        }
     964        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     965        return false;
     966    }
     967
     968    if (!p_psDBRunQuery(config->dbh, query)) {
     969        // rollback
     970        if (!psDBRollback(config->dbh)) {
     971            psError(PS_ERR_UNKNOWN, false, "database error");
     972        }
     973        psError(PS_ERR_UNKNOWN, false, "database error");
     974        psFree(query);
     975        return false;
     976    }
     977    psFree(query);
     978}
     979
     980// populate that table
     981// XXX note that this query currently doesn't not correctly handle the case
     982// where there is more than one duplicate
     983{
     984    psString query = pxDataGet("regtool_populate_dup_table.sql");
     985    if (!query) {
     986        // rollback
     987        if (!psDBRollback(config->dbh)) {
     988            psError(PS_ERR_UNKNOWN, false, "database error");
     989        }
     990        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     991        return false;
     992    }
     993
     994    if (!p_psDBRunQuery(config->dbh, query)) {
     995        // rollback
     996        if (!psDBRollback(config->dbh)) {
     997            psError(PS_ERR_UNKNOWN, false, "database error");
     998        }
     999        psError(PS_ERR_UNKNOWN, false, "database error");
     1000        psFree(query);
     1001        return false;
     1002    }
     1003    psFree(query);
     1004}
     1005
     1006    if (!p_psDBRunQuery(config->dbh, "DELETE FROM rawImfile USING rawImfile, duplicate WHERE duplicate.exp_id = rawImfile.exp_id")) {
     1007        // rollback
     1008        if (!psDBRollback(config->dbh)) {
     1009            psError(PS_ERR_UNKNOWN, false, "database error");
     1010        }
     1011        psError(PS_ERR_UNKNOWN, false, "database error");
     1012        return false;
     1013    }
     1014
     1015    if (!p_psDBRunQuery(config->dbh, "DELETE FROM rawExp USING rawExp, duplicate WHERE duplicate.exp_id = rawExp.exp_id")) {
     1016        // rollback
     1017        if (!psDBRollback(config->dbh)) {
     1018            psError(PS_ERR_UNKNOWN, false, "database error");
     1019        }
     1020        psError(PS_ERR_UNKNOWN, false, "database error");
     1021        return false;
     1022    }
     1023
     1024    if (!p_psDBRunQuery(config->dbh, "DELETE FROM newImfile USING newImfile, duplicate WHERE duplicate.exp_id = newImfile.exp_id")) {
     1025        // rollback
     1026        if (!psDBRollback(config->dbh)) {
     1027            psError(PS_ERR_UNKNOWN, false, "database error");
     1028        }
     1029        psError(PS_ERR_UNKNOWN, false, "database error");
     1030        return false;
     1031    }
     1032
     1033    if (!p_psDBRunQuery(config->dbh, "DELETE FROM newExp USING newExp, duplicate WHERE duplicate.exp_id = newExp.exp_id")) {
     1034        // rollback
     1035        if (!psDBRollback(config->dbh)) {
     1036            psError(PS_ERR_UNKNOWN, false, "database error");
     1037        }
     1038        psError(PS_ERR_UNKNOWN, false, "database error");
     1039        return false;
     1040    }
     1041
     1042    if (!psDBCommit(config->dbh)) {
     1043        psError(PS_ERR_UNKNOWN, false, "database error");
     1044        return false;
     1045    }
     1046
     1047    return true;
     1048}

  • branches/cleanup/ippTools/src/regtool.h

    r14098 r18357  
    3535    REGTOOL_MODE_REVERTPROCESSEDEXP,
    3636    REGTOOL_MODE_UPDATEPROCESSEDEXP,
     37    REGTOOL_MODE_CLEARDUPEXP,
    3738} regtoolMode;
    3839

  • branches/cleanup/ippTools/src/regtoolConfig.c

    r17802 r18357  
    6161    // -addprocessedimfile
    6262    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    63     ADD_OPT(Str,  addprocessedimfileArgs, "-exp_id",         "define exposure ID (required)",        NULL);
     63    ADD_OPT(S64,  addprocessedimfileArgs, "-exp_id",         "define exposure ID (required)",        0);
    6464    ADD_OPT(Str,  addprocessedimfileArgs, "-exp_name",       "define the exp_name (required)",         NULL);
    6565    ADD_OPT(Str,  addprocessedimfileArgs, "-inst",           "define the camera name (required)",     NULL);
    … …  
    117117    // -processedimfile
    118118    psMetadata *processedimfileArgs = psMetadataAlloc();
    119    ADD_OPT(Str,  processedimfileArgs, "-exp_id",    "search by exposure ID",                 NULL);
     119   ADD_OPT(S64,  processedimfileArgs, "-exp_id",    "search by exposure ID",                 0);
    120120   ADD_OPT(Str,  processedimfileArgs, "-exp_name",  "search by exposure name",               NULL);
    121121   ADD_OPT(Str,  processedimfileArgs, "-class_id",  "search by class ID",                    NULL);
    … …  
    126126    // -revertprocessedimfile
    127127    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    128     ADD_OPT(Str, revertprocessedimfileArgs, "-exp_id",        "search by exposure ID (required)", NULL);
     128    ADD_OPT(S64, revertprocessedimfileArgs, "-exp_id",        "search by exposure ID (required)", 0);
    129129    ADD_OPT(Str, revertprocessedimfileArgs, "-tmp_class_id",  "searcy by temp. class ID", NULL);
    130130    ADD_OPT(Str, revertprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    … …  
    133133    // -updateprocessedimfile
    134134    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    135     ADD_OPT(Str, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", NULL);
     135    ADD_OPT(S64, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", 0);
    136136    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    137137    ADD_OPT(S16, updateprocessedimfileArgs, "-code",          "set fault code (required)", INT16_MAX);
    … …  
    151151    // -addprocessedexp
    152152    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    153     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",           0,        "exp_id to operate on (required)", NULL);
     153    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",           0,        "exp_id to operate on (required)", 0);
    154154    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_name",         0,        "define the exp_name (required)", NULL);
    155155    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-inst",             0,        "define the camera name (required)", NULL);
    … …  
    215215    // -processedexp
    216216    psMetadata *processedexpArgs = psMetadataAlloc();
    217     psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", NULL);
     217    psMetadataAddS64(processedexpArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", 0);
    218218    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_name",      0,            "search by exp_name", NULL);
    219219    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-inst",          0,            "search for camera", NULL);
    … …  
    260260    // -revertprocessedexp
    261261    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    262     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",   0,            "search by exposure ID (required)", NULL);
     262    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",   0,            "search by exposure ID (required)", 0);
    263263    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",     0,            "search by fault code", 0);
    264264
    265265    // -updatedprocessedexp
    266266    psMetadata *updatedprocessedexpArgs = psMetadataAlloc();
    267     psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     267    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    268268    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-code",    0,            "set fault code (required)", INT16_MAX);
     269
     270    // -cleardupexp
     271    psMetadata *cleardupexpArgs = psMetadataAlloc();
    269272
    270273    psMetadata *argSets = psMetadataAlloc();
    … …  
    272275
    273276    PXOPT_ADD_MODE("-pendingimfile",           "", REGTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    274     PXOPT_ADD_MODE("-addprocessedimfile",      "",  REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
     277    PXOPT_ADD_MODE("-addprocessedimfile",      "", REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
    275278    PXOPT_ADD_MODE("-processedimfile",         "", REGTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    276279    PXOPT_ADD_MODE("-revertprocessedimfile",   "", REGTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
    277     PXOPT_ADD_MODE("-updateprocessedimfile",   "",   REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
    278     PXOPT_ADD_MODE("-pendingexp",              "",       REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
    279     PXOPT_ADD_MODE("-addprocessedexp",         "",  REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    280     PXOPT_ADD_MODE("-processedexp",            "",     REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     280    PXOPT_ADD_MODE("-updateprocessedimfile",   "", REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     281    PXOPT_ADD_MODE("-pendingexp",              "", REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
     282    PXOPT_ADD_MODE("-addprocessedexp",         "", REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     283    PXOPT_ADD_MODE("-processedexp",            "", REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    281284    PXOPT_ADD_MODE("-revertprocessedexp",      "", REGTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
    282     PXOPT_ADD_MODE("-updateprocessedexp",      "",  REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
     285    PXOPT_ADD_MODE("-updateprocessedexp",      "", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
     286    PXOPT_ADD_MODE("-cleardupexp",             "", REGTOOL_MODE_CLEARDUPEXP,      cleardupexpArgs);
    283287
    284288    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    … …  
    352356
    353357    // define Database handle, if used
    354     config->dbh = pmConfigDB(config->modules);
     358    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    355359    if (!config->dbh) {
    356360        psError(PXTOOLS_ERR_SYS, false, "Can't configure database");

  • branches/cleanup/ippTools/src/stacktool.c

    r18153 r18357  
    4141static bool revertsumskyfileMode(pxConfig *config);
    4242
    43 static bool setstackRunState(pxConfig *config, const char *stack_id, const char *state);
     43static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    4444
    4545# define MODECASE(caseName, func) \
    … …  
    486486    PS_ASSERT_PTR_NON_NULL(config, false);
    487487
    488     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     488    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
    489489    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    490490
    … …  
    502502    PS_ASSERT_PTR_NON_NULL(config, false);
    503503
    504     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
    505     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     504    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     505    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
    506506
    507507    // XXX need to validate the warp_id here
    … …  
    509509    // constrants
    510510    if (!stackInputSkyfileInsert(config->dbh,
    511             (psS64)atoll(stack_id),
    512             (psS64)atoll(warp_id)
     511            stack_id,
     512            warp_id
    513513        )) {
    514514        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    574574
    575575    if (psArrayLength(output)) {
    576         if (!convertIdToStr(output)) {
    577             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    578             psFree(output);
    579             return false;
    580         }
    581 
    582576        // negative simple so the default is true
    583577        if (!ippdbPrintMetadatas(stdout, output, "stackInputSkyfile", !simple)) {
    … …  
    648642
    649643    if (psArrayLength(output)) {
    650         if (!convertIdToStr(output)) {
    651             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    652             psFree(output);
    653             return false;
    654         }
    655 
    656644        // negative simple so the default is true
    657645        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
    … …  
    673661
    674662    // required
    675     PXOPT_LOOKUP_STR(stack_id, config->args, "-stack_id", true, false);
     663    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
    676664
    677665    // optional
    … …  
    696684    // constrants
    697685    if (!stackSumSkyfileInsert(config->dbh,
    698                                (psS64)atoll(stack_id),
     686                               stack_id,
    699687                               uri,
    700688                               path_base,
    … …  
    785773
    786774    if (psArrayLength(output)) {
    787         if (!convertIdToStr(output)) {
    788             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    789             psFree(output);
    790             return false;
    791         }
    792 
    793775        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
    794776            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    836818
    837819
    838 static bool setstackRunState(pxConfig *config, const char *stack_id, const char *state)
    839 {
    840     PS_ASSERT_PTR_NON_NULL(stack_id, false);
     820static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
     821{
    841822    PS_ASSERT_PTR_NON_NULL(state, false);
    842823
    … …  
    853834    }
    854835
    855     char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = '%s'";
     836    char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
    856837    if (!p_psDBRunQuery(config->dbh, query, state, stack_id)) {
    857838        psError(PS_ERR_UNKNOWN, false,
    858                 "failed to change state for stack_id %s", stack_id);
    859         return false;
    860     }
    861 
    862     return true;
    863 }
     839                "failed to change state for stack_id %"PRId64, stack_id);
     840        return false;
     841    }
     842
     843    return true;
     844}

  • branches/cleanup/ippTools/src/stacktoolConfig.c

    r18153 r18357  
    111111    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    112112            "define tessellation ID (required)", NULL);
    113     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-warp_id",
     113    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",
    114114             PS_META_DUPLICATE_OK,
    115              "include this warp ID (multiple OK, required)", NULL);
     115             "include this warp ID (multiple OK, required)", 0);
    116116
    117117    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    … …  
    120120    // -updaterun
    121121    psMetadata *updaterunArgs = psMetadataAlloc();
    122     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
    123             "define stack ID (required)", NULL);
     122    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
     123            "define stack ID (required)", 0);
    124124    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    125125            "set state (required)", NULL);
    … …  
    133133    // -addinputskyfile
    134134    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    135     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    136             "define stack ID (required)", NULL);
    137     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    138             "define warp ID (required)", NULL);
     135    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     136            "define stack ID (required)", 0);
     137    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     138            "define warp ID (required)", 0);
    139139
    140140    // -inputskyfile
    141141    psMetadata *inputskyfileArgs = psMetadataAlloc();
    142     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    143             "search by stack ID", NULL);
    144     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    145             "search by warp ID", NULL);
     142    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     143            "search by stack ID", 0);
     144    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     145            "search by warp ID", 0);
    146146    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    147147            "limit result set to N items", 0);
    … …  
    151151    // -tosum
    152152    psMetadata *tosumArgs = psMetadataAlloc();
    153     psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,
    154             "search by stack ID", NULL);
    155     psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,
    156             "search by warp ID", NULL);
     153    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,
     154            "search by stack ID", 0);
     155    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,
     156            "search by warp ID", 0);
    157157    psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,
    158158            "limit result set to N items", 0);
    … …  
    162162    // -addsumskyfile
    163163    psMetadata *addsumskyfileArgs = psMetadataAlloc();
    164     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    165             "define stack ID (required)", NULL);
     164    psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     165            "define stack ID (required)", 0);
    166166    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    167167            "define URI of file", 0);
    … …  
    183183    // -sumskyfile
    184184    psMetadata *sumskyfileArgs= psMetadataAlloc();
    185     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    186             "search by stack ID", NULL);
    187     psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warp ID", NULL);
     185    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     186            "search by stack ID", 0);
     187    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     188            "search by warp ID", 0);
    189189    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    190190            "limit result set to N items", 0);
    … …  
    194194    // -revertsumskyfile
    195195    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    196     psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    197             "search by stack ID (required)", NULL);
     196    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
     197            "search by stack ID (required)", 0);
    198198    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    199199            "search by fault code", 0);
    … …  
    305305    // do this last so we don't setup a connection before CLI options are
    306306    // validated
    307     config->dbh = pmConfigDB(config->modules);
     307    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    308308    if (!config->dbh) {
    309309        psError(PS_ERR_UNKNOWN, false, "Can't configure database");

  • branches/cleanup/ippTools/src/warptool.c

    r18076 r18357  
    111111
    112112    // required options
    113     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", true, false);
     113    PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false);
    114114    PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false);
    115115    // check mode
    … …  
    133133    warpRunRow *warpRun = warpRunRowAlloc(
    134134            0,          // ID
    135             (psS64)atoll(fake_id),
     135            fake_id,
    136136            mode,
    137137            "run",      // state
    … …  
    175175    PS_ASSERT_PTR_NON_NULL(config, false);
    176176
    177     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
    178     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    179     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    180     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    181 
    182177    psMetadata *where = psMetadataAlloc();
    183     // convert warp_id into a psS64
    184     if (warp_id) {
    185         if (!psMetadataAddS64(where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(warp_id))) {
    186             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    187             psFree(where);
    188             return false;
    189         }
    190     }
    191 
    192     // convert fake_id into a psS64
    193     if (fake_id) {
    194         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fake_id", 0, "==", (psS64)atoll(fake_id))) {
    195             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    196             psFree(where);
    197             return false;
    198         }
    199     }
    200 
    201     // convert chip_id into a psS64
    202     if (chip_id) {
    203         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(chip_id))) {
    204             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    205             psFree(where);
    206             return false;
    207         }
    208     }
    209 
    210     // convert exp_id into a psS64
    211     if (exp_id) {
    212         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    213             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    214             psFree(where);
    215             return false;
    216         }
    217     }
    218 
     178    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     179    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     180    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     181    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    219182    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    220183    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    350313
    351314    if (psArrayLength(output)) {
    352         if (!convertIdToStr(output)) {
    353             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    354             psFree(output);
    355             return false;
    356         }
    357 
    358315        // negative simple so the default is true
    359316        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
    … …  
    425382
    426383    if (psArrayLength(output)) {
    427         if (!convertIdToStr(output)) {
    428             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    429             psFree(output);
    430             return false;
    431         }
    432 
    433384        // negative simple so the default is true
    434385        if (!ippdbPrintMetadatas(stdout, output, "warpInputImfile", !simple)) {
    … …  
    500451
    501452    if (psArrayLength(output)) {
    502         if (!convertIdToStr(output)) {
    503             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    504             psFree(output);
    505             return false;
    506         }
    507 
    508453        // negative simple so the default is true
    509454        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
    … …  
    525470
    526471    PXOPT_LOOKUP_STR(mapfile, config->args, "-mapfile", false, false);
    527     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
     472    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
    528473    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    529474
    … …  
    544489    } else {
    545490        warpSkyCellMapInsert(config->dbh,
    546             (psS64)atoll(warp_id),
     491            warp_id,
    547492            NULL,   // skycell_id
    548493            NULL,   // tess_id
    … …  
    677622
    678623    if (psArrayLength(output)) {
    679         if (!convertIdToStr(output)) {
    680             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    681             psFree(output);
    682             return false;
    683         }
    684 
    685624        // negative simple so the default is true
    686625        if (!ippdbPrintMetadatas(stdout, output, "warpSkyCellMap", !simple)) {
    … …  
    752691
    753692    if (psArrayLength(output)) {
    754         if (!convertIdToStr(output)) {
    755             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    756             psFree(output);
    757             return false;
    758         }
    759 
    760693        // negative simple so the default is true
    761694        if (!ippdbPrintMetadatas(stdout, output, "warpPendingSkyCell", !simple)) {
    … …  
    776709    PS_ASSERT_PTR_NON_NULL(config, false);
    777710
    778     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", true, false);
     711    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
    779712    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    780713    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    … …  
    806739    // XXX need to validate that this coresponds to an warpInputImfile
    807740    if (!warpSkyfileInsert(config->dbh,
    808                            (psS64)atoll(warp_id),
     741                           warp_id,
    809742                           skycell_id,
    810743                           tess_id,
    … …  
    1009942
    1010943    if (psArrayLength(output)) {
    1011         if (!convertIdToStr(output)) {
    1012             psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1013             psFree(output);
    1014             return false;
    1015         }
    1016 
    1017944        // negative simple so the default is true
    1018945        if (!ippdbPrintMetadatas(stdout, output, "warpSkyfile", !simple)) {
    … …  
    1033960    PS_ASSERT_PTR_NON_NULL(config, false);
    1034961
    1035     PXOPT_LOOKUP_STR(warp_id, config->args, "-warp_id", false, false);
    1036     PXOPT_LOOKUP_STR(fake_id, config->args, "-fake_id", false, false);
    1037     PXOPT_LOOKUP_STR(chip_id, config->args, "-chip_id", false, false);
    1038     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    1039 
    1040962    psMetadata *where = psMetadataAlloc();
    1041     // convert warp_id into a psS64
    1042     if (warp_id) {
    1043         if (!psMetadataAddS64(where, PS_LIST_TAIL, "warpRun.warp_id", 0, "==", (psS64)atoll(warp_id))) {
    1044             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    1045             psFree(where);
    1046             return false;
    1047         }
    1048     }
    1049 
     963    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     964    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     965    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     966    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    1050967    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
    1051968    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    1052 
    1053     // convert fake_id into a psS64
    1054     if (fake_id) {
    1055         if (!psMetadataAddS64(where, PS_LIST_TAIL, "fakeRun.fake_id", 0, "==", (psS64)atoll(fake_id))) {
    1056             psError(PS_ERR_UNKNOWN, false, "failed to add item fake_id");
    1057             psFree(where);
    1058             return false;
    1059         }
    1060     }
    1061 
    1062     // convert chip_id into a psS64
    1063     if (chip_id) {
    1064         if (!psMetadataAddS64(where, PS_LIST_TAIL, "chipRun.chip_id", 0, "==", (psS64)atoll(chip_id))) {
    1065             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    1066             psFree(where);
    1067             return false;
    1068         }
    1069     }
    1070 
    1071     // convert exp_id into a psS64
    1072     if (exp_id) {
    1073         if (!psMetadataAddS64(where, PS_LIST_TAIL, "rawExp.exp_id", 0, "==", (psS64)atoll(exp_id))) {
    1074             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1075             psFree(where);
    1076             return false;
    1077         }
    1078     }
    1079969
    1080970    // XXX These may need to be updated with the table name?
    … …  
    11931083    }
    11941084
    1195     if (!convertIdToStr(output)) {
    1196         psError(PS_ERR_UNKNOWN, false, "failed to convert id fields into a strings");
    1197         psFree(output);
    1198         return false;
    1199     }
    1200 
    12011085    // negative simple so the default is true
    12021086    if (!ippdbPrintMetadatas(stdout, output, "warpMask", !simple)) {

  • branches/cleanup/ippTools/src/warptoolConfig.c

    r18076 r18357  
    4949    // -definerun
    5050    psMetadata *definerunArgs = psMetadataAlloc();
    51     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
    52             "define camtool ID (required)", NULL);
     51    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
     52            "define camtool ID (required)", 0);
    5353    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
    5454            "define mode (required)", NULL);
    … …  
    7373    psMetadata *updaterunArgs = psMetadataAlloc();
    7474    // XXX need to allow multiple fake_ids
    75     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
    76             "search by warptool ID", NULL);
     75    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
     76            "search by warptool ID", 0);
    7777    // XXX need to allow multiple fake_ids
    78     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
    79             "search by fake_id", NULL);
     78    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
     79            "search by fake_id", 0);
    8080    // XXX need to allow multiple chip_ids
    81     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    82             "search by chip_id", NULL);
     81    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
     82            "search by chip_id", 0);
    8383    // XXX need to allow multiple exp_ids
    84     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    85             "search by exp_id", NULL);
     84    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
     85            "search by exp_id", 0);
    8686    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    8787            "search by exp_name", NULL);
    … …  
    174174    // -exp
    175175    psMetadata *expArgs = psMetadataAlloc();
    176     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-warp_id", 0,
    177             "search by warptool ID", NULL);
    178     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-fake_id", 0,
    179             "search by camtool ID", NULL);
     176    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-warp_id", 0,
     177            "search by warptool ID", 0);
     178    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-fake_id", 0,
     179            "search by camtool ID", 0);
    180180    psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,
    181181            "limit result set to N items", 0);
    … …  
    185185    // -imfile
    186186    psMetadata *imfileArgs = psMetadataAlloc();
    187     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    188             "search by warptool ID", NULL);
    189     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    190             "search by camtool ID", NULL);
     187    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
     188            "search by warptool ID", 0);
     189    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,
     190            "search by camtool ID", 0);
    191191    psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,
    192192            "limit result set to N items", 0);
    … …  
    196196    // -tooverlap
    197197    psMetadata *tooverlapArgs = psMetadataAlloc();
    198     psMetadataAddStr(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
    199             "search by warp ID", NULL);
     198    psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
     199            "search by warp ID", 0);
    200200    psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,
    201201            "limit result set to N items", 0);
    … …  
    207207    psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,
    208208            "path to skycell <-> imfile mapping file", NULL);
    209     psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
    210             "set warp ID", NULL);
     209    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
     210            "set warp ID", 0);
    211211    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,
    212212            "set fault code", 0);
    … …  
    214214    // -scmap
    215215    psMetadata *scmapArgs = psMetadataAlloc();
    216     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
    217             "search by warptool ID", NULL);
     216    psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
     217            "search by warptool ID", 0);
    218218    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,
    219219            "search by skycell ID", NULL);
    … …  
    227227    // -towarped
    228228    psMetadata *towarpedArgs = psMetadataAlloc();
    229     psMetadataAddStr(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    230             "search by warptool ID", NULL);
     229    psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     230            "search by warptool ID", 0);
    231231    psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,
    232232            "limit result set to N items", 0);
    … …  
    236236    // -addwarped
    237237    psMetadata *addwarpedArgs = psMetadataAlloc();
    238     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    239             "define warptool ID (required)", NULL);
     238    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     239            "define warptool ID (required)", 0);
    240240    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    241241            "define skycell ID (required)", NULL);
    … …  
    271271    // -warped
    272272    psMetadata *warpedArgs = psMetadataAlloc();
    273     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    274             "search by warptool ID", NULL);
     273    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     274            "search by warptool ID", 0);
    275275    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    276276            "define skycell ID", NULL);
    277277    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    278278            "define tessellation ID", NULL);
    279     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
    280             "define exposure tag", NULL);
    281     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,
    282             "define phase 3 version of exposure tag", NULL);
     279    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
     280            "define exposure tag", 0);
     281    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,
     282            "define phase 3 version of exposure tag", 0);
    283283    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    284284            "limit result set to N items", 0);
    … …  
    289289    psMetadata *revertwarpedArgs = psMetadataAlloc();
    290290    // XXX need to allow multiple fake_ids
    291     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    292             "search by warptool ID", NULL);
     291    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
     292            "search by warptool ID", 0);
    293293    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    294294            "search by skycell ID", NULL);
    … …  
    296296            "searcy by tessellation ID", NULL);
    297297    // XXX need to allow multiple fake_ids
    298     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
    299             "search by fake_id", NULL);
     298    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
     299            "search by fake_id", 0);
    300300    // XXX need to allow multiple chip_ids
    301     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
    302             "search by chip_id", NULL);
     301    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
     302            "search by chip_id", 0);
    303303    // XXX need to allow multiple exp_ids
    304     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exp_id", NULL);
     304    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
     305            "search by exp_id", 0);
    306306    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,
    307307            "search by exp_name", NULL);
    … …  
    496496    // do this last so we don't setup a connection before CLI options are
    497497    // validated
    498     config->dbh = pmConfigDB(config->modules);
     498    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));
    499499    if (!config->dbh) {
    500500        psError(PS_ERR_UNKNOWN, false, "Can't configure database");
Note: See TracChangeset for help on using the changeset viewer.