IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18561


Ignore:
Timestamp:
Jul 15, 2008, 10:30:59 AM (18 years ago)
Author:
eugene
Message:

completely deprecate config->where; make all command-line handling consistent; move nearly all sql into share/*.sql; ensure consistency between args supplied and used

Location:
trunk/ippTools
Files:
19 added
41 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/notes.txt

    r18448 r18561  
     1
     22008.07.11 EAM
     3
     4  * break dettool.c into files for each detrend stage
     5  * require -iteration in more places? (esp -add...)
     6  * allow %s, %d arguments in the *.sql files or not?
     7  * adddetrunsummary has the ability to set values for multiple detRunSummary entries.  why?
    18
    292008.07.09 EAM

  • trunk/ippTools/share/Makefile.am

    r18526 r18561  
    1010        chiptool_donecleanup.sql \
    1111        chiptool_find_rawexp.sql \
    12         chiptool_find_unprocessed_imfile.pl \
     12        chiptool_pendingcleanupimfile.sql \
    1313        chiptool_pendingcleanuprun.sql \
    14         chiptool_pendingcleanupimfile.sql \
    1514        chiptool_pendingimfile.sql \
    1615        chiptool_processedimfile.sql \
     16        chiptool_revertprocessedimfile.sql \
    1717        chiptool_run.sql \
    18         chiptool_revertprocessedimfile.sql \
    1918        chiptool_unmasked.sql \
    2019        detselect_search.sql \
    2120        detselect_select.sql \
     21        dettool_addprocessedexp.sql \
     22        dettool_childlessrun.sql \
     23        dettool_definebydetrun.sql \
     24        dettool_detrunsummary.sql \
    2225        dettool_find_completed_runs.sql \
     26        dettool_input.sql \
     27        dettool_normalizedexp.sql \
     28        dettool_normalizedimfile.sql \
    2329        dettool_normalizedstat.sql \
     30        dettool_pending.sql \
     31        dettool_processedimfile.sql \
    2432        dettool_raw.sql \
     33        dettool_residexp.sql \
     34        dettool_residimfile.sql \
    2535        dettool_revertdetrunsummary.sql \
    2636        dettool_revertnormalizedexp.sql \
    … …  
    3343        dettool_revertstacked.sql \
    3444        dettool_runs.sql \
     45        dettool_stacked.sql \
    3546        dettool_start_new_iteration.sql \
    3647        dettool_stop_completed_correct_runs.sql \
    … …  
    3849        dettool_tocorrectimfile.sql \
    3950        dettool_todetrunsummary.sql \
     51        dettool_tonormalize.sql \
    4052        dettool_tonormalizedexp.sql \
    4153        dettool_tonormalizedstat.sql \
    … …  
    6274        flatcorr_find_completed_floatcorruns.sql \
    6375        flatcorr_find_processedimfiles.sql \
     76        flatcorr_pending.sql \
     77        magictool_create_tmp_warpcomplete.sql \
    6478        magictool_find_complete_diffed_exposures.sql \
    6579        magictool_find_complete_warpruns.sql \
     80        magictool_find_unmagiced.sql \
    6681        magictool_inputskyfile.sql \
    6782        magictool_totree.sql \
    … …  
    7388        magictool_addmask.sql \
    7489        magictool_mask.sql \
     90        pstamptool_addjob_otherjob.sql \
     91        pstamptool_addjob_stampjob.sql \
     92        pstamptool_datastore.sql \
     93        pstamptool_pendingjob.sql \
     94        pstamptool_pendingreq.sql \
    7595        pxadmin_create_tables.sql \
    7696        pxadmin_drop_tables.sql \
    7797        pztool_find_completed_exp.sql \
    7898        pztool_pendingimfile.sql \
    79         pztool_revertcopied.sql \
    8099        pztool_revert_downloadimfile_faults.sql \
    81100        pztool_revert_fileset_faults.sql \
     101        pztool_revertcopied.sql \
    82102        regtool_create_dup_table.sql \
    83103        regtool_pendingexp.sql \
    … …  
    95115        warptool_exp.sql \
    96116        warptool_imfile.sql \
     117        warptool_revertwarped.sql \
    97118        warptool_scmap.sql \
    98119        warptool_tooverlap.sql \
    99         warptool_revertwarped.sql \
    100120        warptool_towarped.sql \
    101121        warptool_warped.sql

  • trunk/ippTools/share/dettool_tonormalizedexp.sql

    r15855 r18561  
     1-- this is used by both 'tonormalizedexp' and 'addnormalizedexp'
     2
    13SELECT
    24    *

  • trunk/ippTools/share/dettool_toresidexp.sql

    r15769 r18561  
     1-- this is used by both 'toresidexp' and 'addresidexp'
     2
    13-- which returns a list of exposures for which all component class ids have had
    24-- residuals created.  This list includes the detrend id, iteration, exposure

  • trunk/ippTools/share/dettool_toresidimfile.sql

    r18126 r18561  
    4040    AND detRun.mode = 'master'
    4141    AND detNormalizedImfile.fault = 0
     42    AND detNormalizedExp.fault = 0
    4243    AND detResidImfile.det_id IS NULL
    4344    AND detResidImfile.iteration IS NULL
    … …  
    7374    detRun.state = 'run'
    7475    AND detRun.mode = 'verify'
     76    -- AND detNormalizedImfile.fault = 0
     77    -- AND detNormalizedExp.fault = 0
    7578    AND detResidImfile.det_id IS NULL
    7679    AND detResidImfile.iteration IS NULL

  • trunk/ippTools/share/difftool_queue.sql

    r17712 r18561  
    33        stackRun.tess_id,
    44        stackRun.stack_id,
     5        diffInputSkyfile.template,
    56        warpSkyfile.warp_id
    67FROM stackSumSkyfile

  • trunk/ippTools/src/caltool.c

    r18336 r18561  
    110110
    111111    psString query = psStringCopy("SELECT * FROM calDB");
    112 
    113     if (config->where) {
    114         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    115         psStringAppend(&query, " %s", whereClause);
    116         psFree(whereClause);
    117     }
    118112
    119113    // treat limit == 0 as "no limit"
    … …  
    195189    PS_ASSERT_PTR_NON_NULL(config, false);
    196190
     191    psMetadata *where = psMetadataAlloc();
     192    PXOPT_COPY_STR(config->args, where,  "-cal_id",     "cal_id", "==");
     193
    197194    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    198195    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     196    PXOPT_LOOKUP_BOOL(faulted, config->args, "-simple", false);
    199197
    200198    psString query = psStringCopy("SELECT * FROM calRun");
    201199
    202     if (config->where) {
    203         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
     200    if (faulted) {
     201        // list only faulted rows
     202        psStringAppend(&query, " %s", "WHERE fault != 0");
     203    } else {
     204        // don't list faulted rows
     205        psStringAppend(&query, " %s", "WHERE fault = 0");
     206    }
     207
     208    if (psListLength(where->list)) {
     209        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    204210        psStringAppend(&query, " %s", whereClause);
    205211        psFree(whereClause);
    206212    }
     213    psFree(where);
    207214
    208215    // treat limit == 0 as "no limit"
    209216    if (limit) {
    210217        psString limitString = psDBGenerateLimitSQL(limit);
    211         psStringAppend(&query, " %s", limitString);
     218        psStringAppend(&query, " AND %s", limitString);
    212219        psFree(limitString);
    213220    }

  • trunk/ippTools/src/caltoolConfig.c

    r18172 r18561  
    4949    // -adddb
    5050    psMetadata *adddbArgs = psMetadataAlloc();
    51     psMetadataAddStr(adddbArgs, PS_LIST_TAIL, "-dvodb",  0,
    52             "define DVO db (required)", NULL);
     51    psMetadataAddStr(adddbArgs, PS_LIST_TAIL, "-dvodb",  0,            "define DVO db (required)", NULL);
    5352
    5453    // -dbs
    5554    psMetadata *dbsArgs = psMetadataAlloc();
    56     psMetadataAddU64(dbsArgs, PS_LIST_TAIL, "-limit",  0,
    57             "limit result set to N items", 0);
    58     psMetadataAddBool(dbsArgs, PS_LIST_TAIL, "-simple", 0,
    59             "use the simple output format", false);
     55    psMetadataAddU64(dbsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     56    psMetadataAddBool(dbsArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    6057
    6158    // -addrun
    6259    psMetadata *addrunArgs = psMetadataAlloc();
    63     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-cal_id",  0,
    64             "define calibration DB ID (required)", NULL);
    65     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-region",  0,
    66             "define region (required)", NULL);
    67     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-last_step",  0,
    68             "define last step (required)", NULL);
    69     psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-state",  0,
    70             "define state (required)", NULL);
     60    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-cal_id",  0,            "define calibration DB ID (required)", NULL);
     61    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-region",  0,            "define region (required)", NULL);
     62    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-last_step",  0,            "define last step (required)", NULL);
     63    psMetadataAddStr(addrunArgs, PS_LIST_TAIL, "-state",  0,            "define state (required)", NULL);
    7164
    7265    // -runs
    7366    psMetadata *runsArgs = psMetadataAlloc();
    74     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-cal_id",  0,
    75             "search for calibration ID", NULL);
    76     psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,
    77             "limit result set to N items", 0);
    78     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-faulted",  0,
    79             "only return imfiles with a fault status set", false);
    80     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,
    81             "use the simple output format", false);
     67    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-cal_id",  0,            "search for calibration ID", NULL);
     68    psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     69    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     70    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    8271
    8372    psFree(now);
    … …  
    8675    psMetadata *modes = psMetadataAlloc();
    8776
    88     PXOPT_ADD_MODE("-adddb",   "add a DVO calibration DB",
    89         CALTOOL_MODE_ADDDB,     adddbArgs);
    90     PXOPT_ADD_MODE("-dbs",     "list DVO calibration DBs",
    91         CALTOOL_MODE_DBS,       dbsArgs);
    92     PXOPT_ADD_MODE("-addrun",  "add the results of a calibration run",
    93         CALTOOL_MODE_ADDRUN,    addrunArgs);
    94     PXOPT_ADD_MODE("-runs",    "list the results of calibration runs",
    95         CALTOOL_MODE_RUNS,      runsArgs);
     77    PXOPT_ADD_MODE("-adddb",   "add a DVO calibration DB",        CALTOOL_MODE_ADDDB,     adddbArgs);
     78    PXOPT_ADD_MODE("-dbs",     "list DVO calibration DBs",        CALTOOL_MODE_DBS,       dbsArgs);
     79    PXOPT_ADD_MODE("-addrun",  "add the results of a calibration run",        CALTOOL_MODE_ADDRUN,    addrunArgs);
     80    PXOPT_ADD_MODE("-runs",    "list the results of calibration runs",        CALTOOL_MODE_RUNS,      runsArgs);
    9681
    9782    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    … …  
    10590    psFree(argSets);
    10691    psFree(modes);
    107 
    108     // setup search criterion
    109 #define addWhereStr(name) \
    110 { \
    111     psString str = NULL; \
    112     bool status = false; \
    113     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    114         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    115             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    116             psFree(config); \
    117             return NULL; \
    118         } \
    119     } \
    120 }
    121 
    122     // generate SQL where clause
    123     config->where = psMetadataAlloc();
    124 
    125     addWhereStr(det_id);
    126     {
    127         // XXX this is broke because you can't specify -iteration 0
    128         psMetadataItem *item = psMetadataLookup(config->args, "-iteration");
    129         if (item && psStrcasestr(item->comment, "found")) {
    130             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", item->data.S32)) {
    131                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    132                 psFree(config);
    133                 return NULL;
    134             }
    135         }
    136     }
    137 
    138     addWhereStr(det_id);
    139 
    140     // convert '-code' to 'fault'
    141     {
    142         psS16 fault = 0;
    143         bool status = false;
    144         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    145             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    146                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    147                 psFree(config);
    148                 return NULL;
    149             }
    150         }
    151     }
    152 
    153     if (config->where->list->n < 1) {
    154         psFree(config->where);
    155         config->where = NULL;
    156     }
    15792
    15893    // define Database handle, if used

  • trunk/ippTools/src/camtool.c

    r18459 r18561  
    110110    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    111111    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    112 
    113112    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    114113    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    … …  
    162161    }
    163162
     163    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    164164    if (where && psListLength(where->list)) {
    165165        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    263263    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    264264    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    265 
    266265    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    267266    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    … …  
    334333    PS_ASSERT_PTR_NON_NULL(config, false);
    335334
     335    psMetadata *where = psMetadataAlloc();
     336    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     337    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     338
    336339    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    337340    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    343346    }
    344347
    345     if (config->where) {
    346         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    347         psStringAppend(&query, " %s", whereClause);
     348    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     349    if (psListLength(where->list)) {
     350        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     351        psStringAppend(&query, "%s", whereClause);
    348352        psFree(whereClause);
    349353    }
     354    psFree(where);
    350355
    351356    // treat limit == 0 as "no limit"
    … …  
    390395    PS_ASSERT_PTR_NON_NULL(config, false);
    391396
     397    psMetadata *where = psMetadataAlloc();
     398    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     399    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     400    PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
     401    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     402
    392403    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    393404
    … …  
    398409    }
    399410
    400     if (config->where) {
    401         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    402         psStringAppend(&query, " %s", whereClause);
     411    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     412    if (psListLength(where->list)) {
     413        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     414        psStringAppend(&query, "%s", whereClause);
    403415        psFree(whereClause);
    404416    }
     417    psFree(where);
    405418
    406419    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    463476    PXOPT_LOOKUP_F32(dtime_astrom, config->args, "-dtime_astrom", false, false);
    464477    PXOPT_LOOKUP_STR(hostname, config->args,       "-hostname", false, false);
    465     PXOPT_LOOKUP_F32(n_stars, config->args, "-n_stars", false, false);
    466     PXOPT_LOOKUP_F32(n_extended, config->args, "-n_extended", false, false);
    467     if (n_extended < 0) {
    468         psError(PS_ERR_UNKNOWN, true, "-n_extended is required");
    469         return false;
    470     }
    471     PXOPT_LOOKUP_F32(n_cr, config->args, "-n_cr", false, false);
    472     if (n_cr < 0) {
    473         psError(PS_ERR_UNKNOWN, true, "-n_cr is required");
    474         return false;
    475     }
    476     PXOPT_LOOKUP_F32(n_astrom, config->args, "-n_astrom", false, false);
    477     if (n_astrom < 0) {
    478         psError(PS_ERR_UNKNOWN, true, "-n_astrom is required");
    479         return false;
    480     }
    481 
     478    PXOPT_LOOKUP_S32(n_stars, config->args,        "-n_stars", false, false);
     479    PXOPT_LOOKUP_S32(n_extended, config->args,     "-n_extended", false, false);
     480    PXOPT_LOOKUP_S32(n_cr, config->args,           "-n_cr", false, false);
     481    PXOPT_LOOKUP_S32(n_astrom, config->args,       "-n_astrom", false, false);
    482482    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    483 
    484     // default
    485483    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     484
     485    // generate restrictions
     486    psMetadata *where = psMetadataAlloc();
     487    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
    486488
    487489    psString query = pxDataGet("camtool_find_pendingexp.sql");
    … …  
    491493    }
    492494
    493     {
    494         // build a query to search by cam_id
    495         psMetadata *where = psMetadataAlloc();
    496         if (cam_id) {
    497             if (!psMetadataAddS64(where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    498                 psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    499                 psFree(where);
    500                 psFree(query);
    501                 return false;
    502             }
    503         }
    504 
     495    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     496    if (psListLength(where->list)) {
    505497        psString whereClaus = psDBGenerateWhereSQL(where, NULL);
    506         psFree(where);
    507         if (whereClaus) {
    508             psStringAppend(&query, " %s", whereClaus);
    509             psFree(whereClaus);
    510         }
    511 
    512     }
     498        psStringAppend(&query, "%s", whereClaus);
     499        psFree(whereClaus);
     500    }
     501    psFree(where);
    513502
    514503    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    640629    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    641630
     631    // generate restrictions
     632    psMetadata *where = psMetadataAlloc();
     633    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     634    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",   "==");
     635
    642636    psString query = pxDataGet("camtool_find_processedexp.sql");
    643637    if (!query) {
    … …  
    646640    }
    647641
    648     if (config->where) {
    649         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     642    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     643    if (psListLength(where->list)) {
     644        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    650645        psStringAppend(&query, " AND %s", whereClause);
    651646        psFree(whereClause);
    652647    }
     648    psFree(where);
    653649
    654650    if (faulted) {
    … …  
    716712    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    717713    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    718 
    719     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    720     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     714    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     715    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    721716    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    722717    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    745740    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    746741
    747     if (!psListLength(where->list)
    748         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     742    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    749743        psFree(where);
    750744        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    758752    }
    759753
    760 {
    761     psString query = pxDataGet("camtool_reset_faulted_runs.sql");
    762     if (!query) {
    763         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    764         psFree(where);
    765         return false;
    766     }
    767 
    768     if (where && psListLength(where->list)) {
    769         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    770         psStringAppend(&query, " AND %s", whereClause);
    771         psFree(whereClause);
    772     }
    773 
    774     if (!p_psDBRunQuery(config->dbh, query)) {
    775         // rollback
    776         if (!psDBRollback(config->dbh)) {
    777             psError(PS_ERR_UNKNOWN, false, "database error");
    778         }
    779         psError(PS_ERR_UNKNOWN, false, "database error");
    780         psFree(query);
    781         psFree(where);
    782         return false;
    783     }
    784     psFree(query);
    785 }
    786 
    787 {
    788     psString query = pxDataGet("camtool_revertprocessedexp.sql");
    789     if (!query) {
    790         // rollback
    791         if (!psDBRollback(config->dbh)) {
    792             psError(PS_ERR_UNKNOWN, false, "database error");
    793         }
    794         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    795         psFree(where);
    796         return false;
    797     }
    798 
    799     if (where && psListLength(where->list)) {
    800         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    801         psStringAppend(&query, " AND %s", whereClause);
    802         psFree(whereClause);
    803     }
    804 
    805     if (!p_psDBRunQuery(config->dbh, query)) {
    806         // rollback
    807         if (!psDBRollback(config->dbh)) {
    808             psError(PS_ERR_UNKNOWN, false, "database error");
    809         }
    810         psError(PS_ERR_UNKNOWN, false, "database error");
    811         psFree(query);
    812         psFree(where);
    813         return false;
    814     }
    815     psFree(query);
    816 }
     754    {
     755        psString query = pxDataGet("camtool_reset_faulted_runs.sql");
     756        if (!query) {
     757            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     758            psFree(where);
     759            return false;
     760        }
     761
     762        // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     763        if (where && psListLength(where->list)) {
     764            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     765            psStringAppend(&query, " AND %s", whereClause);
     766            psFree(whereClause);
     767        }
     768
     769        if (!p_psDBRunQuery(config->dbh, query)) {
     770            // rollback
     771            if (!psDBRollback(config->dbh)) {
     772                psError(PS_ERR_UNKNOWN, false, "database error");
     773            }
     774            psError(PS_ERR_UNKNOWN, false, "database error");
     775            psFree(query);
     776            psFree(where);
     777            return false;
     778        }
     779        psFree(query);
     780    }
     781
     782    {
     783        psString query = pxDataGet("camtool_revertprocessedexp.sql");
     784        if (!query) {
     785            // rollback
     786            if (!psDBRollback(config->dbh)) {
     787                psError(PS_ERR_UNKNOWN, false, "database error");
     788            }
     789            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     790            psFree(where);
     791            return false;
     792        }
     793
     794        // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     795        if (where && psListLength(where->list)) {
     796            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     797            psStringAppend(&query, " AND %s", whereClause);
     798            psFree(whereClause);
     799        }
     800
     801        if (!p_psDBRunQuery(config->dbh, query)) {
     802            // rollback
     803            if (!psDBRollback(config->dbh)) {
     804                psError(PS_ERR_UNKNOWN, false, "database error");
     805            }
     806            psError(PS_ERR_UNKNOWN, false, "database error");
     807            psFree(query);
     808            psFree(where);
     809            return false;
     810        }
     811        psFree(query);
     812    }
    817813    psFree(where);
    818814
    … …  
    832828    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    833829
    834     if (!pxSetFaultCode(config->dbh, "camProcessedExp", config->where, code)) {
     830    psMetadata *where = psMetadataAlloc();
     831    PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     832    PXOPT_COPY_S64(config->args, where, "-chip_id",  "chip_id",  "==");
     833    PXOPT_COPY_STR(config->args, where, "-class",    "class",    "==");
     834    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     835
     836    if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, code)) {
    835837        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    836         return false;
    837     }
     838        psFree (where);
     839        return false;
     840    }
     841    psFree (where);
    838842
    839843    return true;

  • trunk/ippTools/src/camtoolConfig.c

    r18453 r18561  
    4747
    4848    // -definebyquery
     49    // XXX need to allow multiple chip_ids
     50    // XXX need to allow multiple exp_ids
    4951    psMetadata *definebydefinebyqueryArgs = psMetadataAlloc();
     52    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
     53    psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
     54    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
     55    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
     56    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
     57    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
     58    psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
     59    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
     60    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
     61    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
     62    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     63    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
     64    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN);
     65    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN);
     66    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_min",             0, "define min", NAN);
     67    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_max",             0, "define max", NAN);
     68    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_min",           0, "define min", NAN);
     69    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_max",           0, "define max", NAN);
     70    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",       0, "define min", NAN);
     71    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",       0, "define max", NAN);
     72    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN);
     73    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define min fraction of saturated pixels", NAN);
     74    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_min",             0, "define max", NAN);
     75    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_max",             0, "define max", NAN);
     76    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "define max", NAN);
     77    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "define max", NAN);
     78    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define max", NAN);
     79    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max", NAN);
     80    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_min",            0, "define min", NAN);
     81    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_max",            0, "define max", NAN);
     82    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_min",             0, "define min", NAN);
     83    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_max",             0, "define max", NAN);
     84    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN);
     85    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN);
     86    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_min",         0, "define min rotator position angle", NAN);
     87    psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
     88    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     89    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
     90    psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     91
     92    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
     93    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_label",          0, "define label", NULL);
     94    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
     95    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",       0, "define exposure group", NULL);
     96    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
     97    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
     98    psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
     99    psMetadataAddBool(definebydefinebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     100
     101    // -updaterun
     102    // XXX need to allow multiple cam_ids
    50103    // XXX need to allow multiple chip_ids
    51     psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0,
    52             "search by chip_id", 0);
    53104    // XXX need to allow multiple exp_ids
    54     psMetadataAddS64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_id",  0,
    55             "search by exp_id", 0);
    56     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_name",  0,
    57             "search by exp_name", NULL);
    58     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
    59             "search for camera", NULL);
    60     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
    61             "search for telescope", NULL);
    62     psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    63             "search for exposures by time (>=)", NULL);
    64     psMetadataAddTime(definebydefinebyqueryArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    65             "search for exposures by time (<)", NULL);
    66     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_tag",  0,
    67             "search by exp_tag", NULL);
    68     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_type",  0,
    69             "search by exp_type", NULL);
    70     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,
    71             "search by filelevel", NULL);
    72     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,
    73             "search by reduction class", NULL);
    74     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    75             "search for filter", NULL);
    76     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
    77             "define min airmass", NAN);
    78     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
    79             "define max airmass", NAN);
    80     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_min",  0,
    81             "define min", NAN);
    82     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ra_max",  0,
    83             "define max", NAN);
    84     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_min",  0,
    85             "define min", NAN);
    86     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-decl_max",  0,
    87             "define max", NAN);
    88     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    89             "define min", NAN);
    90     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    91             "define max", NAN);
    92     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    93             "define max fraction of saturated pixels", NAN);
    94     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    95             "define min fraction of saturated pixels", NAN);
    96     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_min",  0,
    97             "define max", NAN);
    98     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_max",  0,
    99             "define max", NAN);
    100     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    101             "define max", NAN);
    102     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    103             "define max", NAN);
    104     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    105             "define max", NAN);
    106     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    107             "define max", NAN);
    108     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_min",  0,
    109             "define min", NAN);
    110     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-alt_max",  0,
    111             "define max", NAN);
    112     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_min",  0,
    113             "define min", NAN);
    114     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-az_max",  0,
    115             "define max", NAN);
    116     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    117             "define min ccd tempature", NAN);
    118     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    119             "define max ccd tempature", NAN);
    120     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
    121             "define min rotator position angle", NAN);
    122     psMetadataAddF64(definebydefinebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
    123             "define max rotator position angle", NAN);
    124     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-object",  0,
    125             "search by exposure object", NULL);
    126     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,
    127             "define min solar angle", NAN);
    128     psMetadataAddF32(definebydefinebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    129             "define max solar angle", NAN);
    130     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_workdir",  0,
    131             "define workdir", NULL);
    132     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_label",  0,
    133             "define label", NULL);
    134     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_reduction",  0,
    135             "define reduction class", NULL);
    136     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_expgroup",  0,
    137             "define exposure group", NULL);
    138     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    139             "define DVO db", NULL);
    140     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",  0,
    141             "define tess ID", NULL);
    142     psMetadataAddStr(definebydefinebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",  0,
    143             "define end stage", NULL);
    144     psMetadataAddBool(definebydefinebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    145             "allow everything to be queued without search terms", false);
    146 
    147     // -updaterun
    148105    psMetadata *updaterunArgs = psMetadataAlloc();
    149     // XXX need to allow multiple cam_ids
    150     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",  0,
    151             "search by cam_id", 0);
    152     // XXX need to allow multiple chip_ids
    153     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    154             "search by chip_id", 0);
    155     // XXX need to allow multiple exp_ids
    156     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    157             "search by exp_id", 0);
    158     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    159             "search by exp_name", NULL);
    160     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,
    161             "search for camera", NULL);
    162     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,
    163             "search for telescope", NULL);
    164     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    165             "search for exposures by time (>=)", NULL);
    166     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    167             "search for exposures by time (<)", NULL);
    168     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    169             "search by exp_tag", NULL);
    170     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,
    171             "search by exp_type", NULL);
    172     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,
    173             "search by filelevel", NULL);
    174     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,
    175             "search by reduction class", NULL);
    176     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,
    177             "search for filter", NULL);
    178     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    179             "define min airmass", NAN);
    180     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    181             "define max airmass", NAN);
    182     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,
    183             "define min", NAN);
    184     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,
    185             "define max", NAN);
    186     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,
    187             "define min", NAN);
    188     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,
    189             "define max", NAN);
    190     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    191             "define min", NAN);
    192     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    193             "define max", NAN);
    194     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    195             "define max fraction of saturated pixels", NAN);
    196     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    197             "define min fraction of saturated pixels", NAN);
    198     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,
    199             "define max", NAN);
    200     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,
    201             "define max", NAN);
    202     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    203             "define max", NAN);
    204     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    205             "define max", NAN);
    206     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    207             "define max", NAN);
    208     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    209             "define max", NAN);
    210     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,
    211             "define min", NAN);
    212     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,
    213             "define max", NAN);
    214     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,
    215             "define min", NAN);
    216     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,
    217             "define max", NAN);
    218     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    219             "define min ccd tempature", NAN);
    220     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    221             "define max ccd tempature", NAN);
    222     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,
    223             "define min rotator position angle", NAN);
    224     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,
    225             "define max rotator position angle", NAN);
    226     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,
    227             "search by exposure object", NULL);
    228     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,
    229             "define min solar angle", NAN);
    230     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,
    231             "define max solar angle", NAN);
    232 
    233     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,
    234             "allow everything to be queued without search terms", false);
    235     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    236             "set state", NULL);
    237     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,
    238             "set label", NULL);
    239 
     106    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
     107    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
     108    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
     109    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
     110    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
     112    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
     113    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
     114    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
     117    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     118    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
     119    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN);
     120    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN);
     121    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",             0, "define min", NAN);
     122    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",             0, "define max", NAN);
     123    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",           0, "define min", NAN);
     124    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",           0, "define max", NAN);
     125    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",       0, "define min", NAN);
     126    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",       0, "define max", NAN);
     127    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN);
     128    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define min fraction of saturated pixels", NAN);
     129    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",             0, "define max", NAN);
     130    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",             0, "define max", NAN);
     131    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "define max", NAN);
     132    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "define max", NAN);
     133    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define max", NAN);
     134    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max", NAN);
     135    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",            0, "define min", NAN);
     136    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",            0, "define max", NAN);
     137    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",             0, "define min", NAN);
     138    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",             0, "define max", NAN);
     139    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN);
     140    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN);
     141    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",         0, "define min rotator position angle", NAN);
     142    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
     143    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     144    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
     145    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     146
     147    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
     148    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",              0, "set state", NULL);
     149    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",              0, "set label", NULL);
    240150
    241151    // -pendingexp
    242152    psMetadata *pendingexpArgs = psMetadataAlloc();
    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);
    247     psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    248             "limit result set to N items", 0);
    249     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
    250             "use the simple output format", false);
    251 
     153    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id",            0, "search by camtool ID", 0);
     154    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id",           0, "search by chiptool ID", 0);
     155    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",             0, "limit result set to N items", 0);
     156    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",           0, "use the simple output format", false);
    252157
    253158    // -pendingimfile
    254159    psMetadata *pendingimfileArgs = psMetadataAlloc();
    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);
    259     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,
    260             "search by class", NULL);
    261     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    262             "search by class ID", NULL);
    263     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,
    264             "use the simple output format", false);
    265 
     160    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     161    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
     162    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class", 0,            "search by class", NULL);
     163    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
     164    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    266165
    267166    // -addprocessedexp
    268167    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    269     psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    270             "define camtool ID (required)", 0);
    271     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,
    272             "define URI (required)", NULL);
    273     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,
    274             "define exposure background", NAN);
    275     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,
    276             "define exposure background stdev", NAN);
    277     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,
    278             "define exposure background mean stdev", NAN);
    279     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias",  0,
    280             "define bias", NAN);
    281     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias_stdev",  0,
    282             "define bias stdev", NAN);
    283     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    284             "define fringe term 0", NAN);
    285     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    286             "define fringe term 1", NAN);
    287     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    288             "define fringe term 2", NAN);
    289     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,
    290             "define exposure E ra", NAN);
    291     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,
    292             "define exposure E dec", NAN);
    293     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid",  0,
    294             "define aperture residual", NAN);
    295     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,
    296             "define aperture residual stdev", NAN);
    297     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_mean", 0,
    298             "define zero point mean", NAN);
    299     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_stdev", 0,
    300             "define zero point stdev", NAN);
    301     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major", 0,
    302             "define FWHM (major axis; arcsec)", NAN);
    303     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor", 0,
    304             "define FWHM (minor axis; arcsec)", NAN);
    305     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_detrend", 0,
    306             "define elapsed detrend processing time (seconds)", NAN);
    307     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_photom", 0,
    308             "define elapsed photometry processing time (seconds)", NAN);
    309     psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_astrom", 0,
    310             "define elapsed astrometry processing time (seconds)", NAN);
    311     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname", 0,
    312             "define hostname", NULL);
    313     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,
    314             "define number of stars", 0);
    315     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,
    316             "define number of extended objects", 0);
    317     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,
    318             "define number of cosmic rays", 0);
    319     psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,
    320             "define number of astrometry reference objects", 0);
    321     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,
    322             "define base output location", NULL);
    323     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    324             "set fault code", 0);
    325     psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    326             "only return imfiles with a fault status set", false);
     168    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "define camtool ID (required)", 0);
     169    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-uri", 0,            "define URI (required)", NULL);
     170    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
     171    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev", 0,            "define exposure background stdev", NAN);
     172    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,            "define exposure background mean stdev", NAN);
     173    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias",  0,            "define bias", NAN);
     174    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-bias_stdev",  0,            "define bias stdev", NAN);
     175    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe term 0", NAN);
     176    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe term 1", NAN);
     177    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe term 2", NAN);
     178    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_ra", 0,            "define exposure E ra", NAN);
     179    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-sigma_dec", 0,            "define exposure E dec", NAN);
     180    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid",  0,            "define aperture residual", NAN);
     181    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-ap_resid_stdev",  0,            "define aperture residual stdev", NAN);
     182    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_mean", 0,            "define zero point mean", NAN);
     183    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-zp_stdev", 0,            "define zero point stdev", NAN);
     184    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_major", 0,            "define FWHM (major axis; arcsec)", NAN);
     185    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-fwhm_minor", 0,            "define FWHM (minor axis; arcsec)", NAN);
     186    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_detrend", 0,            "define elapsed detrend processing time (seconds)", NAN);
     187    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_photom", 0,            "define elapsed photometry processing time (seconds)", NAN);
     188    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_astrom", 0,            "define elapsed astrometry processing time (seconds)", NAN);
     189    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", NULL);
     190    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_stars", 0,            "define number of stars", 0);
     191    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_extended", 0,            "define number of extended objects", 0);
     192    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_cr", 0,            "define number of cosmic rays", 0);
     193    psMetadataAddS32(addprocessedexpArgs, PS_LIST_TAIL, "-n_astrom", 0,            "define number of astrometry reference objects", 0);
     194    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     195    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     196    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    327197
    328198    // -processedexp
    329199    psMetadata *processedexpArgs = psMetadataAlloc();
    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);
    334     psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    335             "limit result set to N items", 0);
    336     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple", 0,
    337             "use the simple output format", false);
    338     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    339             "only return imfiles with a fault status set", false);
     200    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     201    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
     202    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     203    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     204    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    340205
    341206    // -revertprocessedexp
     207    // XXX need to allow multiple cam_ids
     208    // XXX need to allow multiple chip_ids
     209    // XXX need to allow multiple exp_ids
    342210    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    343     // XXX need to allow multiple cam_ids
    344     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,
    345             "search by cam_id", 0);
    346     // XXX need to allow multiple chip_ids
    347     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,
    348             "search by chip_id", 0);
    349     // XXX need to allow multiple exp_ids
    350     psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    351             "search by exp_id", 0);
    352     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,
    353             "search by exp_name", NULL);
    354     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-inst",  0,
    355             "search for camera", NULL);
    356     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-telescope",  0,
    357             "search for telescope", NULL);
    358     psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    359             "search for exposures by time (>=)", NULL);
    360     psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    361             "search for exposures by time (<)", NULL);
    362     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,
    363             "search by exp_tag", NULL);
    364     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,
    365             "search by exp_type", NULL);
    366     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filelevel",  0,
    367             "search by filelevel", NULL);
    368     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",  0,
    369             "search by reduction class", NULL);
    370     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filter",  0,
    371             "search for filter", NULL);
    372     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_min",  0,
    373             "define min airmass", NAN);
    374     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_max",  0,
    375             "define max airmass", NAN);
    376     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_min",  0,
    377             "define min", NAN);
    378     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_max",  0,
    379             "define max", NAN);
    380     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_min",  0,
    381             "define min", NAN);
    382     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_max",  0,
    383             "define max", NAN);
    384     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    385             "define min", NAN);
    386     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    387             "define max", NAN);
    388     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    389             "define max fraction of saturated pixels", NAN);
    390     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    391             "define min fraction of saturated pixels", NAN);
    392     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_min",  0,
    393             "define max", NAN);
    394     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_max",  0,
    395             "define max", NAN);
    396     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    397             "define max", NAN);
    398     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    399             "define max", NAN);
    400     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    401             "define max", NAN);
    402     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    403             "define max", NAN);
    404     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_min",  0,
    405             "define min", NAN);
    406     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_max",  0,
    407             "define max", NAN);
    408     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_min",  0,
    409             "define min", NAN);
    410     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_max",  0,
    411             "define max", NAN);
    412     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    413             "define min ccd tempature", NAN);
    414     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    415             "define max ccd tempature", NAN);
    416     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_min",  0,
    417             "define min rotator position angle", NAN);
    418     psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_max",  0,
    419             "define max rotator position angle", NAN);
    420     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-object",  0,
    421             "search by exposure object", NULL);
    422     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_min",  0,
    423             "define min solar angle", NAN);
    424     psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_max",  0,
    425             "define max solar angle", NAN);
    426 
    427     psMetadataAddBool(revertprocessedexpArgs, PS_LIST_TAIL, "-all",  0,
    428             "allow everything to be queued without search terms", false);
    429     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    430             "search by fault code", 0);
     211    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",  0,            "search by cam_id", 0);
     212    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     213    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     214    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     215    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     216    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     217    psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     218    psMetadataAddTime(revertprocessedexpArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     219    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     220    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     221    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     222    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     223    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     224    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     225    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     226    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     227    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     228    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     229    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     230    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     231    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     232    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     233    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     234    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     235    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     236    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     237    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     238    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     239    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     240    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     241    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     242    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     243    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     244    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     245    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     246    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     247    psMetadataAddF64(revertprocessedexpArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     248    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     249    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     250    psMetadataAddF32(revertprocessedexpArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     251
     252    psMetadataAddBool(revertprocessedexpArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     253    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    431254
    432255
    433256    // -updateprocessedexp
    434257    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
    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);
    439     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,
    440             "search by class", NULL);
    441     psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,
    442             "search by class ID", NULL);
    443     psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    444             "set fault code (required)", INT16_MAX);
     258    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     259    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chiptool ID", 0);
     260    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,            "search by class", NULL);
     261    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     262    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", INT16_MAX);
    445263
    446264    // -block
    447265    psMetadata *blockArgs = psMetadataAlloc();
    448     psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,
    449             "name of a label to mask out (required)", NULL);
     266    psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to mask out (required)", NULL);
    450267
    451268    // -masked
    452269    psMetadata *maskedArgs = psMetadataAlloc();
    453     psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,
    454             "use the simple output format", false);
     270    psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    455271
    456272    // -unblock
    457273    psMetadata *unblockArgs = psMetadataAlloc();
    458     psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,
    459             "name of a label to unmask (required)", NULL);
     274    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    460275
    461276    psMetadata *argSets = psMetadataAlloc();
    … …  
    485300    psFree(modes);
    486301
    487     // setup search criterion
    488 #define addWhereStr(name) \
    489 { \
    490     psString str = NULL; \
    491     bool status = false; \
    492     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    493         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    494             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    495             psFree(config); \
    496             return NULL; \
    497         } \
    498     } \
    499 }
    500 
    501     // generate SQL where clause
    502     config->where = psMetadataAlloc();
    503 
    504 {
    505     psS64 cam_id = -1;
    506     bool status = false;
    507     if ((cam_id = psMetadataLookupS64(&status, config->args, "-cam_id"))) {
    508         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "cam_id", 0, "==", cam_id)) {
    509             psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id");
    510             psFree(config);
    511             return NULL;
    512         }
    513     }
    514 }
    515 
    516 {
    517     psString str = NULL;
    518     bool status = false;
    519     if ((str = psMetadataLookupStr(&status, config->args, "-chip_id"))) {
    520         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "chip_id", 0, "==", (psS64)atoll(str))) {
    521             psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id");
    522             psFree(config);
    523             return NULL;
    524         }
    525     }
    526 }
    527 
    528     // convert '-inst' to 'camera'
    529     {
    530         psString str = NULL;
    531         bool status = false;
    532         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    533             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    534                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    535                 psFree(config);
    536                 return NULL;
    537             }
    538         }
    539     }
    540     addWhereStr(telescope);
    541     addWhereStr(exp_type);
    542     {
    543         int imfiles = 0;
    544         bool status = false;
    545         if ((imfiles = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    546             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", imfiles)) {
    547                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    548                 psFree(config);
    549                 return NULL;
    550             }
    551         }
    552     }
    553     addWhereStr(class_id);
    554     addWhereStr(filter);
    555 
    556     // convert '-code' to 'fault'
    557     {
    558         psS16 fault = 0;
    559         bool status = false;
    560         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    561             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    562                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    563                 psFree(config);
    564                 return NULL;
    565             }
    566         }
    567     }
    568 
    569     if (psListLength(config->where->list) < 1) {
    570         psFree(config->where);
    571         config->where = NULL;
    572     }
    573 
    574 
    575302    // define Database handle, if used
    576303    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • trunk/ippTools/src/chiptool.c

    r18366 r18561  
    665665    PS_ASSERT_PTR_NON_NULL(config, false);
    666666
     667    psMetadata *where = psMetadataAlloc();
     668    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     669    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "==");
     670    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     671
    667672    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    668673
    669     if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", config->where, code)) {
     674    if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, code)) {
    670675        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    671676        return false;
    672677    }
     678    psFree(where);
    673679
    674680    return true;

  • trunk/ippTools/src/chiptoolConfig.c

    r18366 r18561  
    304304    psMetadata *modes = psMetadataAlloc();
    305305
    306     PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",
    307         CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
    308     PXOPT_ADD_MODE("-updaterun",            "change chip run properties",
    309         CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
    310     PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",
    311         CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
    312     PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",
    313         CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
    314     PXOPT_ADD_MODE("-processedimfile",      "show processed imfiles",
    315         CHIPTOOL_MODE_PROCESSEDIMFILE,      processedimfileArgs);
    316     PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",
    317         CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
    318     PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",
    319         CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
    320     PXOPT_ADD_MODE("-block",                "set a label block",
    321         CHIPTOOL_MODE_BLOCK,                blockArgs);
    322     PXOPT_ADD_MODE("-masked",               "show blocked labels",
    323         CHIPTOOL_MODE_MASKED,               maskedArgs);
    324     PXOPT_ADD_MODE("-unmasked",             "",
    325         CHIPTOOL_MODE_UNMASKED,             unmaskedArgs);
    326     PXOPT_ADD_MODE("-unblock",              "remove a label block",
    327         CHIPTOOL_MODE_UNBLOCK,              unblockArgs);
    328     PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up",
    329         CHIPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    330     PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up",
    331         CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
    332     PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",
    333         CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    334     PXOPT_ADD_MODE("-run",                  "show runs",
    335         CHIPTOOL_MODE_RUN,                  runArgs);
     306    PXOPT_ADD_MODE("-definebyquery",        "create runs from raw exposures",       CHIPTOOL_MODE_DEFINEBYQUERY,        definebyqueryArgs);
     307    PXOPT_ADD_MODE("-updaterun",            "change chip run properties",           CHIPTOOL_MODE_UPDATERUN,            updaterunArgs);
     308    PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CHIPTOOL_MODE_PENDINGIMFILE,        pendingimfileArgs);
     309    PXOPT_ADD_MODE("-addprocessedimfile",   "add a processed imfile",               CHIPTOOL_MODE_ADDPROCESSEDIMFILE,   addprocessedimfileArgs);
     310    PXOPT_ADD_MODE("-processedimfile",      "show processed imfiles",               CHIPTOOL_MODE_PROCESSEDIMFILE,      processedimfileArgs);
     311    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
     312    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
     313    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);
     314    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  CHIPTOOL_MODE_MASKED,               maskedArgs);
     315    PXOPT_ADD_MODE("-unmasked",             "",                                     CHIPTOOL_MODE_UNMASKED,             unmaskedArgs);
     316    PXOPT_ADD_MODE("-unblock",              "remove a label block",                 CHIPTOOL_MODE_UNBLOCK,              unblockArgs);
     317    PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     318    PXOPT_ADD_MODE("-pendingcleanupimfile", "show runs that need to be cleaned up", CHIPTOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
     319    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CHIPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
     320    PXOPT_ADD_MODE("-run",                  "show runs",                            CHIPTOOL_MODE_RUN,                  runArgs);
    336321
    337322    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/detselect.c

    r16170 r18561  
    8181
    8282    psMetadata *where = psMetadataAlloc();
     83
     84    PXOPT_COPY_STR(config->args, where, "-inst",      "camera", "==");
     85    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     86    PXOPT_COPY_STR(config->args, where, "-det_type",  "det_type", "==");
     87    PXOPT_COPY_STR(config->args, where, "-type",      "det_type", "==");
     88    PXOPT_COPY_STR(config->args, where, "-filter",    "filter", "==");
    8389
    8490    // airmass_min  < airmass  < airmass_max
    … …  
    111117    }
    112118
    113     if (config->where) {
    114         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    115         psStringAppend(&query, " AND %s", whereClause);
    116         psFree(whereClause);
    117     }
    118 
    119     {
     119    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     120    if (where && psListLength(where->list)) {
    120121        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    121         psFree(where);
    122         if (whereClause) {
    123             psStringAppend(&query, " AND %s", whereClause);
    124             psFree(whereClause);
    125         }
    126     }
     122        psStringAppend(&query, " AND %s", whereClause);
     123        psFree(whereClause);
     124    }
     125    psFree(where);
    127126
    128127    // we choose the single detrend image which matches all criteria and has
    … …  
    171170    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    172171
     172    psMetadata *where = psMetadataAlloc();
     173    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     174    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     175    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     176
    173177    psString query = pxDataGet("detselect_select.sql");
    174178    if (!query) {
    … …  
    177181    }
    178182
    179 
    180     if (config->where) {
    181         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     183    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     184    if (where && psListLength(where->list)) {
     185        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    182186        psStringAppend(&query, " AND %s", whereClause);
    183187        psFree(whereClause);
    184188    }
     189    psFree(where);
    185190
    186191    if (!p_psDBRunQuery(config->dbh, query)) {

  • trunk/ippTools/src/detselect.h

    r18322 r18561  
    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 
    12833#endif // DETSELECT_H

  • trunk/ippTools/src/detselectConfig.c

    r18322 r18561  
    4646    // -search
    4747    psMetadata *searchArgs = psMetadataAlloc();
    48     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-inst", 0,
    49                      "search by camera", NULL);
    50     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-telescope", 0,
    51                      "search by telescope", NULL);
    52     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-det_type", 0,
    53                      "search by detrend type", NULL);
    54     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-type", 0,
    55                      "search by detrend type (alias for -det_type)", NULL);
    56     psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-filter", 0,
    57                      "search by filter", NULL);
    58     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-airmass", 0,
    59                      "define airmass", NAN);
    60     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-exp_time", 0,
    61                      "search by exposure time", NAN);
    62     psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-ccd_temp", 0,
    63                      "search by ccd tempature", NAN);
    64     psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,
    65                      "search by rotator position angle", NAN);
    66     psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,
    67                       "define time for desired detrend data", NULL);
    68     psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,
    69                       "use the simple output format", false);
    70     psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-unlimit",  0,
    71                       "list all possible detruns, not just the best match", false);
     48    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-inst", 0,                     "search by camera", NULL);
     49    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-telescope", 0,                     "search by telescope", NULL);
     50    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-det_type", 0,                     "search by detrend type", NULL);
     51    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-type", 0,                     "search by detrend type (alias for -det_type)", NULL);
     52    psMetadataAddStr(searchArgs, PS_LIST_TAIL, "-filter", 0,                     "search by filter", NULL);
     53    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-airmass", 0,                     "define airmass", NAN);
     54    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-exp_time", 0,                     "search by exposure time", NAN);
     55    psMetadataAddF32(searchArgs, PS_LIST_TAIL, "-ccd_temp", 0,                     "search by ccd tempature", NAN);
     56    psMetadataAddF64(searchArgs, PS_LIST_TAIL, "-posang", 0,                     "search by rotator position angle", NAN);
     57    psMetadataAddTime(searchArgs, PS_LIST_TAIL, "-time", 0,                      "define time for desired detrend data", NULL);
     58    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-simple",  0,                      "use the simple output format", false);
     59    psMetadataAddBool(searchArgs, PS_LIST_TAIL, "-unlimit",  0,                      "list all possible detruns, not just the best match", false);
    7260 
    7361    // -select
    7462    psMetadata *selectArgs = psMetadataAlloc();
    75     psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-det_id", 0,
    76                      "search by detrend ID", NULL);
    77     psMetadataAddS32(selectArgs, PS_LIST_TAIL, "-iteration", 0,
    78                      "search by iteration number", 0);
    79     psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-class_id", 0,
    80                      "search by class ID", NULL);
    81     psMetadataAddBool(selectArgs, PS_LIST_TAIL, "-simple",  0,
    82                       "use the simple output format", false);
     63    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-det_id", 0,                     "search by detrend ID", NULL);
     64    psMetadataAddS32(selectArgs, PS_LIST_TAIL, "-iteration", 0,                     "search by iteration number", 0);
     65    psMetadataAddStr(selectArgs, PS_LIST_TAIL, "-class_id", 0,                     "search by class ID", NULL);
     66    psMetadataAddBool(selectArgs, PS_LIST_TAIL, "-simple",  0,                      "use the simple output format", false);
    8367   
    8468    psMetadata *argSets = psMetadataAlloc();
    … …  
    9983    psFree(modes);
    10084
    101     // setup search criterion
    102     // generate SQL where clause
    103     config->where = psMetadataAlloc();
    104 
    105     addWhereStr(det_id);
    106     addWhereS32(iteration);
    107     addWhereStr(exp_id);
    108     addWhereStrAlias(inst,camera);
    109 
    110     addWhereStr(telescope);
    111     addWhereStr(det_type);
    112     addWhereStrAlias(type,det_type);
    113 
    114     addWhereStr(exp_type);
    115     addWhereS32(imfiles);
    116     addWhereStr(class);
    117     addWhereStr(class_id);
    118     addWhereStr(filter);
    119 
    120     //    addWhereF32(exp_time);
    121     //    addWhereF64(ccd_temp);
    122     //    addWhereF32(airmass);
    123     //    addWhereTimeStr(use_begin);
    124     //    addWhereTimeStr(use_end);
    125 
    126     if (config->where->list->n < 1) {
    127         psFree(config->where);
    128         config->where = NULL;
    129     }
    130 
    131 
    13285    // define Database handle, if used
    13386    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • trunk/ippTools/src/dettool.c

    r18336 r18561  
    1818 */
    1919
    20 #ifdef HAVB_CONFIG_H
    21 #include <config.h>
    22 #endif
    23 
    24 #include <stdio.h>
    25 #include <string.h>
    26 #include <stdlib.h>
    27 #include <stdint.h>
    28 #include <inttypes.h>
    29 
    30 #include <ippdb.h>
    31 
    32 #include "pxtools.h"
    3320#include "dettool.h"
    3421
    … …  
    9885//static psArray *searchInputImfiles(pxConfig *config, const char *det_id);
    9986static detInputExpRow *rawDetrenTodetInputExpRow(rawExpRow *rawExp, psS64 det_id, psS32 iteration);
    100 static psArray *searchRawImfiles(pxConfig *config, psMetadata *where);
     87static psArray *searchRawImfiles(pxConfig *config);
    10188static bool startNewIteration(pxConfig *config, psS64 det_id);
    10289static psS32 incrementIteration(pxConfig *config, psS64 det_id);
    … …  
    214201    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    215202
    216     psString query = psStringCopy(
    217         "SELECT"
    218         "   rawExp.*"
    219         " FROM rawExp"
    220         " LEFT JOIN detInputExp"
    221         "   ON rawExp.exp_id = detInputExp.exp_id"
    222         " WHERE"
    223         "    detInputExp.exp_id IS NULL"
    224         "    AND rawExp.object != 'object'"
    225     );
    226 
    227     if (config->where) {
    228         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     203    psString query = pxDataGet("dettool_pending.sql");
     204    if (!query) {
     205        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     206        return false;
     207    }
     208   
     209    psMetadata *where = psMetadataAlloc();
     210    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     211    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
     212    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     213    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     214    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     215
     216    if (psListLength(where->list)) {
     217        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    229218        psStringAppend(&query, " AND %s", whereClause);
    230219        psFree(whereClause);
    231220    }
     221    psFree(where);
    232222
    233223    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    315305    // make sure that -exp_id was parsed correctly
    316306    // XXX this can be removed someday
     307    // XXX Special case for a multi : move into a macro?
    317308    if (item->type == PS_DATA_METADATA_MULTI) {
    318309        psListIterator *iter = psListIteratorAlloc(item->data.list, 0, false);
    … …  
    472463#if 0
    473464// This function is used to convert the det_id from an int, as it is used
    474 // internally, to be a string for external use.  The rational being that we may
     465// internally, to be a string for external use.  The rationale being that we may
    475466// want to change how det_id is generated in the future and don't want to
    476467// external programs to become depending on this value being an int.
    … …  
    543534    psMetadata *where = psMetadataAlloc();
    544535    PXOPT_COPY_STR(config->args, where, "-select_exp_type", "exp_type", "==");
    545     // map -inst -> camera
    546536    PXOPT_COPY_STR(config->args, where, "-select_inst", "camera", "==");
    547537    PXOPT_COPY_STR(config->args, where, "-select_telescope", "telescope", "==");
    … …  
    555545    PXOPT_COPY_F32(config->args, where, "-select_exp_time_min", "exp_time", ">=");
    556546    PXOPT_COPY_F32(config->args, where, "-select_exp_time_max", "exp_time", "<=");
    557     PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
    558     PXOPT_COPY_F32(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
    559     PXOPT_COPY_F32(config->args, where, "-select_pon_time_min", "pon_time", ">=");
    560     PXOPT_COPY_F32(config->args, where, "-select_pon_time_max", "pon_time", "<=");
    561     PXOPT_COPY_F32(config->args, where, "-select_posang_min", "posang", ">=");
    562     PXOPT_COPY_F32(config->args, where, "-select_posang_max", "posang", "<=");
    563     PXOPT_COPY_F32(config->args, where, "-select_solang_min", "solang", ">=");
    564     PXOPT_COPY_F32(config->args, where, "-select_solang_max", "solang", "<=");
     547    PXOPT_COPY_F64(config->args, where, "-select_ccd_temp_min", "ccd_temp", ">=");
     548    PXOPT_COPY_F64(config->args, where, "-select_ccd_temp_max", "ccd_temp", "<=");
     549    PXOPT_COPY_F64(config->args, where, "-select_pon_time_min", "pon_time", ">=");
     550    PXOPT_COPY_F64(config->args, where, "-select_pon_time_max", "pon_time", "<=");
     551    PXOPT_COPY_F64(config->args, where, "-select_posang_min", "posang", ">=");
     552    PXOPT_COPY_F64(config->args, where, "-select_posang_max", "posang", "<=");
     553    PXOPT_COPY_F64(config->args, where, "-select_solang_min", "solang", ">=");
     554    PXOPT_COPY_F64(config->args, where, "-select_solang_max", "solang", "<=");
    565555
    566556    if (!psListLength(where->list)) {
    … …  
    571561    // there is some namespace overlap between the names of the fields we'd
    572562    // like to search by to setup a detrun and the names of the fields we'd
    573     // like to assign values to so I've seperated them but prepending set- to
     563    // like to assign values to so I've separated them but prepending set- to
    574564    // the assigned values
    575565
    … …  
    731721    PS_ASSERT_PTR_NON_NULL(config, false);
    732722
    733     // required
    734     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    735 
    736     // optional
    737     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    738     PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false);
    739     PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false);
    740     // check mode
    741     if (mode && !isValidMode(config, mode)) {
    742         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    743         return false;
    744     }
    745     PXOPT_LOOKUP_STR(camera, config->args, "-set_inst", false, false);
    746     PXOPT_LOOKUP_STR(telescope, config->args, "-set_telescope", false, false);
     723   
     724    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     725    PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false); // optional
     726    PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false); // optional
    747727    PXOPT_LOOKUP_STR(exp_type, config->args, "-set_exp_type", false, false);
    748728    PXOPT_LOOKUP_STR(filelevel, config->args, "-set_filelevel", false, false);
    749729    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", false, false);
    750730    PXOPT_LOOKUP_STR(filter, config->args, "-set_filter", false, false);
    751 
    752731    PXOPT_LOOKUP_F32(airmass_min, config->args, "-set_airmass_min", false, false);
    753732    PXOPT_LOOKUP_F32(airmass_max, config->args, "-set_airmass_max", false, false);
    754733    PXOPT_LOOKUP_F32(exp_time_min, config->args, "-set_exp_time_min", false, false);
    755734    PXOPT_LOOKUP_F32(exp_time_max, config->args, "-set_exp_time_max", false, false);
    756     PXOPT_LOOKUP_F32(ccd_temp_min, config->args, "-set_ccd_temp_min", false, false);
    757     PXOPT_LOOKUP_F32(ccd_temp_max, config->args, "-set_ccd_temp_max", false, false);
    758     PXOPT_LOOKUP_F32(posang_min, config->args, "-set_posang_min", false, false);
    759     PXOPT_LOOKUP_F32(posang_max, config->args, "-set_posang_max", false, false);
    760     PXOPT_LOOKUP_F32(solang_min, config->args, "-set_solang_min", false, false);
    761     PXOPT_LOOKUP_F32(solang_max, config->args, "-set_solang_max", false, false);
    762     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     735    PXOPT_LOOKUP_F64(ccd_temp_min, config->args, "-set_ccd_temp_min", false, false);
     736    PXOPT_LOOKUP_F64(ccd_temp_max, config->args, "-set_ccd_temp_max", false, false);
     737    PXOPT_LOOKUP_F64(posang_min, config->args, "-set_posang_min", false, false);
     738    PXOPT_LOOKUP_F64(posang_max, config->args, "-set_posang_max", false, false);
     739    PXOPT_LOOKUP_F64(solang_min, config->args, "-set_solang_min", false, false);
     740    PXOPT_LOOKUP_F64(solang_max, config->args, "-set_solang_max", false, false);
    763741    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    764742    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
    … …  
    767745    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
    768746    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    769 
     747    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     748    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); // optional
     749
     750    // check mode
     751    if (mode && !isValidMode(config, mode)) {
     752        psError(PS_ERR_UNKNOWN, false, "invalud mode");
     753        return false;
     754    }
    770755
    771756    // lookup the detRun that we will be basing this one on
    … …  
    814799    }
    815800
    816     if (camera) {
    817         psFree(detRun->camera);
    818         detRun->camera = psStringCopy(camera);
    819     }
    820 
    821     if (telescope) {
    822         psFree(detRun->telescope);
    823         detRun->telescope = psStringCopy(telescope);
    824     }
    825 
    826801    if (exp_type) {
    827802        psFree(detRun->exp_type);
    … …  
    925900    // XXX: possible mem leak: PXOPT_COPY* will free time_filter but NOTHING
    926901    // that has previously been allocated
    927     PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_begin", "dateobs", ">=");
    928     PXOPT_COPY_TIME(config->args, time_filter, "-filter_input_end", "dateobs", "<");
     902    PXOPT_COPY_TIME(config->args, time_filter, "-set_input_begin", "dateobs", ">=");
     903    PXOPT_COPY_TIME(config->args, time_filter, "-set_input_end", "dateobs", "<");
    929904
    930905    // start a transaction so we don't end up with childlessed det_ids
    … …  
    951926    psS64 newDet_id = psDBLastInsertID(config->dbh);
    952927
    953     psString query = psStringCopy(
    954         "INSERT INTO detInputExp"
    955         "   SELECT"
    956         "       %d,"
    957         "       0,"
    958         "       detResidExp.exp_id,"
    959         "       detResidExp.accept"
    960         "   FROM detResidExp"
    961         "   JOIN rawExp"
    962         "       USING(exp_id)"
    963         "   WHERE det_id = %d"
    964     );
     928    psString query = pxDataGet("dettool_definebydetrun.sql");
     929    if (!query) {
     930        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     931        return false;
     932    }
    965933
    966934    if (time_filter->list->n) {
    … …  
    1017985    PS_ASSERT_PTR_NON_NULL(config, false);
    1018986
     987    psMetadata *where = psMetadataAlloc();
     988    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
     989    PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
     990
     991    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
     992    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     993    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     994
     995    // airmass_min  < airmass  < airmass_max
     996    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_min", "<=");
     997    PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_max", ">=");
     998
     999    // exp_time_min < exp_time < exp_time_max
     1000    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
     1001    PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
     1002
     1003    // ccd_temp_min < ccd_temp < ccd_temp_max
     1004    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
     1005    PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
     1006
     1007    PXOPT_COPY_F64(config->args, where, "-posang", "posang_min", "<=");
     1008    PXOPT_COPY_F64(config->args, where, "-posang", "posang_max", ">=");
     1009
    10191010    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    10201011    PXOPT_LOOKUP_BOOL(active, config->args, "-active", false);
    10211012    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    10221013
    1023     PXOPT_COPY_STR(config->args, config->where, "-inst", "camera", "==");
    1024     PXOPT_COPY_STR(config->args, config->where, "-telescope", "telescope", "==");
    1025     PXOPT_COPY_STR(config->args, config->where, "-filter", "filter", "==");
    1026 
    1027     // airmass_min  < airmass  < airmass_max
    1028     PXOPT_COPY_F32(config->args, config->where, "-airmass", "airmass_min", "<=");
    1029     PXOPT_COPY_F32(config->args, config->where, "-airmass", "airmass_max", ">=");
    1030 
    1031     // exp_time_min < exp_time < exp_time_max
    1032     PXOPT_COPY_F32(config->args, config->where, "-exp_time", "exp_time_min", "<=");
    1033     PXOPT_COPY_F32(config->args, config->where, "-exp_time", "exp_time_max", ">=");
    1034 
    1035     // ccd_temp_min < ccd_temp < ccd_temp_max
    1036     PXOPT_COPY_F32(config->args, config->where, "-ccd_temp", "ccd_temp_min", "<=");
    1037     PXOPT_COPY_F32(config->args, config->where, "-ccd_temp", "ccd_temp_max", ">=");
    1038 
    1039     PXOPT_COPY_F64(config->args, config->where, "-posang", "posang_min", "<=");
    1040     PXOPT_COPY_F64(config->args, config->where, "-posang", "posang_max", ">=");
    1041 
    10421014    psString query = pxDataGet("dettool_runs.sql");
    10431015    if (!query) {
    … …  
    10461018    }
    10471019
    1048     if (config->where && active) {
    1049         psString whereClause = psDBGenerateWhereSQL(config->where, "detRun");
     1020    if (psListLength(where->list) && active) {
     1021        psString whereClause = psDBGenerateWhereSQL(where, "detRun");
    10501022        psStringAppend(&query, " %s AND (detRun.state = 'run' OR detRun.state = 'stop' OR detRun.state = 'register')", whereClause);
    10511023        psFree(whereClause);
    10521024    }
    1053     if (config->where && !active) {
    1054         psString whereClause = psDBGenerateWhereSQL(config->where, "detRun");
     1025    if (psListLength(where->list) && !active) {
     1026        psString whereClause = psDBGenerateWhereSQL(where, "detRun");
    10551027        psStringAppend(&query, " %s", whereClause);
    10561028        psFree(whereClause);
    10571029    }
    1058     if (!config->where && active) {
     1030    if (!psListLength(where->list) && active) {
    10591031        psStringAppend(&query, " WHERE (detRun.state = 'run' OR detRun.state = 'stop' OR detRun.state = 'register')");
    10601032    }
     1033    psFree (where);
    10611034
    10621035    // treat limit == 0 as "no limit"
    … …  
    10801053    }
    10811054
    1082 // XXX old version
    1083 # if 0
    1084     // XXX fix the hard coding of the table name
    1085     psArray *runs = psDBSelectRows(config->dbh, "detRun", config->where, 0);
    1086     if (!runs) {
    1087         psError(PS_ERR_UNKNOWN, false, "database error");
    1088         return false;
    1089     }
    1090 # endif
    1091 
    10921055    if (!psArrayLength(runs)) {
    10931056        psTrace("dettool", PS_LOG_INFO, "no rows found");
    … …  
    11121075    PS_ASSERT_PTR_NON_NULL(config, false);
    11131076
     1077    psMetadata *where = psMetadataAlloc();
     1078    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
     1079
    11141080    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    11151081    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11161082
    1117     psString query = psStringCopy(
    1118             "SELECT DISTINCT\n"
    1119             "   detRun.*\n"
    1120             " FROM detRun\n"
    1121             " LEFT JOIN detRun as foo\n"
    1122             "   ON foo.parent = detRun.det_id\n"
    1123             " WHERE\n"
    1124             "   detRun.state = 'stop'\n"
    1125             "   AND detRun.mode = 'master'\n"
    1126             "   AND foo.det_id IS NULL\n"
    1127         );
    1128 
    1129     if (config->where) {
    1130         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detRun");
     1083    // find the exp_id of all the exposures that we want to queue up.
     1084    psString query = pxDataGet("dettool_childlessrun.sql");
     1085    if (!query) {
     1086        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1087        psFree(where);
     1088        return false;
     1089    }
     1090
     1091    if (psListLength(where->list)) {
     1092        psString whereClause = psDBGenerateWhereConditionSQL(where, "detRun");
    11311093        psStringAppend(&query, " AND %s", whereClause);
    11321094        psFree(whereClause);
    11331095    }
     1096    psFree (where);
    11341097
    11351098    // treat limit == 0 as "no limit"
    … …  
    11881151    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11891152
    1190     // select detInputExp.*
    1191     // select rawExp.*
    1192     // by:
    1193     // exp_id
    1194 
    1195     psString query = psStringCopy(
    1196         "SELECT DISTINCT *"
    1197         " FROM detInputExp"
    1198         " JOIN rawExp"
    1199         " USING(exp_id)"
    1200         );
    1201 
    1202     if (config->where) {
    1203         psString whereClause = psDBGenerateWhereSQL(config->where, "detInputExp");
     1153    psMetadata *where = psMetadataAlloc();
     1154    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1155    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1156    PXOPT_COPY_S64(config->args, where, "-exp_id",    "exp_id", "==");
     1157
     1158    psString query = pxDataGet("dettool_input.sql");
     1159    if (!query) {
     1160        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1161        psFree(where);
     1162        return false;
     1163    }
     1164
     1165    if (psListLength(where->list)) {
     1166        psString whereClause = psDBGenerateWhereSQL(where, "detInputExp");
    12041167        psStringAppend(&query, " %s", whereClause);
    12051168        psFree(whereClause);
    12061169    }
     1170    psFree (where);
    12071171
    12081172    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    12421206    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    12431207
     1208    psMetadata *where = psMetadataAlloc();
     1209
    12441210    psString query = pxDataGet("dettool_raw.sql");
    12451211    if (!query) {
    … …  
    12481214    }
    12491215
    1250     if (config->where) {
    1251         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     1216    if (psListLength(where->list)) {
     1217        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    12521218        psStringAppend(&query, " AND %s", whereClause);
    12531219        psFree(whereClause);
    12541220    }
     1221    psFree (where);
    12551222
    12561223    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    12881255    PS_ASSERT_PTR_NON_NULL(config, false);
    12891256
     1257    psMetadata *where = psMetadataAlloc();
     1258    PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
     1259    PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
     1260    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1261
    12901262    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    12911263    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    12971269    }
    12981270
    1299     if (config->where) {
    1300         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     1271    if (psListLength(where->list)) {
     1272        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    13011273        psStringAppend(&query, " AND %s", whereClause);
    13021274        psFree(whereClause);
    13031275    }
     1276    psFree (where);
    13041277
    13051278    // treat limit == 0 as "no limit"
    … …  
    13401313}
    13411314
    1342 static psArray *searchRawImfiles(pxConfig *config, psMetadata *where)
    1343 {
    1344     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1345 
    1346     // use the default where if "where" is NULL
    1347     if (!where) {
    1348         where = config->where;
    1349     }
    1350 
    1351     // select exp_ids from detInputExp matching det_idp
    1352     // where query should be pre-generated
    1353     psArray *detInputExp =
    1354         detInputExpSelectRowObjects(config->dbh, where, 0);
    1355     if (!detInputExp) {
    1356         psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
    1357         return NULL;
    1358     }
    1359 
    1360     // generate where query with just the exp_ids
    1361     psMetadata *where_exp_ids = psMetadataAlloc();
    1362     for (long i = 0; i < psArrayLength(detInputExp); i++) {
    1363         detInputExpRow *row = detInputExp->data[i];
    1364         if (!psMetadataAddS64(where_exp_ids, PS_LIST_TAIL, "exp_id",
    1365                 PS_META_DUPLICATE_OK, "==", row->exp_id)
    1366         ) {
    1367             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1368             psFree(detInputExp);
    1369             psFree(where_exp_ids);
    1370             return NULL;
    1371         }
    1372     }
    1373     psFree(detInputExp);
    1374 
    1375     // select rawImfiles with matching exp_ids
    1376     psArray *rawImfiles =
    1377         rawImfileSelectRowObjects(config->dbh, where_exp_ids, 0);
    1378     psFree(where_exp_ids);
    1379     if (!rawImfiles) {
    1380         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    1381         return NULL;
    1382     }
    1383 
    1384     return rawImfiles;
    1385 }
    1386 
    13871315static bool addprocessedimfileMode(pxConfig *config)
    13881316{
    13891317    PS_ASSERT_PTR_NON_NULL(config, false);
    13901318
    1391     // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev
    1392     // are required
     1319    // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev are required
    13931320    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    13941321    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    … …  
    14161343    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    14171344
    1418 
    14191345    // find the matching rawImfile by exp_id/class_id
    14201346    psMetadata *where = psMetadataAlloc();
    1421     if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    1422         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1423         psFree(where);
    1424         return false;
    1425     }
    1426     if (!psMetadataAddStr(where, PS_LIST_TAIL, "class_id", 0, "==", class_id)) {
    1427         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    1428         psFree(where);
    1429         return false;
    1430     }
     1347    PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
     1348    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    14311349
    14321350    psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    14331351    psFree(where);
     1352
    14341353    if (!rawImfiles) {
    14351354        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found ");
    14361355        return false;
    14371356    }
    1438 
    14391357
    14401358    // create a new detProcessedImfile object
    … …  
    14731391}
    14741392
     1393static bool processedimfileMode(pxConfig *config)
     1394{
     1395    PS_ASSERT_PTR_NON_NULL(config, false);
     1396
     1397    char *value = NULL;
     1398
     1399    PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
     1400    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     1401    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1402    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1403
     1404    psMetadata *where = psMetadataAlloc();
     1405    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1406    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1407    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1408
     1409    psString query = pxDataGet("dettool_processedimfile.sql");
     1410    if (!query) {
     1411        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1412        psFree(where);
     1413        return false;
     1414    }
     1415
     1416    // add the two required restrictions: detRun.state and detRun.mode
     1417    // NOTE the above query requires one of the following two WHERE statements
     1418    {
     1419        bool status;
     1420        if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
     1421            psStringAppend(&query, " WHERE detRun.state = '%s'", value);
     1422        } else {
     1423            psStringAppend(&query, " WHERE detRun.state = 'run'");
     1424        }
     1425        if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
     1426            psStringAppend(&query, " AND detRun.mode = '%s'", value);
     1427        } else {
     1428            psStringAppend(&query, " AND detRun.mode = 'master'");
     1429        }
     1430    }
     1431
     1432    if (psListLength(where->list)) {
     1433        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
     1434        psStringAppend(&query, " AND %s", whereClause);
     1435        psFree(whereClause);
     1436    }
     1437    psFree (where);
     1438
     1439    // restrict search to included imfiles
     1440    if (included) {
     1441        psStringAppend(&query, " AND detInputExp.include = 1");
     1442    }
     1443
     1444    if (faulted) {
     1445        // list only faulted rows
     1446        psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
     1447    } else {
     1448        // don't list faulted rows
     1449        psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
     1450    }
     1451
     1452    // treat limit == 0 as "no limit"
     1453    if (limit) {
     1454        psString limitString = psDBGenerateLimitSQL(limit);
     1455        psStringAppend(&query, " %s", limitString);
     1456        psFree(limitString);
     1457    }
     1458
     1459    if (!p_psDBRunQuery(config->dbh, query)) {
     1460        psError(PS_ERR_UNKNOWN, false, "database error");
     1461        psFree(query);
     1462        return false;
     1463    }
     1464    psFree(query);
     1465
     1466    psArray *output = p_psDBFetchResult(config->dbh);
     1467    if (!output) {
     1468        psError(PS_ERR_UNKNOWN, false, "database error");
     1469        return false;
     1470    }
     1471    if (!psArrayLength(output)) {
     1472        psTrace("dettool", PS_LOG_INFO, "no rows found");
     1473        psFree(output);
     1474        return true;
     1475    }
     1476
     1477    // negative simple so the default is true
     1478    if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
     1479        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1480        psFree(output);
     1481        return false;
     1482    }
     1483
     1484    psFree(output);
     1485
     1486    return true;
     1487}
     1488
     1489static bool revertprocessedimfileMode(pxConfig *config)
     1490{
     1491    PS_ASSERT_PTR_NON_NULL(config, false);
     1492
     1493    psMetadata *where = psMetadataAlloc();
     1494    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1495    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1496    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     1497    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     1498
     1499    psString query = pxDataGet("dettool_revertprocessedimfile.sql");
     1500    if (!query) {
     1501        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1502        return false;
     1503    }
     1504
     1505    if (psListLength(where->list)) {
     1506        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
     1507        psStringAppend(&query, " AND %s", whereClause);
     1508        psFree(whereClause);
     1509    }
     1510    psFree(where);
     1511
     1512    if (!p_psDBRunQuery(config->dbh, query)) {
     1513        psError(PS_ERR_UNKNOWN, false, "database error");
     1514        psFree(query);
     1515        return false;
     1516    }
     1517    psFree(query);
     1518
     1519    if (psDBAffectedRows(config->dbh) < 1) {
     1520        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     1521        return false;
     1522    }
     1523
     1524    return true;
     1525}
     1526
    14751527static bool toprocessedexpMode(pxConfig *config)
    14761528{
    … …  
    14851537        return false;
    14861538    }
    1487 
    1488     // XXX does it make sense to accept any search params?
    1489 #if 0
    1490     if (config->where) {
    1491         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    1492         psStringAppend(&query, " AND %s", whereClause);
    1493         psFree(whereClause);
    1494     }
    1495 #endif
    14961539
    14971540    // treat limit == 0 as "no limit"
    … …  
    15611604    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    15621605
    1563 
    1564     psString query = psStringCopy(
    1565         " SELECT DISTINCT"
    1566         "    detProcessedImfile.det_id,"
    1567         "    detRun.iteration,"
    1568         "    detRun.det_type,"
    1569         "    detProcessedImfile.exp_id"
    1570         " FROM detRun"
    1571         " JOIN detInputExp"
    1572         "    ON detRun.det_id = detInputExp.det_id"
    1573         "    AND detRun.iteration = detInputExp.iteration"
    1574         " JOIN rawExp"
    1575         "    ON detInputExp.exp_id = rawExp.exp_id"
    1576         " JOIN detProcessedImfile"
    1577         "    ON detInputExp.det_id = detProcessedImfile.det_id"
    1578         "    AND detInputExp.exp_id = detProcessedImfile.exp_id"
    1579         " LEFT JOIN detProcessedExp"
    1580         "    ON detInputExp.det_id = detProcessedExp.det_id"
    1581         "    AND detProcessedImfile.exp_id= detProcessedExp.exp_id"
    1582         " LEFT JOIN rawImfile"
    1583         "    ON detInputExp.exp_id = rawImfile.exp_id"
    1584         "    AND detProcessedImfile.class_id = rawImfile.class_id"
    1585         " WHERE"
    1586         "   detRun.state = 'run'"
    1587         "   AND detRun.mode = 'master'"
    1588         "   AND detProcessedExp.det_id IS NULL"
    1589         "   AND detProcessedExp.exp_id IS NULL"
    1590         "   AND detInputExp.include = 1"
    1591         "   AND detRun.det_id = %s"
    1592         "   AND detProcessedImfile.exp_id = '%s'"
    1593         " GROUP BY"
    1594         "    detProcessedImfile.class_id,"
    1595         "    rawImfile.class_id,"
    1596         "    detRun.det_id"
    1597         " HAVING"
    1598         "    COUNT(detProcessedImfile.class_id) = COUNT(rawImfile.class_id)"
    1599         );
     1606    psString query = pxDataGet("dettool_addprocessedexp.sql");
     1607    if (!query) {
     1608        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1609        return false;
     1610    }
    16001611
    16011612    if (!p_psDBRunQuery(config->dbh, query, det_id, exp_id)) {
    … …  
    16541665    PS_ASSERT_PTR_NON_NULL(config, false);
    16551666
     1667    psMetadata *where = psMetadataAlloc();
     1668    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1669    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1670
    16561671    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1672    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    16571673    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1658     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    16591674
    16601675    psString query = psStringCopy("SELECT * FROM detProcessedExp");
    16611676
    1662     if (config->where) {
    1663         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
     1677    if (psListLength(where->list)) {
     1678        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    16641679        psStringAppend(&query, " %s", whereClause);
    16651680        psFree(whereClause);
    16661681    }
     1682    psFree(where);
    16671683
    16681684    if (faulted) {
    … …  
    17161732    PS_ASSERT_PTR_NON_NULL(config, false);
    17171733
     1734    psMetadata *where = psMetadataAlloc();
     1735    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     1736    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     1737    PXOPT_COPY_S16(config->args, where, "-code",   "fault", "==");
     1738
    17181739    psString query = pxDataGet("dettool_revertprocessedexp.sql");
    17191740    if (!query) {
    … …  
    17221743    }
    17231744
    1724     if (config->where) {
    1725         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedExp");
     1745    if (psListLength(where->list)) {
     1746        psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedExp");
    17261747        psStringAppend(&query, " AND %s", whereClause);
    17271748        psFree(whereClause);
    17281749    }
     1750    psFree(where);
    17291751
    17301752    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    17561778        return false;
    17571779    }
    1758 
    1759     // XXX does it make sense to accept any search params?
    1760 #if 0
    1761     if (config->where) {
    1762         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    1763         psStringAppend(&query, " AND %s", whereClause);
    1764         psFree(whereClause);
    1765     }
    1766 #endif
    17671780
    17681781    // treat limit == 0 as "no limit"
    … …  
    18031816}
    18041817
    1805 static bool processedimfileMode(pxConfig *config)
    1806 {
    1807     PS_ASSERT_PTR_NON_NULL(config, false);
    1808 
    1809     char *value = NULL;
    1810 
    1811     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1812     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1813     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    1814 
    1815     psString query = psStringCopy(
    1816         " SELECT DISTINCT"
    1817         "   detRun.det_type,"
    1818         "   rawExp.exp_time,"
    1819         "   detProcessedImfile.*"
    1820         " FROM detProcessedImfile"
    1821         " JOIN detRun"
    1822         "   USING(det_id)"
    1823         " JOIN detInputExp"
    1824         "   ON detRun.det_id = detInputExp.det_id"
    1825         "   AND detRun.iteration = detInputExp.iteration"
    1826         "   AND detProcessedImfile.exp_id = detInputExp.exp_id"
    1827         " JOIN rawExp"
    1828         "   ON rawExp.exp_id = detProcessedImfile.exp_id"
    1829         " WHERE"
    1830     );
    1831     // NOTE the above WHERE is completed with the following line:
    1832 
    1833     // add the two required restrictions: detRun.state and detRun.mode
    1834     {
    1835         bool status;
    1836         if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    1837             psStringAppend(&query, " detRun.state = '%s'", value);
    1838         } else {
    1839             psStringAppend(&query, " detRun.state = 'run'");
     1818// this is NOT a command-line mode : it is used by 'addstackedMode'
     1819static psArray *searchRawImfiles(pxConfig *config)
     1820{
     1821    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1822
     1823    psMetadata *where = psMetadataAlloc();
     1824    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1825    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1826
     1827    // select exp_ids from detInputExp matching det_id & iteration
     1828    // where query should be pre-generated
     1829    psArray *detInputExp = detInputExpSelectRowObjects(config->dbh, where, 0);
     1830    psFree (where);
     1831
     1832    if (!detInputExp) {
     1833        psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
     1834        return NULL;
     1835    }
     1836
     1837    // generate where query with just the exp_ids
     1838    psMetadata *where_exp_ids = psMetadataAlloc();
     1839    for (long i = 0; i < psArrayLength(detInputExp); i++) {
     1840        detInputExpRow *row = detInputExp->data[i];
     1841        if (!psMetadataAddS64(where_exp_ids, PS_LIST_TAIL, "exp_id",
     1842                PS_META_DUPLICATE_OK, "==", row->exp_id)
     1843        ) {
     1844            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1845            psFree(detInputExp);
     1846            psFree(where_exp_ids);
     1847            return NULL;
    18401848        }
    1841         if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
    1842             psStringAppend(&query, " AND detRun.mode = '%s'", value);
    1843         } else {
    1844             psStringAppend(&query, " AND detRun.mode = 'master'");
    1845         }
    1846     }
    1847 
    1848     if (config->where) {
    1849         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedImfile");
    1850         psStringAppend(&query, " AND %s", whereClause);
    1851         psFree(whereClause);
    1852     }
    1853 
    1854     {
    1855         bool status = false;
    1856         bool included = psMetadataLookupBool(&status, config->args, "-included");
    1857         if (!status) {
    1858             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1859             return false;
    1860         }
    1861         // restrict search to included imfiles
    1862         if (included) {
    1863             psStringAppend(&query, " AND detInputExp.include = 1");
    1864         }
    1865     }
    1866 
    1867     if (faulted) {
    1868         // list only faulted rows
    1869         psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
    1870     } else {
    1871         // don't list faulted rows
    1872         psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
    1873     }
    1874 
    1875     // treat limit == 0 as "no limit"
    1876     if (limit) {
    1877         psString limitString = psDBGenerateLimitSQL(limit);
    1878         psStringAppend(&query, " %s", limitString);
    1879         psFree(limitString);
    1880     }
    1881 
    1882     if (!p_psDBRunQuery(config->dbh, query)) {
    1883         psError(PS_ERR_UNKNOWN, false, "database error");
    1884         psFree(query);
    1885         return false;
    1886     }
    1887     psFree(query);
    1888 
    1889     psArray *output = p_psDBFetchResult(config->dbh);
    1890     if (!output) {
    1891         psError(PS_ERR_UNKNOWN, false, "database error");
    1892         return false;
    1893     }
    1894     if (!psArrayLength(output)) {
    1895         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1896         psFree(output);
    1897         return true;
    1898     }
    1899 
    1900     // negative simple so the default is true
    1901     if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    1902         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1903         psFree(output);
    1904         return false;
    1905     }
    1906 
    1907     psFree(output);
    1908 
    1909     return true;
    1910 }
    1911 
    1912 
    1913 static bool revertprocessedimfileMode(pxConfig *config)
    1914 {
    1915     PS_ASSERT_PTR_NON_NULL(config, false);
    1916 
    1917     psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    1918     if (!query) {
    1919         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1920         return false;
    1921     }
    1922 
    1923     if (config->where) {
    1924         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detProcessedImfile");
    1925         psStringAppend(&query, " AND %s", whereClause);
    1926         psFree(whereClause);
    1927     }
    1928 
    1929     if (!p_psDBRunQuery(config->dbh, query)) {
    1930         psError(PS_ERR_UNKNOWN, false, "database error");
    1931         psFree(query);
    1932         return false;
    1933     }
    1934     psFree(query);
    1935 
    1936     if (psDBAffectedRows(config->dbh) < 1) {
    1937         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1938         return false;
    1939     }
    1940 
    1941     return true;
    1942 }
    1943 
     1849    }
     1850    psFree(detInputExp);
     1851
     1852    // select rawImfiles with matching exp_ids
     1853    psArray *rawImfiles =
     1854        rawImfileSelectRowObjects(config->dbh, where_exp_ids, 0);
     1855    psFree(where_exp_ids);
     1856    if (!rawImfiles) {
     1857        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
     1858        return NULL;
     1859    }
     1860
     1861    return rawImfiles;
     1862}
    19441863
    19451864static bool addstackedMode(pxConfig *config)
    … …  
    19471866    PS_ASSERT_PTR_NON_NULL(config, false);
    19481867
    1949     // det_id, class_id, uri, & recipe are required
     1868    // det_id, iteration, class_id, uri, & recipe are required
    19501869    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1870    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", true, false);
    19511871    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    19521872
    … …  
    19671887    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    19681888
    1969     // default values
    1970     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    1971 
    19721889    // correlate the class_id against the input exposure(s)
    1973 
    1974     // we have to generate our own where clause as we want to search only by the
    1975     // det_id
    1976     psMetadata *where = psMetadataAlloc();
    1977     if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==",
    1978             (psS64)atoll(det_id))) {
    1979         psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1980         psFree(where);
    1981         return false;
    1982     }
    1983 
    1984     psArray *rawImfiles = searchRawImfiles(config, where);
    1985     psFree(where);
     1890    // searchRawImfiles defines a where clause to search by det_id and iteration
     1891    psArray *rawImfiles = searchRawImfiles(config);
    19861892
    19871893    if (!rawImfiles) {
    … …  
    20451951    PS_ASSERT_PTR_NON_NULL(config, false);
    20461952
     1953    psMetadata *where = psMetadataAlloc();
     1954    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1955    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     1956    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     1957    PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
     1958
    20471959    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1960    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    20481961    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2049     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2050 
    2051     // select detStackedImfile.*
    2052     // by:
    2053     // where det_id, iteration, class_id is not in detNormalizedImfile
    2054 
    2055     psString query = psStringCopy(
    2056         "SELECT"
    2057         "   detStackedImfile.*"
    2058         " FROM detStackedImfile"
    2059         " JOIN detRun"
    2060         "   USING(det_id, iteration)"
    2061         " WHERE"
    2062         "   detRun.state = 'run'"
    2063         "   AND detRun.mode = 'master'"
    2064     );
    2065 
    2066     if (config->where) {
    2067         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detStackedImfile");
     1962
     1963    psString query = pxDataGet("dettool_stacked.sql");
     1964    if (!query) {
     1965        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1966        psFree(where);
     1967        return false;
     1968    }
     1969
     1970    if (psListLength(where->list)) {
     1971        psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    20681972        psStringAppend(&query, " AND %s", whereClause);
    20691973        psFree(whereClause);
    20701974    }
     1975    psFree(where);
    20711976
    20721977    if (faulted) {
    … …  
    21202025    PS_ASSERT_PTR_NON_NULL(config, false);
    21212026
     2027    psMetadata *where = psMetadataAlloc();
     2028    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2029    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2030    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2031    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2032
    21222033    psString query = pxDataGet("dettool_revertstacked.sql");
    21232034    if (!query) {
    … …  
    21262037    }
    21272038
    2128     if (config->where) {
    2129         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detStackedImfile");
     2039    if (psListLength(where->list)) {
     2040        psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    21302041        psStringAppend(&query, " AND %s", whereClause);
    21312042        psFree(whereClause);
    21322043    }
     2044    psFree(where);
    21332045
    21342046    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    21592071        return false;
    21602072    }
    2161 
    2162     // XXX does it make sense to accept any search params?
    2163 #if 0
    2164     if (config->where) {
    2165         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2166         psStringAppend(&query, " AND %s", whereClause);
    2167         psFree(whereClause);
    2168     }
    2169 #endif
    21702073
    21712074    // treat limit == 0 as "no limit"
    … …  
    22402143    PS_ASSERT_PTR_NON_NULL(config, false);
    22412144
     2145    psMetadata *where = psMetadataAlloc();
     2146    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2147    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2148    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2149
    22422150    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2151    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    22432152    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2244     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    22452153
    22462154    psString query = pxDataGet("dettool_normalizedstat.sql");
    … …  
    22582166    }
    22592167
    2260     if (config->where) {
    2261         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     2168    if (psListLength(where->list)) {
     2169        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    22622170        psStringAppend(&query, " AND %s", whereClause);
    22632171        psFree(whereClause);
    22642172    }
     2173    psFree(where);
    22652174
    22662175    // treat limit == 0 as "no limit"
    … …  
    23052214    PS_ASSERT_PTR_NON_NULL(config, false);
    23062215
     2216    psMetadata *where = psMetadataAlloc();
     2217    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2218    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2219    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2220    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2221
    23072222    psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    23082223    if (!query) {
    … …  
    23112226    }
    23122227
    2313     if (config->where) {
    2314         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedStatImfile");
     2228    if (psListLength(where->list)) {
     2229        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedStatImfile");
    23152230        psStringAppend(&query, " AND %s", whereClause);
    23162231        psFree(whereClause);
    23172232    }
     2233    psFree(where);
    23182234
    23192235    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    23392255    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    23402256
    2341     // select detNormalizedStatImfile.*
    2342     // by:
    2343     // where det_id, iteration, class_id is not in detNormalizedImfile
    2344 
    2345     psString query = psStringCopy(
    2346         "SELECT DISTINCT"
    2347         "   detRun.det_type,"
    2348         "   detRun.workdir,"
    2349         "   rawExp.camera,"
    2350         "   detStackedImfile.uri,"
    2351         "   detNormalizedStatImfile.*"
    2352         " FROM detRun"
    2353         " JOIN detStackedImfile"
    2354         "   USING(det_id, iteration)"
    2355         " JOIN detInputExp"
    2356         "   USING(det_id, iteration)"
    2357         " JOIN rawExp"
    2358         "   ON detInputExp.exp_id = rawExp.exp_id"
    2359         " JOIN detNormalizedStatImfile"
    2360         "   ON detStackedImfile.det_id = detNormalizedStatImfile.det_id"
    2361         "   AND detStackedImfile.iteration = detNormalizedStatImfile.iteration"
    2362         "   AND detStackedImfile.class_id = detNormalizedStatImfile.class_id"
    2363         " LEFT JOIN detNormalizedImfile"
    2364         "   ON detNormalizedStatImfile.det_id = detNormalizedImfile.det_id"
    2365         "   AND detNormalizedStatImfile.iteration = detNormalizedImfile.iteration"
    2366         "   AND detNormalizedStatImfile.class_id = detNormalizedImfile.class_id"
    2367         " WHERE"
    2368         "   detNormalizedImfile.det_id IS NULL"
    2369         "   AND detNormalizedImfile.iteration IS NULL"
    2370         "   AND detNormalizedImfile.class_id IS NULL"
    2371         "   AND detNormalizedStatImfile.fault = 0"
    2372         "   AND detRun.state = 'run'"
    2373         );
    2374 
    2375     // XXX does it make sense to accept any search params?
    2376 #if 0
    2377     if (config->where) {
    2378         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2379         psStringAppend(&query, " AND %s", whereClause);
    2380         psFree(whereClause);
    2381     }
    2382 #endif
     2257    psString query = pxDataGet("dettool_tonormalize.sql");
     2258    if (!query) {
     2259        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2260        return false;
     2261    }
    23832262
    23842263    // treat limit == 0 as "no limit"
    … …  
    24192298}
    24202299
    2421 #if 0
    2422 // XXX this function was left in commented as this method may be useful in the
    2423 // future
    2424 static psArray *validDetInputClassIds(pxConfig *config, const char *det_id)
    2425 {
    2426     PS_ASSERT_PTR_NON_NULL(config, NULL);
    2427     // det_id is input as a string because the fact that it is an integer
    2428     // is just a database impliementation detail.
    2429     PS_ASSERT_PTR_NON_NULL(det_id, NULL);
    2430 
    2431     psArray *rawImfiles = searchInputImfiles(config, det_id);
    2432     if (!rawImfiles) {
    2433         return NULL;
    2434     }
    2435 
    2436     psArray *valid_class_ids = NULL;
    2437     {
    2438         // All this jumping through hoops is so that we end up with unique
    2439         // values. PP thinks that making multiple passes through this array and
    2440         // deleting matched elements would end up being more expensive then a
    2441         // double sort and stagger scheme. JH thinks it would be cheaper to
    2442         // just do a unqiue sort and delete.  So this is really just a cheap
    2443         // hack to avoid implimenting a unique sort function but at least it's
    2444         // stable.
    2445         psHash *hash = psHashAlloc(psArrayLength(rawImfiles));
    2446         for (long i = 0; i < psArrayLength(rawImfiles); i++) {
    2447             psHashAdd(hash,
    2448                 ((rawImfileRow *)rawImfiles->data[i])->class_id,
    2449                 ((rawImfileRow *)rawImfiles->data[i])->class_id
    2450             );
    2451         }
    2452         valid_class_ids = psHashToArray(hash);
    2453         psFree(hash);
    2454     }
    2455     psFree(rawImfiles);
    2456 
    2457     return valid_class_ids;
    2458 }
    2459 
    2460 static psArray *searchInputImfiles(pxConfig *config, const char *det_id)
    2461 {
    2462     PS_ASSERT_PTR_NON_NULL(config, NULL);
    2463     // det_id is input as a string because the fact that it is an integer
    2464     // is just a database impliementation detail.
    2465     PS_ASSERT_PTR_NON_NULL(det_id, NULL);
    2466 
    2467     psArray *inputExps = NULL;
    2468     {
    2469         psMetadata *where = psMetadataAlloc();
    2470         if (!psMetadataAddS32(where, PS_LIST_TAIL, "det_id", 0, "==",
    2471                 (psS32)atoi(det_id))) {
    2472             psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    2473             psFree(where);
    2474             return NULL;
    2475         }
    2476         inputExps = detInputExpSelectRowObjects(config->dbh, where, 0);
    2477         psFree(where);
    2478     }
    2479     if (!inputExps) {
    2480         psError(PS_ERR_UNKNOWN, false, "no detInputExp rows found");
    2481         return NULL;
    2482     }
    2483 
    2484     // find rawImfiles associated with detInputExps
    2485     psArray *rawImfiles = NULL;
    2486     {
    2487         psMetadata *where = psMetadataAlloc();
    2488         for (long i = 0; i < psArrayLength(inputExps); i++) {
    2489             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id",
    2490                     PS_META_DUPLICATE_OK, "==",
    2491                     ((detInputExpRow *)inputExps->data[i])->exp_id)) {
    2492                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    2493                 psFree(inputExps);
    2494                 psFree(where);
    2495                 return NULL;
    2496             }
    2497         }
    2498         psFree(inputExps);
    2499         rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    2500         // XXX this really should be sorted for uniqueness
    2501         psFree(where);
    2502     }
    2503     if (!rawImfiles) {
    2504         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    2505         return NULL;
    2506     }
    2507 
    2508     return rawImfiles;
    2509 }
    2510 #endif
    2511 
    25122300static bool addnormalizedimfileMode(pxConfig *config)
    25132301{
    … …  
    25162304    // required
    25172305    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     2306    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    25182307    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    25192308
    … …  
    25332322    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    25342323    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    2535 
    2536     // default values
    2537     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    25382324
    25392325    if (!detNormalizedImfileInsert(config->dbh,
    … …  
    25602346}
    25612347
    2562 
    25632348static bool normalizedimfileMode(pxConfig *config)
    25642349{
    25652350    PS_ASSERT_PTR_NON_NULL(config, false);
     2351
     2352    psMetadata *where = psMetadataAlloc();
     2353    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2354    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2355    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2356    PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
    25662357
    25672358    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    25692360    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    25702361
    2571     psString query = psStringCopy(
    2572         "SELECT"
    2573         " detNormalizedImfile.*"
    2574         " FROM detNormalizedImfile"
    2575         " JOIN detRun"
    2576         "   USING(det_id, iteration)"
    2577         " WHERE"
    2578         "   detRun.state = 'run'"
    2579         "   AND detRun.mode = 'master'"
    2580     );
    2581 
    2582     if (config->where) {
    2583         bool status;
    2584         int iteration = psMetadataLookupS32 (&status, config->where, "iteration");
    2585         if (status) {
    2586             psMetadataRemoveKey (config->where, "iteration");
    2587             psMetadataAddS32 (config->where, PS_LIST_TAIL, "iteration", 0, "==", iteration);
    2588         }
    2589         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedImfile");
     2362    psString query = pxDataGet("dettool_normalizedimfile.sql");
     2363    if (!query) {
     2364        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2365        return false;
     2366    }
     2367
     2368    if (psListLength(where->list)) {
     2369        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedImfile");
    25902370        psStringAppend(&query, " AND %s", whereClause);
    25912371        psFree(whereClause);
    25922372    }
     2373    psFree(where);
    25932374
    25942375    if (faulted) {
    … …  
    26422423    PS_ASSERT_PTR_NON_NULL(config, false);
    26432424
     2425    psMetadata *where = psMetadataAlloc();
     2426    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2427    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2428    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2429    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2430
    26442431    psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    26452432    if (!query) {
    … …  
    26482435    }
    26492436
    2650     if (config->where) {
    2651         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedImfile");
     2437    if (psListLength(where->list)) {
     2438        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedImfile");
    26522439        psStringAppend(&query, " AND %s", whereClause);
    26532440        psFree(whereClause);
    26542441    }
     2442    psFree(where);
    26552443
    26562444    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    26682456    return true;
    26692457}
    2670 
    26712458
    26722459static bool tonormalizedexpMode(pxConfig *config)
    … …  
    26822469        return false;
    26832470    }
    2684 
    2685     // XXX does it make sense to accept any search params?
    2686 #if 0
    2687     if (config->where) {
    2688         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2689         psStringAppend(&query, " AND %s", whereClause);
    2690         psFree(whereClause);
    2691     }
    2692 #endif
    26932471
    26942472    // treat limit == 0 as "no limit"
    … …  
    27322510{
    27332511    PS_ASSERT_PTR_NON_NULL(config, false);
    2734 
    2735     // required
    2736     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    2737 
     2512   
     2513    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     2514    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    27382515    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2739 
    2740     // Required if code == 0
    2741     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    2742 
    2743     // optional
     2516    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    27442517    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    27452518    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    27522525    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    27532526
    2754     // default values
    2755     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    2756 
    27572527    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    27582528    if (!query) {
    … …  
    27612531    }
    27622532
    2763     psStringAppend(&query,
    2764             " WHERE det_id = %s"
    2765             " AND iteration = %d", det_id, iteration);
    2766 
     2533    // XXX in some other places, we put the arguments in the .sql and supply them to RunQuery
     2534    psStringAppend(&query, " WHERE det_id = %s AND iteration = %d", det_id, iteration);
    27672535
    27682536    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    28132581    PS_ASSERT_PTR_NON_NULL(config, false);
    28142582
     2583    psMetadata *where = psMetadataAlloc();
     2584    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2585    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2586    PXOPT_COPY_STR(config->args, where, "-recip",  "recipe", "==");
     2587
    28152588    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    28162589    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    28172590    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    28182591
    2819     psString query = psStringCopy(
    2820         "SELECT"
    2821         "   detNormalizedExp.*"
    2822         " FROM detNormalizedExp"
    2823         " JOIN detRun"
    2824         "   USING(det_id, iteration)"
    2825         " WHERE"
    2826         "   detRun.state = 'run'"
    2827         "   AND detRun.mode = 'master'"
    2828     );
    2829 
    2830     if (config->where) {
    2831         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
     2592    psString query = pxDataGet("dettool_normalizedexp.sql");
     2593    if (!query) {
     2594        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2595        return false;
     2596    }
     2597
     2598    if (psListLength(where->list)) {
     2599        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    28322600        psStringAppend(&query, " %s", whereClause);
    28332601        psFree(whereClause);
    28342602    }
     2603    psFree(where);
    28352604
    28362605    if (faulted) {
    … …  
    28852654    PS_ASSERT_PTR_NON_NULL(config, false);
    28862655
     2656    psMetadata *where = psMetadataAlloc();
     2657    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2658    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2659    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2660
    28872661    psString query = pxDataGet("dettool_revertnormalizedexp.sql");
    28882662    if (!query) {
    … …  
    28912665    }
    28922666
    2893     if (config->where) {
    2894         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detNormalizedExp");
     2667    if (psListLength(where->list)) {
     2668        psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedExp");
    28952669        psStringAppend(&query, " AND %s", whereClause);
    28962670        psFree(whereClause);
    28972671    }
     2672    psFree(where);
    28982673
    28992674    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    29252700        return false;
    29262701    }
    2927 
    2928     // XXX does it make sense to accept any search params?
    2929 #if 0
    2930     if (config->where) {
    2931         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    2932         psStringAppend(&query, " AND %s", whereClause);
    2933         psFree(whereClause);
    2934     }
    2935 #endif
    29362702
    29372703    // treat limit == 0 as "no limit"
    … …  
    29772743    PS_ASSERT_PTR_NON_NULL(config, false);
    29782744
    2979     // required
    2980     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    2981     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    2982     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    2983 
     2745   
     2746    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     2747    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     2748    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false); // required
     2749    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    29842750    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2985 
    2986     // Required if code == 0
    2987     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    2988     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    2989 
    2990     // optional
     2751    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false); // Required if code == 0
     2752    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    29912753    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    29922754    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    29952757    PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
    29962758    PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
    2997 
    29982759    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    29992760    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    … …  
    30022763    PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
    30032764    PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
    3004 
    30052765    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    30062766    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    … …  
    30092769    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    30102770    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    3011 
    3012     // default values
    3013     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    30142771
    30152772    if (!detResidImfileInsert(config->dbh,
    … …  
    30522809    PS_ASSERT_PTR_NON_NULL(config, false);
    30532810
     2811    psMetadata *where = psMetadataAlloc();
     2812    PXOPT_COPY_STR(config->args, where, "-det_id",     "det_id", "==");
     2813    PXOPT_COPY_S32(config->args, where, "-iteration",  "iteration", "==");
     2814    PXOPT_COPY_STR(config->args, where, "-exp_id",     "exp_id", "==");
     2815    PXOPT_COPY_STR(config->args, where, "-class_id",   "class_id", "==");
     2816    PXOPT_COPY_STR(config->args, where, "-recip",      "recipe", "==");
     2817
    30542818    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    30552819    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    30562820    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    30572821
    3058     // select detResidImfile.*
    3059     // by:
    3060     // where det_id, iteration, exp_id is not in detResidExp;
    3061 
    3062     psString query = psStringCopy(
    3063         "SELECT"
    3064         "   detRun.det_type,"
    3065         "   detRun.mode,"
    3066         "   detResidImfile.*,"
    3067         "   rawExp.exp_time"
    3068         " FROM detResidImfile"
    3069         " JOIN detRun"
    3070         "   USING(det_id, iteration)"
    3071         " JOIN rawExp"
    3072         "   USING(exp_id)"
    3073         " WHERE"
    3074     );
    3075     // NOTE the above WHERE is completed with the following line:
    3076 
     2822    psString query = pxDataGet("dettool_residimfile.sql");
     2823    if (!query) {
     2824        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2825        return false;
     2826    }
     2827
     2828    // NOTE: the query ends in a WHERE, add the required restriction on detRun.state
    30772829    char *value = NULL;
    3078 
    3079     // add the two required restrictions: detRun.state and detRun.mode
    30802830    bool status;
    30812831    if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    … …  
    30852835    }
    30862836
    3087     if (config->where) {
    3088         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detResidImfile");
     2837    if (psListLength(where->list)) {
     2838        psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidImfile");
    30892839        psStringAppend(&query, " AND %s", whereClause);
    30902840        psFree(whereClause);
    30912841    }
     2842    psFree(where);
    30922843
    30932844    if (faulted) {
    … …  
    31412892    PS_ASSERT_PTR_NON_NULL(config, false);
    31422893
     2894    psMetadata *where = psMetadataAlloc();
     2895    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     2896    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     2897    PXOPT_COPY_STR(config->args, where, "-exp_id",  "exp_id", "==");
     2898    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     2899    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     2900
    31432901    psString query = pxDataGet("dettool_revertresidimfile.sql");
    31442902    if (!query) {
    … …  
    31472905    }
    31482906
    3149     if (config->where) {
    3150         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detResidImfile");
     2907    if (psListLength(where->list)) {
     2908        psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidImfile");
    31512909        psStringAppend(&query, " AND %s", whereClause);
    31522910        psFree(whereClause);
    31532911    }
     2912    psFree(where);
    31542913
    31552914    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    31692928
    31702929
     2930/*
     2931  The SQL returns a list of exposures for which all component class ids have had residuals
     2932  created.  This list includes the detrend id, iteration, exposure id, detrend type, and
     2933  whether the exposure was included in the stack for this iteration.
     2934*/
     2935
    31712936static bool toresidexpMode(pxConfig *config)
    31722937{
    31732938    PS_ASSERT_PTR_NON_NULL(config, false);
    3174 
    3175     /*
    3176 which returns a list of exposures for which all component class ids
    3177 have had residuals created.  This list includes the detrend id,
    3178 iteration, exposure id, detrend type, and whether the exposure was
    3179 included in the stack for this iteration.
    3180     */
    31812939
    31822940    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    31882946        return false;
    31892947    }
    3190 
    3191     // XXX does it make sense to accept any search params?
    3192 #if 0
    3193     if (config->where) {
    3194         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    3195         psStringAppend(&query, " AND %s", whereClause);
    3196         psFree(whereClause);
    3197     }
    3198 #endif
    31992948
    32002949    // treat limit == 0 as "no limit"
    … …  
    32352984}
    32362985
     2986/*
     2987  The SQL returns a list of exposures for which all component class ids have had residuals
     2988  created.  This list includes the detrend id, iteration, exposure id, detrend type, and
     2989  whether the exposure was included in the stack for this iteration.
     2990*/
     2991
    32372992static bool addresidexpMode(pxConfig *config)
    32382993{
    32392994    PS_ASSERT_PTR_NON_NULL(config, false);
    32402995
    3241     // required
    3242     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    3243     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    3244 
     2996    // limit search by det_id, iteration, exp_id
     2997    psMetadata *where = psMetadataAlloc();
     2998    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     2999    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3000    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     3001
     3002    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     3003    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
     3004    PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false); // required
    32453005    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    3246 
    3247     // Required if code == 0
    3248     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    3249 
    3250     // optional
     3006    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    32513007    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    32523008    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    32553011    PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
    32563012    PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
    3257 
    32583013    PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    32593014    PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    … …  
    32623017    PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
    32633018    PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
    3264 
    32653019    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    32663020    PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    … …  
    32693023    PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    32703024    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    3271 
    3272     // default values
    3273     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    32743025    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    3275 
    3276     /*
    3277 which returns a list of exposures for which all component class ids
    3278 have had residuals created.  This list includes the detrend id,
    3279 iteration, exposure id, detrend type, and whether the exposure was
    3280 included in the stack for this iteration.
    3281     */
    32823026
    32833027    psString query = pxDataGet("dettool_toresidexp.sql");
    … …  
    32873031    }
    32883032
    3289     {
    3290         // build a query to search by det_id, iteration, exp_id
    3291         psMetadata *where = psMetadataAlloc();
    3292 
    3293         PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    3294         PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3295         PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    3296 
    3297 
    3298         // there's not
    3299         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    3300         psFree(where);
    3301         if (whereClause) {
    3302             psStringAppend(&query, " WHERE %s", whereClause);
    3303             psFree(whereClause);
    3304         }
    3305     }
     3033    if (psListLength(where->list)) {
     3034        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     3035        psStringAppend(&query, " WHERE %s", whereClause);
     3036        psFree(whereClause);
     3037    }
     3038    psFree(where);
    33063039
    33073040    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    33623095    PS_ASSERT_PTR_NON_NULL(config, false);
    33633096
    3364     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    3365     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     3097    psMetadata *where = psMetadataAlloc();
     3098    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     3099    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3100    PXOPT_COPY_STR(config->args, where, "-exp_id",    "exp_id", "==");
     3101    PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
     3102
     3103    PXOPT_LOOKUP_U64(limit,    config->args, "-limit", false, false);
     3104    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple", false);
    33663105    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    3367 
    3368     psString query = psStringCopy(
    3369         "SELECT"
    3370         "   detRun.mode,"
    3371         "   detResidExp.*,"
    3372         "   detInputExp.include"
    3373         " FROM detRun"
    3374         " JOIN detInputExp"
    3375         "   USING(det_id, iteration)"
    3376         " JOIN detResidExp"
    3377         "   USING(det_id, iteration, exp_id)"
    3378         " WHERE"
    3379         "   detRun.state = 'run'"
    3380     );
    3381 
    3382     if (config->where) {
    3383         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detResidExp");
     3106    PXOPT_LOOKUP_BOOL(reject,  config->args, "-reject", false);
     3107
     3108    psString query = pxDataGet("dettool_residexp.sql");
     3109    if (!query) {
     3110        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     3111        return false;
     3112    }
     3113
     3114    if (psListLength(where->list)) {
     3115        psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidExp");
    33843116        psStringAppend(&query, " AND %s", whereClause);
    33853117        psFree(whereClause);
    33863118    }
     3119    psFree(where);
    33873120
    33883121    if (faulted) {
    … …  
    33943127    }
    33953128
     3129    // list only accepted rows
     3130    // XXX the usage of this flag is unclear : -reject means "accepted"?
     3131    if (reject) {
     3132        psStringAppend(&query, " %s", "AND detResidExp.accept != 0");
     3133    }
     3134
    33963135    // treat limit == 0 as "no limit"
    33973136    if (limit) {
    … …  
    34363175    PS_ASSERT_PTR_NON_NULL(config, false);
    34373176
     3177    psMetadata *where = psMetadataAlloc();
     3178    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     3179    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3180    PXOPT_COPY_STR(config->args, where, "-exp_id",    "exp_id", "==");
     3181    PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     3182
    34383183    psString query = pxDataGet("dettool_revertresidexp.sql");
    34393184    if (!query) {
    … …  
    34423187    }
    34433188
    3444     if (config->where) {
    3445         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detResidExp");
     3189    if (psListLength(where->list)) {
     3190        psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidExp");
    34463191        psStringAppend(&query, " AND %s", whereClause);
    34473192        psFree(whereClause);
    34483193    }
     3194    psFree(where);
    34493195
    34503196    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    34643210
    34653211
     3212static bool updateresidexpMode(pxConfig *config)
     3213{
     3214    PS_ASSERT_PTR_NON_NULL(config, false);
     3215
     3216    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
     3217
     3218    // build a query to search by det_id, iteration, exp_id
     3219    psMetadata *where = psMetadataAlloc();
     3220    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
     3221    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3222    PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     3223
     3224    // find the values we're going to set
     3225    // copy everything but det_id, iteration, & exp_id from the args and
     3226    // remove the '-' prefix
     3227    psMetadata *set = psMetadataAlloc();
     3228    PXOPT_COPY_STR(config->args, set, "-recip", "recipe", "==");
     3229    PXOPT_COPY_F64(config->args, set, "-bg", "bg", "==");
     3230    PXOPT_COPY_F64(config->args, set, "-bg_stdev", "bg_stdev", "==");
     3231    PXOPT_COPY_F64(config->args, set, "-bg_mean_stdev", "bg_mean_stdev", "==");
     3232    PXOPT_COPY_STR(config->args, set, "-path_base", "path_base", "==");
     3233
     3234    // this can't be PXOPT_ macro-ized as reject is !'d
     3235    if (!psMetadataAddBool(set, PS_LIST_TAIL, "accept", 0, "==", !reject)) {
     3236        psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
     3237        psFree(set);
     3238        psFree(where);
     3239        return false;
     3240    }
     3241
     3242    long changed = psDBUpdateRows(config->dbh, "detResidExp", where, set);
     3243    psFree(set);
     3244    psFree(where);
     3245
     3246    if (changed < 0) {
     3247        psError(PS_ERR_UNKNOWN, false, "no rows were updated");
     3248        return false;
     3249    }
     3250
     3251    return true;
     3252}
     3253
     3254/* The SQL returns a list of detrend runs (with detrend id, iteration and detrend type) which
     3255 * have completed all residexps.
     3256 */
     3257
    34663258static bool todetrunsummaryMode(pxConfig *config)
    34673259{
    … …  
    34703262    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    34713263    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    3472 
    3473     /* which returns a list of detrend runs (with detrend id, iteration and
    3474      * detrend type) which have completed all residexps.
    3475      */
    34763264
    34773265    psString query = pxDataGet("dettool_todetrunsummary.sql");
    … …  
    34803268        return false;
    34813269    }
    3482 
    3483     // XXX does it make sense to accept any search params?
    3484 #if 0
    3485     if (config->where) {
    3486         psString whereClause = psDBGenerateWhereConditionSQL(config->where);
    3487         psStringAppend(&query, " AND %s", whereClause);
    3488         psFree(whereClause);
    3489     }
    3490 #endif
    34913270
    34923271    // treat limit == 0 as "no limit"
    … …  
    35273306}
    35283307
    3529 static bool updateresidexpMode(pxConfig *config)
    3530 {
    3531     PS_ASSERT_PTR_NON_NULL(config, false);
    3532 
    3533     PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    3534 
     3308// this function is used to generate the detrunSummary entries used below
     3309// XXX why is this a separate function?  roll it back into adddetrunsummary?
     3310static detRunSummaryRow *mdToDetRunSummary(pxConfig *config, psMetadata *row)
     3311{
     3312    PS_ASSERT_PTR_NON_NULL(config, false);
     3313
     3314    bool status = false;
     3315    // from row
     3316    psS64 det_id = psMetadataLookupS64(&status, row, "det_id");
     3317    if (!status) {
     3318        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for det_id");
     3319        return false;
     3320    }
     3321    psS32 iteration = psMetadataLookupS32(&status, row, "iteration");
     3322    if (!status) {
     3323        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for iteration");
     3324        return false;
     3325    }
     3326
     3327    // optional
     3328    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
     3329    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
     3330    PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
     3331
     3332    // default values
     3333    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     3334    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
     3335
     3336    return detRunSummaryRowAlloc(
     3337            det_id,
     3338            iteration,
     3339            bg,
     3340            bg_stdev,
     3341            bg_mean_stdev,
     3342            accept,
     3343            code
     3344        );
     3345}
     3346
     3347static bool adddetrunsummaryMode(pxConfig *config)
     3348{
     3349    PS_ASSERT_PTR_NON_NULL(config, false);
     3350   
    35353351    // build a query to search by det_id, iteration, exp_id
    35363352    psMetadata *where = psMetadataAlloc();
    35373353    PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    35383354    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3539     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    3540 
    3541     // find the values we're going to set
    3542     // copy everything but det_id, iteration, & exp_id from the args and
    3543     // remove the '-' prefix
    3544     psMetadata *set = psMetadataAlloc();
    3545     // XXX if PXOPT_COPY_* errors here the where md will leak
    3546     PXOPT_COPY_STR(config->args, set, "-recip", "recipe", "==");
    3547     PXOPT_COPY_F64(config->args, set, "-bg", "bg", "==");
    3548     PXOPT_COPY_F64(config->args, set, "-bg_stdev", "bg_stdev", "==");
    3549     PXOPT_COPY_F64(config->args, set, "-bg_mean_stdev", "bg_mean_stdev", "==");
    3550     PXOPT_COPY_STR(config->args, set, "-path_base", "path_base", "==");
    3551 
    3552     // this can't be PXOPT_ macro-ized as reject is !'d
    3553     if (!psMetadataAddBool(set, PS_LIST_TAIL, "accept", 0, "==", !reject)) {
    3554         psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
    3555         psFree(set);
    3556         psFree(where);
    3557         return false;
    3558     }
    3559 
    3560     long changed = psDBUpdateRows(config->dbh, "detResidExp", where, set);
    3561     psFree(set);
    3562     psFree(where);
    3563 
    3564     if (changed < 0) {
    3565         psError(PS_ERR_UNKNOWN, false, "no rows were updated");
    3566         return false;
    3567     }
    3568 
    3569     return true;
    3570 }
    3571 
    3572 static bool adddetrunsummaryMode(pxConfig *config)
    3573 {
    3574     PS_ASSERT_PTR_NON_NULL(config, false);
    3575 
    3576     // required
    3577     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    3578 
    3579     // optional
     3355
     3356    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    35803357    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
     3358
     3359    // The values supplied as arguments on the command (eg, -bg) are parsed
     3360    // by mdToDetRunSummary below.
     3361    // XXX why is there ever more than one?
    35813362
    35823363    psString query = pxDataGet("dettool_find_completed_runs.sql");
    … …  
    35863367    }
    35873368
    3588     // build a query to search by det_id, iteration, exp_id
    3589     psMetadata *where = psMetadataAlloc();
    3590     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    3591     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3592 
    3593     {
    3594         // there's not
     3369    if (psListLength(where->list)) {
    35953370        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    3596         psFree(where);
    3597         if (whereClause) {
    3598             psStringAppend(&query, " WHERE %s", whereClause);
    3599             psFree(whereClause);
    3600         }
    3601     }
     3371        psStringAppend(&query, " WHERE %s", whereClause);
     3372        psFree(whereClause);
     3373    }
     3374    psFree(where);
    36023375
    36033376    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    36263399    }
    36273400
     3401    // XXX why is there ever more than one result here?
    36283402    for (long i = 0; i < psArrayLength(output); i++) {
    36293403        psMetadata *row = output->data[i];
    … …  
    36543428
    36553429    // XXX this logic does not deal with the case of -code being set
     3430    // XXX it should be an error for -again and -code to both be set
    36563431    if (again) {
    36573432        if (!startNewIteration(config, (psS64)atoll(det_id))) {
    … …  
    36803455}
    36813456
    3682 static detRunSummaryRow *mdToDetRunSummary(pxConfig *config, psMetadata *row)
    3683 {
    3684     PS_ASSERT_PTR_NON_NULL(config, false);
    3685 
    3686     bool status = false;
    3687     // from row
    3688     psS64 det_id = psMetadataLookupS64(&status, row, "det_id");
    3689     if (!status) {
    3690         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for det_id");
    3691         return false;
    3692     }
    3693     psS32 iteration = psMetadataLookupS32(&status, row, "iteration");
    3694     if (!status) {
    3695         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for iteration");
    3696         return false;
    3697     }
    3698 
    3699     // optional
    3700     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    3701     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    3702     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    3703     // default values
    3704     PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    3705     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    3706 
    3707     return detRunSummaryRowAlloc(
    3708             det_id,
    3709             iteration,
    3710             bg,
    3711             bg_stdev,
    3712             bg_mean_stdev,
    3713             accept,
    3714             code
    3715         );
    3716 }
    3717 
    37183457static bool detrunsummaryMode(pxConfig *config)
    37193458{
    37203459    PS_ASSERT_PTR_NON_NULL(config, false);
     3460
     3461    psMetadata *where = psMetadataAlloc();
     3462    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     3463    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    37213464
    37223465    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    37243467    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    37253468
    3726     psString query = psStringCopy(
    3727         "SELECT DISTINCT\n"
    3728         "   detRunSummary.*,\n"
    3729         "   detRun.det_type,\n"
    3730         "   detRun.mode\n"
    3731         " FROM detRun\n"
    3732         " JOIN detRunSummary\n"
    3733         "   USING(det_id, iteration)\n"
    3734         " WHERE\n"
    3735         "   detRun.state = 'run'\n"
    3736         );
    3737 
    3738     if (config->where) {
    3739         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     3469    psString query = pxDataGet("dettool_detrunsummary.sql");
     3470    if (!query) {
     3471        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     3472        psFree(where);
     3473        return false;
     3474    }
     3475
     3476    if (psListLength(where->list)) {
     3477        psString whereClause = psDBGenerateWhereConditionSQL(where, "NULL");
    37403478        psStringAppend(&query, " AND %s", whereClause);
    37413479        psFree(whereClause);
    37423480    }
     3481    psFree(where);
    37433482
    37443483    if (faulted) {
    … …  
    37923531    PS_ASSERT_PTR_NON_NULL(config, false);
    37933532
     3533    psMetadata *where = psMetadataAlloc();
     3534    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     3535    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     3536    PXOPT_COPY_STR(config->args, where, "-code",      "fault", "==");
     3537
    37943538    psString query = pxDataGet("dettool_revertdetrunsummary.sql");
    37953539    if (!query) {
    … …  
    37983542    }
    37993543
    3800     if (config->where) {
    3801         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "detRunSummary");
     3544    if (psListLength(where->list)) {
     3545        psString whereClause = psDBGenerateWhereConditionSQL(where, "detRunSummary");
    38023546        psStringAppend(&query, " AND %s", whereClause);
    38033547        psFree(whereClause);
    38043548    }
     3549    psFree(where);
    38053550
    38063551    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    38233568{
    38243569    PS_ASSERT_PTR_NON_NULL(config, false);
    3825 
    3826     // required
    3827     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    3828 
     3570   
     3571    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    38293572    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    38303573    PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    … …  
    38543597    PS_ASSERT_PTR_NON_NULL(config, false);
    38553598
    3856     // det_id is required
    3857     // XXX this isn't strictly nessicary but not having the det_id complicates
    3858     // incrementing the iteration number
    3859     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    3860 
     3599    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    38613600    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
    38623601    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
     3602
    38633603    // either -rerun or -state must be specified
    38643604    if (!(again || state)) {
    … …  
    38673607    }
    38683608    if (again && state) {
    3869         psError(PS_ERR_UNKNOWN, true, "either -again or -state must be specified");
     3609        psError(PS_ERR_UNKNOWN, true, "-accept and -reject are exclusive");
    38703610        return false;
    38713611    }
    … …  
    38863626}
    38873627
     3628// used by updatedetrunMode
    38883629static bool startNewIteration(pxConfig *config, psS64 det_id)
    38893630{
    … …  
    38963637    }
    38973638
    3898     // XXX this query was not restricted by det_id, resulting
    3899     // in an inconsistent UPDATE below.  I added this AND clause
    3900     // though there may be a cleaner method (EAM 2006.10.08)
     3639    // restrict the update only to the specified det_id
    39013640    psStringAppend(&query, " WHERE det_id = %" PRId64 , det_id);
    39023641
    … …  
    41513890    PS_ASSERT_PTR_NON_NULL(config, false);
    41523891
    4153     // required
    4154     PXOPT_LOOKUP_STR(det_type, config->args, "-det_type", true, false);
    4155     PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
    4156 
    4157     // optional
     3892    PXOPT_LOOKUP_STR(det_type, config->args, "-det_type", true, false); // required
     3893    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", true, false); // required
    41583894    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    41593895    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
    … …  
    41783914    PXOPT_LOOKUP_STR(parent, config->args, "-parent", false, false);
    41793915    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    4180 
    4181     // default
    41823916    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    41833917
    … …  
    41913925                      0,            // the iteration is fixed at 0
    41923926                      det_type,
    4193                       "register",   // mode
     3927                      "register",   // mode is required to be "register"
    41943928                      "register",   // state
    41953929                      filelevel,
    … …  
    42623996}
    42633997
     3998// NOTE : this function is also used by addcorrectimfileMode
    42643999bool register_detrend_imfileMode(pxConfig *config)
    42654000{
    42664001    PS_ASSERT_PTR_NON_NULL(config, false);
    4267 
    4268     // required
    4269     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    4270     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    4271     PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false);
    4272 
    4273     // optional
     4002   
     4003    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     4004    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
     4005    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false); // required
    42744006    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    42754007    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    43894121    return true;
    43904122}
     4123
     4124
     4125#if 0
     4126// XXX this function was left in commented as this method may be useful in the
     4127// future
     4128static psArray *validDetInputClassIds(pxConfig *config, const char *det_id)
     4129{
     4130    PS_ASSERT_PTR_NON_NULL(config, NULL);
     4131    // det_id is input as a string because the fact that it is an integer
     4132    // is just a database impliementation detail.
     4133    PS_ASSERT_PTR_NON_NULL(det_id, NULL);
     4134
     4135    psArray *rawImfiles = searchInputImfiles(config, det_id);
     4136    if (!rawImfiles) {
     4137        return NULL;
     4138    }
     4139
     4140    psArray *valid_class_ids = NULL;
     4141    {
     4142        // All this jumping through hoops is so that we end up with unique
     4143        // values. PP thinks that making multiple passes through this array and
     4144        // deleting matched elements would end up being more expensive then a
     4145        // double sort and stagger scheme. JH thinks it would be cheaper to
     4146        // just do a unqiue sort and delete.  So this is really just a cheap
     4147        // hack to avoid implimenting a unique sort function but at least it's
     4148        // stable.
     4149        psHash *hash = psHashAlloc(psArrayLength(rawImfiles));
     4150        for (long i = 0; i < psArrayLength(rawImfiles); i++) {
     4151            psHashAdd(hash,
     4152                ((rawImfileRow *)rawImfiles->data[i])->class_id,
     4153                ((rawImfileRow *)rawImfiles->data[i])->class_id
     4154            );
     4155        }
     4156        valid_class_ids = psHashToArray(hash);
     4157        psFree(hash);
     4158    }
     4159    psFree(rawImfiles);
     4160
     4161    return valid_class_ids;
     4162}
     4163
     4164static psArray *searchInputImfiles(pxConfig *config, const char *det_id)
     4165{
     4166    PS_ASSERT_PTR_NON_NULL(config, NULL);
     4167    // det_id is input as a string because the fact that it is an integer
     4168    // is just a database impliementation detail.
     4169    PS_ASSERT_PTR_NON_NULL(det_id, NULL);
     4170
     4171    psArray *inputExps = NULL;
     4172    {
     4173        psMetadata *where = psMetadataAlloc();
     4174        if (!psMetadataAddS32(where, PS_LIST_TAIL, "det_id", 0, "==",
     4175                (psS32)atoi(det_id))) {
     4176            psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
     4177            psFree(where);
     4178            return NULL;
     4179        }
     4180        inputExps = detInputExpSelectRowObjects(config->dbh, where, 0);
     4181        psFree(where);
     4182    }
     4183    if (!inputExps) {
     4184        psError(PS_ERR_UNKNOWN, false, "no detInputExp rows found");
     4185        return NULL;
     4186    }
     4187
     4188    // find rawImfiles associated with detInputExps
     4189    psArray *rawImfiles = NULL;
     4190    {
     4191        psMetadata *where = psMetadataAlloc();
     4192        for (long i = 0; i < psArrayLength(inputExps); i++) {
     4193            if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id",
     4194                    PS_META_DUPLICATE_OK, "==",
     4195                    ((detInputExpRow *)inputExps->data[i])->exp_id)) {
     4196                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     4197                psFree(inputExps);
     4198                psFree(where);
     4199                return NULL;
     4200            }
     4201        }
     4202        psFree(inputExps);
     4203        rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
     4204        // XXX this really should be sorted for uniqueness
     4205        psFree(where);
     4206    }
     4207    if (!rawImfiles) {
     4208        psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
     4209        return NULL;
     4210    }
     4211
     4212    return rawImfiles;
     4213}
     4214#endif
     4215

  • trunk/ippTools/src/dettool.h

    r18157 r18561  
    1717 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
    1818 */
     19
     20#ifdef HAVE_CONFIG_H
     21#include <config.h>
     22#endif
    1923
    2024#ifndef DETTOOL_H

  • trunk/ippTools/src/dettoolConfig.c

    r18172 r18561  
    1818 */
    1919
    20 #ifdef HAVE_CONFIG_H
    21 #include <config.h>
    22 #endif
    23 
    24 #include <psmodules.h>
    25 
    26 #include "pxtools.h"
    2720#include "dettool.h"
    2821
    … …  
    4639
    4740    // -pending
     41    // XXX EAM : is this used?  does it make sense?
    4842    psMetadata *pendingArgs = psMetadataAlloc();
    49     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,
    50             "search by exposure ID", NULL);
    51     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,
    52             "search by exposure type", NULL);
    53     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,
    54             "search by camera", NULL);
    55     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,
    56             "search by telescope", NULL);
    57     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,
    58             "search by filter", NULL);
    59     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-uri",  0,
    60             "search by URL", NULL);
    61     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,
    62             "use the simple output format", false);
     43    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     44    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exposure type", NULL);
     45    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera", NULL);
     46    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,            "search by telescope", NULL);
     47    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,            "search by filter", NULL);
     48    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-uri",  0,            "search by URL", NULL);
     49    psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6350
    6451    // -definebytag
    6552    psMetadata *definebytagArgs = psMetadataAlloc();
    66     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_id",
    67             PS_META_DUPLICATE_OK,
    68             "include this exposure (multiple OK, required)", NULL);
    69     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-det_type",  0,
    70             "define the type of detrend run (required)", NULL);
    71     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,
    72             "define the mode of this detrend run", "master");
    73     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filelevel",  0,
    74             "define filelevel", NULL);
    75     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,
    76             "define workdir (required)", NULL);
    77     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-inst",  0,
    78             "define camera", NULL);
    79     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-telescope",  0,
    80             "define telescope", NULL);
    81     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_type",  0,
    82             "define exposure type", NULL);
    83     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filter",  0,
    84             "define filter ", NULL);
    85     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_min",  0,
    86             "define min airmass", NAN);
    87     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_max",  0,
    88             "define max airmass", NAN);
    89     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    90             "define min exposure time", NAN);
    91     psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    92             "define max exposure time", NAN);
    93     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    94             "define min ccd tempature", NAN);
    95     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    96             "define max ccd tempature", NAN);
    97     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,
    98             "define min rotator position angle", NAN);
    99     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,
    100             "define max rotator position angle", NAN);
    101     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,
    102             "define min solar angle", NAN);
    103     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,
    104             "define max solar angle", NAN);
    105     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,
    106             "time detrend run was registered", now);
    107     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,
    108             "detrend applies to exposures taken during this period", NULL);
    109     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,
    110             "detrend applies to exposures taken during this period", NULL);
    111     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,
    112             "start of detrend run applicable period", NULL);
    113     psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,
    114             "end of detrend run applicable period", NULL);
    115     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-reduction",  0,
    116             "define reduction class for processing", NULL);
    117     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-label",  0,
    118             "define detrun label", NULL);
    119     psMetadataAddBool(definebytagArgs, PS_LIST_TAIL, "-simple",  0,
    120             "use the simple output format", false);
     53    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_id",            PS_META_DUPLICATE_OK,           "include this exposure (multiple OK, required)", NULL);
     54    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     55    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
     56    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel", NULL);
     57    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", NULL);
     58    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-inst",  0,            "define camera", NULL);
     59    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     60    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_type",  0,            "define exposure type", NULL);
     61    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     62    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     63    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     64    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     65    psMetadataAddF32(definebytagArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     66    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     67    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     68    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     69    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     70    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     71    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     72    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     73    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     74    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     75    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     76    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     77    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class for processing", NULL);
     78    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     79    psMetadataAddBool(definebytagArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    12180
    12281    // -definebyquery
    12382    psMetadata *definebyqueryArgs = psMetadataAlloc();
    124     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-det_type",  0,
    125             "define the type of detrend run (required)", NULL);
    126     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-mode",  0,
    127             "define the mode of this detrend run", "master");
    128     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,
    129             "define filelevel", NULL);
    130     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,
    131             "define workdir (required)", NULL);
    132     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,
    133             "define camera (required)", NULL);
    134     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,
    135             "define telescope", NULL);
    136     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,
    137             "define filter ", NULL);
    138     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,
    139             "define min airmass", NAN);
    140     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,
    141             "define max airmass", NAN);
    142     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    143             "define min exposure time", NAN);
    144     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    145             "define max exposure time", NAN);
    146     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    147             "define min ccd tempature", NAN);
    148     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    149             "define max ccd tempature", NAN);
    150     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,
    151             "define min rotator position angle", NAN);
    152     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,
    153             "define max rotator position angle", NAN);
    154     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,
    155             "define min solar angle", NAN);
    156     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,
    157             "define max solar angle", NAN);
    158     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    159             "time detrend run was registered", now);
    160     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,
    161             "detrend applies to exposures taken during this period", NULL);
    162     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,
    163             "detrend applies to exposures taken during this period", NULL);
    164     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,
    165             "start of detrend run applicable period", NULL);
    166     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,
    167             "end of detrend run applicable period", NULL);
    168     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    169             "search for exp_type", NULL);
    170     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,
    171             "search for camera", NULL);
    172     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,
    173             "search for telescope", NULL);
    174     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,
    175             "search for filter", NULL);
    176     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    177             "search for uri", NULL);
    178     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    179             "search for exposures by time (>=)", NULL);
    180     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    181             "search for exposures by time (<)", NULL);
    182     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    183             "define min airmass", NAN);
    184     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
    185             "define max airmass", NAN);
    186     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
    187             "define max fraction of saturated pixels", NAN);
    188     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
    189             "define min exposure time", NAN);
    190     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
    191             "define max exposure time", NAN);
    192     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
    193             "define min ccd tempature", NAN);
    194     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    195             "define max ccd tempature", NAN);
    196     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_min",  0,
    197             "define min power-on time", NAN);
    198     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_max",  0,
    199             "define max power-on time", NAN);
    200     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    201             "define min rotator position angle", NAN);
    202     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,
    203             "define max rotator position angle", NAN);
    204     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,
    205             "define min solar angle", NAN);
    206     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,
    207             "define max solar angle", NAN);
    208     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,
    209             "print the exposures that would be included in the detrend run and exit", false);
    210     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,
    211             "define reduction class for processing", NULL);
    212     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0,
    213             "define detrun label", NULL);
    214     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    215             "use the simple output format", false);
    216 
    217     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
    218             "use a random subset of elements", false);
    219     psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
    220             "use this number of random elements", 20);
     83    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     84    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
     85    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel", NULL);
     86    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", NULL);
     87    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",  0,            "define camera (required)", NULL);
     88    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     89    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     90    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     91    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     92    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     93    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     94    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     95    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     96    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     97    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     98    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     99    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     100    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     101    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     102    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     103    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     104    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     105    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,            "search for exp_type", NULL);
     106    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,            "search for camera", NULL);
     107    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,            "search for telescope", NULL);
     108    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,            "search for filter", NULL);
     109    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,            "search for uri", NULL);
     110    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     111    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,            "search for exposures by time (<)", NULL);
     112    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,            "define min airmass", NAN);
     113    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,            "define max airmass", NAN);
     114    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,            "define max fraction of saturated pixels", NAN);
     115    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,            "define min exposure time", NAN);
     116    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,            "define max exposure time", NAN);
     117    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,            "define min ccd tempature", NAN);
     118    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,            "define max ccd tempature", NAN);
     119    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_min",  0,            "define min power-on time", NAN);
     120    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_pon_time_max",  0,            "define max power-on time", NAN);
     121    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
     122    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
     123    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
     124    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     125    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
     126    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class for processing", NULL);
     127    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     128    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     129    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,            "use a random subset of elements", false);
     130    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,            "use this number of random elements", 20);
    221131
    222132    // -definebydetrun
    223133    psMetadata *definebydetrunArgs = psMetadataAlloc();
    224     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,
    225             "det ID to base a new detRun on (required)", NULL);
    226     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_det_type",  0,
    227             "define the type of detrend run", NULL);
    228     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_mode",  0,
    229             "define the mode of this detrend run", "master");
    230     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_type",  0,
    231             "define exposure type", NULL);
    232     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filelevel",  0,
    233             "define filelevel", NULL);
    234     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_workdir",  0,
    235             "define workdir", NULL);
    236     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filter",  0,
    237             "define filter ", NULL);
    238     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_min",  0,
    239             "define airmass", NAN);
    240     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_max",  0,
    241             "define airmass", NAN);
    242     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_min",  0,
    243             "define exposure time", NAN);
    244     psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_max",  0,
    245             "define exposure time", NAN);
    246     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_min",  0,
    247             "define ccd tempature", NAN);
    248     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_max",  0,
    249             "define ccd tempature", NAN);
    250     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,
    251             "define rotator position angle", NAN);
    252     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,
    253             "define rotator position angle", NAN);
    254     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,
    255             "time detrend run was registered", now);
    256     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,
    257             "start of period to apply detrend too", NULL);
    258     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,
    259             "end of period to apply detrend too", NULL);
    260     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,
    261             "start of detrend run applicable period", NULL);
    262     psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,
    263             "end of detrend run applicable period", NULL);
    264     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,
    265             "define solar angle", NAN);
    266     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,
    267             "define solar angle", NAN);
    268     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-filter_input_begin", 0,
    269             "filter input detrun exp to be in this period", NULL);
    270     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-filter_input_end", 0,
    271             "filter input detrun exp to be in this period", NULL);
    272     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_reduction",  0,
    273             "define reduction class for processing", NULL);
    274     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_label",  0,
    275             "define detrun label", NULL);
    276     psMetadataAddBool(definebydetrunArgs, PS_LIST_TAIL, "-simple", 0,
    277             "use the simple output format", false);
    278 
     134    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to base a new detRun on (required)", NULL);
     135    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_det_type",  0,            "define the type of detrend run", NULL);
     136    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_mode",  0,            "define the mode of this detrend run", "master");
     137    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_type",  0,            "define exposure type", NULL);
     138    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filelevel",  0,            "define filelevel", NULL);
     139    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     140    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_filter",  0,            "define filter ", NULL);
     141    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_min",  0,            "define airmass", NAN);
     142    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_airmass_max",  0,            "define airmass", NAN);
     143    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_min",  0,            "define exposure time", NAN);
     144    psMetadataAddF32(definebydetrunArgs, PS_LIST_TAIL, "-set_exp_time_max",  0,            "define exposure time", NAN);
     145    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_min",  0,            "define ccd tempature", NAN);
     146    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_ccd_temp_max",  0,            "define ccd tempature", NAN);
     147    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,            "define rotator position angle", NAN);
     148    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,            "define rotator position angle", NAN);
     149    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,            "define solar angle", NAN);
     150    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,            "define solar angle", NAN);
     151    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
     152    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,            "start of period to apply detrend too", NULL);
     153    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_end",  0,            "end of period to apply detrend too", NULL);
     154    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_begin",  0,            "start of detrend run applicable period", NULL);
     155    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_use_end",  0,            "end of detrend run applicable period", NULL);
     156    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class for processing", NULL);
     157    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_label",  0,            "define detrun label", NULL);
     158    psMetadataAddBool(definebydetrunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
     159    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_input_begin", 0,     "require input exp to be in this period", NULL);
     160    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_input_end", 0,       "require input exp to be in this period", NULL);
     161
     162    // *** these are in dettool_correction.c ***
    279163    // -makecorrection
    280164    psMetadata *makecorrectionArgs = psMetadataAlloc();
    281     psMetadataAddStr(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,
    282             "det ID to be corrected (required)", NULL);
    283     psMetadataAddBool(makecorrectionArgs, PS_LIST_TAIL, "-simple", 0,
    284             "use the simple output format", false);
     165    psMetadataAddStr(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to be corrected (required)", NULL);
     166    psMetadataAddBool(makecorrectionArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    285167
    286168    // -tocorrectexp
    287169    psMetadata *tocorrectexpArgs = psMetadataAlloc();
    288     psMetadataAddU64(tocorrectexpArgs, PS_LIST_TAIL, "-limit",  0,
    289             "limit result set to N items", 0);
    290     psMetadataAddBool(tocorrectexpArgs, PS_LIST_TAIL, "-simple",  0,
    291             "use the simple output format", false);
     170    psMetadataAddU64(tocorrectexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     171    psMetadataAddBool(tocorrectexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    292172
    293173    // -tocorrectimfile
    294174    psMetadata *tocorrectimfileArgs = psMetadataAlloc();
    295     psMetadataAddStr(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    296             "search for detrend ID", NULL);
    297     psMetadataAddU64(tocorrectimfileArgs, PS_LIST_TAIL, "-limit",  0,
    298             "limit result set to N items", 0);
    299     psMetadataAddBool(tocorrectimfileArgs, PS_LIST_TAIL, "-simple",  0,
    300             "use the simple output format", false);
     175    psMetadataAddStr(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     176    psMetadataAddU64(tocorrectimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     177    psMetadataAddBool(tocorrectimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    301178
    302179    // -addcorrectimfile
    303180    psMetadata *addcorrectimfileArgs = psMetadataAlloc();
    304     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    305             "define detrend ID (required)", NULL);
    306     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    307             "search for class ID (required)", NULL);
    308     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,
    309             "define resid file URI", NULL);
    310     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,
    311             "define exposure background", NAN);
    312     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    313             "define exposure background stdev", NAN);
    314     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    315             "define exposure background mean stdev", NAN);
    316     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    317             "define user statistic (1)", NAN);
    318     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    319             "define user statistic (2)", NAN);
    320     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    321             "define user statistic (3)", NAN);
    322     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    323             "define user statistic (4)", NAN);
    324     psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    325             "define user statistic (5)", NAN);
    326     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    327             "define base output location", NULL);
     181    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     182    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
     183    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
     184    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     185    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     186    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     187    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     188    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     189    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     190    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     191    psMetadataAddF64(addcorrectimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     192    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    328193
    329194    // -runs
    330195    psMetadata *runsArgs = psMetadataAlloc();
    331     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_type",  0,
    332             "search for type of detrend run", NULL);
    333     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,
    334             "use the simple output format", false);
    335     psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-active",  0,
    336             "only return active detRuns", false);
    337     psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,
    338             "limit result set to N items", 0);
    339     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_id", 0,
    340             "search for detrend ID", NULL);
    341 
    342     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-inst", 0,
    343             "search for camera (instrument)", NULL);
    344     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-telescope", 0,
    345             "search for telescope", NULL);
    346     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-filter", 0,
    347             "search for filter", NULL);
    348 
    349     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-airmass", 0,
    350             "match airmass", NAN);
    351     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-exp_time", 0,
    352             "match exp time", NAN);
    353     psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-ccd_temp", 0,
    354             "match ccd temp", NAN);
    355     psMetadataAddF64(runsArgs, PS_LIST_TAIL, "-posang", 0,
    356             "match posang", NAN);
     196    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_type",  0,            "search for type of detrend run", NULL);
     197    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     198    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-inst", 0,            "search for camera (instrument)", NULL);
     199    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-telescope", 0,            "search for telescope", NULL);
     200    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-filter", 0,            "search for filter", NULL);
     201    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-airmass", 0,            "match airmass", NAN);
     202    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-exp_time", 0,            "match exp time", NAN);
     203    psMetadataAddF32(runsArgs, PS_LIST_TAIL, "-ccd_temp", 0,            "match ccd temp", NAN);
     204    psMetadataAddF64(runsArgs, PS_LIST_TAIL, "-posang", 0,            "match posang", NAN);
     205    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     206    psMetadataAddBool(runsArgs, PS_LIST_TAIL, "-active",  0,            "only return active detRuns", false);
     207    psMetadataAddU64(runsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    357208
    358209    // -childlessrun
    359210    psMetadata *childlessrunArgs = psMetadataAlloc();
    360     psMetadataAddStr(childlessrunArgs, PS_LIST_TAIL, "-det_type",  0,
    361             "search for type of detrend run", NULL);
    362     psMetadataAddU64(childlessrunArgs, PS_LIST_TAIL, "-limit",  0,
    363             "limit result set to N items", 0);
    364     psMetadataAddBool(childlessrunArgs, PS_LIST_TAIL, "-simple",  0,
    365             "use the simple output format", false);
     211    psMetadataAddStr(childlessrunArgs, PS_LIST_TAIL, "-det_type",  0,            "search for type of detrend run", NULL);
     212    psMetadataAddU64(childlessrunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     213    psMetadataAddBool(childlessrunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    366214
    367215    // -input
    368216    psMetadata *inputArgs = psMetadataAlloc();
    369     psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-det_id", 0,
    370             "search for detrend ID", NULL);
    371     psMetadataAddS32(inputArgs, PS_LIST_TAIL, "-iteration",  0,
    372             "define iteration number", 0);
    373     psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-exp_id",  0,
    374             "search for exp ID", NULL);
    375     psMetadataAddBool(inputArgs, PS_LIST_TAIL, "-simple",  0,
    376             "use the simple output format", false);
     217    psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     218    psMetadataAddS32(inputArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     219    psMetadataAddS64(inputArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", 0);
     220    psMetadataAddBool(inputArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    377221
    378222    // -raw
    379223    psMetadata *rawArgs = psMetadataAlloc();
    380     psMetadataAddBool(rawArgs, PS_LIST_TAIL, "-simple",  0,
    381             "use the simple output format", false);
     224    psMetadataAddBool(rawArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    382225
    383226    // -toprocessedimfile
    384227    psMetadata *toprocessedimfileArgs = psMetadataAlloc();
    385     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    386             "search for detrend ID", NULL);
    387     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    388             "search for exp ID", NULL);
    389     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    390             "search for class ID", NULL);
    391     psMetadataAddU64(toprocessedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    392             "limit result set to N items", 0);
    393     psMetadataAddBool(toprocessedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    394             "use the simple output format", false);
     228    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     229    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     230    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     231    psMetadataAddU64(toprocessedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     232    psMetadataAddBool(toprocessedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    395233
    396234    // -addprocessedimfile
    397235    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    398     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    399             "define detrend ID (required)", NULL);
    400     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    401             "define exp ID (required)", NULL);
    402     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    403             "define class ID (required)", NULL);
    404     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,
    405             "define URI", NULL);
    406     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-recip",  0,
    407             "define recipe", NULL);
    408     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,
    409             "define exposure background", NAN);
    410     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    411             "define exposure background stdev", NAN);
    412     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    413             "define exposure background mean stdev", NAN);
    414     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,
    415             "define fringe slope (0th term)", NAN);
    416     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,
    417             "define fringe slope (1st term)", NAN);
    418     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,
    419             "define fringe slope (2nd term)", NAN);
    420     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    421             "define user statistic (1)", NAN);
    422     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    423             "define user statistic (2)", NAN);
    424     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    425             "define user statistic (3)", NAN);
    426     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    427             "define user statistic (4)", NAN);
    428     psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    429             "define user statistic (5)", NAN);
    430     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    431             "define base output location", NULL);
    432     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    433             "set fault code", 0);
     236    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     237    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID (required)", NULL);
     238    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     239    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     240    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
     241    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     242    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     243    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     244    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     245    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     246    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     247    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     248    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     249    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     250    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     251    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     252    psMetadataAddF64(addprocessedimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     253    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    434254
    435255    // -processedimfile
    436256    psMetadata *processedimfileArgs = psMetadataAlloc();
    437     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    438             "search for detrend ID", NULL);
    439     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    440             "search for exp ID", NULL);
    441     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    442             "search for class ID", NULL);
    443     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_state",  0,
    444             "search for state", NULL);
    445     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_mode",  0,
    446             "search for mode", NULL);
    447     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-chip",  0,
    448             "restrict results to completed 'chip' sets", false);
    449     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-exp",  0,
    450             "restrict results to complete 'exposures'", false);
    451     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,
    452             "restrict results to exposures 'includeded' in the current iteration", false);
    453     psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    454             "limit result set to N items", 0);
    455     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    456             "only return imfiles with a fault status set", false);
    457     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    458             "use the simple output format", false);
     257    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     258    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     259    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     260    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
     261    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_mode",  0,            "search for mode", NULL);
     262    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-included",  0,            "restrict results to exposures 'includeded' in the current iteration", false);
     263    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     264    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     265    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     266
     267    // XXX these don't seem to be used anymore
     268    // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-chip",  0,            "restrict results to completed 'chip' sets", false);
     269    // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-exp",  0,            "restrict results to complete 'exposures'", false);
    459270
    460271    // -revertprocessedimfile
    461272    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    462     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    463             "search for detrend ID (required)", NULL);
    464     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    465             "search by exposure ID", NULL);
    466     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    467             "search by class ID", NULL);
    468     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    469             "search by fault code", 0);
     273    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", NULL);
     274    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     275    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     276    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    470277
    471278    // -toprocessedexp
    472279    psMetadata *toprocessedexpArgs = psMetadataAlloc();
    473     psMetadataAddU64(toprocessedexpArgs, PS_LIST_TAIL, "-limit",  0,
    474             "limit result set to N items", 0);
    475     psMetadataAddBool(toprocessedexpArgs, PS_LIST_TAIL, "-simple",  0,
    476             "use the simple output format", false);
     280    psMetadataAddU64(toprocessedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     281    psMetadataAddBool(toprocessedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    477282
    478283    // -addproccessedexp
    479284    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    480     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    481             "define detrend ID (required)", NULL);
    482     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    483             "define detrend ID (required)", NULL);
    484     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-recip",  0,
    485             "define recipe", NULL);
    486     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,
    487             "define exposure background", NAN);
    488     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    489             "define exposure background stdev", NAN);
    490     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    491             "define exposure background mean stdev", NAN);
    492     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    493             "define fringe slope (0th term)", NAN);
    494     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    495             "define fringe slope (1st term)", NAN);
    496     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    497             "define fringe slope (2nd term)", NAN);
    498     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_1",  0,
    499             "define user statistic (1)", NAN);
    500     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_2",  0,
    501             "define user statistic (2)", NAN);
    502     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_3",  0,
    503             "define user statistic (3)", NAN);
    504     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_4",  0,
    505             "define user statistic (4)", NAN);
    506     psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_5",  0,
    507             "define user statistic (5)", NAN);
    508     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    509             "define base output location", NULL);
    510     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    511             "set fault code", 0);
     285    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     286    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     287    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     288    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     289    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     290    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     291    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     292    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     293    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     294    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     295    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     296    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     297    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     298    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     299    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     300    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    512301
    513302    // -proccessedexp
    514303    psMetadata *processedexpArgs = psMetadataAlloc();
    515     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    516             "define detrend ID", NULL);
    517     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    518             "define detrend ID", NULL);
    519     psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,
    520             "limit result set to N items", 0);
    521     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    522             "only return imfiles with a fault status set", false);
    523     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,
    524             "use the simple output format", false);
     304    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     305    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp ID", NULL);
     306    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     307    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     308    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    525309
    526310    // -revertprocessedexp
    527311    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    528     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    529             "search by detrend ID (required)", NULL);
    530     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    531             "search by exposure ID", NULL);
    532     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    533             "search by fault code", 0);
     312    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
     313    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     314    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    534315
    535316    // -tostacked
    536317    psMetadata *tostackedArgs = psMetadataAlloc();
    537     psMetadataAddU64(tostackedArgs, PS_LIST_TAIL, "-limit",  0,
    538             "limit result set to N items", 0);
    539     psMetadataAddBool(tostackedArgs, PS_LIST_TAIL, "-simple",  0,
    540             "use the simple output format", false);
     318    psMetadataAddU64(tostackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     319    psMetadataAddBool(tostackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    541320
    542321    // -addstacked
    543322    psMetadata *addstackedArgs = psMetadataAlloc();
    544     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,
    545             "define detrend ID (required)", NULL);
    546     psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,
    547             "define iteration number", 0);
    548     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,
    549             "define class ID (required)", NULL);
    550     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-recip",  0,
    551             "define recipe", NULL);
    552     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg",  0,
    553             "define exposure background", NAN);
    554     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    555             "define exposure background stdev", NAN);
    556     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    557             "define exposure background mean stdev", NAN);
    558     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_1",  0,
    559             "define user statistic (1)", NAN);
    560     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_2",  0,
    561             "define user statistic (2)", NAN);
    562     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_3",  0,
    563             "define user statistic (3)", NAN);
    564     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_4",  0,
    565             "define user statistic (4)", NAN);
    566     psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_5",  0,
    567             "define user statistic (5)", NAN);
    568     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,
    569             "define URI", NULL);
    570     psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-code",  0,
    571             "set fault code", 0);
     323    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     324    psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number (required)", 0);
     325    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     326    psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     327    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
     328    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     329    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     330    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     331    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     332    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     333    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     334    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     335    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     336    psMetadataAddF64(addstackedArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
    572337
    573338    // -stacked
    574339    psMetadata *stackedArgs = psMetadataAlloc();
    575     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-det_id",  0,
    576             "search for detrend ID", NULL);
    577     psMetadataAddS32(stackedArgs, PS_LIST_TAIL, "-iteration",  0,
    578             "search for iteration number", 0);
    579     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-class_id",  0,
    580             "search for class ID", NULL);
    581     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,
    582             "search for recipe", NULL);
    583     psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,
    584             "limit result set to N items", 0);
    585     psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,
    586             "only return imfiles with a fault status set", false);
    587     psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,
    588             "use the simple output format", false);
     340    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     341    psMetadataAddS32(stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     342    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     343    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     344    psMetadataAddU64(stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     345    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     346    psMetadataAddBool(stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    589347
    590348    // -revertstacked
    591349    psMetadata *revertstackedArgs= psMetadataAlloc();
    592     psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,
    593             "search for detrend ID (required)", NULL);
    594     psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,
    595             "search by iteration number", 0);
    596     psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,
    597             "search by class ID", NULL);
    598     psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,
    599             "search by fault code", 0);
     350    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", NULL);
     351    psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     352    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     353    psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     354
     355    // -tonormalizedstat
     356    psMetadata *tonormalizedstatArgs = psMetadataAlloc();
     357    psMetadataAddU64(tonormalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     358    psMetadataAddBool(tonormalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     359
     360    // -addnormalizedstat
     361    psMetadata *addnormstatArgs = psMetadataAlloc();
     362    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     363    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     364    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     365    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,            "define normal value (required)", NAN);
     366    psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     367
     368    // -normalizedstat
     369    psMetadata *normalizedstatArgs = psMetadataAlloc();
     370    psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     371    psMetadataAddS32(normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     372    psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     373    psMetadataAddU64(normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     374    psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     375    psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     376
     377    // -revertnormalizedstat
     378    psMetadata *revertnormalizedstatArgs= psMetadataAlloc();
     379    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
     380    psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     381    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     382    psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    600383
    601384    // -tonormalize
    602385    psMetadata *tonormalizeArgs = psMetadataAlloc();
    603     psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,
    604             "limit result set to N items", 0);
    605     psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,
    606             "use the simple output format", false);
    607 
    608     // -addnormalizedstat
    609     psMetadata *addnormstatArgs = psMetadataAlloc();
    610     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,
    611             "define detrend ID (required)", NULL);
    612     psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,
    613             "define iteration number", 0);
    614     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,
    615             "define class ID (required)", NULL);
    616     psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,
    617             "define normal value (required)", NAN);
    618     psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-code",  0,
    619             "set fault code", 0);
    620 
    621     // -normalizedstat
    622     psMetadata *normalizedstatArgs = psMetadataAlloc();
    623     psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,
    624             "search by detrend ID", NULL);
    625     psMetadataAddS32(normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,
    626             "search by iteration number", 0);
    627     psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,
    628             "search by class ID", NULL);
    629     psMetadataAddU64(normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,
    630             "limit result set to N items", 0);
    631     psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-faulted",  0,
    632             "only return imfiles with a fault status set", false);
    633     psMetadataAddBool(normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,
    634             "use the simple output format", false);
    635 
    636     // -revertnormalizedstat
    637     psMetadata *revertnormalizedstatArgs= psMetadataAlloc();
    638     psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,
    639             "search by detrend ID (required)", NULL);
    640     psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,
    641             "search by iteration number", 0);
    642     psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,
    643             "search by class ID", NULL);
    644     psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,
    645             "search by fault code", 0);
    646 
    647     // -tonormstat
    648     psMetadata *tonormstatArgs = psMetadataAlloc();
    649     psMetadataAddU64(tonormstatArgs, PS_LIST_TAIL, "-limit",  0,
    650             "limit result set to N items", 0);
    651     psMetadataAddBool(tonormstatArgs, PS_LIST_TAIL, "-simple",  0,
    652             "use the simple output format", false);
     386    psMetadataAddU64(tonormalizeArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     387    psMetadataAddBool(tonormalizeArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    653388
    654389    // -addnormalizedimfile
    655390    psMetadata *addnormalizedimfileArgs = psMetadataAlloc();
    656     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    657             "define detrend ID (required)", NULL);
    658     psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    659             "define iteration number", 0);
    660     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    661             "define class ID (required)", NULL);
    662     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-uri", 0,
    663             "define URI", NULL);
    664     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg", 0,
    665             "define exposure background", NAN);
    666     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_stdev", 0,
    667             "define exposure background stdev", NAN);
    668     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,
    669             "define exposure background mean stdev", NAN);
    670     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    671             "define user statistic (1)", NAN);
    672     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    673             "define user statistic (2)", NAN);
    674     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    675             "define user statistic (3)", NAN);
    676     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    677             "define user statistic (4)", NAN);
    678     psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    679             "define user statistic (5)", NAN);
    680     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-path_base", 0,
    681             "define base output location", NULL);
    682     psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
    683             "set fault code", 0);
     391    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "define detrend ID (required)", NULL);
     392    psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "define iteration number", 0);
     393    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "define class ID (required)", NULL);
     394    psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     395    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI", NULL);
     396    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
     397    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_stdev", 0,            "define exposure background stdev", NAN);
     398    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev", 0,            "define exposure background mean stdev", NAN);
     399    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     400    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     401    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     402    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     403    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     404    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
    684405
    685406    // -normalizedimfile
    686407    psMetadata *normalizedimfileArgs = psMetadataAlloc();
    687     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    688             "search for detrend ID", NULL);
    689     psMetadataAddS32(normalizedimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    690             "search for iteration number", 0);
    691     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    692             "search for class ID", NULL);
    693     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,
    694             "search for recipe", NULL);
    695     psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    696             "limit result set to N items", 0);
    697     psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    698             "only return imfiles with a fault status set", false);
    699     psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    700             "use the simple output format", false);
     408    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     409    psMetadataAddS32(normalizedimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     410    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     411    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     412    psMetadataAddU64(normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     413    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     414    psMetadataAddBool(normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    701415
    702416    // -revertnormalizedimfile
    703417    psMetadata *revertnormalizedimfileArgs = psMetadataAlloc();
    704     psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    705             "search by detrend ID (required)", NULL);
    706     psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    707             "search by iteration number", 0);
    708     psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,
    709             "search by class ID", NULL);
    710     psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,
    711             "search by fault code", 0);
     418    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     419    psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     420    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
     421    psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    712422
    713423    // -tonormalizedexp
    714424    psMetadata *tonormalizedexpArgs = psMetadataAlloc();
    715     psMetadataAddU64(tonormalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
    716             "limit result set to N items", 0);
    717     psMetadataAddBool(tonormalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
    718             "use the simple output format", false);
     425    psMetadataAddU64(tonormalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     426    psMetadataAddBool(tonormalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    719427
    720428    // -addnormalizedexp
    721429    psMetadata *addnormalizedexpArgs = psMetadataAlloc();
    722     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    723             "define detrend ID (required)", NULL);
    724     psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,
    725             "define iteration number", 0);
    726     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-recip",  0,
    727             "search for recipe", NULL);
    728     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg",  0,
    729             "define exposure background", NAN);
    730     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    731             "define exposure background stdev", NAN);
    732     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    733             "define exposure background mean stdev", NAN);
    734 
    735     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_1",  0,
    736             "define user statistic (1)", NAN);
    737     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_2",  0,
    738             "define user statistic (2)", NAN);
    739     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_3",  0,
    740             "define user statistic (3)", NAN);
    741     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_4",  0,
    742             "define user statistic (4)", NAN);
    743     psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_5",  0,
    744             "define user statistic (5)", NAN);
    745 
    746     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    747             "define base output location", NULL);
    748     psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
    749             "set fault code", 0);
     430    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     431    psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     432    psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     433    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     434    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     435    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     436    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     437    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     438    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     439    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     440    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     441    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     442    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    750443
    751444    // -normalizedexp
    752445    psMetadata *normalizedexpArgs = psMetadataAlloc();
    753     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,
    754             "define detrend ID", NULL);
    755     psMetadataAddS32(normalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,
    756             "define iteration number", 0);
    757     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-recip",  0,
    758             "search for recipe", NULL);
    759     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg",  0,
    760             "define exposure background", NAN);
    761     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    762             "define exposure background stdev", NAN);
    763     psMetadataAddF64(normalizedexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    764             "define exposure background mean stdev", NAN);
    765     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-path_base",  0,
    766             "define base output location", NULL);
    767     psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,
    768             "limit result set to N items", 0);
    769     psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    770             "only return imfiles with a fault status set", false);
    771     psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,
    772             "use the simple output format", false);
     446    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     447    psMetadataAddS32(normalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     448    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     449    psMetadataAddU64(normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     450    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     451    psMetadataAddBool(normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    773452
    774453    // -revertnormalizedexp
    775454    psMetadata *revertnormalizedexpArgs = psMetadataAlloc();
    776     psMetadataAddStr(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,
    777             "search by detrend ID (required)", NULL);
    778     psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,
    779             "search by iteration number", 0);
    780     psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,
    781             "search by fault code", 0);
     455    psMetadataAddStr(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     456    psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     457    psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    782458
    783459    // -toresidimfile
    784460    psMetadata *toresidimfileArgs = psMetadataAlloc();
    785     psMetadataAddU64(toresidimfileArgs, PS_LIST_TAIL, "-limit",  0,
    786             "limit result set to N items", 0);
    787     psMetadataAddBool(toresidimfileArgs, PS_LIST_TAIL, "-simple",  0,
    788             "use the simple output format", false);
     461    psMetadataAddU64(toresidimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     462    psMetadataAddBool(toresidimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     463
     464    // -addresidimfile
     465    psMetadata *addresidimfileArgs = psMetadataAlloc();
     466    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     467    psMetadataAddS32(addresidimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     468    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     469    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     470    psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     471    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
     472    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     473    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     474    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     475    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     476    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_skewness",  0,            "define exposure background skewness", NAN);
     477    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,            "define exposure background kurtosis", NAN);
     478    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bin_stdev",  0,            "define exposure background binned stdev", NAN);
     479    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     480    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     481    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     482    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,            "define fringe residual (0th term)", NAN);
     483    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,            "define fringe residual (1st term)", NAN);
     484    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,            "define fringe residual (2nd term)", NAN);
     485    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     486    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     487    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     488    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     489    psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     490    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     491
     492    // -residimfile
     493    psMetadata *residimfileArgs = psMetadataAlloc();
     494    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     495    psMetadataAddS32(residimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     496    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     497    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
     498    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     499    psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     500    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     501    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     502    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
     503
     504    // -revertresidimfile
     505    psMetadata *revertresidimfileArgs =  psMetadataAlloc();
     506    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,          "search by detrend ID (required)", NULL);
     507    psMetadataAddS32(revertresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
     508    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,         "search by detrend ID", NULL);
     509    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,       "search for class ID", NULL);
     510    psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,           "search by fault code", 0);
    789511
    790512    // -toresidexp
    791513    psMetadata *toresidexpArgs = psMetadataAlloc();
    792     psMetadataAddU64(toresidexpArgs, PS_LIST_TAIL, "-limit",  0,
    793             "limit result set to N items", 0);
    794     psMetadataAddBool(toresidexpArgs, PS_LIST_TAIL, "-simple",  0,
    795             "use the simple output format", false);
    796 
    797     // -addresidimfile
    798     psMetadata *addresidimfileArgs = psMetadataAlloc();
    799     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    800             "define detrend ID (required)", NULL);
    801     psMetadataAddS32(addresidimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    802             "define iteration number", 0);
    803     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    804             "define detrend ID (required)", NULL);
    805     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    806             "define class ID (required)", NULL);
    807     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-uri",  0,
    808             "define resid file URI", NULL);
    809     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-recip",  0,
    810             "define recipe", NULL);
    811     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg",  0,
    812             "define exposure background", NAN);
    813     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    814             "define exposure background stdev", NAN);
    815     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    816             "define exposure background mean stdev", NAN);
    817     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_skewness",  0,
    818             "define exposure background skewness", NAN);
    819     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,
    820             "define exposure background kurtosis", NAN);
    821     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-bin_stdev",  0,
    822             "define exposure background binned stdev", NAN);
    823     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_0",  0,
    824             "define fringe slope (0th term)", NAN);
    825     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_1",  0,
    826             "define fringe slope (1st term)", NAN);
    827     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_2",  0,
    828             "define fringe slope (2nd term)", NAN);
    829     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,
    830             "define fringe residual (0th term)", NAN);
    831     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,
    832             "define fringe residual (1st term)", NAN);
    833     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,
    834             "define fringe residual (2nd term)", NAN);
    835     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_1",  0,
    836             "define user statistic (1)", NAN);
    837     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_2",  0,
    838             "define user statistic (2)", NAN);
    839     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_3",  0,
    840             "define user statistic (3)", NAN);
    841     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_4",  0,
    842             "define user statistic (4)", NAN);
    843     psMetadataAddF64(addresidimfileArgs, PS_LIST_TAIL, "-user_5",  0,
    844             "define user statistic (5)", NAN);
    845     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    846             "define base output location", NULL);
    847     psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,
    848             "set fault code", 0);
    849 
    850     // -residimfile
    851     psMetadata *residimfileArgs = psMetadataAlloc();
    852     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,
    853             "search for detrend ID", NULL);
    854     psMetadataAddS32(residimfileArgs, PS_LIST_TAIL, "-iteration",  0,
    855             "search for iteration number", 0);
    856     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    857             "define detrend ID", NULL);
    858     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    859             "search for class ID", NULL);
    860     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,
    861             "search for recipe", NULL);
    862     psMetadataAddU64(residimfileArgs, PS_LIST_TAIL, "-limit",  0,
    863             "limit result set to N items", 0);
    864     psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    865             "only return imfiles with a fault status set", false);
    866     psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,
    867             "use the simple output format", false);
    868     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-select_state",  0,
    869             "search for state", NULL);
    870 
    871     // -revertresidimfile
    872     psMetadata *revertresidimfileArgs =  psMetadataAlloc();
    873     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,
    874             "search by detrend ID (required)", NULL);
    875     psMetadataAddS32(revertresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,
    876             "search by iteration number", 0);
    877     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    878             "search by detrend ID", NULL);
    879     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    880             "search for class ID", NULL);
    881     psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,
    882             "search by fault code", 0);
     514    psMetadataAddU64(toresidexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     515    psMetadataAddBool(toresidexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    883516
    884517    // -addresidexp
    885518    psMetadata *addresidexpArgs = psMetadataAlloc();
    886     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,
    887             "define detrend ID (required)", NULL);
    888     psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,
    889             "define iteration number", 0);
    890     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    891             "define detrend ID (required)", NULL);
    892     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,
    893             "define recipe", NULL);
    894     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg",  0,
    895             "define exposure background", NAN);
    896     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    897             "define exposure background stdev", NAN);
    898     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    899             "define exposure background mean stdev", NAN);
    900     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_skewness",  0,
    901             "define exposure background skewness", NAN);
    902     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,
    903             "define exposure background kurtosis", NAN);
    904     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bin_stdev",  0,
    905             "define exposure background binned stdev", NAN);
    906     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_0",  0,
    907             "define fringe slope (0th term)", NAN);
    908     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_1",  0,
    909             "define fringe slope (1st term)", NAN);
    910     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_2",  0,
    911             "define fringe slope (2nd term)", NAN);
    912     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,
    913             "define fringe residual (0th term)", NAN);
    914     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,
    915             "define fringe residual (1st term)", NAN);
    916     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,
    917             "define fringe residual (2nd term)", NAN);
    918     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_1",  0,
    919             "define user statistic (1)", NAN);
    920     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_2",  0,
    921             "define user statistic (2)", NAN);
    922     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_3",  0,
    923             "define user statistic (3)", NAN);
    924     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_4",  0,
    925             "define user statistic (4)", NAN);
    926     psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_5",  0,
    927             "define user statistic (5)", NAN);
    928     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-path_base",  0,
    929             "define base output location", NULL);
    930     psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,
    931             "set fault code", 0);
    932     psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,
    933             "exposure is not to be stacked in the next iteration", false);
     519    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     520    psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     521    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     522    psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     523    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     524    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     525    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     526    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     527    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_skewness",  0,            "define exposure background skewness", NAN);
     528    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg_kurtosis",  0,            "define exposure background kurtosis", NAN);
     529    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bin_stdev",  0,            "define exposure background binned stdev", NAN);
     530    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_0",  0,            "define fringe slope (0th term)", NAN);
     531    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_1",  0,            "define fringe slope (1st term)", NAN);
     532    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_2",  0,            "define fringe slope (2nd term)", NAN);
     533    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_0",  0,            "define fringe residual (0th term)", NAN);
     534    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_1",  0,            "define fringe residual (1st term)", NAN);
     535    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-fringe_resid_2",  0,            "define fringe residual (2nd term)", NAN);
     536    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     537    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     538    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     539    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     540    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     541    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     542    psMetadataAddBool(addresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    934543
    935544    // -residexp
    936545    psMetadata *residexpArgs = psMetadataAlloc();
    937     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-det_id",  0,
    938             "search for detrend ID", NULL);
    939     psMetadataAddS32(residexpArgs, PS_LIST_TAIL, "-iteration",  0,
    940             "search for iteration number", 0);
    941     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    942             "search for exp ID", NULL);
    943     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,
    944             "search for recipe", NULL);
    945     psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,
    946             "limit result set to N items", 0);
    947     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,
    948             "only return imfiles with a fault status set", false);
    949     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,
    950             "search for acceptable residuals", false);
    951     psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-simple",  0,
    952             "use the simple output format", false);
     546    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     547    psMetadataAddS32(residexpArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     548    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     549    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
     550    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,            "search for acceptable residuals", false);
     551    psMetadataAddU64(residexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     552    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     553    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    953554
    954555    // -revertresidexp
    955556    psMetadata *revertresidexpArgs = psMetadataAlloc();
    956     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,
    957             "search by detrend ID (required)", NULL);
    958     psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,
    959             "search by iteration number", 0);
    960     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    961             "search by detrend ID", NULL);
    962     psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,
    963             "search by fault code", 0);
     557    psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     558    psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     559    psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     560    psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     561
     562    // -updateresidexp
     563    psMetadata *updateresidexpArgs = psMetadataAlloc();
     564    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID", NULL);
     565    psMetadataAddS32(updateresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     566    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID", NULL);
     567    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
     568    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     569    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     570    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     571    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     572    psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
    964573
    965574    // -todetrunsummary
    966575    psMetadata *todetrunsummaryArgs = psMetadataAlloc();
    967     psMetadataAddBool(todetrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
    968             "use the simple output format", false);
    969     psMetadataAddU64(todetrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,
    970             "limit result set to N items", 0);
    971 
    972     // -updateresidexp
    973     psMetadata *updateresidexpArgs = psMetadataAlloc();
    974     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,
    975             "define detrend ID", NULL);
    976     psMetadataAddS32(updateresidexpArgs, PS_LIST_TAIL, "-iteration",  0,
    977             "define iteration number", 0);
    978     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,
    979             "define exp ID", NULL);
    980     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-recip",  0,
    981             "define recipe", NULL);
    982     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg",  0,
    983             "define exposure background", NAN);
    984     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    985             "define exposure background stdev", NAN);
    986     psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    987             "define exposure background mean stdev", NAN);
    988     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,
    989             "define base output location", NULL);
    990     psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,
    991             "exposure is not to be stacked in the next iteration", false);
     576    psMetadataAddBool(todetrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     577    psMetadataAddU64(todetrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    992578
    993579    // -adddetrunsummary
    994580    psMetadata *adddetrunsummaryArgs = psMetadataAlloc();
    995     psMetadataAddStr(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
    996             "define detrend ID (required)", NULL);
    997     psMetadataAddS32(adddetrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
    998             "define iteration number", 0);
    999     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg",  0,
    1000             "define exposure background", NAN);
    1001     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    1002             "define exposure background stdev", NAN);
    1003     psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    1004             "define exposure background mean stdev", NAN);
    1005     psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
    1006             "set fault code", 0);
    1007     psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,
    1008             "declare that this detrun iteration is accepted as a master", false);
    1009     psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-again",  0,
    1010             "start a new iteration of this detrend run", false);
     581    psMetadataAddStr(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     582    psMetadataAddS32(adddetrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
     583    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     584    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     585    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     586    psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     587    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
     588    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
    1011589
    1012590    // -detrunsummary
    1013591    psMetadata *detrunsummaryArgs = psMetadataAlloc();
    1014     psMetadataAddStr(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,
    1015             "search for detrend ID", NULL);
    1016     psMetadataAddU64(detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,
    1017                      "limit result set to N items", 0);
    1018     psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,
    1019             "search for iteration number", 0);
    1020     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,
    1021             "only return imfiles with a fault status set", false);
    1022     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,
    1023             "search for acceptable residuals", false);
    1024     psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,
    1025             "use the simple output format", false);
     592    psMetadataAddStr(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     593    psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
     594    psMetadataAddU64(detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,                     "limit result set to N items", 0);
     595    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     596    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     597    psMetadataAddBool(detrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "search for acceptable residuals", false);
    1026598
    1027599    // -revertdetrunsummary
    1028600    psMetadata *revertdetrunsummaryArgs = psMetadataAlloc();
    1029     psMetadataAddStr(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,
    1030             "search by detrend ID (required)", NULL);
    1031     psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,
    1032             "search by iteration number", 0);
    1033     psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,
    1034             "search by fault code", 0);
     601    psMetadataAddStr(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     602    psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     603    psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    1035604
    1036605    // -updatedetrunsummary
    1037606    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);
     607    psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     608    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
     609    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "reject this detrun iteration as a master", false);
    1044610
    1045611    // -updatedetrun
    1046612    psMetadata *updatedetrunArgs = psMetadataAlloc();
    1047     psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,
    1048             "search for detrend master for detrend ID (required)", NULL);
    1049     psMetadataAddBool(updatedetrunArgs, PS_LIST_TAIL, "-again",  0,
    1050             "start a new iteration of this detrend run", false);
    1051     psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-state",  0,
    1052             "set the state of this detrend run", false);
     613    psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     614    psMetadataAddBool(updatedetrunArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
     615    psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-state",  0,            "set the state of this detrend run", false);
    1053616
    1054617    // -rerun
    1055618    psMetadata *rerunArgs = psMetadataAlloc();
    1056     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-det_id",  0,
    1057             "search for detrend master for detrend ID (required)", NULL);
    1058     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,
    1059             "include this exposure (multiple OK, required)", NULL);
     619    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     620    psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,            "include this exposure (multiple OK, required)", NULL);
    1060621
    1061622    // -register_detrend
    1062623    psMetadata *register_detrendArgs = psMetadataAlloc();
    1063     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-det_type",  0,
    1064             "define the type of detrend run (required)", NULL);
    1065     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-mode",  0,
    1066             "define the mode of this detrend run", "master");
    1067     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filelevel",  0,
    1068             "define filelevel (required)", NULL);
    1069     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,
    1070             "define workdir", NULL);
    1071     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-inst",  0,
    1072             "define camera", NULL);
    1073     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-telescope",  0,
    1074             "define telescope", NULL);
    1075     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-exp_type",  0,
    1076             "define exposure type", NULL);
    1077     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filter",  0,
    1078             "define filter ", NULL);
    1079     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_min",  0,
    1080             "define min airmass", NAN);
    1081     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_max",  0,
    1082             "define max airmass", NAN);
    1083     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    1084             "define min exposure time", NAN);
    1085     psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    1086             "define max exposure time", NAN);
    1087     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    1088             "define min ccd tempature", NAN);
    1089     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    1090             "define max ccd tempature", NAN);
    1091     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,
    1092             "define min rotator position angle", NAN);
    1093     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,
    1094             "define max rotator position angle", NAN);
    1095     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,
    1096             "define min solar angle", NAN);
    1097     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,
    1098             "define max solar angle", NAN);
    1099     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,
    1100             "time detrend run was registered", now);
    1101     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,
    1102             "detrend applies to exposures taken during this period", NULL);
    1103     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,
    1104             "detrend applies to exposures taken during this period", NULL);
    1105     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,
    1106             "start of detrend run applicable period", NULL);
    1107     psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,
    1108             "end of detrend run applicable period", NULL);
    1109     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,
    1110             "define parent det_id", NULL);
    1111     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-label",  0,
    1112             "define detrun label", NULL);
    1113     psMetadataAddBool(register_detrendArgs, PS_LIST_TAIL, "-simple",  0,
    1114             "use the simple output format", false);
     624    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
     625    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filelevel",  0,            "define filelevel (required)", NULL);
     626    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir", NULL);
     627    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-inst",  0,            "define camera", NULL);
     628    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-telescope",  0,            "define telescope", NULL);
     629    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-exp_type",  0,            "define exposure type", NULL);
     630    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-filter",  0,            "define filter ", NULL);
     631    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     632    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     633    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min exposure time", NAN);
     634    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max exposure time", NAN);
     635    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     636    psMetadataAddF32(register_detrendArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     637    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     638    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     639    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     640    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     641    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     642    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
     643    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_end",  0,            "detrend applies to exposures taken during this period", NULL);
     644    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
     645    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
     646    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,            "define parent det_id", NULL);
     647    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
     648    psMetadataAddBool(register_detrendArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    1115649
    1116650    // -register_detrend_imfile
    1117651    psMetadata *register_detrend_imfileArgs = psMetadataAlloc();
    1118     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,
    1119             "define detrend ID (required)", NULL);
    1120     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-class_id",  0,
    1121             "search for class ID (required)", NULL);
    1122     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-uri",  0,
    1123             "define resid file URI (required)", NULL);
    1124     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg",  0,
    1125             "define exposure background", NAN);
    1126     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    1127             "define exposure background stdev", NAN);
    1128     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,
    1129             "define exposure background mean stdev", NAN);
    1130     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_1",  0,
    1131             "define user statistic (1)", NAN);
    1132     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_2",  0,
    1133             "define user statistic (2)", NAN);
    1134     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_3",  0,
    1135             "define user statistic (3)", NAN);
    1136     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_4",  0,
    1137             "define user statistic (4)", NAN);
    1138     psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_5",  0,
    1139             "define user statistic (5)", NAN);
    1140     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-path_base",  0,
    1141             "define base output location", NULL);
     652    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     653    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
     654    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI (required)", NULL);
     655    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     656    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     657    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
     658    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_1",  0,            "define user statistic (1)", NAN);
     659    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_2",  0,            "define user statistic (2)", NAN);
     660    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_3",  0,            "define user statistic (3)", NAN);
     661    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_4",  0,            "define user statistic (4)", NAN);
     662    psMetadataAddF64(register_detrend_imfileArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
     663    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    1142664
    1143665    psFree(now);
    … …  
    1175697    PXOPT_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
    1176698
    1177     PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
     699    PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormalizedstatArgs);
    1178700    PXOPT_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
    1179701    PXOPT_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
    … …  
    1213735    psFree(modes);
    1214736
    1215     // setup search criterion
    1216 #define addWhereStr(name) \
    1217 { \
    1218     psString str = NULL; \
    1219     bool status = false; \
    1220     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    1221         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    1222             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    1223             psFree(config); \
    1224             return NULL; \
    1225         } \
    1226     } \
    1227 }
    1228 
    1229     // generate SQL where clause
    1230     config->where = psMetadataAlloc();
    1231 
    1232     addWhereStr(det_id);
    1233     {
    1234         // XXX this is broke because you can't specify -iteration 0
    1235         psMetadataItem *item = psMetadataLookup(config->args, "-iteration");
    1236         if (item && psStrcasestr(item->comment, "found")) {
    1237             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", item->data.S32)) {
    1238                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    1239                 psFree(config);
    1240                 return NULL;
    1241             }
    1242         }
    1243     }
    1244     addWhereStr(det_type);
    1245     addWhereStr(exp_id);
    1246     addWhereStr(class_id);
    1247     // convert '-inst' to 'camera'
    1248     {
    1249         psString str = NULL;
    1250         bool status = false;
    1251         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    1252             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    1253                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    1254                 psFree(config);
    1255                 return NULL;
    1256             }
    1257         }
    1258     }
    1259     addWhereStr(telescope);
    1260     addWhereStr(exp_type);
    1261     {
    1262         int n = 0;
    1263         bool status = false;
    1264         if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    1265             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    1266                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    1267                 psFree(config);
    1268                 return NULL;
    1269             }
    1270         }
    1271     }
    1272     addWhereStr(filter);
    1273     addWhereStr(recipe);
    1274     {
    1275         int n = 0;
    1276         bool status = false;
    1277         if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    1278             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    1279                 psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    1280                 psFree(config);
    1281                 return NULL;
    1282             }
    1283         }
    1284     }
    1285     {
    1286         bool boolean = false;
    1287         bool status = false;
    1288 
    1289         // map reject -> !accept
    1290         if ((boolean = psMetadataLookupBool(&status, config->args, "-reject"))) {
    1291             if (!psMetadataAddBool(config->where, PS_LIST_TAIL, "accept", 0, "==", !boolean)) {
    1292                 psError(PS_ERR_UNKNOWN, false, "failed to add item reject");
    1293                 psFree(config);
    1294                 return NULL;
    1295             }
    1296         }
    1297     }
    1298 
    1299     // convert '-code' to 'fault'
    1300     {
    1301         psS16 fault = 0;
    1302         bool status = false;
    1303         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    1304             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    1305                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    1306                 psFree(config);
    1307                 return NULL;
    1308             }
    1309         }
    1310     }
    1311 
    1312     if (config->where->list->n < 1) {
    1313         psFree(config->where);
    1314         config->where = NULL;
    1315     }
    1316 
    1317737    // define Database handle, if used
    1318738    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/dettool_correction.c

    r18336 r18561  
    1818 */
    1919
    20 #ifdef HAVB_CONFIG_H
    21 #include <config.h>
    22 #endif
    23 
    24 #include <stdio.h>
    25 #include <string.h>
    26 #include <stdlib.h>
    27 #include <stdint.h>
    28 #include <inttypes.h>
    29 
    30 #include <ippdb.h>
    31 
    32 #include "pxtools.h"
    3320#include "dettool.h"
    3421
    … …  
    3724    PS_ASSERT_PTR_NON_NULL(config, false);
    3825
    39     bool status     = false;
    40     psString det_id = psMetadataLookupStr(&status, config->args, "-det_id");
    41     if (!status) {
    42         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -det_id");
    43         return false;
    44     }
    45     if (!det_id) {
    46         psError(PS_ERR_UNKNOWN, true, "-det_id is required");
    47         return false;
    48     }
    49 
    50     psArray *runs = detRunSelectRowObjects(config->dbh, config->where, 1);
     26    PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     27    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); // optional
     28
     29    // build the needed where
     30    psMetadata *where = psMetadataAlloc();
     31    psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", (psS64)atoll(det_id));
     32    psArray *runs = detRunSelectRowObjects(config->dbh, where, 1);
     33    psFree (where);
     34
    5135    if (!psArrayLength(runs)) {
    5236        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    10387    }
    10488
    105     psArray *detRuns = NULL;
    106     {
    107         psMetadata *where = psMetadataAlloc();
    108         psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", new_det_id);
    109         detRuns = psDBSelectRows(config->dbh, "detRun", where, 0);
    110         psFree(where);
    111     }
     89    psMetadata *where_new = psMetadataAlloc();
     90    psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", new_det_id);
     91    psArray *detRuns = psDBSelectRows(config->dbh, "detRun", where_new, 0);
     92    psFree(where_new);
     93
    11294    if (!detRuns) {
    11395        psError(PS_ERR_UNKNOWN, false, "can't find the detRun we just created");
    … …  
    118100        psAbort("found more then one detRun matching det_id %" PRId64 "(this should not happen)", new_det_id);
    119101        return false;
    120     }
    121 
    122     bool simple = false;
    123     {
    124         bool status = false;
    125         simple = psMetadataLookupBool(&status, config->args, "-simple");
    126         if (!status) {
    127             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    128             return false;
    129         }
    130102    }
    131103
    … …  
    145117    PS_ASSERT_PTR_NON_NULL(config, false);
    146118
    147     bool status = false;
    148     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    149     if (!status) {
    150         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    151         return false;
    152     }
     119    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     120    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    153121
    154122    psString query = pxDataGet("dettool_tocorrectexp.sql");
    … …  
    183151    }
    184152
    185     bool simple = false;
    186     {
    187         bool status = false;
    188         simple = psMetadataLookupBool(&status, config->args, "-simple");
    189         if (!status) {
    190             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    191             return false;
    192         }
    193     }
    194 
    195153    // negative simple so the default is true
    196154    if (!ippdbPrintMetadatas(stdout, output, "detRun", !simple)) {
    … …  
    209167    PS_ASSERT_PTR_NON_NULL(config, false);
    210168
    211     bool status = false;
    212     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    213     if (!status) {
    214         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    215         return false;
    216     }
     169    psMetadata *where = psMetadataAlloc();
     170    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
     171
     172    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     173    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    217174
    218175    psString query = pxDataGet("dettool_tocorrectimfile.sql");
    … …  
    222179    }
    223180
    224     if (config->where) {
    225         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "det1");
     181    if (psListLength(where->list)) {
     182        // NOTE the SQL uses an intermediate table 'det1' for this query
     183        psString whereClause = psDBGenerateWhereConditionSQL(where, "det1");
    226184        psStringAppend(&query, " AND %s", whereClause);
    227185        psFree(whereClause);
    228186    }
     187    psFree (where);
    229188
    230189    // treat limit == 0 as "no limit"
    … …  
    253212    }
    254213
    255     bool simple = false;
    256     {
    257         bool status = false;
    258         simple = psMetadataLookupBool(&status, config->args, "-simple");
    259         if (!status) {
    260             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    261             return false;
    262         }
    263     }
    264 
    265214    // negative simple so the default is true
    266215    if (!ippdbPrintMetadatas(stdout, output, "detPendingCorrectImfile", !simple)) {
    … …  
    275224}
    276225
     226// NOTE : the command-line args are parsed by register_detrend_imfileMode
    277227bool addcorrectimfileMode(pxConfig *config)
    278228{

  • trunk/ippTools/src/difftool.c

    r18336 r18561  
    104104
    105105    // default
     106    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    106107    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    107     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    108108
    109109    diffRunRow *run = diffRunRowAlloc(
    … …  
    282282    PS_ASSERT_PTR_NON_NULL(config, false);
    283283
     284    psMetadata *where = psMetadataAlloc();
     285
     286    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     287    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     288    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     289    PXOPT_COPY_STR(config->args, where,  "-tess_id", "tess_id", "==");
     290    PXOPT_COPY_STR(config->args, where,  "-kind", "kind", "==");
     291
    284292    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    285293    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     294    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    286295
    287296    // find all rawImfiles matching the default query
    … …  
    292301    }
    293302
    294     if (config->where) {
    295         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    296         psStringAppend(&query, " %s", whereClause);
     303    if (template) {
     304        // list only faulted rows
     305        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template != 0");
     306    } else {
     307        // don't list faulted rows
     308        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template = 0");
     309    }
     310
     311    if (psListLength(where->list)) {
     312        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     313        psStringAppend(&query, " AND %s", whereClause);
    297314        psFree(whereClause);
    298315    }
     316    psFree(where);
    299317
    300318    // treat limit == 0 as "no limit"
    … …  
    351369    PS_ASSERT_PTR_NON_NULL(config, false);
    352370
     371    psMetadata *where = psMetadataAlloc();
     372    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     373
    353374    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    354375    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    360381    }
    361382
    362     if (config->where) {
    363         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     383    if (psListLength(where->list)) {
     384        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    364385        psStringAppend(&query, " AND %s", whereClause);
    365386        psFree(whereClause);
    366387    }
     388    psFree(where);
    367389
    368390    // treat limit == 0 as "no limit"
    … …  
    418440{
    419441    PS_ASSERT_PTR_NON_NULL(config, false);
    420 
    421     // required
    422     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    423 
    424     // default to 0
     442   
     443    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false); // required
    425444    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    426 
    427     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
    428     if (code == 0 && !uri) {
    429         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    430         return false;
    431     }
    432 
    433     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    434     if (code == 0 && !path_base) {
    435         psError(PS_ERR_UNKNOWN, true, "-path_base is required");
    436         return false;
    437     }
     445    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
     446    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (code == 0), false);
    438447
    439448    // optional
    … …  
    441450    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    442451    PXOPT_LOOKUP_F32(dtime_diff, config->args, "-dtime_diff", false, false);
    443     PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    444     PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    445452    PXOPT_LOOKUP_S32(stamps_num, config->args, "-stamps_num", false, false);
    446453    PXOPT_LOOKUP_F32(stamps_rms, config->args, "-stamps_rms", false, false);
    447454    PXOPT_LOOKUP_S32(sources, config->args, "-sources", false, false);
     455    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
     456    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    448457
    449458    if (!psDBTransaction(config->dbh)) {
    … …  
    495504    PS_ASSERT_PTR_NON_NULL(config, false);
    496505
     506    psMetadata *where = psMetadataAlloc();
     507    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     508    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     509    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
     510
    497511    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    498512    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    504518    }
    505519
    506     if (config->where) {
    507         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     520    if (psListLength(where->list)) {
     521        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    508522        psStringAppend(&query, " AND %s", whereClause);
    509523        psFree(whereClause);
    510524    }
     525    psFree(where);
    511526
    512527    // treat limit == 0 as "no limit"
    … …  
    563578    PS_ASSERT_PTR_NON_NULL(config, false);
    564579
     580    psMetadata *where = psMetadataAlloc();
     581    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     582    PXOPT_COPY_S16(config->args, where, "-code",     "fault", "==");
     583
    565584    psString query = pxDataGet("difftool_revertdiffskyfile.sql");
    566585    if (!query) {
    … …  
    569588    }
    570589
    571     if (config->where) {
    572         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "diffSkyfile");
     590    if (psListLength(where->list)) {
     591        psString whereClause = psDBGenerateWhereConditionSQL(where, "diffSkyfile");
    573592        psStringAppend(&query, " AND %s", whereClause);
    574593        psFree(whereClause);
    575594    }
     595    psFree(where);
    576596
    577597    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    741761    PS_ASSERT_PTR_NON_NULL(config, false);
    742762
    743     // required options
    744     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    745     PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    746     PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    747 
    748     // optional
     763    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
     764    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false); // required options
     765    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
     766    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    749767    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);
     768    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
     769    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    751770
    752771    if (template_stack_id && template_warp_id) {
    … …  
    760779    }
    761780
    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);
    764781    if (input_stack_id && input_warp_id) {
    765782        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Only one input can be defined.");
    … …  
    787804    PS_ASSERT_PTR_NON_NULL(config, false);
    788805
    789     // required options
    790     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    791 
    792     // default
     806    psMetadata *where = psMetadataAlloc();
     807
     808    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diff_id", "==");
     809    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     810    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     811    PXOPT_COPY_STR(config->args, where,  "-tess_id", "tess_id", "==");
     812    PXOPT_COPY_STR(config->args, where,  "-kind", "kind", "==");
     813    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
     814    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     815    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    793816    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    794     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    795817
    796818    // find all things to queue
    … …  
    801823    }
    802824
    803     if (config->where) {
    804         psString whereClause = psDBGenerateWhereSQL(config->where, NULL);
    805         psStringAppend(&query, " %s", whereClause);
     825    if (template) {
     826        // list only faulted rows
     827        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template != 0");
     828    } else {
     829        // don't list faulted rows
     830        psStringAppend(&query, " %s", "WHERE diffInputSkyfile.template = 0");
     831    }
     832
     833    if (psListLength(where->list)) {
     834        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     835        psStringAppend(&query, " AND %s", whereClause);
    806836        psFree(whereClause);
    807837    }
     838    psFree(where);
    808839
    809840    if (!p_psDBRunQuery(config->dbh, query)) {

  • trunk/ippTools/src/difftoolConfig.c

    r18518 r18561  
    4747    // -definerun
    4848    psMetadata *definerunArgs = psMetadataAlloc();
    49     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    50             "define workdir (required)", NULL);
    51     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    52             "time detrend run was registered", now);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    54             "define skycell ID (required)", NULL);
    55     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    56             "define tessellation ID (required)", NULL);
    57     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    58             "use the simple output format", false);
     49    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     50    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     51    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     52    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     53    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    5954
    6055    // -updaterun
    6156    psMetadata *updaterunArgs = psMetadataAlloc();
    62     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,
    63             "define diff ID (required)", 0);
    64     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    65             "set state (required)", NULL);
    66 #if 0
    67     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    68             "define workdir (required)", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    70             "time detrend run was registered", now);
    71 #endif
     57    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
     58    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    7259
    7360    // -addinputskyfile
    7461    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    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);
    81     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    82             "define kind", NULL);
    83     psMetadataAddBool(addinputskyfileArgs, PS_LIST_TAIL, "-template",  0,
    84             "this sky cell file is the subtrahend", false);
     62    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define diff ID (required)", 0);
     63    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID", 0);
     64    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warp ID", 0);
     65    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-kind", 0,            "define kind", NULL);
     66    psMetadataAddBool(addinputskyfileArgs, PS_LIST_TAIL, "-template",  0,            "this sky cell file is the subtrahend", false);
    8567
    8668    // -inputskyfile
    8769    psMetadata *inputskyfileArgs = psMetadataAlloc();
    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);
    92     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,
    93             "search by skycell ID", NULL);
    94     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,
    95             "search by tess ID", NULL);
    96     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-kind", 0,
    97             "search by kind", NULL);
    98     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-template",  0,
    99             "search by subtrahend", false);
    100     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    101             "limit result set to N items", 0);
    102     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    103             "use the simple output format", false);
     70    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     71    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     72    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     73    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     74    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-kind", 0,            "search by kind", NULL);
     75    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-template",  0,            "search by subtrahend", false);
     76    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     77    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    10478
    10579    // -todiffskyfile
    10680    psMetadata *todiffskyfileArgs = psMetadataAlloc();
    107     psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    108             "search by diff ID", 0);
    109     psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    110             "limit result set to N items", 0);
    111     psMetadataAddBool(todiffskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    112             "use the simple output format", false);
     81    psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     82    psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     83    psMetadataAddBool(todiffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    11384
    11485    // -adddiffskyfile
    11586    psMetadata *adddiffskyfileArgs = psMetadataAlloc();
    116     psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    117             "define warp ID (required)", 0);
    118     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    119             "define URI of file", 0);
    120     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,
    121             "define base output location", 0);
    122     psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,
    123             "define exposure background", NAN);
    124     psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    125             "define exposure background mean stdev", NAN);
    126     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-dtime_diff",  0,
    127             "define elapsed processing time", NAN);
    128     psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_num",  0,
    129             "define subtraction stamp number", 0);
    130     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_rms",  0,
    131             "define subtraction stamp rms", NAN);
    132     psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-sources",  0,
    133             "define number of sources", 0);
    134     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,
    135             "define hostname", 0);
    136     psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,
    137             "define %% of good pixels", NAN);
    138     psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    139             "set fault code", 0);
     87    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define warp ID (required)", 0);
     88    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     89    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     90    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     91    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     92    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background mean stdev", NAN);
     93    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-dtime_diff",  0,            "define elapsed processing time", NAN);
     94    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_num",  0,            "define subtraction stamp number", 0);
     95    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-stamps_rms",  0,            "define subtraction stamp rms", NAN);
     96    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-sources",  0,            "define number of sources", 0);
     97    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     98    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    14099
    141100    // -diffskyfile
    142101    psMetadata *diffskyfileArgs = psMetadataAlloc();
    143     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    144             "search by warp ID", 0);
    145     psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,
    146             "define skycell ID", NULL);
    147     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,
    148             "define tessellation ID", NULL);
    149     psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    150             "limit result set to N items", 0);
    151     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    152             "use the simple output format", false);
     102    psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by warp ID", 0);
     103    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
     104    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
     105    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     106    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    153107
    154108    // -revertdiffskyfile
    155109    psMetadata *revertdiffskyfileArgs = psMetadataAlloc();
    156     psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    157             "define warp ID (required)", 0);
    158     psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,
    159             "search by fault code", 0);
     110    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define warp ID (required)", 0);
     111    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    160112
    161113    // -definepoprun
    162114    psMetadata *definepoprunArgs = psMetadataAlloc();
    163     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-workdir", 0,
    164             "define workdir (required)", NULL);
    165     psMetadataAddTime(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,
    166             "time detrend run was registered", now);
    167     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    168             "define skycell ID (required)", NULL);
    169     psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-tess_id",  0,
    170             "define tessellation ID (required)", NULL);
    171     psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,
    172             "use the simple output format", false);
    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);
     115    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     116    psMetadataAddTime(definepoprunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     117    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     118    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     119    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     120    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,            "define warp ID for template", 0);
     121    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,            "define stack ID for template", 0);
     122    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_warp_id", 0,            "define warp ID for input", 0);
     123    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,            "define stack ID for input", 0);
    181124
    182125    // -definebyquery
    183126    psMetadata *queueArgs = psMetadataAlloc();
    184     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,
    185             "define workdir (required)", NULL);
    186     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered",  0,
    187             "time detrend run was registered", now);
    188     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-simple",  0,
    189             "use the simple output format", false);
     127    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
     128    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     129    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     130    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     131    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-kind", 0,            "search by kind", NULL);
     132    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     133    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     134    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-template",  0,            "search by subtrahend", false);
     135    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    190136
    191137    psFree(now);
    … …  
    216162    psFree(modes);
    217163
    218     // setup search criterion
    219 #define addWhereStr(name) \
    220 { \
    221     psString str = NULL; \
    222     bool status = false; \
    223     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    224         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    225             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    226             psFree(config); \
    227             return NULL; \
    228         } \
    229     } \
    230 }
    231 
    232 #define addWhereS32(name) \
    233 { \
    234     psS32 s32 = 0; \
    235     bool status = false; \
    236     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    237         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    238             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    239             psFree(config); \
    240             return NULL; \
    241         } \
    242     } \
    243 }
    244 
    245 
    246     // generate SQL where clause
    247     config->where = psMetadataAlloc();
    248 
    249 {
    250     psS64 s64 = 0;
    251     bool status = false;
    252     if ((s64 = psMetadataLookupS64(&status, config->args, "-diff_id"))) {
    253         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "diff_id", 0, "==", s64)) {
    254             psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id");
    255             psFree(config);
    256             return NULL;
    257         }
    258     }
    259 }
    260 {
    261     psString str = NULL;
    262     bool status = false;
    263     if ((str = psMetadataLookupStr(&status, config->args, "-warp_id"))) {
    264         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(str))) {
    265             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    266             psFree(config);
    267             return NULL;
    268         }
    269     }
    270 }
    271     addWhereStr(skycell_id);
    272     addWhereStr(tess_id);
    273 
    274     // convert '-code' to 'fault'
    275     {
    276         psS16 fault = 0;
    277         bool status = false;
    278         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    279             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    280                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    281                 psFree(config);
    282                 return NULL;
    283             }
    284         }
    285     }
    286 
    287     if (config->where->list->n < 1) {
    288         psFree(config->where);
    289         config->where = NULL;
    290     }
    291 
    292164    // define Database handle, if used
    293165    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/flatcorr.c

    r18336 r18561  
    9292    PS_ASSERT_PTR_NON_NULL(config, false);
    9393
    94     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", false, false);
    95 
    9694    psMetadata *where = psMetadataAlloc();
    97     // convert exp_id into a psS64
    98     if (exp_id) {
    99         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", 0, "==", (psS64)atoll(exp_id))) {
    100             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    101             psFree(where);
    102             return false;
    103         }
    104     }
    105 
     95
     96    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    10697    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    10798    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    110101    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    111102    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
     103    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
    112104    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelvel", "==");
    113105    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    114106    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    115     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    116     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     107    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     108    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    117109    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    118110    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    157149    PXOPT_LOOKUP_STR(region, config->args, "-set_region", false, false);
    158150
    159     // default
    160     PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
    161 
    162151    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    163152    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    324313
    325314    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     315    PXOPT_LOOKUP_BOOL(limit, config->args, "-limit", false);
    326316
    327317    // create a temp table to hold completely processed chipRuns
    328 {
    329     psString query = pxDataGet("flatcorr_create_tmp_chiprundone.sql");
    330     if (!query) {
    331         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    332         return false;
    333     }
    334 
    335     if (!p_psDBRunQuery(config->dbh, query)) {
    336         psError(PS_ERR_UNKNOWN, false, "database error");
    337         psFree(query);
    338         return false;
    339     }
    340 
    341     psFree(query);
    342 }
    343 
     318    {
     319        psString query = pxDataGet("flatcorr_create_tmp_chiprundone.sql");
     320        if (!query) {
     321            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     322            return false;
     323        }
     324
     325        if (!p_psDBRunQuery(config->dbh, query)) {
     326            psError(PS_ERR_UNKNOWN, false, "database error");
     327            psFree(query);
     328            return false;
     329        }
     330
     331        psFree(query);
     332    }
    344333   
    345334    // find all completed chipRuns
    346 {
    347     psString query = pxDataGet("flatcorr_completely_processed_chiprun.sql");
    348     if (!query) {
    349         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    350         return false;
    351     }
    352 
    353     if (!p_psDBRunQuery(config->dbh, query)) {
    354         psError(PS_ERR_UNKNOWN, false, "database error");
    355         psFree(query);
    356         return false;
    357     }
    358 
    359     psFree(query);
    360 }
     335    {
     336        psString query = pxDataGet("flatcorr_completely_processed_chiprun.sql");
     337        if (!query) {
     338            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     339            return false;
     340        }
     341
     342        if (!p_psDBRunQuery(config->dbh, query)) {
     343            psError(PS_ERR_UNKNOWN, false, "database error");
     344            psFree(query);
     345            return false;
     346        }
     347
     348        psFree(query);
     349    }
     350
    361351    // find flatcorrRun's that have had all of their chipRun's completed by
    362352    // comparing against the temp table
    … …  
    367357    }
    368358
     359    // treat limit == 0 as "no limit"
     360    if (limit) {
     361        psString limitString = psDBGenerateLimitSQL(limit);
     362        psStringAppend(&query, " %s", limitString);
     363        psFree(limitString);
     364    }
     365
    369366    if (!p_psDBRunQuery(config->dbh, query)) {
    370367        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    377374        psErrorCode err = psErrorCodeLast();
    378375        switch (err) {
    379             case PS_ERR_DB_CLIENT:
    380                 psError(PXTOOLS_ERR_SYS, false, "database error");
    381             case PS_ERR_DB_SERVER:
    382                 psError(PXTOOLS_ERR_PROG, false, "database error");
    383             default:
    384                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
     376          case PS_ERR_DB_CLIENT:
     377            psError(PXTOOLS_ERR_SYS, false, "database error");
     378          case PS_ERR_DB_SERVER:
     379            psError(PXTOOLS_ERR_PROG, false, "database error");
     380          default:
     381            psError(PXTOOLS_ERR_PROG, false, "unknown error");
    385382        }
    386383
    … …  
    412409    PS_ASSERT_PTR_NON_NULL(config, false);
    413410
     411    psMetadata *where = psMetadataAlloc();
     412    PXOPT_COPY_S64(config->args, where, "-corr_id", "corr_id", "==");
     413
    414414    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    415415    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    422422    }
    423423
    424     if (config->where) {
    425         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
     424    if (psListLength(where->list)) {
     425        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    426426        psStringAppend(&query, " AND %s", whereClause);
    427427        psFree(whereClause);
    428428    }
     429    psFree(where);
    429430
    430431    // treat limit == 0 as "no limit"

  • trunk/ippTools/src/flatcorrConfig.c

    r18172 r18561  
    4848    psMetadata *newrunArgs = psMetadataAlloc();
    4949    // XXX need to allow multiple exp_ids
    50     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_id",  0,
    51             "search by exp_id", NULL);
    52     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_name",  0,
    53             "search by exp_name", NULL);
    54     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-inst",  0,
    55             "search for camera", NULL);
    56     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-telescope",  0,
    57             "search for telescope", NULL);
    58     psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,   
    59             "search for exposures by time (>=)", NULL);
    60     psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    61             "search for exposures by time (<)", NULL);
    62     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    63             "search by exp_tag", NULL);
    64     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_type",  0,
    65             "search by exp_type", "object");
    66     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filelevel",  0,
    67             "search by filelevel", NULL);
    68     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-reduction",  0,
    69             "search by reduction class", NULL);
    70     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filter",  0,
    71             "search for filter", NULL);
    72     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    73             "define min airmass", NAN);
    74     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    75             "define max airmass", NAN);
    76     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_min",  0,
    77             "define min", NAN);
    78     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_max",  0,
    79             "define max", NAN);
    80     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_min",  0,
    81             "define min", NAN);
    82     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_max",  0,
    83             "define max", NAN);
    84     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    85             "define min", NAN);
    86     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    87             "define max", NAN);
    88     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    89             "define max fraction of saturated pixels", NAN);
    90     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    91             "define min fraction of saturated pixels", NAN);
    92     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_min",  0,
    93             "define max", NAN);
    94     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_max",  0,
    95             "define max", NAN);
    96     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    97             "define max", NAN);
    98     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    99             "define max", NAN);
    100     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    101             "define max", NAN);
    102     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    103             "define max", NAN);
    104     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_min",  0,
    105             "define min", NAN);
    106     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_max",  0,
    107             "define max", NAN);
    108     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_min",  0,
    109             "define min", NAN);
    110     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_max",  0,
    111             "define max", NAN);
    112     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,   
    113             "define min ccd tempature", NAN);
    114     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    115             "define max ccd tempature", NAN);
    116     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_min",  0,
    117             "define min rotator position angle", NAN);
    118     psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_max",  0,
    119             "define max rotator position angle", NAN);
    120     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-object",  0,
    121             "search by exposure object", NULL);
    122     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_min",  0,
    123             "define min solar angle", NAN);
    124     psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_max",  0,
    125             "define max solar angle", NAN);
    126     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_workdir",  0,
    127             "define workdir", NULL);
    128     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_label",  0,
    129             "define label", NULL);
    130     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_reduction",  0,
    131             "define reduction class", NULL);
    132     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_expgroup",  0,
    133             "define exposure group", NULL);
    134     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    135             "define DVO db", NULL);
    136     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_filter",  0,
    137             "define filter", NULL);
    138     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_tess_id",  0,
    139             "define tessalation", NULL);
    140     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_end_stage",  0,
    141             "define processing end stage", NULL);
    142     psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_region",  0,
    143             "define region", NULL);
     50    psMetadataAddS64(newrunArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     51    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     52    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     53    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     54    psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,               "search for exposures by time (>=)", NULL);
     55    psMetadataAddTime(newrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     56    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     57    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
     58    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     59    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     60    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     61    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     62    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     63    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     64    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     65    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     66    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     67    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     68    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     69    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     70    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     71    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     72    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     73    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     74    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     75    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     76    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     77    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     78    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     79    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     80    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     81    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,               "define min ccd tempature", NAN);
     82    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     83    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     84    psMetadataAddF64(newrunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     85    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     86    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     87    psMetadataAddF32(newrunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
    14488
    145     psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-pretend",  0,
    146             "print the exposures that would be included in the detrend run and exit", false);
    147     psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-simple", 0,
    148             "use the simple output format", false);
     89    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     90    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
     91    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
     92    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
     93    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
     94    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_filter",  0,            "define filter", NULL);
     95    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessalation", NULL);
     96    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define processing end stage", NULL);
     97    psMetadataAddStr(newrunArgs, PS_LIST_TAIL, "-set_region",  0,            "define region", NULL);
     98
     99    psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
     100    psMetadataAddBool(newrunArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    149101
    150102    // -addexp
    151103    psMetadata *addexpArgs = psMetadataAlloc();
    152     psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-corr_id", 0,
    153             "define Flat Correction ID (required)", NULL);
    154     psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    155             "define Chip ID (required)", NULL);
     104    psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-corr_id", 0,            "define Flat Correction ID (required)", NULL);
     105    psMetadataAddStr(addexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "define Chip ID (required)", NULL);
    156106
    157107    // -pending
    158108    psMetadata *pendingArgs = psMetadataAlloc();
    159     psMetadataAddU64(pendingArgs, PS_LIST_TAIL, "-limit",  0,
    160             "limit result set to N items", 0);
    161     psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple", 0,
    162             "use the simple output format", false);
     109    psMetadataAddU64(pendingArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     110    psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    163111
    164112    // -flatcorrimfile
    165113    psMetadata *flatcorrimfileArgs = psMetadataAlloc();
    166     psMetadataAddStr(flatcorrimfileArgs, PS_LIST_TAIL, "-corr_id",  0,
    167             "search by flat correction ID (required)", NULL);
    168     psMetadataAddU64(flatcorrimfileArgs, PS_LIST_TAIL, "-limit",  0,
    169             "limit result set to N items", 0);
    170     psMetadataAddBool(flatcorrimfileArgs, PS_LIST_TAIL, "-simple", 0,
    171             "use the simple output format", false);
     114    psMetadataAddStr(flatcorrimfileArgs, PS_LIST_TAIL, "-corr_id",  0,            "search by flat correction ID (required)", NULL);
     115    psMetadataAddU64(flatcorrimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     116    psMetadataAddBool(flatcorrimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    172117
    173118    // -done
    174119    psMetadata *doneArgs = psMetadataAlloc();
    175     psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-corr_id",  0,
    176             "define correction id (required)", NULL);
    177     psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-stats",  0,
    178             "define stats (required)", NULL);
     120    psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-corr_id",  0,            "define correction id (required)", NULL);
     121    psMetadataAddStr(doneArgs, PS_LIST_TAIL, "-stats",  0,            "define stats (required)", NULL);
    179122
    180123    // -updaterun
    181124    psMetadata *updaterunArgs = psMetadataAlloc();
    182     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-corr_id",  0,
    183             "define correction id (required)", NULL);
    184     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    185             "set state (required)", NULL);
     125    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-corr_id",  0,            "define correction id (required)", NULL);
     126    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    186127
    187128    psFree(now);
    … …  
    190131    psMetadata *modes = psMetadataAlloc();
    191132
    192     PXOPT_ADD_MODE("-newrun",  "start a new flat correction run",
    193         FLATCORR_MODE_NEWRUN,       newrunArgs);
    194     PXOPT_ADD_MODE("-addexp",  "add an exp to a flat correction run",
    195         FLATCORR_MODE_ADDEXP,       addexpArgs);
    196     PXOPT_ADD_MODE("-pending", "show flat correction runs needing to be processed",
    197         FLATCORR_MODE_PENDING,      pendingArgs);
    198     PXOPT_ADD_MODE("-flatcorrimfile", "list all the imfiles in a flat correction run",
    199         FLATCORR_MODE_FLATCORRIMFILE, flatcorrimfileArgs);
    200     PXOPT_ADD_MODE("-done",  "change a flat calibration run's state",
    201         FLATCORR_MODE_DONE,         doneArgs);
    202     PXOPT_ADD_MODE("-updaterun",  "change a flat calibration run's state",
    203         FLATCORR_MODE_UPDATERUN,   updaterunArgs);
     133    PXOPT_ADD_MODE("-newrun",  "start a new flat correction run",        FLATCORR_MODE_NEWRUN,       newrunArgs);
     134    PXOPT_ADD_MODE("-addexp",  "add an exp to a flat correction run",        FLATCORR_MODE_ADDEXP,       addexpArgs);
     135    PXOPT_ADD_MODE("-pending", "show flat correction runs needing to be processed",        FLATCORR_MODE_PENDING,      pendingArgs);
     136    PXOPT_ADD_MODE("-flatcorrimfile", "list all the imfiles in a flat correction run",        FLATCORR_MODE_FLATCORRIMFILE, flatcorrimfileArgs);
     137    PXOPT_ADD_MODE("-done",  "change a flat calibration run's state",        FLATCORR_MODE_DONE,         doneArgs);
     138    PXOPT_ADD_MODE("-updaterun",  "change a flat calibration run's state",        FLATCORR_MODE_UPDATERUN,   updaterunArgs);
    204139
    205140    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    … …  
    213148    psFree(argSets);
    214149    psFree(modes);
    215 
    216     // setup search criterion
    217 #define addWhereStr(name) \
    218 { \
    219     psString str = NULL; \
    220     bool status = false; \
    221     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    222         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    223             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    224             psFree(config); \
    225             return NULL; \
    226         } \
    227     } \
    228 }
    229 
    230     // generate SQL where clause
    231     config->where = psMetadataAlloc();
    232 
    233 {   
    234     psString str = NULL;
    235     bool status = false;
    236     if ((str = psMetadataLookupStr(&status, config->args, "-corr_id"))) {
    237         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "corr_id", 0, "==", (psS64)atoll(str))) {
    238             psError(PS_ERR_UNKNOWN, false, "failed to add item corr_id");
    239             psFree(config);
    240             return NULL;
    241         }
    242     }
    243 }
    244 
    245     if (config->where->list->n < 1) {
    246         psFree(config->where);
    247         config->where = NULL;
    248     }
    249150
    250151    // define Database handle, if used

  • trunk/ippTools/src/guidetool.c

    r14023 r18561  
    6161    PS_ASSERT_PTR_NON_NULL(config, false);
    6262
     63    psMetadata *where = psMetadataAlloc();
     64    PXOPT_COPY_STR(config->args, where, "-exp_id",        "exp_id", "==");
     65    PXOPT_COPY_STR(config->args, where, "-inst",          "camera", "==");
     66    PXOPT_COPY_STR(config->args, where, "-telescope",     "telescope", "==");
     67    PXOPT_COPY_STR(config->args, where, "-exp_type",      "exp_type", "==");
     68    PXOPT_COPY_S32(config->args, where, "-imfiles",       "imfiles", "==");
     69    PXOPT_COPY_STR(config->args, where, "-filter",        "filter", "==");
     70    PXOPT_COPY_STR(config->args, where, "-recip",         "recipe", "==");
     71    PXOPT_COPY_S32(config->args, where, "-guide_version", "guide_version", "==");
     72    if (!psListLength(where->list)) {
     73        psFree (where);
     74        where = NULL;
     75    }
     76
    6377    // return all guidePendingExp rows unless there CLI search options
    64     psArray *guidePendingExp = guidePendingExpSelectRowObjects(
    65         config->dbh,
    66         config->where ? config->where : NULL,
    67         0
    68     );
     78    psArray *guidePendingExp = guidePendingExpSelectRowObjects(config->dbh, where, 0);
     79    psFree (where);
     80
    6981    if (!guidePendingExp) {
    7082        psError(PS_ERR_UNKNOWN, false, "no guidePendingExp found");
    7183        return false;
    7284    }
    73 
    7485    psMetadata *output = psMetadataAlloc();
    7586
    … …  
    94105    PS_ASSERT_PTR_NON_NULL(config, false);
    95106   
     107    psMetadata *where = psMetadataAlloc();
     108    PXOPT_COPY_STR(config->args, where, "-exp_id",        "exp_id", "==");
     109    PXOPT_COPY_STR(config->args, where, "-inst",          "camera", "==");
     110    PXOPT_COPY_STR(config->args, where, "-telescope",     "telescope", "==");
     111    PXOPT_COPY_STR(config->args, where, "-exp_type",      "exp_type", "==");
     112    PXOPT_COPY_S32(config->args, where, "-imfiles",       "imfiles", "==");
     113    PXOPT_COPY_STR(config->args, where, "-filter",        "filter", "==");
     114    if (!psListLength(where->list)) {
     115        psFree (where);
     116        where = NULL;
     117    }
     118
    96119    // return all rawScienceExp rows unless there CLI search options
    97     psArray *rawScienceExps = rawScienceExpSelectRowObjects(
    98         config->dbh,
    99         config->where ? config->where : NULL,
    100         0
    101     );
    102 
     120    psArray *rawScienceExps = rawScienceExpSelectRowObjects(config->dbh, where, 0);
     121    psFree (where);
     122   
    103123    if (!rawScienceExps) {
    104124        psError(PS_ERR_UNKNOWN, false, "no rawScienceExp rows found");

  • trunk/ippTools/src/guidetoolConfig.c

    r18172 r18561  
    5252    // -pending search
    5353    psMetadata *pendingArgs = psMetadataAlloc();
    54     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,
    55         "define exposure ID", NULL);
    56     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,
    57         "define camera of interest", NULL);
    58     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,
    59         "define telescope of interest", NULL);
    60     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,
    61         "define exposure type", NULL);
    62     psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-imfiles",  0,
    63         "define number of imfiles", 0);
    64     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,
    65         "define filter of interest", NULL);
    66     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-recipe",  0,
    67         "define recipe of interest", NULL);
    68     psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-guide_version",  0,
    69         "define guide_version of interest", 0);
     54    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,        "define exposure ID", NULL);
     55    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,        "define camera of interest", NULL);
     56    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,        "define telescope of interest", NULL);
     57    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,        "define exposure type", NULL);
     58    psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-imfiles",  0,        "define number of imfiles", 0);
     59    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,        "define filter of interest", NULL);
     60    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-recipe",  0,        "define recipe of interest", NULL);
     61    psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-guide_version",  0,        "define guide_version of interest", 0);
    7062
    7163    // -define inputs
    7264    psMetadata *defineArgs = psMetadataAlloc();
    73     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_id",  0,
    74         "define class", NULL);
    75     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-inst",  0,
    76         "define camera of interest", NULL);
    77     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-telescope",  0,
    78         "define camera of interest", NULL);
    79     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_type",  0,
    80         "define class", NULL);
    81     psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-imfiles",  0,
    82         "define number of imfiles", 0);
    83     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-filter",  0,
    84         "define filter of interest", NULL);
     65    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_id",  0,        "define class", NULL);
     66    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-inst",  0,        "define camera of interest", NULL);
     67    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-telescope",  0,        "define camera of interest", NULL);
     68    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_type",  0,        "define class", NULL);
     69    psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-imfiles",  0,        "define number of imfiles", 0);
     70    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-filter",  0,        "define filter of interest", NULL);
    8571    // these two are inputs NOT search parameters
    86     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-recipe",  0,
    87         "define recipe of interest", NULL);
    88     psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-guide_version",  0,
    89         "define guide_version of interest", 0);
     72    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-recipe",  0,        "define recipe of interest", NULL);
     73    psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-guide_version",  0,        "define guide_version of interest", 0);
    9074
    9175    // find which mode we're running under
    … …  
    146130    psFree(defineArgs);
    147131
    148     // setup search criterion
    149 #define addWhereStr(name) \
    150     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    151         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    152             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    153             exit(EXIT_FAILURE); \
    154         } \
    155     }
    156 
    157     // generate SQL where clause
    158     config->where = psMetadataAlloc();
    159 
    160 {
    161     psString str = NULL;
    162     int n = 0;
    163     bool status = false;
    164 
    165     addWhereStr(exp_id);
    166     // convert '-inst' to 'camera'
    167     if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    168         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    169             psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    170             exit(EXIT_FAILURE);
    171         }
    172     }
    173     addWhereStr(telescope);
    174     addWhereStr(exp_type);
    175     if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    176         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    177             psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    178             exit(EXIT_FAILURE);
    179         }
    180     }
    181     addWhereStr(filter);
    182     addWhereStr(stats);
    183     addWhereStr(recipe);
    184     if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    185         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    186             psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    187             exit(EXIT_FAILURE);
    188         }
    189     }
    190 }
    191 
    192     if (config->where->list->n < 1) {
    193         psFree(config->where);
    194         config->where = NULL;
    195     }
    196 
    197132    // define Database handle, if used
    198133    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • trunk/ippTools/src/magictool.c

    r18526 r18561  
    104104    PS_ASSERT_PTR_NON_NULL(config, false);
    105105
     106    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     107    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     108    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     109    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     110
    106111    // create warped skycells temp table
    107 {
    108     char *query =
    109         "CREATE TEMPORARY TABLE warpComplete\n"
    110         " (warp_id BIGINT, skycell_id VARCHAR(64), tess_id VARCHAR(64),\n"
    111         " PRIMARY KEY(warp_id, skycell_id, tess_id)) ENGINE=MEMORY\n";
    112 
    113     if (!p_psDBRunQuery(config->dbh, query)) {
    114         psError(PS_ERR_UNKNOWN, false, "database error");
    115         return false;
    116     }
    117 }
     112    {
     113        psString query = pxDataGet("magictool_create_tmp_warpcomplete.sql");
     114        if (!query) {
     115            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     116            return false;
     117        }
     118
     119        if (!p_psDBRunQuery(config->dbh, query)) {
     120            psError(PS_ERR_UNKNOWN, false, "database error");
     121            return false;
     122        }
     123    }
    118124
    119125    // find warped skycells
    120 {
    121     psString query = pxDataGet("magictool_find_complete_warpruns.sql");
     126    {
     127        psString query = pxDataGet("magictool_find_complete_warpruns.sql");
     128        if (!query) {
     129            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     130            return false;
     131        }
     132
     133        if (!p_psDBRunQuery(config->dbh, query)) {
     134            psError(PS_ERR_UNKNOWN, false, "database error");
     135            psFree(query);
     136            return false;
     137        }
     138        psFree(query);
     139    }
     140
     141    // find the diff_id's of the warped skycells
     142    {
     143        psString query = pxDataGet("magictool_find_complete_diffed_exposures.sql");
     144        if (!query) {
     145            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     146            return false;
     147        }
     148
     149        if (!p_psDBRunQuery(config->dbh, query)) {
     150            psError(PS_ERR_UNKNOWN, false, "database error");
     151            psFree(query);
     152            return false;
     153        }
     154        psFree(query);
     155    }
     156    psArray *output = p_psDBFetchResult(config->dbh);
     157    if (!output) {
     158        psErrorCode err = psErrorCodeLast();
     159        switch (err) {
     160          case PS_ERR_DB_CLIENT:
     161            psError(PXTOOLS_ERR_SYS, false, "database error");
     162          case PS_ERR_DB_SERVER:
     163            psError(PXTOOLS_ERR_PROG, false, "database error");
     164          default:
     165            psError(PXTOOLS_ERR_PROG, false, "unknown error");
     166        }
     167
     168        return false;
     169    }
     170    if (!psArrayLength(output)) {
     171        psTrace("magictool", PS_LOG_INFO, "no rows found");
     172        psFree(output);
     173        return true;
     174    }
     175
     176    // pre-allocate enough hash buckets for 1 unique warp_id per row
     177    psHash *groups = psHashAlloc(psArrayLength(output));
     178    // iterate over result set, and group by warp_id
     179    for (long i = 0; i < psArrayLength(output); i++) {
     180        // lookup the key we're grouping by
     181        bool status = false;
     182        psS64 warp_id = psMetadataLookupS64(&status, output->data[i], "warp_id");
     183        if (!status) {
     184            psAbort("failed to lookup value for warp_id");
     185        }
     186
     187        psString key = psDBIntToString(warp_id);
     188        // look to see if there is a bin for this key
     189        psArray *groupBin = psHashLookup(groups, key);
     190        if (!groupBin) {
     191            // if not, create one
     192            groupBin = psArrayAlloc(0);
     193            psHashAdd(groups, key, groupBin);
     194        }
     195        psFree(key);
     196
     197        // add this row to the bin
     198        psArrayAdd(groupBin, 0, output->data[i]);
     199        psFree(groupBin);
     200    }
     201    psFree(output);
     202
     203    // create a magic run
     204    psArray *grouped =  psHashToArray(groups);
     205    psFree(groups);
     206
     207    // iterate over array of grouped warp_ids
     208    for (long i = 0; i < psArrayLength(grouped); i++) {
     209        psArray *group = grouped->data[i];
     210
     211        // create a new magicRun for this group
     212        magicRunRow *run = magicRunRowAlloc(
     213            0,                          // ID
     214            "reg",                      // state
     215            workdir,                    // workdir
     216            "dirty",                    // workdir_state
     217            label,                      // label
     218            dvodb,                      // dvodb
     219            registered,                 // registered
     220            0                           // fault
     221            );
     222        if (!run) {
     223            psAbort("failed to alloc magicRun object");
     224        }
     225        if (!magicRunInsertObject(config->dbh, run)) {
     226            psError(PS_ERR_UNKNOWN, false, "database error");
     227            psFree(run);
     228            psFree(grouped);
     229            return false;
     230        }
     231
     232        // get the assigned warp_id
     233        psS64 magic_id = psDBLastInsertID(config->dbh);
     234
     235        // insert all rows in this bin into the new magicRun
     236        for (long j = 0; j < psArrayLength(group); j++) {
     237            psMetadata *row = group->data[j];
     238
     239            bool status = false;
     240            psS64 diff_id = psMetadataLookupS64(&status, row, "diff_id");
     241            if (!status) {
     242                psAbort("failed to lookup value for diff_id");
     243            }
     244            psString node = psMetadataLookupStr(&status, row, "skycell_id");
     245            if (!status) {
     246                psAbort("failed to lookup value for diff_id");
     247            }
     248
     249            if (!magicInputSkyfileInsert(config->dbh,
     250                                         magic_id,
     251                                         diff_id,
     252                                         node)) {
     253                psError(PS_ERR_UNKNOWN, false, "database error");
     254                psFree(grouped);
     255                return false;
     256            }
     257        }
     258
     259        // set magicRun.state to 'run'
     260        return setmagicRunState(config, magic_id, "run");
     261    }
     262    psFree(grouped);
     263
     264    return true;
     265}
     266
     267static psS64 definerunMode(pxConfig *config)
     268{
     269    PS_ASSERT_PTR_NON_NULL(config, false);
     270
     271    // required
     272    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     273
     274    // optional
     275    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     276    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     277    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     278    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     279
     280    magicRunRow *run = magicRunRowAlloc(
     281            0,          // ID
     282            "reg",      // state
     283            workdir,
     284            "dirty",    // workdir_state
     285            label,
     286            dvodb,
     287            registered,
     288            0
     289    );
     290
     291    if (!run) {
     292        psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
     293        return false;
     294    }
     295    if (!magicRunInsertObject(config->dbh, run)) {
     296        psError(PS_ERR_UNKNOWN, false, "database error");
     297        psFree(run);
     298        return false;
     299    }
     300
     301    // get the assigned warp_id
     302    psS64 magic_id = psDBLastInsertID(config->dbh);
     303    run->magic_id = magic_id;
     304
     305    if (!magicRunPrintObject(stdout, run, !simple)) {
     306            psError(PS_ERR_UNKNOWN, false, "failed to print object");
     307            psFree(run);
     308            return false;
     309    }
     310
     311    psFree(run);
     312
     313    return magic_id;
     314}
     315
     316
     317static bool updaterunMode(pxConfig *config)
     318{
     319    PS_ASSERT_PTR_NON_NULL(config, false);
     320
     321    // required
     322    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     323    PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
     324
     325    if (state) {
     326        // set detRun.state to state
     327        return setmagicRunState(config, (psS64)atoll(magic_id), state);
     328    }
     329
     330    return true;
     331}
     332
     333
     334static bool addinputskyfileMode(pxConfig *config)
     335{
     336    PS_ASSERT_PTR_NON_NULL(config, false);
     337
     338    // required
     339    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     340    PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
     341    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
     342
     343    magicInputSkyfileInsert(
     344            config->dbh,
     345            (psS64)atoll(magic_id),
     346            (psS64)atoll(diff_id),
     347            node
     348    );
     349
     350    return true;
     351}
     352
     353
     354static bool inputskyfileMode(pxConfig *config)
     355{
     356    PS_ASSERT_PTR_NON_NULL(config, false);
     357
     358    psMetadata *where = psMetadataAlloc();
     359    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     360    PXOPT_COPY_STR(config->args, where, "-diff_id", "diff_id", "==");
     361    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
     362
     363    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     364    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     365
     366    // find all rawImfiles matching the default query
     367    psString query = pxDataGet("magictool_inputskyfile.sql");
    122368    if (!query) {
    123369        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    125371    }
    126372
     373    if (psListLength(where->list)) {
     374        psString whereClause = psDBGenerateWhereConditionSQL(where, "magicInputSkyfile");
     375        psStringAppend(&query, " AND %s", whereClause);
     376        psFree(whereClause);
     377    }
     378    psFree(where);
     379
     380    // treat limit == 0 as "no limit"
     381    if (limit) {
     382        psString limitString = psDBGenerateLimitSQL(limit);
     383        psStringAppend(&query, " %s", limitString);
     384        psFree(limitString);
     385    }
     386
    127387    if (!p_psDBRunQuery(config->dbh, query)) {
    128388        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    131391    }
    132392    psFree(query);
    133 }
    134 
    135     // find the diff_id's of the warped skycells
    136 {
    137     psString query = pxDataGet("magictool_find_complete_diffed_exposures.sql");
    138     if (!query) {
    139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    140         return false;
    141     }
    142 
    143     if (!p_psDBRunQuery(config->dbh, query)) {
    144         psError(PS_ERR_UNKNOWN, false, "database error");
    145         psFree(query);
    146         return false;
    147     }
    148     psFree(query);
    149 }
     393
    150394    psArray *output = p_psDBFetchResult(config->dbh);
    151395    if (!output) {
    … …  
    168412    }
    169413
    170     // pre-allocate enough hash buckets for 1 unique warp_id per row
    171     psHash *groups = psHashAlloc(psArrayLength(output));
    172     // iterate over result set, and group by warp_id
    173     for (long i = 0; i < psArrayLength(output); i++) {
    174         // lookup the key we're grouping by
    175         bool status = false;
    176         psS64 warp_id = psMetadataLookupS64(&status, output->data[i], "warp_id");
    177         if (!status) {
    178             psAbort("failed to lookup value for warp_id");
    179         }
    180 
    181         psString key = psDBIntToString(warp_id);
    182         // look to see if there is a bin for this key
    183         psArray *groupBin = psHashLookup(groups, key);
    184         if (!groupBin) {
    185             // if not, create one
    186             groupBin = psArrayAlloc(0);
    187             psHashAdd(groups, key, groupBin);
    188         }
    189         psFree(key);
    190 
    191         // add this row to the bin
    192         psArrayAdd(groupBin, 0, output->data[i]);
    193         psFree(groupBin);
    194     }
     414    if (psArrayLength(output)) {
     415        // negative simple so the default is true
     416        if (!ippdbPrintMetadatas(stdout, output, "magicInputSkyfile", !simple)) {
     417            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     418            psFree(output);
     419            return false;
     420        }
     421    }
     422
    195423    psFree(output);
    196424
    197     // create a magic run
    198     psArray *grouped =  psHashToArray(groups);
    199     psFree(groups);
    200 
    201     // iterate over array of grouped warp_ids
    202     for (long i = 0; i < psArrayLength(grouped); i++) {
    203         psArray *group = grouped->data[i];
    204 
    205         // create a new magicRun for this group
    206         // XXX This need to have options passed through to it
    207 
    208         magicRunRow *run = magicRunRowAlloc(
    209                 0,          // ID
    210                 "reg",      // state
    211                 NULL,       // workdir
    212                 "dirty",    // workdir_state
    213                 NULL,       // label
    214                 NULL,       // dvodb
    215                 NULL,       // registered
    216                 0           // fault
    217         );
    218         if (!run) {
    219             psAbort("failed to alloc magicRun object");
    220         }
    221         if (!magicRunInsertObject(config->dbh, run)) {
    222             psError(PS_ERR_UNKNOWN, false, "database error");
    223             psFree(run);
    224             psFree(grouped);
    225             return false;
    226         }
    227 
    228         // get the assigned warp_id
    229         psS64 magic_id = psDBLastInsertID(config->dbh);
    230 
    231         // insert all rows in this bin into the new magicRun
    232         for (long j = 0; j < psArrayLength(group); j++) {
    233             psMetadata *row = group->data[j];
    234 
    235             bool status = false;
    236             psS64 diff_id = psMetadataLookupS64(&status, row, "diff_id");
    237             if (!status) {
    238                 psAbort("failed to lookup value for diff_id");
    239             }
    240             psString node = psMetadataLookupStr(&status, row, "skycell_id");
    241             if (!status) {
    242                 psAbort("failed to lookup value for diff_id");
    243             }
    244 
    245             if (!magicInputSkyfileInsert(config->dbh,
    246                 magic_id,
    247                 diff_id,
    248                 node)) {
    249                 psError(PS_ERR_UNKNOWN, false, "database error");
    250                 psFree(grouped);
    251                 return false;
    252             }
    253         }
    254 
    255         // set magicRun.state to 'run'
    256         return setmagicRunState(config, magic_id, "run");
    257     }
    258     psFree(grouped);
    259 
    260     return true;
    261 }
    262 
    263 static psS64 definerunMode(pxConfig *config)
    264 {
    265     PS_ASSERT_PTR_NON_NULL(config, false);
    266 
    267     // required
    268     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    269 
    270     // optional
    271     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    272     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    273     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    274     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    275 
    276     magicRunRow *run = magicRunRowAlloc(
    277             0,          // ID
    278             "reg",      // state
    279             workdir,
    280             "dirty",    // workdir_state
    281             label,
    282             dvodb,
    283             registered,
    284             0
    285     );
    286 
    287     if (!run) {
    288         psError(PS_ERR_UNKNOWN, false, "failed to alloc magicRun object");
    289         return false;
    290     }
    291     if (!magicRunInsertObject(config->dbh, run)) {
    292         psError(PS_ERR_UNKNOWN, false, "database error");
    293         psFree(run);
    294         return false;
    295     }
    296 
    297     // get the assigned warp_id
    298     psS64 magic_id = psDBLastInsertID(config->dbh);
    299     run->magic_id = magic_id;
    300 
    301     if (!magicRunPrintObject(stdout, run, !simple)) {
    302             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    303             psFree(run);
    304             return false;
    305     }
    306 
    307     psFree(run);
    308 
    309     return magic_id;
    310 }
    311 
    312 
    313 static bool updaterunMode(pxConfig *config)
    314 {
    315     PS_ASSERT_PTR_NON_NULL(config, false);
    316 
    317     // required
    318     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
    319     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    320 
    321     if (state) {
    322         // set detRun.state to state
    323         return setmagicRunState(config, (psS64)atoll(magic_id), state);
    324     }
    325 
    326     return true;
    327 }
    328 
    329 
    330 static bool addinputskyfileMode(pxConfig *config)
    331 {
    332     PS_ASSERT_PTR_NON_NULL(config, false);
    333 
    334     // required
    335     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
    336     PXOPT_LOOKUP_STR(diff_id, config->args, "-diff_id", true, false);
    337     PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
    338 
    339     magicInputSkyfileInsert(
    340             config->dbh,
    341             (psS64)atoll(magic_id),
    342             (psS64)atoll(diff_id),
    343             node
    344     );
    345 
    346     return true;
    347 }
    348 
    349 
    350 static bool inputskyfileMode(pxConfig *config)
    351 {
    352     PS_ASSERT_PTR_NON_NULL(config, false);
     425    return true;
     426}
     427
     428static bool totreeMode(pxConfig *config)
     429{
     430    PS_ASSERT_PTR_NON_NULL(config, false);
     431
     432    psMetadata *where = psMetadataAlloc();
     433    PXOPT_COPY_STR(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    353434
    354435    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    355436    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    356437
    357     // find all rawImfiles matching the default query
    358     psString query = pxDataGet("magictool_inputskyfile.sql");
     438    // look for "inputs" that need to processed
     439    psString query = pxDataGet("magictool_totree.sql");
    359440    if (!query) {
    360441        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    362443    }
    363444
    364     if (config->where) {
    365         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "magicInputSkyfile");
     445    if (psListLength(where->list)) {
     446        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    366447        psStringAppend(&query, " AND %s", whereClause);
    367448        psFree(whereClause);
    368449    }
     450    psFree(where);
    369451
    370452    // treat limit == 0 as "no limit"
    … …  
    404486    if (psArrayLength(output)) {
    405487        // negative simple so the default is true
    406         if (!ippdbPrintMetadatas(stdout, output, "magicInputSkyfile", !simple)) {
     488        if (!ippdbPrintMetadatas(stdout, output, "totree", !simple)) {
    407489            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    408490            psFree(output);
    … …  
    416498}
    417499
    418 
    419 static bool totreeMode(pxConfig *config)
    420 {
    421     PS_ASSERT_PTR_NON_NULL(config, false);
     500static bool inputtreeMode(pxConfig *config)
     501{
     502    PS_ASSERT_PTR_NON_NULL(config, false);
     503
     504    // required
     505    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     506    PXOPT_LOOKUP_STR(dep_file, config->args, "-dep_file", true, false);
     507
     508    if (!parseAndInsertNodeDeps(config, (psS64)atoll(magic_id), dep_file)) {
     509        psError(PS_ERR_UNKNOWN, false, "failed to parse file");
     510        return false;
     511    }
     512
     513    return true;
     514}
     515
     516static bool inputsMode(pxConfig *config)
     517{
     518    PS_ASSERT_PTR_NON_NULL(config, false);
     519
     520    psMetadata *where = psMetadataAlloc();
     521    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     522    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    422523
    423524    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    424525    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    425526
    426     // look for "inputs" that need to processed
    427     psString query = pxDataGet("magictool_totree.sql");
     527    psString query = pxDataGet("magictool_inputs.sql");
    428528    if (!query) {
    429529        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    430530        return false;
    431531    }
     532
     533    if (psListLength(where->list)) {
     534        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     535        psStringAppend(&query, " AND %s", whereClause);
     536        psFree(whereClause);
     537    }
     538    psFree(where);
    432539
    433540    // treat limit == 0 as "no limit"
    … …  
    467574    if (psArrayLength(output)) {
    468575        // negative simple so the default is true
    469         if (!ippdbPrintMetadatas(stdout, output, "totree", !simple)) {
     576        if (!ippdbPrintMetadatas(stdout, output, "magicNode", !simple)) {
    470577            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    471578            psFree(output);
    … …  
    478585    return true;
    479586}
    480 
    481 
    482 static bool inputtreeMode(pxConfig *config)
    483 {
    484     PS_ASSERT_PTR_NON_NULL(config, false);
    485 
    486     // required
    487     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
    488     PXOPT_LOOKUP_STR(dep_file, config->args, "-dep_file", true, false);
    489 
    490     if (!parseAndInsertNodeDeps(config, (psS64)atoll(magic_id), dep_file)) {
    491         psError(PS_ERR_UNKNOWN, false, "failed to parse file");
    492         return false;
    493     }
    494 
    495     return true;
    496 }
    497 
    498587
    499588bool findBaseNodes(void *arg, pxNode *node)
    … …  
    573662    PS_ASSERT_PTR_NON_NULL(config, false);
    574663
    575     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", false, false);
     664    psMetadata *where = psMetadataAlloc();
     665    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     666
    576667    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    577668
    … …  
    583674    }
    584675
    585     if (magic_id) {
    586         psMetadata *where = psMetadataAlloc();
    587         psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
    588         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    589         psFree(where);
     676    psString whereClause = NULL;
     677    if (psListLength(where->list)) {
     678        whereClause = psDBGenerateWhereSQL(where, NULL);
    590679        psStringAppend(&query, " %s", whereClause);
    591         psFree(whereClause);
    592     }
     680        psFree(whereClause);
     681    }
     682    psFree(where);
    593683
    594684    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    615705    if (!psArrayLength(output)) {
    616706        psTrace("magictool", PS_LOG_INFO, "no rows found");
    617 //        psFree(output);
    618 //        return true;
     707        // psFree(output);
     708        // return true;
    619709    }
    620710
    … …  
    626716    }
    627717
    628 
    629     if (magic_id) {
    630         psMetadata *where = psMetadataAlloc();
    631         psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
    632         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    633         psFree(where);
     718    if (whereClause) {
    634719        psStringAppend(&query, " %s", whereClause);
    635         psFree(whereClause);
    636720    }
    637721
    … …  
    686770    pxNode *root = psHashLookup(forest, "root");
    687771    psFree(forest);
    688 //    pxTreePrint(stdout, root);
     772    // pxTreePrint(stdout, root);
    689773
    690774    // crawl through the tree and looking for nodes with children that are all
    … …  
    703787
    704788    psFree(output);
     789    psFree(whereClause);
    705790
    706791    return true;
    … …  
    735820}
    736821
    737 static bool inputsMode(pxConfig *config)
     822static bool tomaskMode(pxConfig *config)
    738823{
    739824    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    742827    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    743828
    744     psString query = pxDataGet("magictool_inputs.sql");
     829    // look for "inputs" that need to processed
     830    psString query = pxDataGet("magictool_tomask.sql");
    745831    if (!query) {
    746832        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    747833        return false;
    748     }
    749 
    750     if (config->where) {
    751         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    752         psStringAppend(&query, " AND %s", whereClause);
    753         psFree(whereClause);
    754834    }
    755835
    … …  
    790870    if (psArrayLength(output)) {
    791871        // negative simple so the default is true
    792         if (!ippdbPrintMetadatas(stdout, output, "magicNode", !simple)) {
     872        if (!ippdbPrintMetadatas(stdout, output, "toprocess", !simple)) {
    793873            psError(PS_ERR_UNKNOWN, false, "failed to print array");
    794874            psFree(output);
    … …  
    803883
    804884
    805 static bool tomaskMode(pxConfig *config)
    806 {
    807     PS_ASSERT_PTR_NON_NULL(config, false);
     885static bool addmaskMode(pxConfig *config)
     886{
     887    PS_ASSERT_PTR_NON_NULL(config, false);
     888
     889    // required
     890    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     891
     892    // optional
     893    PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     894    PXOPT_LOOKUP_S32(streaks, config->args, "-streaks", false, false);
     895
     896    // default values
     897    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     898
     899    if (!psDBTransaction(config->dbh)) {
     900        psError(PS_ERR_UNKNOWN, false, "database error");
     901        return false;
     902    }
     903
     904    if (!magicMaskInsert(config->dbh,
     905                         (psS64)atoll(magic_id),
     906                         uri,
     907                         streaks,
     908                         code
     909        )) {
     910        psError(PS_ERR_UNKNOWN, false, "database error");
     911        return false;
     912    }
     913
     914    // Set the magicRun state
     915    psString query = pxDataGet("magictool_addmask.sql");
     916    if (!query) {
     917        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     918        return false;
     919    }
     920
     921    // manually add constraint
     922    psStringAppend(&query, " AND magic_id = %s", magic_id);
     923
     924    if (!p_psDBRunQuery(config->dbh, query)) {
     925        psError(PS_ERR_UNKNOWN, false, "database error");
     926        psFree(query);
     927        return false;
     928    }
     929    psFree(query);
     930
     931    if (!psDBCommit(config->dbh)) {
     932        psError(PS_ERR_UNKNOWN, false, "database error");
     933        return false;
     934    }
     935
     936    return true;
     937}
     938
     939
     940static bool maskMode(pxConfig *config)
     941{
     942    PS_ASSERT_PTR_NON_NULL(config, false);
     943
     944    psMetadata *where = psMetadataAlloc();
     945    PXOPT_COPY_STR(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    808946
    809947    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    810948    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    811949
    812     // look for "inputs" that need to processed
    813     psString query = pxDataGet("magictool_tomask.sql");
     950    psString query = pxDataGet("magictool_mask.sql");
    814951    if (!query) {
    815952        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    816953        return false;
    817954    }
     955
     956    if (psListLength(where->list)) {
     957        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     958        psStringAppend(&query, " AND %s", whereClause);
     959        psFree(whereClause);
     960    }
     961    psFree(where);
    818962
    819963    // treat limit == 0 as "no limit"
    … …  
    853997    if (psArrayLength(output)) {
    854998        // negative simple so the default is true
    855         if (!ippdbPrintMetadatas(stdout, output, "toprocess", !simple)) {
    856             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    857             psFree(output);
    858             return false;
    859         }
    860     }
    861 
    862     psFree(output);
    863 
    864     return true;
    865 }
    866 
    867 
    868 static bool addmaskMode(pxConfig *config)
    869 {
    870     PS_ASSERT_PTR_NON_NULL(config, false);
    871 
    872     // required
    873     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
    874 
    875     // optional
    876     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
    877     PXOPT_LOOKUP_S32(streaks, config->args, "-streaks", false, false);
    878 
    879     // default values
    880     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    881 
    882     if (!psDBTransaction(config->dbh)) {
    883         psError(PS_ERR_UNKNOWN, false, "database error");
    884         return false;
    885     }
    886 
    887     if (!magicMaskInsert(config->dbh,
    888                          (psS64)atoll(magic_id),
    889                          uri,
    890                          streaks,
    891                          code
    892         )) {
    893         psError(PS_ERR_UNKNOWN, false, "database error");
    894         return false;
    895     }
    896 
    897     // Set the magicRun state
    898     psString query = pxDataGet("magictool_addmask.sql");
    899     if (!query) {
    900         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    901         return false;
    902     }
    903 
    904     // Add "magic_id = value"
    905     psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    906     psStringAppend(&query, " AND %s", whereClause);
    907     psFree(whereClause);
    908 
    909     if (!p_psDBRunQuery(config->dbh, query)) {
    910         psError(PS_ERR_UNKNOWN, false, "database error");
    911         psFree(query);
    912         return false;
    913     }
    914     psFree(query);
    915 
    916     if (!psDBCommit(config->dbh)) {
    917         psError(PS_ERR_UNKNOWN, false, "database error");
    918         return false;
    919     }
    920 
    921     return true;
    922 }
    923 
    924 
    925 static bool maskMode(pxConfig *config)
    926 {
    927     PS_ASSERT_PTR_NON_NULL(config, false);
    928 
    929     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    930     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    931 
    932     psString query = pxDataGet("magictool_mask.sql");
    933     if (!query) {
    934         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    935         return false;
    936     }
    937 
    938     if (config->where) {
    939         psString whereClause = psDBGenerateWhereConditionSQL(config->where, NULL);
    940         psStringAppend(&query, " AND %s", whereClause);
    941         psFree(whereClause);
    942     }
    943 
    944     // treat limit == 0 as "no limit"
    945     if (limit) {
    946         psString limitString = psDBGenerateLimitSQL(limit);
    947         psStringAppend(&query, " %s", limitString);
    948         psFree(limitString);
    949     }
    950 
    951     if (!p_psDBRunQuery(config->dbh, query)) {
    952         psError(PS_ERR_UNKNOWN, false, "database error");
    953         psFree(query);
    954         return false;
    955     }
    956     psFree(query);
    957 
    958     psArray *output = p_psDBFetchResult(config->dbh);
    959     if (!output) {
    960         psErrorCode err = psErrorCodeLast();
    961         switch (err) {
    962             case PS_ERR_DB_CLIENT:
    963                 psError(PXTOOLS_ERR_SYS, false, "database error");
    964             case PS_ERR_DB_SERVER:
    965                 psError(PXTOOLS_ERR_PROG, false, "database error");
    966             default:
    967                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    968         }
    969 
    970         return false;
    971     }
    972     if (!psArrayLength(output)) {
    973         psTrace("magictool", PS_LOG_INFO, "no rows found");
    974         psFree(output);
    975         return true;
    976     }
    977 
    978     if (psArrayLength(output)) {
    979         // negative simple so the default is true
    980999        if (!ippdbPrintMetadatas(stdout, output, "magicNode", !simple)) {
    9811000            psError(PS_ERR_UNKNOWN, false, "failed to print array");

  • trunk/ippTools/src/magictoolConfig.c

    r18526 r18561  
    4949    // -definebyquery
    5050    psMetadata *queueArgs = psMetadataAlloc();
     51    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
     52    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     53    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
     54    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    5155
    5256    // -definerun
    5357    psMetadata *definerunArgs = psMetadataAlloc();
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    55             "define workdir (required)", NULL);
    56     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,
    57             "define label", NULL);
    58     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
    59             "define dvodb", NULL);
    60     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    61             "time detrend run was registered", now);
    62     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    63             "use the simple output format", false);
     58    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     59    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
     60    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
     61    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     62    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6463
    6564    // -updaterun
    6665    psMetadata *updaterunArgs = psMetadataAlloc();
    67     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0,
    68             "define warptool ID (required)", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    70             "set state (required)", NULL);
    71 #if 0
    72     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    73             "define workdir (required)", NULL);
    74     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    75             "time detrend run was registered", now);
    76 #endif
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0,            "define warptool ID (required)", NULL);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    7768
    7869    // -addinputskyfile
    7970    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    80     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,
    81             "define magictool ID (required)", NULL);
    82     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    83             "define difftool ID (required)", NULL);
    84     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node",  0,
    85             "define symbolic node name (required)", NULL);
     71    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     72    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define difftool ID (required)", NULL);
     73    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node",  0,            "define symbolic node name (required)", NULL);
    8674
    8775    // -inputskyfile
    8876    psMetadata *inputskyfileArgs = psMetadataAlloc();
    89     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,
    90             "search by magictool ID", NULL);
    91     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    92             "search by difftool ID", NULL);
    93     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-node",  0,
    94             "search by symbolic node name", NULL);
    95     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    96             "limit result set to N items", 0);
    97     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    98             "use the simple output format", false);
     77    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magictool ID", NULL);
     78    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by difftool ID", NULL);
     79    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-node",  0,            "search by symbolic node name", NULL);
     80    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     81    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    9982
    10083    // -totree
    … …  
    10689    // -inputtree
    10790    psMetadata *inputtreeArgs = psMetadataAlloc();
    108     psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0,
    109             "define magictool ID (required)", NULL);
    110     psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0,
    111             "order of operations dep. file (required)", NULL);
     91    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     92    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0,            "order of operations dep. file (required)", NULL);
    11293    psMetadataAddS16(inputtreeArgs, PS_LIST_TAIL, "-code",  0, "set fault code", 0);
    11394
    11495    // -inputs
    11596    psMetadata *inputsArgs = psMetadataAlloc();
    116     psMetadataAddStr(inputsArgs, PS_LIST_TAIL, "-magic_id", 0,
    117             "search by magictool ID", NULL);
    118     psMetadataAddStr(inputsArgs, PS_LIST_TAIL, "-node",  0,
    119             "search by symbolic node name", NULL);
    120     psMetadataAddU64(inputsArgs, PS_LIST_TAIL, "-limit",  0,
    121             "limit result set to N items", 0);
    122     psMetadataAddBool(inputsArgs, PS_LIST_TAIL, "-simple",  0,
    123             "use the simple output format", false);
     97    psMetadataAddStr(inputsArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magictool ID", NULL);
     98    psMetadataAddStr(inputsArgs, PS_LIST_TAIL, "-node",  0,            "search by symbolic node name", NULL);
     99    psMetadataAddU64(inputsArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     100    psMetadataAddBool(inputsArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    124101
    125102    // -tooprocess
    126103    psMetadata *toprocessArgs = psMetadataAlloc();
    127     psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0,
    128             "search by magic ID", NULL);
    129     psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit",  0,
    130             "limit result set to N items", 0);
    131     psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple",  0,
    132             "use the simple output format", false);
     104    psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magic ID", NULL);
     105    psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     106    psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    133107
    134108    // -addresult
    135109    psMetadata *addresultArgs = psMetadataAlloc();
    136     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-magic_id", 0,
    137             "define magictool ID (required)", NULL);
    138     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node",  0,
    139             "define symbolic node name (required)", NULL);
    140     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri",  0,
    141             "define URI", NULL);
     110    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     111    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node",  0,            "define symbolic node name (required)", NULL);
     112    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri",  0,            "define URI (required)", NULL);
    142113    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-code",  0, "set fault code", 0);
    143114
    144115    // -tomask
    145116    psMetadata *tomaskArgs = psMetadataAlloc();
    146     psMetadataAddU64(tomaskArgs, PS_LIST_TAIL, "-limit",  0,
    147             "limit result set to N items", 0);
    148     psMetadataAddBool(tomaskArgs, PS_LIST_TAIL, "-simple",  0,
    149             "use the simple output format", false);
     117    psMetadataAddU64(tomaskArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     118    psMetadataAddBool(tomaskArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    150119
    151120    // -addmask
    152121    psMetadata *addmaskArgs = psMetadataAlloc();
    153     psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0,
    154             "define magictool ID (required)", NULL);
     122    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0,          "define magictool ID (required)", NULL);
    155123    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri",  0, "define URI", NULL);
    156124    psMetadataAddS32(addmaskArgs, PS_LIST_TAIL, "-streaks",  0, "define number of streaks", 0);
    157125    psMetadataAddS16(addmaskArgs, PS_LIST_TAIL, "-code",  0, "set fault code", 0);
     126
     127# if (0)
     128    // -toskyfilemask
     129    psMetadata *toskyfilemaskArgs = psMetadataAlloc();
     130    psMetadataAddStr(toskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magic ID", NULL);
     131    psMetadataAddU64(toskyfilemaskArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     132    psMetadataAddBool(toskyfilemaskArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     133
     134    // -addskyfilemask
     135    psMetadata *addskyfilemaskArgs = psMetadataAlloc();
     136    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     137    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-diff_id",  0,            "define difftool ID (required)", NULL);
     138    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-uri",  0,            "define URI (required)", NULL);
     139# endif
    158140
    159141    // -mask
    … …  
    193175    psFree(modes);
    194176
    195     // setup search criterion
    196 #define addWhereStr(name) \
    197 { \
    198     psString str = NULL; \
    199     bool status = false; \
    200     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    201         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    202             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    203             psFree(config); \
    204             return NULL; \
    205         } \
    206     } \
    207 }
    208 
    209 #define addWhereS32(name) \
    210 { \
    211     psS32 s32 = 0; \
    212     bool status = false; \
    213     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    214         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    215             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    216             psFree(config); \
    217             return NULL; \
    218         } \
    219     } \
    220 }
    221 
    222 
    223     // generate SQL where clause
    224     config->where = psMetadataAlloc();
    225 
    226 {
    227     psString str = NULL;
    228     bool status = false;
    229     if ((str = psMetadataLookupStr(&status, config->args, "-magic_id"))) {
    230         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(str))) {
    231             psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id");
    232             psFree(config);
    233             return NULL;
    234         }
    235     }
    236 }
    237     addWhereStr(skycell_id);
    238     addWhereStr(tess_id);
    239     addWhereStr(exp_id);
    240     addWhereStr(node);
    241 
    242     // convert '-code' to 'fault'
    243     {
    244         psS16 fault = 0;
    245         bool status = false;
    246         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    247             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    248                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    249                 psFree(config);
    250                 return NULL;
    251             }
    252         }
    253     }
    254 
    255     if (config->where->list->n < 1) {
    256         psFree(config->where);
    257         config->where = NULL;
    258     }
    259 
    260177    // define Database handle, if used
    261178    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/pstamptool.c

    r18531 r18561  
    102102    PS_ASSERT_PTR_NON_NULL(config, false);
    103103
    104     bool status = false;
    105     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    106     if (!status) {
    107         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    108         return false;
    109     }
    110     if (!uri) {
    111         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    112         return false;
    113     }
    114     psString outProduct = psMetadataLookupStr(&status, config->args, "-out_product");
    115     if (!status) {
    116         psError(PS_ERR_UNKNOWN, false, "failed to looku value for -out_product");
    117         return false;
    118     }
    119     if (!outProduct) {
    120         psError(PS_ERR_UNKNOWN, true, "-out_product is required");
    121         return false;
    122     }
    123 
    124     psString lastFileset = psMetadataLookupStr(&status, config->args, "-last_fileset");
    125     psString state = psMetadataLookupStr(&status, config->args, "-state");
    126     if (!state) {
    127         state = "enabled";
    128     }
     104    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
     105    PXOPT_LOOKUP_STR(outProduct,  config->args, "-out_product",   true, false);
     106    PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset", false, false);
     107    PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    129108
    130109    if (!pstampDataStoreInsert(config->dbh,
    … …  
    144123static bool datastoreMode(pxConfig *config)
    145124{
    146     bool status = false;
    147     PS_ASSERT_PTR_NON_NULL(config, false);
    148 
    149     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    150     if (!status) {
    151         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    152         return false;
    153     }
    154 
    155     psString query = NULL;
    156     psStringAppend(&query, "SELECT * FROM pstampDataStore");
    157     if (ds_id) {
    158         psStringAppend(&query, " WHERE ds_id = '%s'", ds_id);
    159     }
     125    PS_ASSERT_PTR_NON_NULL(config, false);
     126
     127    psMetadata *where = psMetadataAlloc();
     128    PXOPT_COPY_STR(config->args, where, "-ds_id", "ds_id", "==");
     129
     130    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     131
     132    psString query = pxDataGet("pstamptool_datastore.sql");
     133    if (!query) {
     134        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     135        return false;
     136    }
     137
     138    if (psListLength(where->list)) {
     139        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     140        psStringAppend(&query, " %s", whereClause);
     141        psFree(whereClause);
     142    }
     143    psFree(where);
     144
    160145    if (!p_psDBRunQuery(config->dbh, query)) {
    161146        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    172157        psFree(output);
    173158        return true;
    174     }
    175 
    176     bool simple = false;
    177     {
    178         bool status = false;
    179         simple = psMetadataLookupBool(&status, config->args, "-simple");
    180         if (!status) {
    181             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    182             return false;
    183         }
    184159    }
    185160
    … …  
    197172static bool moddatastoreMode(pxConfig *config)
    198173{
    199     bool    status;
    200 
    201     PS_ASSERT_PTR_NON_NULL(config, false);
    202 
    203     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    204     if (!status) {
    205         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    206         return false;
    207     }
    208     if (!ds_id) {
    209         psError(PS_ERR_UNKNOWN, true, "-ds_id is required");
    210         return false;
    211     }
    212     psString lastFileset = psMetadataLookupStr(&status, config->args, "-last_fileset");
    213     if (!status) {
    214         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -last_fileset");
    215         return false;
    216     }
    217     psString state = psMetadataLookupStr(&status, config->args, "-state");
    218     if (!status) {
    219         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    220         return false;
    221     }
     174    PS_ASSERT_PTR_NON_NULL(config, false);
     175
     176    PXOPT_LOOKUP_STR(ds_id,       config->args, "-ds_id",         true, false);
     177    PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset",  false, false);
     178    PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    222179
    223180    if (!state && !lastFileset) {
    … …  
    226183    }
    227184
    228     char *query = NULL;
     185    char *query = psStringCopy ("UPDATE pstampDataStore SET");
    229186    bool needComma = false;
    230187   
    231     psStringAppend(&query, "UPDATE pstampDataStore SET");
    232 
    233188    if (lastFileset) {
    234189        psStringAppend(&query, " lastFileset = '%s'", lastFileset);
    … …  
    237192
    238193    if (state) {
    239         psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ",
    240             state);
     194        psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ", state);
    241195        needComma = true; // be ready in case we add another field
    242196    }
    … …  
    262216static bool addReqMode(pxConfig *config)
    263217{
    264     bool    status;
    265 
    266     PS_ASSERT_PTR_NON_NULL(config, false);
    267 
    268     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    269     if (!status) {
    270         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    271         return false;
    272     }
    273     if (!uri) {
    274         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    275         return false;
    276     }
    277 
    278     // Data Store ID is optional
    279     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    280     if (!status) {
    281         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    282         return false;
    283     }
    284     if (!ds_id) {
    285         ds_id = "0";
    286     }
     218    PS_ASSERT_PTR_NON_NULL(config, false);
     219
     220    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
     221    // PXOPT_LOOKUP_STR(outFileset,  config->args, "-out_fileset",   true, false);
     222    PXOPT_LOOKUP_STR(ds_id,       config->args, "-ds_id",         false, false);
    287223
    288224    char *query ="INSERT INTO pstampRequest"
    … …  
    313249    PS_ASSERT_PTR_NON_NULL(config, false);
    314250
    315     bool status = false;
    316     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    317     if (!status) {
    318         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    319         return false;
    320     }
    321 
    322     psString query = psStringCopy(
    323             "SELECT"
    324             " *"
    325             " FROM pstampRequest"
    326             " WHERE state = 'new'"
    327         );
    328 
    329     if (config->where) {
    330         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pstampRequest");
     251    psMetadata *where = psMetadataAlloc();
     252    PXOPT_COPY_STR(config->args, where, "-ds_id", "ds_id", "==");
     253
     254    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     255    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     256
     257    psString query = pxDataGet("pstamptool_pendingreq.sql");
     258    if (!query) {
     259        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     260        return false;
     261    }
     262
     263    if (psListLength(where->list)) {
     264        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampRequest");
    331265        psStringAppend(&query, " AND %s", whereClause);
    332266        psFree(whereClause);
    333267    }
     268    psFree(where);
    334269
    335270    // treat limit == 0 as "no limit"
    … …  
    358293    }
    359294
    360     bool simple = false;
    361     {
    362         bool status = false;
    363         simple = psMetadataLookupBool(&status, config->args, "-simple");
    364         if (!status) {
    365             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    366             psFree(output);
    367             return false;
    368         }
    369     }
    370 
    371295    // negative simple so the default is true
    372296    if (!ippdbPrintMetadatas(stdout, output, "pstampRequest", !simple)) {
    … …  
    380304    return true;
    381305}
    382 static bool completedReqMode(pxConfig *config)
    383 {
    384     PS_ASSERT_PTR_NON_NULL(config, false);
    385 
    386     bool status = false;
    387     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    388     if (!status) {
    389         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    390         return false;
    391     }
     306
     307static bool listReqMode(pxConfig *config)
     308{
     309    PS_ASSERT_PTR_NON_NULL(config, false);
     310
     311    PXOPT_LOOKUP_STR(req_id,  config->args, "-req_id", true, false);
     312    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
     313    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    392314
    393315    psString query = NULL;
    394316    psStringAppend(&query,
    395         "SELECT * FROM pstampRequest WHERE state = 'run' AND "
    396             "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
    397             " AND pstampJob.state != 'stop') = 0" );
    398 
     317                   "SELECT * FROM pstampRequest WHERE state = 'run' AND "
     318                   "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
     319                   " AND pstampJob.state != 'stop') = 0" );
     320   
    399321    // treat limit == 0 as "no limit"
    400322    if (limit) {
    … …  
    409331        return false;
    410332    }
     333    psFree(query);
    411334
    412335    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    415338        return false;
    416339    }
    417 
    418340    if (!psArrayLength(output)) {
    419341        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    420342        psFree(output);
    421343        return true;
    422     }
    423 
    424     bool simple = false;
    425     {
    426         bool status = false;
    427         simple = psMetadataLookupBool(&status, config->args, "-simple");
    428         if (!status) {
    429             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    430             psFree(output);
    431             return false;
    432         }
    433344    }
    434345
    … …  
    445356}
    446357
    447 static bool listReqMode(pxConfig *config)
    448 {
    449     PS_ASSERT_PTR_NON_NULL(config, false);
    450 
    451     bool status = false;
    452     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    453     if (!status) {
    454         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    455         return false;
    456     }
    457 
    458     psString query = NULL;
    459 
    460     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    461    
    462     if (req_id) {
    463         psStringAppend(&query,
    464                 "SELECT"
    465                 " *"
    466                 " FROM pstampRequest"
    467                 " WHERE req_id = %s", req_id
    468             );
    469     } else {
    470         fprintf(stderr, "req_id must be specified\n");
    471         exit (1);
    472     }
     358static bool completedReqMode(pxConfig *config)
     359{
     360    PS_ASSERT_PTR_NON_NULL(config, false);
     361
     362    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     363    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     364
     365    psString query =
     366        "SELECT * FROM pstampRequest WHERE state = 'run' AND "
     367            "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
     368            " AND pstampJob.state != 'stop') = 0" ;
    473369
    474370    // treat limit == 0 as "no limit"
    … …  
    484380        return false;
    485381    }
    486     psFree(query);
    487382
    488383    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    491386        return false;
    492387    }
     388
    493389    if (!psArrayLength(output)) {
    494390        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    495391        psFree(output);
    496392        return true;
    497     }
    498 
    499     bool simple = false;
    500     {
    501         bool status = false;
    502         simple = psMetadataLookupBool(&status, config->args, "-simple");
    503         if (!status) {
    504             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    505             psFree(output);
    506             return false;
    507         }
    508393    }
    509394
    … …  
    522407static bool processedReqMode(pxConfig *config)
    523408{
    524     bool    status;
    525 
    526     PS_ASSERT_PTR_NON_NULL(config, false);
    527 
    528     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    529     if (!status) {
    530         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -req_id");
    531         return false;
    532     }
    533     if (!req_id) {
    534         psError(PS_ERR_UNKNOWN, true, "-req_id is required");
    535         return false;
    536     }
    537     psString state = psMetadataLookupStr(&status, config->args, "-state");
    538     if (!status) {
    539         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    540         return false;
    541     }
    542     psString outProduct = psMetadataLookupStr(&status, config->args, "-outProduct");
    543     if (!status) {
    544         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -outProduct");
    545         return false;
    546     }
    547     psString fault = psMetadataLookupStr(&status, config->args, "-fault");
    548     if (!status) {
    549         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fault");
    550         return false;
    551     }
    552 
    553     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    554     if (!status) {
    555         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    556         return false;
    557     }
    558     psString name = psMetadataLookupStr(&status, config->args, "-name");
    559     if (!status) {
    560         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -name");
    561         return false;
    562     }
    563     psString reqType = psMetadataLookupStr(&status, config->args, "-reqType");
    564     if (!status) {
    565         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reqType");
    566         return false;
    567     }
     409    PS_ASSERT_PTR_NON_NULL(config, false);
     410
     411    PXOPT_LOOKUP_STR(req_id,     config->args, "-req_id",     true, false);
     412    PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
     413    PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
     414    PXOPT_LOOKUP_STR(fault,      config->args, "-fault",      false, false);
     415    PXOPT_LOOKUP_STR(uri,        config->args, "-uri",        false, false);
     416    PXOPT_LOOKUP_STR(name,       config->args, "-name",       false, false);
     417    PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    568418
    569419    psString query = NULL;
    … …  
    621471static bool revertReqMode(pxConfig *config)
    622472{
    623     bool    status;
    624 
    625     PS_ASSERT_PTR_NON_NULL(config, false);
    626 
    627     psS64 req_id = psMetadataLookupS64(&status, config->args, "-req_id");
    628     if (!status) {
    629         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -req_id");
    630         return false;
    631     }
    632     if (!req_id) {
    633         psError(PS_ERR_UNKNOWN, true, "-req_id is required");
    634         return false;
    635     }
    636        
     473    PS_ASSERT_PTR_NON_NULL(config, false);
     474
     475    PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",     true, false);
    637476
    638477    printf("Revert request %" PRId64 "\n", req_id);
    … …  
    653492static bool addJobMode(pxConfig *config)
    654493{
    655     bool    status;
    656494    bool    stampJob = false;
    657 
    658     PS_ASSERT_PTR_NON_NULL(config, false);
    659 
    660     psString job_type = psMetadataLookupStr(&status, config->args, "-job_type");
    661     if (!status) {
    662         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -job_type");
    663         return false;
    664     }
    665     if (job_type) {
    666         if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
    667             stampJob = false;
    668         } else if (!strcmp(job_type, "stamp")) {
    669             stampJob = true;
    670         } else {
    671             psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    672             return false;
    673         }
     495    char   *query = NULL;
     496
     497    PS_ASSERT_PTR_NON_NULL(config, false);
     498
     499    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",        true, false);
     500    PXOPT_LOOKUP_STR(req_id,      config->args, "-req_id",     true, false);
     501    PXOPT_LOOKUP_STR(rownum,      config->args, "-rownum",     true, false);
     502    PXOPT_LOOKUP_STR(job_type,    config->args, "-job_type",   false, false);
     503    PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", true,  false);
     504    PXOPT_LOOKUP_STR(argString,   config->args, "-args",       false, false);
     505    PXOPT_LOOKUP_STR(stateString, config->args, "-state",      false, false);
     506    PXOPT_LOOKUP_STR(fault,       config->args, "-fault",      false, false);
     507
     508    // default value for job_type is defined in pstamptoolConfig.c
     509    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
     510        stampJob = false;
     511    } else if (!strcmp(job_type, "stamp")) {
     512        stampJob = true;
    674513    } else {
    675         job_type = "stamp";
    676         stampJob = true;
    677     }
    678 
    679     psString rownum = psMetadataLookupStr(&status, config->args, "-rownum");
    680     if (!status) {
    681         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -rownum");
    682         return false;
    683     }
    684     if (!rownum) {
    685         psError(PS_ERR_UNKNOWN, true, "-rownum is required");
    686         return false;
    687     }
    688     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    689     if (!status) {
    690         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    691         return false;
    692     }
    693     if (!uri) {
    694         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    695         return false;
    696     }
    697 
    698     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    699     if (!status) {
    700         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -req_id");
    701         return false;
    702     }
    703     if (!req_id) {
    704         psError(PS_ERR_UNKNOWN, true, "-req_id is required");
    705         return false;
    706     }
    707 
    708     psString outputBase = psMetadataLookupStr(&status, config->args, "-outputBase");
    709     if (!status) {
    710         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -outputBase");
    711         return false;
    712     }
    713     if (!outputBase) {
    714         psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
    715         return false;
    716     }
    717 
    718     psString argString = psMetadataLookupStr(&status, config->args, "-args");
    719     if (!status) {
    720         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -args");
    721         return false;
    722     }
    723     if (!argString) {
    724         if (stampJob) {
    725             psError(PS_ERR_UNKNOWN, true, "-args is required");
    726             return false;
    727         }
    728     }
    729 
    730     psString stateString = psMetadataLookupStr(&status, config->args, "-state");
    731     if (!status) {
    732         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    733         return false;
    734     }
    735     if (!stateString) {
    736         stateString = "run";
    737     }
    738     psString fault = psMetadataLookupStr(&status, config->args, "-fault");
    739     if (!status) {
    740         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fault");
    741         return false;
    742     }
    743     if (!fault) {
    744         fault = "0";
    745     }
    746 
    747     char *query;
    748    
     514        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     515        return false;
     516    }
     517
     518    if (stampJob && !argString) {
     519        psError(PS_ERR_UNKNOWN, true, "-args is required for stamp job");
     520        return false;
     521    }
     522
    749523    if (stampJob) {
    750         query ="INSERT INTO pstampJob"
    751                  " (req_id, rownum, state, jobType, uri, outputBase, fault, args)"
    752                  " VALUES( %s, '%s', '%s', '%s', '%s', '%s', %s, '%s')";
     524        query = pxDataGet("pstamptool_addjob_stampjob.sql");
    753525    } else {
    754         query ="INSERT INTO pstampJob"
    755                  " (req_id, rownum, state, jobType, uri, outputBase, fault)"
    756                  " VALUES( %s, '%s', '%s', '%s', '%s', '%s', %s)";
     526        query = pxDataGet("pstamptool_addjob_otherjob.sql");
     527    }
     528    if (!query) {
     529        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     530        return false;
    757531    }
    758532
    … …  
    780554    PS_ASSERT_PTR_NON_NULL(config, false);
    781555
    782     bool status = false;
    783     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    784     if (!status) {
    785         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    786         return false;
    787     }
     556    PXOPT_LOOKUP_STR(req_id, config->args, "-req_id", false, false);
     557    PXOPT_LOOKUP_STR(job_id, config->args, "-job_id", false, false);
     558
     559    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     560    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    788561
    789562    psString query = NULL;
    790563
    791     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    792     psString job_id = psMetadataLookupStr(&status, config->args, "-job_id");
    793    
     564    if (!req_id && !job_id) {
     565        fprintf(stderr, "either req_id or job_id must be specified\n");
     566        exit (1);
     567    }
     568
    794569    if (req_id) {
    795570        psStringAppend(&query,
    … …  
    799574                " WHERE req_id = %s", req_id
    800575            );
    801     } else if (job_id) {
     576    } else {
    802577        psStringAppend(&query,
    803578                "SELECT"
    … …  
    806581                " WHERE job_id = %s", job_id
    807582            );
    808     } else {
    809         fprintf(stderr, "either req_id or job_id must be specified\n");
    810         exit (1);
    811     }
     583    }
    812584
    813585    // treat limit == 0 as "no limit"
    … …  
    836608    }
    837609
    838     bool simple = false;
    839     {
    840         bool status = false;
    841         simple = psMetadataLookupBool(&status, config->args, "-simple");
    842         if (!status) {
    843             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    844             psFree(output);
    845             return false;
    846         }
    847     }
    848 
    849610    // negative simple so the default is true
    850611    if (!ippdbPrintMetadatas(stdout, output, "pstampJob", !simple)) {
    … …  
    863624    PS_ASSERT_PTR_NON_NULL(config, false);
    864625
    865     bool status = false;
    866     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    867     if (!status) {
    868         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    869         return false;
    870     }
    871 
    872     psString query = psStringCopy(
    873             "SELECT"
    874             " *"
    875             " FROM pstampJob"
    876             " WHERE state = 'run'"
    877         );
    878 
    879     if (config->where) {
    880         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pstampJob");
     626    psMetadata *where = psMetadataAlloc();
     627    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     628
     629    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     630    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     631
     632    psString query = pxDataGet("pstamptool_pendingjob.sql");
     633    if (!query) {
     634        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     635        return false;
     636    }
     637
     638    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     639    if (psListLength(where->list)) {
     640        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
    881641        psStringAppend(&query, " AND %s", whereClause);
    882642        psFree(whereClause);
    883643    }
     644    psFree(where);
    884645
    885646    // treat limit == 0 as "no limit"
    … …  
    908669    }
    909670
    910     bool simple = false;
    911     {
    912         bool status = false;
    913         simple = psMetadataLookupBool(&status, config->args, "-simple");
    914         if (!status) {
    915             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    916             psFree(output);
    917             return false;
    918         }
    919     }
    920 
    921671    // negative simple so the default is true
    922672    if (!ippdbPrintMetadatas(stdout, output, "pstampJob", !simple)) {
    … …  
    933683static bool processedJobMode(pxConfig *config)
    934684{
    935     bool    status;
    936 
    937     PS_ASSERT_PTR_NON_NULL(config, false);
    938 
    939     psString job_id = psMetadataLookupStr(&status, config->args, "-job_id");
    940     if (!status) {
    941         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -job_id");
    942         return false;
    943     }
    944     if (!job_id) {
    945         psError(PS_ERR_UNKNOWN, true, "-job_id is required");
    946         return false;
    947     }
    948     psString state = psMetadataLookupStr(&status, config->args, "-state");
    949     if (!status) {
    950         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    951         return false;
    952     }
    953     if (!state) {
    954         psError(PS_ERR_UNKNOWN, true, "-state is required");
    955         return false;
    956     }
    957     psString fault = psMetadataLookupStr(&status, config->args, "-fault");
    958     if (!status) {
    959         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -fault");
    960         return false;
    961     }
     685    PS_ASSERT_PTR_NON_NULL(config, false);
     686
     687    PXOPT_LOOKUP_STR(job_id,    config->args, "-job_id", true, false);
     688    PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
     689    PXOPT_LOOKUP_STR(fault,     config->args, "-fault",  false, false);
    962690
    963691    psString faultStr = NULL;
    … …  
    967695        psStringAppend(&faultStr, ", fault = '%s'", fault);
    968696    }
    969        
     697
    970698    char *query ="UPDATE pstampJob"
    971                  " SET state = '%s' %s"
    972                  " WHERE job_id = '%s'";
    973 
     699        " SET state = '%s' %s"
     700        " WHERE job_id = '%s'";
     701   
    974702    if (!p_psDBRunQuery(config->dbh, query, state, faultStr, job_id)) {
    975703        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/pstamptoolConfig.c

    r18531 r18561  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,
    48             "define storage uri", NULL);
    49     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,
    50             "define last fileset seen", NULL);
    51     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-state", 0,
    52             "define datastore state", NULL);
    53     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-out_product", 0,
    54             "define output product name", NULL);
     47    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri",          0, "define storage uri (required)", NULL);
     48    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-out_product",  0, "define output product name (required)", NULL);
     49    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0, "define last fileset seen", NULL);
     50    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-state",        0, "define datastore state", "enabled");
    5551   
    5652    // -datastore
    5753    psMetadata *datastoreArgs = psMetadataAlloc();
    58     psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,
    59             "use the simple output format", false);
    60     psMetadataAddStr(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,
    61             "define ds_id", NULL);
     54    psMetadataAddStr(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", NULL);
     55    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    6256
    6357    // -moddatastore
    6458    psMetadata *moddatastoreArgs = psMetadataAlloc();
    65     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,
    66             "define ds_id", NULL);
    67     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,
    68             "define storage uri", NULL);
    69     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,
    70             "define storage uri", NULL);
    71     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-out_product", 0,
    72             "define output product name", NULL);
    73 
     59    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", "0");
     60    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,            "define storage uri", NULL);
     61    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,            "define storage uri", NULL);
    7462
    7563    // -addreq
    7664    psMetadata *addreqArgs = psMetadataAlloc();
    77     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,
    78             "define request file uri", NULL);
    79     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,
    80             "define request ds_id", NULL);
     65    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,            "define request file uri", NULL);
     66    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,            "define request ds_id", NULL);
     67    // psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-out_fileset", 0,            "define request output_fileset", NULL);
    8168
    8269    // -pendingreq
    8370    psMetadata *pendingreqArgs = psMetadataAlloc();
    84     psMetadataAddStr(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,
    85             "define req_id", NULL);
    86     psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,
    87             "limit result set to N items", 0);
    88     psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,
    89             "use the simple output format", false);
     71    psMetadataAddStr(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", NULL);
     72    psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     73    psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    9074
    9175    // -listreq
    9276    psMetadata *listreqArgs = psMetadataAlloc();
    93     psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-req_id", 0,
    94             "define req_id", NULL);
    95     psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,
    96             "limit result set to N items", 0);
    97     psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,
    98             "use the simple output format", false);
     77    psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", NULL);
     78    psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     79    psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    9980
    10081    // -completedreq
    10182    psMetadata *completedreqArgs = psMetadataAlloc();
    102     psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,
    103             "limit result set to N items", 0);
    104     psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,
    105             "use the simple output format", false);
     83    psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     84    psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10685
    10786    // -processedreq
    10887    psMetadata *processedreqArgs = psMetadataAlloc();
    109     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-req_id", 0,
    110             "req_id for which to change state", NULL);
    111     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-state", 0,
    112             "new state", NULL);
    113     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-outProduct", 0,
    114             "define request outProduct", NULL);
    115     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-fault", 0,
    116             "define request fault code", NULL);
    117     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-uri", 0,
    118             "define the uri", NULL);
    119     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-name", 0,
    120             "define the name", NULL);
    121     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-reqType", 0,
    122             "define the reqType", NULL);
     88    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", NULL);
     89    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
     90    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL);
     91    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", NULL);
     92    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL);
     93    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL);
     94    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-reqType", 0,            "define the reqType", NULL);
    12395
    12496    // -revertreq
    12597    psMetadata *revertreqArgs = psMetadataAlloc();
    126     psMetadataAddS64(revertreqArgs, PS_LIST_TAIL, "-req_id", 0,
    127             "req_id for which to revert", 0);
     98    psMetadataAddS64(revertreqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to revert", 0);
    12899
    129100    // -addjob
    130101    psMetadata *addjobArgs = psMetadataAlloc();
    131     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,
    132             "define job file uri", NULL);
    133     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-req_id", 0,
    134             "define job req_id", NULL);
    135     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,
    136             "define job rownum", NULL);
    137     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,
    138             "define job job_type", NULL);
    139     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,
    140             "define job outputBase", NULL);
    141     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,
    142             "define job args", NULL);
    143     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,
    144             "new state", NULL);
    145     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-fault", 0,
    146             "new result", NULL);
     102    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,            "define job file uri", NULL);
     103    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", NULL);
     104    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,            "define job rownum", NULL);
     105    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
     106    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
     107    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,            "define job args", NULL);
     108    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
     109    // psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-result", 0,            "new result", "0");
     110    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
    147111
    148112    // -listjob
    149113    psMetadata *listjobArgs = psMetadataAlloc();
    150     psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-req_id", 0,
    151             "define request", NULL);
    152     psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-job_id", 0,
    153             "define job", NULL);
    154     psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,
    155             "limit result set to N items", 0);
    156     psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,
    157             "use the simple output format", false);
     114    psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", NULL);
     115    psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", NULL);
     116    psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     117    psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    158118
    159119    // -pendingjob
    160120    psMetadata *pendingjobArgs = psMetadataAlloc();
    161     psMetadataAddStr(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,
    162             "define job", NULL);
    163     psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,
    164             "limit result set to N items", 0);
    165     psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,
    166             "use the simple output format", false);
     121    psMetadataAddStr(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", NULL);
     122    psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     123    psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    167124
    168125    // -processedjob
    169126    psMetadata *processedjobArgs = psMetadataAlloc();
    170     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-job_id", 0,
    171             "req_id for which to change state", NULL);
    172     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-state", 0,
    173             "new state", NULL);
    174     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-fault", 0,
    175             "new result", NULL);
    176 
    177 #define PXTOOL_MODE(option, modeval, argset) \
    178 { \
    179     int N = 0; \
    180     if ((N = psArgumentGet (argc, argv, option))) { \
    181         psArgumentRemove (N, &argc, argv); \
    182         if (config->mode) { \
    183             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    184             psFree(config); \
    185             return NULL; \
    186         } \
    187         config->mode = modeval; \
    188         config->args = psMemIncrRefCounter(argset); \
    189     } \
    190     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    191         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    192     } \
    193     psFree(argset); \
    194 }
     127    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", NULL);
     128    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
     129    // psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-result", 0,            "new result", NULL);
     130    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
    195131
    196132    psMetadata *argSets = psMetadataAlloc();
    … …  
    224160    psFree(modes);
    225161
    226     // setup search criterion
    227 #define addWhereStr(name) \
    228 { \
    229     psString str = NULL; \
    230     bool status = false; \
    231     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    232         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    233             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    234             psFree(config); \
    235             return NULL; \
    236         } \
    237     } \
    238 }
    239 
    240     // generate SQL where clause
    241     config->where = psMetadataAlloc();
    242 
    243     addWhereStr(req_id);
    244     addWhereStr(job_id);
    245 
    246     if (config->where->list->n < 1) {
    247         psFree(config->where);
    248         config->where = NULL;
    249     }
    250 
    251162    // define Database handle, if used
    252163    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/pxconfig.c

    r17015 r18561  
    4343    config->dbh             = NULL;
    4444    config->modules         = NULL;
    45     config->where           = NULL;
     45    // XXX config->where           = NULL;
    4646    config->args            = NULL;
    4747
    … …  
    5454    psFree(config->dbh);
    5555    psFree(config->modules);
    56     psFree(config->where);
     56    // XXX psFree(config->where);
    5757    psFree(config->args);
    5858}

  • trunk/ippTools/src/pxconfig.h

    r14018 r18561  
    3030    psDB *dbh;
    3131    psMetadata *args;
    32     psMetadata *where;
     32    // XXX deprecate psMetadata *where;
    3333    int argc;
    3434    char **argv;

  • trunk/ippTools/src/pxinjectConfig.c

    r18336 r18561  
    4545    // -newExp
    4646    psMetadata *newExpArgs = psMetadataAlloc();
    47     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_exp_name",  0,
    48             "define the exp_name (required)", NULL);
    49     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_inst",  0,
    50             "define the camera name (required)", NULL);
    51     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_telescope",  0,
    52             "define the telescope name (required)", NULL);
    53     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-workdir",  0,
    54             "define workdir (required)", 0);
    55     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-reduction",  0,
    56             "define reduction class", NULL);
    57     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-dvodb",  0,
    58             "define the dvodb for the next processing step", NULL);
    59     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tess_id",  0,
    60             "define the tess_id for the next processing step", NULL);
    61     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-end_stage",  0,
    62             "define the end goal processing step", NULL);
    63     psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-label",  0,
    64             "define a label (carried to chip stage)", NULL);
    65     psMetadataAddBool(newExpArgs, PS_LIST_TAIL, "-simple",  0,
    66             "use the simple output format", false);
     47    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_exp_name",  0,            "define the exp_name (required)", NULL);
     48    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_inst",  0,            "define the camera name (required)", NULL);
     49    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tmp_telescope",  0,            "define the telescope name (required)", NULL);
     50    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-workdir",  0,            "define workdir (required)", 0);
     51    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
     52    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-dvodb",  0,            "define the dvodb for the next processing step", NULL);
     53    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-tess_id",  0,            "define the tess_id for the next processing step", NULL);
     54    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-end_stage",  0,            "define the end goal processing step", NULL);
     55    psMetadataAddStr(newExpArgs, PS_LIST_TAIL, "-label",  0,            "define a label (carried to chip stage)", NULL);
     56    psMetadataAddBool(newExpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6757
    6858    // -newImfile
    6959    psMetadata *newImfileArgs = psMetadataAlloc();
    70     psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    71             "define the exp_id (required)", 0);
    72     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,
    73             "define the class ID (required)", NULL);
    74     psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-uri",  0,
    75             "define the URI (required)", NULL);
     60    psMetadataAddS64(newImfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define the exp_id (required)", 0);
     61    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-tmp_class_id",  0,            "define the class ID (required)", NULL);
     62    psMetadataAddStr(newImfileArgs, PS_LIST_TAIL, "-uri",  0,            "define the URI (required)", NULL);
    7663
    7764    // -updatenewExp
    7865    psMetadata *updatenewExpArgs = psMetadataAlloc();
    79     psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,
    80             "define the exp_id (required)", 0);
    81     psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,
    82             "set state (required)", NULL);
    83 
     66    psMetadataAddS64(updatenewExpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define the exp_id (required)", 0);
     67    psMetadataAddStr(updatenewExpArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    8468
    8569    psMetadata *argSets = psMetadataAlloc();
    … …  
    10185    psFree(modes);
    10286
    103     // setup search criterion
    104 #define addWhereStr(name) \
    105 { \
    106     psString str = NULL; \
    107     bool status = false; \
    108     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    109         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    110             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    111             psFree(config); \
    112             return NULL; \
    113         } \
    114     } \
    115 }
    116 
    117     // generate SQL where clause
    118     config->where = psMetadataAlloc();
    119 
    120     addWhereStr(det_id);
    121     {
    122         int n = 0;
    123         bool status = false;
    124         if ((n = psMetadataLookupS32(&status, config->args, "-iteration"))) {
    125             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "iteration", 0, "==", n)) {
    126                 psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    127                 psFree(config);
    128                 return NULL;
    129             }
    130         }
    131     }
    132     addWhereStr(det_type);
    133     addWhereStr(exp_id);
    134     addWhereStr(class_id);
    135     // convert '-inst' to 'camera'
    136     {
    137         psString str = NULL;
    138         bool status = false;
    139         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    140             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    141                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    142                 psFree(config);
    143                 return NULL;
    144             }
    145         }
    146     }
    147     addWhereStr(telescope);
    148     {
    149         int n = 0;
    150         bool status = false;
    151         if ((n = psMetadataLookupS32(&status, config->args, "-imfiles"))) {
    152             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "imfiles", 0, "==", n)) {
    153                 psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles");
    154                 psFree(config);
    155                 return NULL;
    156             }
    157         }
    158     }
    159     addWhereStr(filter);
    160     addWhereStr(stats);
    161     addWhereStr(recipe);
    162     {
    163         int n = 0;
    164         bool status = false;
    165         if ((n = psMetadataLookupS32(&status, config->args, "-guide_version"))) {
    166             if (!psMetadataAddS32(config->where, PS_LIST_TAIL, "guide_version", 0, "==", n)) {
    167                 psError(PS_ERR_UNKNOWN, false, "failed to add item guide_version");
    168                 psFree(config);
    169                 return NULL;
    170             }
    171         }
    172     }
    173     {
    174         bool boolean = false;
    175         bool status = false;
    176 
    177         if ((boolean = psMetadataLookupBool(&status, config->args, "-accept"))) {
    178             if (!psMetadataAddBool(config->where, PS_LIST_TAIL, "accept", 0, "==", boolean)) {
    179                 psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
    180                 psFree(config);
    181                 return NULL;
    182             }
    183         }
    184     }
    185 
    186     if (config->where->list->n < 1) {
    187         psFree(config->where);
    188         config->where = NULL;
    189     }
    190 
    19187    // define Database handle, if used
    19288    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/pxtools.h

    r18366 r18561  
    2222
    2323#include <stdio.h>
     24#include <string.h>   // for strcmp and strncmp
    2425#include <strings.h>  // for strcasecmp
    2526#include <unistd.h>   // for unlink
     27
     28// #include <stdlib.h>
     29// #include <stdint.h>
     30// #include <inttypes.h>
     31
    2632#include <pslib.h>
    2733#include <psmodules.h>
    … …  
    253259  PXOPT_COPY_PRIMITIVE(from, to, psU64, U64, oldname, newname, comment)
    254260
     261
     262/*** these PXOPT_ADD_WHERE macros are used to construct the default sql elements ***/
     263
     264#define PXOPT_ADD_WHERE_STR(name) \
     265{ \
     266    psString str = NULL; \
     267    bool status = false; \
     268    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     269        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
     270            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     271            psFree(config); \
     272            return NULL; \
     273        } \
     274    } \
     275}
     276
     277#define PXOPT_ADD_WHERE_STR_ALIAS(name,realname) \
     278{ \
     279    psString str = NULL; \
     280    bool status = false; \
     281    if ((str = psMetadataLookupStr(&status, config->args, name))) { \
     282        if (!psMetadataAddStr(config->where, PS_LIST_TAIL, realname, 0, "==", str)) {\
     283            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", name); \
     284            psFree(config); \
     285            return NULL; \
     286        } \
     287    } \
     288}
     289
     290#define PXOPT_ADD_WHERE_S16(name) \
     291{ \
     292    psS16 s16 = 0; \
     293    bool status = false; \
     294    if ((s16= psMetadataLookupS16(&status, config->args, "-" #name))) { \
     295        if (!psMetadataAddS16(config->where, PS_LIST_TAIL, #name, 0, "==", s16)) { \
     296            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     297            psFree(config); \
     298            return NULL; \
     299        } \
     300    } \
     301}
     302
     303#define PXOPT_ADD_WHERE_BOOL(name) \
     304{ \
     305    bool value = false;  \
     306    bool status = false; \
     307    if ((value = psMetadataLookupBool(&status, config->args, "-" #name))) { \
     308        if (!psMetadataAddBool(config->where, PS_LIST_TAIL, #name, 0, "==", value)) { \
     309            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     310            psFree(config); \
     311            return NULL; \
     312        } \
     313    } \
     314}
     315
     316#define PXOPT_ADD_WHERE_S32(name) \
     317{ \
     318    psS32 s32 = 0; \
     319    bool status = false; \
     320    if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
     321        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
     322            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     323            psFree(config); \
     324            return NULL; \
     325        } \
     326    } \
     327}
     328
     329#define PXOPT_ADD_WHERE_S64(name) \
     330{ \
     331    psS64 s64 = 0; \
     332    bool status = false; \
     333    if ((s64= psMetadataLookupS64(&status, config->args, "-" #name))) { \
     334        if (!psMetadataAddS64(config->where, PS_LIST_TAIL, #name, 0, "==", s64)) { \
     335            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     336            psFree(config); \
     337            return NULL; \
     338        } \
     339    } \
     340}
     341
     342#define PXOPT_ADD_WHERE_F32(name) \
     343{ \
     344    psF32 var = 0; \
     345    bool status = false; \
     346    if ((var = psMetadataLookupF32(&status, config->args, "-" #name))) { \
     347        if (!isnan(var)) { \
     348            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     349                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     350                psFree(config); \
     351                return NULL; \
     352            } \
     353        } \
     354    } \
     355}
     356
     357#define PXOPT_ADD_WHERE_F64(name) \
     358{ \
     359    psF64 var = 0; \
     360    bool status = false; \
     361    if ((var = psMetadataLookupF64(&status, config->args, "-" #name))) { \
     362        if (!isnan(var))  { \
     363            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, #name, 0, "==", var)) { \
     364                psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     365                psFree(config); \
     366                return NULL; \
     367            } \
     368        } \
     369    } \
     370}
     371
     372#define PXOPT_ADD_WHERE_BOOL_ALIAS(flag,name)   \
     373{ \
     374    bool value = 0; \
     375    bool status = false; \
     376    if ((value = psMetadataLookupBool(&status, config->args, flag))) {  \
     377        if (!psMetadataAddBOOL(config->where, PS_LIST_TAIL, name, 0, "==", value)) { \
     378            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     379            psFree(config); \
     380            return NULL; \
     381        } \
     382    } \
     383}
     384
     385#define PXOPT_ADD_WHERE_S16_ALIAS(flag,name)    \
     386{ \
     387    psS16 s16 = 0; \
     388    bool status = false; \
     389    if ((s16= psMetadataLookupS16(&status, config->args, flag))) {      \
     390        if (!psMetadataAddS16(config->where, PS_LIST_TAIL, name, 0, "==", s16)) { \
     391            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     392            psFree(config); \
     393            return NULL; \
     394        } \
     395    } \
     396}
     397
     398#define PXOPT_ADD_WHERE_S32_ALIAS(flag,name)    \
     399{ \
     400    psS32 s32 = 0; \
     401    bool status = false; \
     402    if ((s32= psMetadataLookupS32(&status, config->args, flag))) {      \
     403        if (!psMetadataAddS32(config->where, PS_LIST_TAIL, name, 0, "==", s32)) { \
     404            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     405            psFree(config); \
     406            return NULL; \
     407        } \
     408    } \
     409}
     410
     411#define PXOPT_ADD_WHERE_S64_ALIAS(flag,name)    \
     412{ \
     413    psS64 s64 = 0; \
     414    bool status = false; \
     415    if ((s64= psMetadataLookupS64(&status, config->args, flag))) {      \
     416        if (!psMetadataAddS64(config->where, PS_LIST_TAIL, name, 0, "==", s64)) { \
     417            psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     418            psFree(config); \
     419            return NULL; \
     420        } \
     421    } \
     422}
     423
     424#define PXOPT_ADD_WHERE_F32_ALIAS(flag,name)    \
     425{ \
     426    psF32 var = 0; \
     427    bool status = false; \
     428    if ((var = psMetadataLookupF32(&status, config->args, flag))) {     \
     429        if (!isnan(var))  { \
     430            if (!psMetadataAddF32(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \
     431                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     432                psFree(config); \
     433                return NULL; \
     434            } \
     435        } \
     436    } \
     437}
     438
     439#define PXOPT_ADD_WHERE_F64_ALIAS(flag,name)    \
     440{ \
     441    psF64 var = 0; \
     442    bool status = false; \
     443    if ((var = psMetadataLookupF64(&status, config->args, flag))) {     \
     444        if (!isnan(var))  { \
     445            if (!psMetadataAddF64(config->where, PS_LIST_TAIL, name, 0, "==", var)) { \
     446                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", flag); \
     447                psFree(config); \
     448                return NULL; \
     449            } \
     450        } \
     451    } \
     452}
     453
     454#define PXOPT_ADD_WHERE_TIME_STR(name) \
     455{ \
     456    psString str = NULL; \
     457    bool status = false; \
     458    if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
     459        psTime *time = psTimeFromISO(str, PS_TIME_UTC); \
     460        if (!time) { \
     461            psError(PS_ERR_UNKNOWN, false, "failed to convert " #name " into a psTime object"); \
     462            psFree(config); \
     463            return NULL; \
     464        } \
     465        psMetadataItem *item = psMetadataLookup(config->args, "-" #name); \
     466        if (item) { \
     467            str = item->comment; \
     468        } else { \
     469            str = NULL; \
     470        } \
     471        if (!psMetadataAddTime(config->where, PS_LIST_TAIL, #name, 0, str, time)) {\
     472            psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
     473            psFree(config); \
     474            return NULL; \
     475        } \
     476        psFree(time); \
     477    } \
     478}
     479
    255480#endif // PXTOOLS_H

  • trunk/ippTools/src/pztool.c

    r18314 r18561  
    162162    PS_ASSERT_PTR_NON_NULL(config, false);
    163163
     164    psMetadata *where = psMetadataAlloc();
     165    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     166    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     167    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     168    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
     169
    164170    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    165171
    166172    psString query = psStringCopy("SELECT * FROM summitExp");
    167173
    168     if (config->where) {
    169         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "summitExp");
     174    if (psListLength(where->list)) {
     175        psString whereClause = psDBGenerateWhereConditionSQL(where, "summitExp");
    170176        psStringAppend(&query, " AND %s", whereClause);
    171177        psFree(whereClause);
    172178    }
     179    psFree(where);
    173180
    174181    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    206213    PS_ASSERT_PTR_NON_NULL(config, false);
    207214
     215    psMetadata *where = psMetadataAlloc();
     216    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     217    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     218    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     219    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
     220
    208221    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    209222    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    210223    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    211224
     225    // XXX leave this query here ?
    212226    psString query = psStringCopy(
    213227            "SELECT"
    … …  
    223237        );
    224238
    225     if (config->where) {
    226         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadExp");
     239    if (psListLength(where->list)) {
     240        psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadExp");
    227241        psStringAppend(&query, " AND %s", whereClause);
    228242        psFree(whereClause);
    229243    }
     244    psFree(where);
    230245
    231246    psStringAppend(&query, " ORDER BY summitExp.dateobs");
    … …  
    274289{
    275290    PS_ASSERT_PTR_NON_NULL(config, false);
     291
     292    psMetadata *where = psMetadataAlloc();
     293    PXOPT_COPY_STR(config->args, where,  "-exp_name",     "exp_name", "==");
     294    PXOPT_COPY_STR(config->args, where,  "-inst",         "camera", "==");
     295    PXOPT_COPY_STR(config->args, where,  "-telescope",    "telescope", "==");
     296    PXOPT_COPY_STR(config->args, where,  "-exp_type",     "exp_type", "==");
    276297
    277298    PXOPT_LOOKUP_BOOL(desc, config->args, "-desc", false);
    … …  
    300321        psStringAppend(&query, " WHERE camera = \"%s\"", camera);
    301322
    302         if (config->where) {
    303             psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadImfile");
     323        if (psListLength(where->list)) {
     324            psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadImfile");
    304325            psStringAppend(&query, " AND %s", whereClause);
    305326            psFree(whereClause);
    … …  
    347368        psFree(result);
    348369    }
     370    psFree(where);
    349371
    350372    // stitch the arrays of imfiles together
    … …  
    378400    // default values
    379401    PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     402
     403    // NOTE : the rest of the command-line args are parsed in copydoneCompleteExp
    380404
    381405    if (!pzDownloadImfileInsert(config->dbh,
    … …  
    447471    }
    448472
     473    // XXX this is a bit ugly : could just use the PXOPT_COPY_* methods
     474    // and not pass exp_name, camera, or telescope as additional args
    449475    psMetadata *where = psMetadataAlloc();
    450476    if (exp_name) {
    … …  
    472498    }
    473499
    474     if (config->where) {
     500    if (psListLength(where->list)) {
    475501        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    476502        psStringAppend(&query, " %s", whereClause);
    … …  
    720746    PS_ASSERT_PTR_NON_NULL(config, false);
    721747
     748    psMetadata *where = psMetadataAlloc();
     749    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
     750    PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     751    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     752    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
     753    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
     754
    722755    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    723756
    724     if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", config->where, code)) {
     757    if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", where, code)) {
    725758        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    726         return false;
    727     }
     759        psFree (where);
     760        return false;
     761    }
     762    psFree(where);
    728763
    729764    return true;
    … …  
    734769{
    735770    PS_ASSERT_PTR_NON_NULL(config, false);
     771
     772    psMetadata *where = psMetadataAlloc();
     773    PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
     774    PXOPT_COPY_STR(config->args, where, "-inst", "inst", "==");
     775    PXOPT_COPY_STR(config->args, where, "-telescope", "telescope", "==");
     776    PXOPT_COPY_STR(config->args, where,  "-class", "class", "==");
     777    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
    736778
    737779    psString query = pxDataGet("pztool_revertcopied.sql");
    … …  
    741783    }
    742784
    743     if (config->where) {
    744         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pzDownloadImfile");
     785    if (psListLength(where->list)) {
     786        psString whereClause = psDBGenerateWhereConditionSQL(where, "pzDownloadImfile");
    745787        psStringAppend(&query, " AND %s", whereClause);
    746788        psFree(whereClause);
    747789    }
     790    psFree(where);
    748791
    749792    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    803846{
    804847    PS_ASSERT_PTR_NON_NULL(config, false);
     848
     849    // NOTE : the command-line args are parsed in copydoneCompleteExp
    805850
    806851    // start a transaction so it's all rows or nothing

  • trunk/ippTools/src/pztoolConfig.c

    r18314 r18561  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-inst", 0,
    48             "define camera ID", NULL);
    49     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-telescope", 0,
    50             "define telescope ID", NULL);
    51     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,
    52             "define storage uri", NULL);
     47    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     48    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     49    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,            "define storage uri", NULL);
    5350   
    5451    // -datastore
    5552    psMetadata *datastoreArgs = psMetadataAlloc();
    56     psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,
    57             "use the simple output format", false);
     53    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    5854
    5955    // -seen
    6056    psMetadata *seenArgs = psMetadataAlloc();
    61     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_name", 0,
    62             "define exposure ID", NULL);
    63     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-inst", 0,
    64             "define camera ID", NULL);
    65     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-telescope", 0,
    66             "define telescope ID", NULL);
    67     psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_type", 0,
    68             "define exposure type", NULL);
    69     psMetadataAddBool(seenArgs, PS_LIST_TAIL, "-simple", 0,
    70             "use the simple output format", false);
     57    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     58    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     59    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     60    psMetadataAddStr(seenArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     61    psMetadataAddBool(seenArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    7162   
    7263    // -pendingexp
    7364    psMetadata *pendingexpArgs = psMetadataAlloc();
    74     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_name", 0,
    75             "define exposure ID", NULL);
    76     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst", 0,
    77             "define camera ID", NULL);
    78     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope", 0,
    79             "define telescope ID", NULL);
    80     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,
    81             "define exposure type", NULL);
    82     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,
    83             "sort ouput in descending format", false);
    84     psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    85             "limit result set to N items", 0);
    86     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
    87             "use the simple output format", false);
     65    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     66    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     67    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     68    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     69    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
     70    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     71    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    8872
    8973    // -pendingimfile
    9074    psMetadata *pendingimfileArgs = psMetadataAlloc();
    91     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_name", 0,
    92             "define exposure ID", NULL);
    93     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst", 0,
    94             "define camera ID", NULL);
    95     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-telescope", 0,
    96             "define telescope ID", NULL);
    97     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_type", 0,
    98             "define exposure type", NULL);
    99     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,
    100             "sort ouput in descending format", false);
    101     psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
    102             "limit result set to N items", 0);
    103     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,
    104             "use the simple output format", false);
     75    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     76    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     77    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     78    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-exp_type", 0,            "define exposure type", NULL);
     79    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
     80    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     81    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10582
    10683    // -copydone
    10784    psMetadata *copydoneArgs = psMetadataAlloc();
    108     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-exp_name", 0,
    109             "define exposure ID (required)", NULL);
    110     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-inst", 0,
    111             "define camera ID (required)", NULL);
    112     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-telescope", 0,
    113             "define telescope ID (required)", NULL);
    114     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class", 0,
    115             "define class", NULL);
    116     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class_id", 0,
    117             "define class_id", NULL);
    118     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-uri", 0,
    119             "define storage uri", NULL);
    120     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-workdir",  0,
    121         "define the \"default\" workdir for this exposure", NULL);
    122     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-dvodb",  0,
    123         "define the dvodb for the next processing step", NULL);
    124     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-tess_id",  0,
    125         "define the tess_id for the next processing step", NULL);
    126     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-end_stage",  0,
    127         "define the end goal processing step", NULL);
    128     psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,
    129         "define the label for the chip stage", NULL);
    130     psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-code",  0,
    131             "set fault code", 0);
     85    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     86    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     87    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     88    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     89    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     90    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-uri", 0,            "define storage uri", NULL);
     91    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-workdir",  0,        "define the \"default\" workdir for this exposure", NULL);
     92    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-dvodb",  0,        "define the dvodb for the next processing step", NULL);
     93    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-tess_id",  0,        "define the tess_id for the next processing step", NULL);
     94    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-end_stage",  0,        "define the end goal processing step", NULL);
     95    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
     96    psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    13297
    13398    // -copied
    13499    psMetadata *copiedArgs = psMetadataAlloc();
    135     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    136             "define exposure ID", NULL);
    137     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,
    138             "define camera ID", NULL);
    139     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,
    140             "define telescope ID", NULL);
    141     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class", 0,
    142             "define class", NULL);
    143     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class_id", 0,
    144             "define class_id", NULL);
    145     psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-faulted",  0,
    146             "only return imfiles with a fault status set", false);
    147     psMetadataAddU64(copiedArgs, PS_LIST_TAIL, "-limit",  0,
    148             "limit result set to N items", 0);
    149     psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-simple",  0,
    150             "use the simple output format", false);
     100    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     101    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     102    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
     103    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     104    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     105    psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     106    psMetadataAddU64(copiedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     107    psMetadataAddBool(copiedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    151108
    152109    // -updatecopied
    153110    psMetadata *updatecopiedArgs = psMetadataAlloc();
    154     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    155             "define exposure ID (required)", NULL);
    156     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,
    157             "define camera ID (required)", NULL);
    158     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,
    159             "define telescope ID (required)", NULL);
    160     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class", 0,
    161             "define class", NULL);
    162     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class_id", 0,
    163             "define class_id", NULL);
    164     psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-code",  0,
    165             "search by fault code", 0);
     111    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     112    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     113    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     114    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     115    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     116    psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    166117
    167118    // -revertcopied
    168119    psMetadata *revertcopiedArgs = psMetadataAlloc();
    169     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,
    170             "define exposure ID (required)", NULL);
    171     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,
    172             "define camera ID (required)", NULL);
    173     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,
    174             "define telescope ID (required)", NULL);
    175     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class", 0,
    176             "define class", NULL);
    177     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class_id", 0,
    178             "define class_id", NULL);
    179     psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-code",  0,
    180             "search by fault code", 0);
     120    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     121    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     122    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
     123    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
     124    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
     125    psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    181126
    182127    // -clearcommonfaults
    … …  
    185130    // -advance
    186131    psMetadata *advanceArgs = psMetadataAlloc();
    187     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-workdir",  0,
    188         "define the \"default\" workdir for this exposure", NULL);
    189     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-dvodb",  0,
    190         "define the dvodb for the next processing step", NULL);
    191     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-tess_id",  0,
    192         "define the tess_id for the next processing step", NULL);
    193     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-end_stage",  0,
    194         "define the end goal processing step", NULL);
    195     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-label",  0,
    196         "define the label for the chip stage", NULL);
     132    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-workdir",  0,        "define the \"default\" workdir for this exposure", NULL);
     133    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-dvodb",  0,        "define the dvodb for the next processing step", NULL);
     134    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-tess_id",  0,        "define the tess_id for the next processing step", NULL);
     135    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-end_stage",  0,        "define the end goal processing step", NULL);
     136    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
    197137
    198138    psMetadata *argSets = psMetadataAlloc();
    … …  
    222162    psFree(modes);
    223163
    224     // setup search criterion
    225 #define addWhereStr(name) \
    226 { \
    227     psString str = NULL; \
    228     bool status = false; \
    229     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    230         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    231             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    232             psFree(config); \
    233             return NULL; \
    234         } \
    235     } \
    236 }
    237 
    238     // generate SQL where clause
    239     config->where = psMetadataAlloc();
    240 
    241     addWhereStr(exp_name);
    242     addWhereStr(telescope);
    243     // convert '-inst' to 'camera'
    244     {
    245         psString str = NULL;
    246         bool status = false;
    247         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    248             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    249                 psError(PS_ERR_UNKNOWN, false, "failed to add item camera");
    250                 psFree(config);
    251                 return NULL;
    252             }
    253         }
    254     }
    255     addWhereStr(exp_type);
    256     addWhereStr(class);
    257     addWhereStr(class_id);
    258 
    259     if (config->where->list->n < 1) {
    260         psFree(config->where);
    261         config->where = NULL;
    262     }
    263 
    264164    // define Database handle, if used
    265165    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/regtool.c

    r18402 r18561  
    297297    PS_ASSERT_PTR_NON_NULL(config, false);
    298298
    299     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    300     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    301     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    302 
    303299    psMetadata *where = psMetadataAlloc();
    304300    PXOPT_COPY_S64(config->args, where,  "-exp_id", "exp_id", "==");
    … …  
    306302    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
    307303
     304    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     305    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     306    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     307
    308308    psString query = pxDataGet("regtool_processedimfile.sql");
    309309    if (!query) {
    … …  
    313313    }
    314314
    315     if (where) {
     315    if (psListLength(where->list)) {
    316316        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    317317        psStringAppend(&query, " AND %s", whereClause);
    … …  
    381381    PS_ASSERT_PTR_NON_NULL(config, false);
    382382
     383    psMetadata *where = psMetadataAlloc();
     384    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     385    PXOPT_COPY_STR(config->args, where,  "-tmp_class_id", "tmp_class_id", "==");
     386    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
     387    PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     388
    383389    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    384390    if (!query) {
    385391        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    386         return false;
    387     }
    388 
    389     if (config->where) {
    390         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawImfile");
     392        psFree(where);
     393        return false;
     394    }
     395
     396    if (psListLength(where->list)) {
     397        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    391398        psStringAppend(&query, " AND %s", whereClause);
    392399        psFree(whereClause);
    393400    }
     401    psFree(where);
    394402
    395403    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    413421    PS_ASSERT_PTR_NON_NULL(config, false);
    414422
     423    psMetadata *where = psMetadataAlloc();
     424    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     425    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
     426
    415427    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    416428
    417     if (!pxSetFaultCode(config->dbh, "rawImfile", config->where, code)) {
     429    if (!pxSetFaultCode(config->dbh, "rawImfile", where, code)) {
    418430        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    419         return false;
    420     }
     431        psFree (where);
     432        return false;
     433    }
     434    psFree (where);
    421435
    422436    return true;
    … …  
    511525
    512526    // optional
     527    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
     528    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
     529    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    513530    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    514531    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    515532    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    516     PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    517     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    518533    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    519534    PXOPT_LOOKUP_STR(filter, config->args, "-filter", false, false);
    … …  
    561576    PXOPT_LOOKUP_STR(label,  config->args, "-label", false, false);
    562577    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    563     PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
    564578
    565579    // default
    … …  
    789803    PS_ASSERT_PTR_NON_NULL(config, false);
    790804
    791     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    792     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    793     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    794 
    795805    psString query = pxDataGet("regtool_processedexp.sql");
    796806    if (!query) {
    … …  
    812822    PXOPT_COPY_STR(config->args, where,  "-reduction", "reduction", "==");
    813823    PXOPT_COPY_STR(config->args, where,  "-filter", "filter", "==");
    814     PXOPT_COPY_F64(config->args, where,  "-airmass_min", "airmass", ">=");
    815     PXOPT_COPY_F64(config->args, where,  "-airmass_max", "airmass", "<");
     824    PXOPT_COPY_F32(config->args, where,  "-airmass_min", "airmass", ">=");
     825    PXOPT_COPY_F32(config->args, where,  "-airmass_max", "airmass", "<");
    816826    PXOPT_COPY_F64(config->args, where,  "-ra_min", "ra", ">=");
    817827    PXOPT_COPY_F64(config->args, where,  "-ra_max", "ra", "<");
    … …  
    832842    PXOPT_COPY_F64(config->args, where,  "-az_min", "az", ">=");
    833843    PXOPT_COPY_F64(config->args, where,  "-az_max", "az", "<");
    834     PXOPT_COPY_F32(config->args, where,  "-ccd_temp_min", "ccd_temp", ">=");
    835     PXOPT_COPY_F32(config->args, where,  "-ccd_temp_max", "ccd_temp", "<");
     844    PXOPT_COPY_F64(config->args, where,  "-ccd_temp_min", "ccd_temp", ">=");
     845    PXOPT_COPY_F64(config->args, where,  "-ccd_temp_max", "ccd_temp", "<");
    836846    PXOPT_COPY_F64(config->args, where,  "-posang_min", "posang", ">=");
    837847    PXOPT_COPY_F64(config->args, where,  "-posang_max", "posang", "<");
    … …  
    839849    PXOPT_COPY_F32(config->args, where,  "-solang_min", "solang", ">=");
    840850    PXOPT_COPY_F32(config->args, where,  "-solang_max", "solang", "<");
     851
     852    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     853    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     854    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    841855
    842856    if (psListLength(where->list)) {
    … …  
    906920    PS_ASSERT_PTR_NON_NULL(config, false);
    907921
     922    psMetadata *where = psMetadataAlloc();
     923    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     924    PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     925
    908926    psString query = pxDataGet("regtool_revertprocessedexp.sql");
    909927    if (!query) {
    910928        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    911         return false;
    912     }
    913 
    914     if (config->where) {
    915         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     929        psFree(where);
     930        return false;
     931    }
     932
     933    if (psListLength(where->list)) {
     934        psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    916935        psStringAppend(&query, " AND %s", whereClause);
     936        psFree(where);
    917937        psFree(whereClause);
    918938    }
     939    psFree(where);
    919940
    920941    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    938959    PS_ASSERT_PTR_NON_NULL(config, false);
    939960
     961    psMetadata *where = psMetadataAlloc();
     962    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     963
    940964    PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    941965
    942     if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
     966    if (!pxSetFaultCode(config->dbh, "rawExp", where, code)) {
    943967        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    944         return false;
    945     }
     968        psFree(where);
     969        return false;
     970    }
     971    psFree(where);
    946972
    947973    return true;

  • trunk/ippTools/src/regtoolConfig.c

    r18336 r18561  
    5050    // -pendingimfile
    5151    psMetadata *pendingimfileArgs = psMetadataAlloc();
    52 // support for this options is unimplemented
    53 #if 0
    54     ADD_OPT(Str,  pendingimfileArgs, "-exp_id",    "search by exposure ID", NULL);
    55     ADD_OPT(Str,  pendingimfileArgs, "-class",     "search by class",       NULL);
    56     ADD_OPT(Str,  pendingimfileArgs, "-class_id",  "search by class ID",    NULL);
    57 #endif
    5852    ADD_OPT(U64,  pendingimfileArgs, "-limit",     "limit result set to N items",  0);
    5953    ADD_OPT(Bool, pendingimfileArgs, "-simple",    "use the simple output format", false);
    … …  
    6862    ADD_OPT(Str,  addprocessedimfileArgs, "-class_id",       "define class ID (required)",         NULL);
    6963    ADD_OPT(Str,  addprocessedimfileArgs, "-uri",            "define URI (required)",             NULL);
     64
    7065    ADD_OPT(Str,  addprocessedimfileArgs, "-exp_type",       "define exposure type",             NULL);
    7166    ADD_OPT(Str,  addprocessedimfileArgs, "-filelevel",      "define filelevel",             NULL);
    7267    ADD_OPT(Str,  addprocessedimfileArgs, "-filter",         "define filter ",                 NULL);
    7368    ADD_OPT(Str,  addprocessedimfileArgs, "-comment",        "define comment ",             NULL);
     69
    7470    ADD_OPT(F32,  addprocessedimfileArgs, "-airmass",        "define airmass",                 NAN);
    7571    ADD_OPT(F64,  addprocessedimfileArgs, "-ra",             "define RA",                 NAN);
    … …  
    9490    ADD_OPT(F32,  addprocessedimfileArgs, "-m2_tip",         "define M2 TIP position",                NAN);
    9591    ADD_OPT(F32,  addprocessedimfileArgs, "-m2_tilt",        "define M2 TILT position",         NAN);
     92
    9693    ADD_OPT(F32,  addprocessedimfileArgs, "-env_temperature","define Environmental Temperature",     NAN);
    9794    ADD_OPT(F32,  addprocessedimfileArgs, "-env_humidity",   "define Environmental Humidity",         NAN);
    … …  
    139136    // -pendingexp
    140137    psMetadata *pendingexpArgs = psMetadataAlloc();
    141 // support for these options in unimplemented
    142 #if 0
    143     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_id",   0,        "search by exposure ID", NULL);
    144     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-inst",     0,        "search by camera", NULL);
    145     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-telescope",0,        "search by telescope", NULL);
    146     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-exp_type", 0,        "search by exposure type", NULL);
    147 #endif
    148138    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",    0,        "limit result set to N items", 0);
    149139    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple",  0,        "use the simple output format", false);
    … …  
    156146    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-telescope",        0,        "define the telescope name (required)", NULL);
    157147    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_tag",          0,        "define the external exposure tag name (required)", NULL);
     148    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-filelevel",        0,        "define the data partitioning level of this file (required)", NULL);
     149
    158150    psMetadataAddTime(addprocessedexpArgs, PS_LIST_TAIL, "-dateobs",         0,        "define observation time", NULL);
    159151    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_type",         0,        "define exposure type", NULL);
    160     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-filelevel",        0,        "define the data partitioning level of this file", NULL);
    161152    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-workdir",          0,        "define the \"default\" workdir for this exposure", NULL);
    162153    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dvodb",            0,        "define the dvodb for the next processing step", NULL);
    … …  
    208199    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-hostname",         0,        "define host name", NULL);
    209200    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",             0,        "set fault code", 0);
    210     /*
    211     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-recip",  0,        "define URL", NULL);
    212     psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-mosiac",  0,        "define URL", NULL);
    213     */
    214201
    215202    // -processedexp
    … …  
    297284    psFree(modes);
    298285
    299     // setup search criterion
    300 #define addWhereStr(name) \
    301 { \
    302     psString str = NULL; \
    303     bool status = false; \
    304     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    305         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    306             psError(PXTOOLS_ERR_PROG, false, "failed to add item " #name); \
    307             psFree(config); \
    308             return NULL; \
    309         } \
    310     } \
    311 }
    312 
    313     // generate SQL where clause
    314     config->where = psMetadataAlloc();
    315 
    316     addWhereStr(exp_id);
    317     addWhereStr(exp_name);
    318     // convert '-inst' to 'camera'
    319     {
    320         psString str = NULL;
    321         bool status = false;
    322         if ((str = psMetadataLookupStr(&status, config->args, "-inst"))) {
    323             if (!psMetadataAddStr(config->where, PS_LIST_TAIL, "camera", 0, "==", str)) {
    324                 psError(PXTOOLS_ERR_PROG, false, "failed to add item camera");
    325                 psFree(config);
    326                 return NULL;
    327             }
    328         }
    329     }
    330 
    331     addWhereStr(telescope);
    332     addWhereStr(exp_type);
    333     addWhereStr(class);
    334     addWhereStr(class_id);
    335     addWhereStr(tmp_class_id);
    336     addWhereStr(filter);
    337 
    338     // convert '-code' to 'fault'
    339     {
    340         psS16 fault = 0;
    341         bool status = false;
    342         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    343             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    344                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    345                 psFree(config);
    346                 return NULL;
    347             }
    348         }
    349     }
    350 
    351     if (config->where->list->n < 1) {
    352         psFree(config->where);
    353         config->where = NULL;
    354     }
    355 
    356 
    357286    // define Database handle, if used
    358287    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

  • trunk/ippTools/src/stacktool.c

    r18336 r18561  
    524524    PS_ASSERT_PTR_NON_NULL(config, false);
    525525
     526    psMetadata *where = psMetadataAlloc();
     527    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     528    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     529
    526530    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    527531    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    533537    }
    534538
    535     if (config->where) {
    536         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "stackInputSkyfile");
     539    if (psListLength(where->list)) {
     540        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackInputSkyfile");
    537541        psStringAppend(&query, " AND %s", whereClause);
    538542        psFree(whereClause);
    539543    }
     544    psFree(where);
    540545
    541546    // treat limit == 0 as "no limit"
    … …  
    592597    PS_ASSERT_PTR_NON_NULL(config, false);
    593598
     599    psMetadata *where = psMetadataAlloc();
     600    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     601    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     602
    594603    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    595604    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    601610    }
    602611
    603     if (config->where) {
    604         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "stackSumSkyfile");
     612    if (psListLength(where->list)) {
     613        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackSumSkyfile");
    605614        psStringAppend(&query, " AND %s", whereClause);
    606615        psFree(whereClause);
    607616    }
     617    psFree(where);
    608618
    609619    // treat limit == 0 as "no limit"
    … …  
    723733    PS_ASSERT_PTR_NON_NULL(config, false);
    724734
     735    psMetadata *where = psMetadataAlloc();
     736    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     737    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     738
    725739    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    726740    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    732746    }
    733747
    734     if (config->where) {
    735         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "stackSumSkyfile");
     748    if (psListLength(where->list)) {
     749        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackSumSkyfile");
    736750        psStringAppend(&query, " AND %s", whereClause);
    737751        psFree(whereClause);
    738752    }
     753    psFree(where);
    739754
    740755    // treat limit == 0 as "no limit"
    … …  
    790805    PS_ASSERT_PTR_NON_NULL(config, false);
    791806
     807    psMetadata *where = psMetadataAlloc();
     808    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     809    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     810
    792811    psString query = pxDataGet("stacktool_revertsumskyfile.sql");
    793812    if (!query) {
    … …  
    796815    }
    797816
    798     if (config->where) {
    799         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "stackSumSkyfile");
     817    if (psListLength(where->list)) {
     818        psString whereClause = psDBGenerateWhereConditionSQL(where, "stackSumSkyfile");
    800819        psStringAppend(&query, " AND %s", whereClause);
    801820        psFree(whereClause);
    802821    }
     822    psFree(where);
    803823
    804824    if (!p_psDBRunQuery(config->dbh, query)) {

  • trunk/ippTools/src/stacktoolConfig.c

    r18336 r18561  
    4747    // -definebyquery
    4848    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0,
    50             "define workdir (required)", NULL);
    51     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,
    52             "time detrend run was registered", now);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id",  0,
    54             "search for skycell_id", NULL);
    55     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,
    56             "define min good_frac", 0.0);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,
    58             "search for exp_type", "object");
    59     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,
    60             "search for camera", NULL);
    61     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,
    62             "search for telescope", NULL);
    63     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,
    64             "search for filter", NULL);
    65     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,
    66             "search for uri", NULL);
    67     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,
    68             "search for exposures by time (>=)", NULL);
    69     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,
    70             "search for exposures by time (<)", NULL);
    71     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,
    72             "define min airmass", NAN);
    73     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,
    74             "define max airmass", NAN);
    75     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,
    76             "define max fraction of saturated pixels", NAN);
    77     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,
    78             "define min exposure time", NAN);
    79     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,
    80             "define max exposure time", NAN);
    81     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,
    82             "define min ccd tempature", NAN);
    83     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,
    84             "define max ccd tempature", NAN);
    85     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,
    86             "define min rotator position angle", NAN);
    87     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,
    88             "define max rotator position angle", NAN);
    89     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,
    90             "define min solar angle", NAN);
    91     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,
    92             "define max solar angle", NAN);
    93     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,
    94             "use a random subset of elements", false);
    95     psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,
    96             "use this number of random elements", 20);
    97 
    98     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,
    99             "allow everything to be queued without search terms", false);
    100     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,
    101             "use the simple output format", false);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     50    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id",  0,            "search for skycell_id", NULL);
     52    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min",  0,            "define min good_frac", 0.0);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type",  0,            "search for exp_type", "object");
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst",  0,            "search for camera", NULL);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope",  0,            "search for telescope", NULL);
     56    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter",  0,            "search for filter", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_uri",  0,            "search for uri", NULL);
     58    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     59    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-select_dateobs_end", 0,            "search for exposures by time (<)", NULL);
     60    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_min",  0,            "define min airmass", NAN);
     61    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_airmass_max",  0,            "define max airmass", NAN);
     62    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_sat_pixel_frac_max",  0,            "define max fraction of saturated pixels", NAN);
     63    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_min",  0,            "define min exposure time", NAN);
     64    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_time_max",  0,            "define max exposure time", NAN);
     65    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_min",  0,            "define min ccd tempature", NAN);
     66    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_ccd_temp_max",  0,            "define max ccd tempature", NAN);
     67    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
     68    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
     69    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
     70    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     71    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-random_subset",  0,            "use a random subset of elements", false);
     72    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random_limit",  0,            "use this number of random elements", 20);
     73    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     74    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    10275
    10376    // -definerun
    10477    psMetadata *definerunArgs = psMetadataAlloc();
    105     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    106             "define workdir (required)", NULL);
    107     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    108             "time detrend run was registered", now);
    109     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,
    110             "define skycell ID (required)", NULL);
    111     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,
    112             "define tessellation ID (required)", NULL);
    113     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",
    114              PS_META_DUPLICATE_OK,
    115              "include this warp ID (multiple OK, required)", 0);
    116 
    117     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    118             "use the simple output format", false);
     78    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     79    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     80    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     81    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     82    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-warp_id",             PS_META_DUPLICATE_OK,             "include this warp ID (multiple OK, required)", 0);
     83    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    11984
    12085    // -updaterun
    12186    psMetadata *updaterunArgs = psMetadataAlloc();
    122     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,
    123             "define stack ID (required)", 0);
    124     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    125             "set state (required)", NULL);
    126 #if 0
    127     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    128             "define workdir (required)", NULL);
    129     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    130             "time detrend run was registered", now);
    131 #endif
     87    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     88    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    13289
    13390    // -addinputskyfile
    13491    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    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);
     92    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     93    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warp ID (required)", 0);
    13994
    14095    // -inputskyfile
    14196    psMetadata *inputskyfileArgs = psMetadataAlloc();
    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);
    146     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    147             "limit result set to N items", 0);
    148     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    149             "use the simple output format", false);
     97    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     98    psMetadataAddS64(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     99    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     100    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    150101
    151102    // -tosum
    152103    psMetadata *tosumArgs = psMetadataAlloc();
    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);
    157     psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,
    158             "limit result set to N items", 0);
    159     psMetadataAddBool(tosumArgs, PS_LIST_TAIL, "-simple",  0,
    160             "use the simple output format", false);
     104    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     105    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     106    psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     107    psMetadataAddBool(tosumArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    161108
    162109    // -addsumskyfile
    163110    psMetadata *addsumskyfileArgs = psMetadataAlloc();
    164     psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    165             "define stack ID (required)", 0);
    166     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,
    167             "define URI of file", 0);
    168     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-path_base", 0,
    169             "define base output location", 0);
    170     psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg",  0,
    171             "define exposue background", NAN);
    172     psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    173             "define exposue background mean stdev", NAN);
    174     psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-dtime_stack",  0,
    175             "define elapsed processing time", NAN);
    176     psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,
    177             "define hostname", 0);
    178     psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,
    179             "define %% of good pixels", NAN);
    180     psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    181             "set fault code", 0);
     111    psMetadataAddS64(addsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
     112    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     113    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     114    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposue background", NAN);
     115    psMetadataAddF64(addsumskyfileArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposue background mean stdev", NAN);
     116    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-dtime_stack",  0,            "define elapsed processing time", NAN);
     117    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     118    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     119    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    182120
    183121    // -sumskyfile
    184122    psMetadata *sumskyfileArgs= psMetadataAlloc();
    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);
    189     psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    190             "limit result set to N items", 0);
    191     psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    192             "use the simple output format", false);
     123    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
     124    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     125    psMetadataAddU64(sumskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     126    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    193127
    194128    // -revertsumskyfile
    195129    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    196     psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,
    197             "search by stack ID (required)", 0);
    198     psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,
    199             "search by fault code", 0);
     130    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID (required)", 0);
     131    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    200132
    201133    psFree(now);
    … …  
    204136    psMetadata *modes   = psMetadataAlloc();
    205137
    206     PXOPT_ADD_MODE("-definebyquery", "Define a new stackRun by searching for warp IDs",
    207         STACKTOOL_MODE_DEFINEBYQUERY,  definebyqueryArgs);
     138    PXOPT_ADD_MODE("-definebyquery", "Define a new stackRun by searching for warp IDs", STACKTOOL_MODE_DEFINEBYQUERY,  definebyqueryArgs);
    208139    PXOPT_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
    209140    PXOPT_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
    … …  
    226157    psFree(modes);
    227158
    228     // setup search criterion
    229 #define addWhereStr(name) \
    230 { \
    231     psString str = NULL; \
    232     bool status = false; \
    233     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    234         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    235             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    236             psFree(config); \
    237             return NULL; \
    238         } \
    239     } \
    240 }
    241 
    242 #define addWhereS32(name) \
    243 { \
    244     psS32 s32 = 0; \
    245     bool status = false; \
    246     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    247         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    248             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    249             psFree(config); \
    250             return NULL; \
    251         } \
    252     } \
    253 }
    254 
    255 
    256     // generate SQL where clause
    257     config->where = psMetadataAlloc();
    258 
    259 {
    260     psString str = NULL;
    261     bool status = false;
    262     if ((str = psMetadataLookupStr(&status, config->args, "-warp_id"))) {
    263         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", (psS64)atoll(str))) {
    264             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    265             psFree(config);
    266             return NULL;
    267         }
    268     }
    269 }
    270 
    271 {
    272     psString str = NULL;
    273     bool status = false;
    274     if ((str = psMetadataLookupStr(&status, config->args, "-stack_id"))) {
    275         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "stack_id", 0, "==", (psS64)atoll(str))) {
    276             psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id");
    277             psFree(config);
    278             return NULL;
    279         }
    280     }
    281 }
    282 
    283     addWhereStr(skycell_id);
    284     addWhereStr(tess_id);
    285 
    286     // convert '-code' to 'fault'
    287     {
    288         psS16 fault = 0;
    289         bool status = false;
    290         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    291             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    292                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    293                 psFree(config);
    294                 return NULL;
    295             }
    296         }
    297     }
    298 
    299     if (config->where->list->n < 1) {
    300         psFree(config->where);
    301         config->where = NULL;
    302     }
    303 
    304159    // define Database handle, if used
    305160    // do this last so we don't setup a connection before CLI options are

  • trunk/ippTools/src/warptool.c

    r18336 r18561  
    109109{
    110110    PS_ASSERT_PTR_NON_NULL(config, false);
    111 
    112     // required options
    113     PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false);
    114     PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false);
    115     // check mode
    116     if (mode && !isValidMode(config, mode)) {
    117         psError(PS_ERR_UNKNOWN, false, "invalud mode");
    118         return false;
    119     }
    120     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    121 
    122     // optional
     111   
     112    PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", true, false); // required
     113    PXOPT_LOOKUP_STR(mode, config->args, "-mode", true, false); // required
     114    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required
    123115    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    124116    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    125117    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    126118    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    127 
    128     // default
    129119    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    130120    PXOPT_LOOKUP_BOOL(magiced, config->args, "-magiced", false);
    131121    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     122
     123    // check mode
     124    if (mode && !isValidMode(config, mode)) {
     125        psError(PS_ERR_UNKNOWN, false, "invalid mode");
     126        return false;
     127    }
    132128
    133129    warpRunRow *warpRun = warpRunRowAlloc(
    … …  
    190186    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    191187    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    192 
    193     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    194     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     188    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     189    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    195190    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    196191    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    211206    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
    212207    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
    213     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
    214     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     208    PXOPT_COPY_F64(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     209    PXOPT_COPY_F64(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
    215210    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
    216211    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    … …  
    262257    PS_ASSERT_PTR_NON_NULL(config, false);
    263258
     259    psMetadata *where = psMetadataAlloc();
     260    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     261    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     262
    264263    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    265264    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    272271    }
    273272
    274     if (config->where) {
    275         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     273    if (psListLength(where->list)) {
     274        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    276275        psStringAppend(&query, " AND %s", whereClause);
    277276        psFree(whereClause);
    278277    }
     278    psFree(where);
    279279
    280280    // treat limit == 0 as "no limit"
    … …  
    331331    PS_ASSERT_PTR_NON_NULL(config, false);
    332332
     333    psMetadata *where = psMetadataAlloc();
     334    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     335    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     336
    333337    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    334338    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    341345    }
    342346
    343     if (config->where) {
    344         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     347    if (psListLength(where->list)) {
     348        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    345349        psStringAppend(&query, " AND %s", whereClause);
    346350        psFree(whereClause);
    347351    }
     352    psFree(where);
    348353
    349354    // treat limit == 0 as "no limit"
    … …  
    400405    PS_ASSERT_PTR_NON_NULL(config, false);
    401406
     407    psMetadata *where = psMetadataAlloc();
     408    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     409
    402410    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    403411    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    410418    }
    411419
    412     if (config->where) {
    413         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpRun");
     420    if (psListLength(where->list)) {
     421        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpRun");
    414422        psStringAppend(&query, " AND %s", whereClause);
    415423        psFree(whereClause);
    416424    }
     425    psFree(where);
    417426
    418427    // treat limit == 0 as "no limit"
    … …  
    571580    PS_ASSERT_PTR_NON_NULL(config, false);
    572581
     582    psMetadata *where = psMetadataAlloc();
     583    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     584    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     585    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
     586
    573587    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    574588    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    581595    }
    582596
    583     if (config->where) {
    584         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
     597    if (psListLength(where->list)) {
     598        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyCellMap");
    585599        psStringAppend(&query, " AND %s", whereClause);
    586600        psFree(whereClause);
    587601    }
     602    psFree(where);
    588603
    589604    // treat limit == 0 as "no limit"
    … …  
    635650}
    636651
    637 
    638652static bool towarpedMode(pxConfig *config)
    639653{
    640654    PS_ASSERT_PTR_NON_NULL(config, false);
     655
     656    psMetadata *where = psMetadataAlloc();
     657    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    641658
    642659    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    650667    }
    651668
    652     if (config->where) {
    653         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyCellMap");
     669    if (psListLength(where->list)) {
     670        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyCellMap");
    654671        psStringAppend(&query, " AND %s", whereClause);
    655672        psFree(whereClause);
    656673    }
     674    psFree(where);
    657675
    658676    // treat limit == 0 as "no limit"
    … …  
    891909    PS_ASSERT_PTR_NON_NULL(config, false);
    892910
     911    psMetadata *where = psMetadataAlloc();
     912    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warp_id", "==");
     913    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     914    PXOPT_COPY_STR(config->args, where, "-tess_id",    "tess_id", "==");
     915    PXOPT_COPY_S64(config->args, where, "-exp_id",     "exp_id", "==");
     916    PXOPT_COPY_S64(config->args, where, "-fake_id",    "fake_id", "==");
     917
    893918    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    894919    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    901926    }
    902927
    903     if (config->where) {
    904         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "warpSkyfile");
     928    if (psListLength(where->list)) {
     929        psString whereClause = psDBGenerateWhereConditionSQL(where, "warpSkyfile");
    905930        psStringAppend(&query, " AND %s", whereClause);
    906931        psFree(whereClause);
    907932    }
     933    psFree(where);
    908934
    909935    // treat limit == 0 as "no limit"
    … …  
    962988    psMetadata *where = psMetadataAlloc();
    963989    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     990    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
     991    PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    964992    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    965993    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    966994    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    967     PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id", "==");
    968     PXOPT_COPY_STR(config->args, where, "-tess_id", "tess_id", "==");
    969995
    970996    // XXX These may need to be updated with the table name?
    … …  
    9801006    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
    9811007
    982     PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    983     PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
     1008    PXOPT_COPY_F32(config->args, where, "-airmass_min", "airmass", ">=");
     1009    PXOPT_COPY_F32(config->args, where, "-airmass_max", "airmass", "<");
    9841010    PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    9851011    PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    … …  
    10001026    PXOPT_COPY_F64(config->args, where, "-az_min", "az", ">=");
    10011027    PXOPT_COPY_F64(config->args, where, "-az_max", "az", "<");
    1002     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
    1003     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
     1028    PXOPT_COPY_F64(config->args, where, "-ccd_temp_min", "ccd_temp", ">=");
     1029    PXOPT_COPY_F64(config->args, where, "-ccd_temp_max", "ccd_temp", "<");
    10041030    PXOPT_COPY_F64(config->args, where, "-posang_min", "posang", ">=");
    10051031    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    … …  
    10071033    PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    10081034    PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
    1009 //    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     1035    PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
    10101036
    10111037    if (!psListLength(where->list)

  • trunk/ippTools/src/warptoolConfig.c

    r18461 r18561  
    4949    // -definerun
    5050    psMetadata *definerunArgs = psMetadataAlloc();
    51     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,
    52             "define camtool ID (required)", 0);
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
    54             "define mode (required)", NULL);
    55     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    56             "define workdir (required)", NULL);
    57     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,
    58             "define label", NULL);
    59     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
    60             "define dvodb", NULL);
    61     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,
    62             "define tess_id", NULL);
    63     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,
    64             "define end stage", NULL);
    65     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    66             "time detrend run was registered", now);
    67     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-magiced",  0,
    68             "has this exposure been magiced", false);
    69     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    70             "use the simple output format", false);
     51    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-fake_id", 0,            "define camtool ID (required)", 0);
     52    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,            "define mode (required)", NULL);
     53    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
     55    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,            "define end stage", NULL);
     58    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     59    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-magiced",  0,            "has this exposure been magiced", false);
     60    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    7161
    7262    // -updaterun
     63    // XXX need to allow multiple fake_ids
     64    // XXX need to allow multiple fake_ids
     65    // XXX need to allow multiple chip_ids
     66    // XXX need to allow multiple exp_ids
    7367    psMetadata *updaterunArgs = psMetadataAlloc();
    74     // XXX need to allow multiple fake_ids
    75     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
    76             "search by warptool ID", 0);
    77     // XXX need to allow multiple fake_ids
    78     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,
    79             "search by fake_id", 0);
    80     // XXX need to allow multiple chip_ids
    81     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,
    82             "search by chip_id", 0);
    83     // XXX need to allow multiple exp_ids
    84     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    85             "search by exp_id", 0);
    86     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    87             "search by exp_name", NULL);
    88     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,
    89             "search for camera", NULL);
    90     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,
    91             "search for telescope", NULL);
    92     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    93             "search for exposures by time (>=)", NULL);
    94     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    95             "search for exposures by time (<)", NULL);
    96     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    97             "search by exp_tag", NULL);
    98     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,
    99             "search by exp_type", NULL);
    100     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,
    101             "search by filelevel", NULL);
    102     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,
    103             "search by reduction class", NULL);
    104     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,
    105             "search for filter", NULL);
    106     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    107             "define min airmass", NAN);
    108     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    109             "define max airmass", NAN);
    110     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,
    111             "define min", NAN);
    112     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,
    113             "define max", NAN);
    114     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,
    115             "define min", NAN);
    116     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,
    117             "define max", NAN);
    118     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    119             "define min", NAN);
    120     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    121             "define max", NAN);
    122     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    123             "define max fraction of saturated pixels", NAN);
    124     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    125             "define min fraction of saturated pixels", NAN);
    126     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,
    127             "define max", NAN);
    128     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,
    129             "define max", NAN);
    130     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    131             "define max", NAN);
    132     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    133             "define max", NAN);
    134     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    135             "define max", NAN);
    136     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    137             "define max", NAN);
    138     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,
    139             "define min", NAN);
    140     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,
    141             "define max", NAN);
    142     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,
    143             "define min", NAN);
    144     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,
    145             "define max", NAN);
    146     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    147             "define min ccd tempature", NAN);
    148     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    149             "define max ccd tempature", NAN);
    150     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,
    151             "define min rotator position angle", NAN);
    152     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,
    153             "define max rotator position angle", NAN);
    154     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,
    155             "search by exposure object", NULL);
    156     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,
    157             "define min solar angle", NAN);
    158     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,
    159             "define max solar angle", NAN);
    160 
    161     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,
    162             "allow everything to be queued without search terms", false);
    163     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    164             "set state", NULL);
    165     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,
    166             "set label", NULL);
     68    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     69    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake_id", 0);
     70    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     71    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     72    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     73    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     74    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     75    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     76    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     77    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     79    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     80    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     81    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     82    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     83    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     84    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     85    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     86    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     87    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     88    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     89    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     90    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     91    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     92    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     93    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     94    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     95    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     96    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     97    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     98    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     99    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     100    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     101    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     102    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     103    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     104    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     105    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     106    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     107    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     108    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     109
     110    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     112    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "set label", NULL);
     113
    167114#if 0
    168     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    169             "define workdir (required)", NULL);
    170     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    171             "time detrend run was registered", now);
     115    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     116    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    172117#endif
    173118
    174119    // -exp
    175120    psMetadata *expArgs = psMetadataAlloc();
    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);
    180     psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,
    181             "limit result set to N items", 0);
    182     psMetadataAddBool(expArgs, PS_LIST_TAIL, "-simple",  0,
    183             "use the simple output format", false);
     121    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     122    psMetadataAddS64(expArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by camtool ID", 0);
     123    psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     124    psMetadataAddBool(expArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    184125
    185126    // -imfile
    186127    psMetadata *imfileArgs = psMetadataAlloc();
    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);
    191     psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,
    192             "limit result set to N items", 0);
    193     psMetadataAddBool(imfileArgs, PS_LIST_TAIL, "-simple",  0,
    194             "use the simple output format", false);
     128    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     129    psMetadataAddS64(imfileArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by camtool ID", 0);
     130    psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     131    psMetadataAddBool(imfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    195132
    196133    // -tooverlap
    197134    psMetadata *tooverlapArgs = psMetadataAlloc();
    198     psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
    199             "search by warp ID", 0);
    200     psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,
    201             "limit result set to N items", 0);
    202     psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,
    203             "use the simple output format", false);
     135    psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     136    psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     137    psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    204138
    205139    // -addoverlap
    206140    psMetadata *addoverlapArgs = psMetadataAlloc();
    207     psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,
    208             "path to skycell <-> imfile mapping file", NULL);
    209     psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,
    210             "set warp ID", 0);
    211     psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,
    212             "set fault code", 0);
     141    psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,            "path to skycell <-> imfile mapping file", NULL);
     142    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,            "set warp ID", 0);
     143    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    213144
    214145    // -scmap
    215146    psMetadata *scmapArgs = psMetadataAlloc();
    216     psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
    217             "search by warptool ID", 0);
    218     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,
    219             "search by skycell ID", NULL);
    220     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-tess_id", 0,
    221             "search by tess ID", NULL);
    222     psMetadataAddU64(scmapArgs, PS_LIST_TAIL, "-limit",  0,
    223             "limit result set to N items", 0);
    224     psMetadataAddBool(scmapArgs, PS_LIST_TAIL, "-simple",  0,
    225             "use the simple output format", false);
     147    psMetadataAddS64(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     148    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,            "search by skycell ID", NULL);
     149    psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", NULL);
     150    psMetadataAddU64(scmapArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     151    psMetadataAddBool(scmapArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    226152
    227153    // -towarped
    228154    psMetadata *towarpedArgs = psMetadataAlloc();
    229     psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    230             "search by warptool ID", 0);
    231     psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,
    232             "limit result set to N items", 0);
    233     psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,
    234             "use the simple output format", false);
     155    psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     156    psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     157    psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    235158
    236159    // -addwarped
    237160    psMetadata *addwarpedArgs = psMetadataAlloc();
    238     psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    239             "define warptool ID (required)", 0);
    240     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    241             "define skycell ID (required)", NULL);
    242     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    243             "define tessellation ID (required)", NULL);
    244     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-uri", 0,
    245             "define URI of file", 0);
    246     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-path_base", 0,
    247             "define base output location", 0);
    248     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg",  0,
    249             "define exposure background", NAN);
    250     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    251             "define exposure background stdev", NAN);
    252     psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-dtime_warp",  0,
    253             "define elapsed processing time", NAN);
    254     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmin",  0,
    255             "define minimum x value", INT_MAX);
    256     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmax",  0,
    257             "define maximum x value", -INT_MAX);
    258     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymin",  0,
    259             "define minimum y value", INT_MAX);
    260     psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymax",  0,
    261             "define maximum y value", -INT_MAX);
    262     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,
    263             "define hostname", 0);
    264     psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,
    265             "define %% of good pixels", NAN);
    266     psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-ignore",  0,
    267             "define if this skycell should be ignored", false);
    268     psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,
    269             "set fault code", 0);
     161    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "define warptool ID (required)", 0);
     162    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID (required)", NULL);
     163    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     164    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     165    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
     166    psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
     167    psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
     168    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-dtime_warp",  0,            "define elapsed processing time", NAN);
     169    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmin",  0,            "define minimum x value", INT_MAX);
     170    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-xmax",  0,            "define maximum x value", -INT_MAX);
     171    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymin",  0,            "define minimum y value", INT_MAX);
     172    psMetadataAddS32(addwarpedArgs, PS_LIST_TAIL, "-ymax",  0,            "define maximum y value", -INT_MAX);
     173    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
     174    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
     175    psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-ignore",  0,            "define if this skycell should be ignored", false);
     176    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    270177
    271178    // -warped
    272179    psMetadata *warpedArgs = psMetadataAlloc();
    273     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    274             "search by warptool ID", 0);
    275     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    276             "define skycell ID", NULL);
    277     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    278             "define tessellation ID", 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);
    283     psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    284             "limit result set to N items", 0);
    285     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,
    286             "use the simple output format", false);
     180    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     181    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
     182    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
     183    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "define exposure tag", 0);
     184    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,            "define phase 3 version of exposure tag", 0);
     185    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     186    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    287187
    288188    // -revertwarped
     189    // XXX need to allow multiple fake_ids
     190    // XXX need to allow multiple fake_ids
     191    // XXX need to allow multiple chip_ids
     192    // XXX need to allow multiple exp_ids
    289193    psMetadata *revertwarpedArgs = psMetadataAlloc();
    290     // XXX need to allow multiple fake_ids
    291     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    292             "search by warptool ID", 0);
    293     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    294             "search by skycell ID", NULL);
    295     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    296             "searcy by tessellation ID", NULL);
    297     // XXX need to allow multiple fake_ids
    298     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,
    299             "search by fake_id", 0);
    300     // XXX need to allow multiple chip_ids
    301     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,
    302             "search by chip_id", 0);
    303     // XXX need to allow multiple exp_ids
    304     psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,
    305             "search by exp_id", 0);
    306     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,
    307             "search by exp_name", NULL);
    308     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-inst",  0,
    309             "search for camera", NULL);
    310     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-telescope",  0,
    311             "search for telescope", NULL);
    312     psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    313             "search for exposures by time (>=)", NULL);
    314     psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    315             "search for exposures by time (<)", NULL);
    316     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_tag",  0,
    317             "search by exp_tag", NULL);
    318     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_type",  0,
    319             "search by exp_type", NULL);
    320     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filelevel",  0,
    321             "search by filelevel", NULL);
    322     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,
    323             "search by reduction class", NULL);
    324     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filter",  0,
    325             "search for filter", NULL);
    326     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_min",  0,
    327             "define min airmass", NAN);
    328     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_max",  0,
    329             "define max airmass", NAN);
    330     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_min",  0,
    331             "define min", NAN);
    332     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_max",  0,
    333             "define max", NAN);
    334     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_min",  0,
    335             "define min", NAN);
    336     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_max",  0,
    337             "define max", NAN);
    338     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    339             "define min", NAN);
    340     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    341             "define max", NAN);
    342     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    343             "define max fraction of saturated pixels", NAN);
    344     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    345             "define min fraction of saturated pixels", NAN);
    346     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_min",  0,
    347             "define max", NAN);
    348     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_max",  0,
    349             "define max", NAN);
    350     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    351             "define max", NAN);
    352     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    353             "define max", NAN);
    354     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    355             "define max", NAN);
    356     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    357             "define max", NAN);
    358     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_min",  0,
    359             "define min", NAN);
    360     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_max",  0,
    361             "define max", NAN);
    362     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_min",  0,
    363             "define min", NAN);
    364     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_max",  0,
    365             "define max", NAN);
    366     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    367             "define min ccd tempature", NAN);
    368     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    369             "define max ccd tempature", NAN);
    370     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_min",  0,
    371             "define min rotator position angle", NAN);
    372     psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_max",  0,
    373             "define max rotator position angle", NAN);
    374     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-object",  0,
    375             "search by exposure object", NULL);
    376     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_min",  0,
    377             "define min solar angle", NAN);
    378     psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_max",  0,
    379             "define max solar angle", NAN);
    380 
    381     psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,
    382             "search by fault code", 0);
    383     psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,
    384             "allow everything to be queued without search terms", false);
     194    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     195    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "search by skycell ID", NULL);
     196    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "searcy by tessellation ID", NULL);
     197    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake_id", 0);
     198    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip_id", 0);
     199    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     200    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     201    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     202    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     203    psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     204    psMetadataAddTime(revertwarpedArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     205    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     206    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", NULL);
     207    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     208    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     209    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     210    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     211    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     212    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     213    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     214    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     215    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     216    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     217    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     218    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     219    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     220    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     221    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     222    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     223    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     224    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     225    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     226    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     227    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     228    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     229    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     230    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     231    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     232    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     233    psMetadataAddF64(revertwarpedArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     234    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     235    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     236    psMetadataAddF32(revertwarpedArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     237
     238    psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     239    psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    385240
    386241    // -block
    387242    psMetadata *blockArgs = psMetadataAlloc();
    388     psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,
    389             "name of a label to mask out (required)", NULL);
     243    psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to mask out (required)", NULL);
    390244
    391245    // -masked
    392246    psMetadata *maskedArgs = psMetadataAlloc();
    393     psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,
    394             "use the simple output format", false);
     247    psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    395248
    396249    // -unblock
    397250    psMetadata *unblockArgs = psMetadataAlloc();
    398     psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,
    399             "name of a label to unmask (required)", NULL);
     251    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    400252
    401253    psFree(now);
    … …  
    429281    psFree(modes);
    430282
    431     // setup search criterion
    432 #define addWhereStr(name) \
    433 { \
    434     psString str = NULL; \
    435     bool status = false; \
    436     if ((str = psMetadataLookupStr(&status, config->args, "-" #name))) { \
    437         if (!psMetadataAddStr(config->where, PS_LIST_TAIL, #name, 0, "==", str)) {\
    438             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    439             psFree(config); \
    440             return NULL; \
    441         } \
    442     } \
    443 }
    444 
    445 #define addWhereS32(name) \
    446 { \
    447     psS32 s32 = 0; \
    448     bool status = false; \
    449     if ((s32= psMetadataLookupS32(&status, config->args, "-" #name))) { \
    450         if (!psMetadataAddS32(config->where, PS_LIST_TAIL, #name, 0, "==", s32)) { \
    451             psError(PS_ERR_UNKNOWN, false, "failed to add item " #name); \
    452             psFree(config); \
    453             return NULL; \
    454         } \
    455     } \
    456 }
    457 
    458 
    459     // generate SQL where clause
    460     config->where = psMetadataAlloc();
    461 
    462 {
    463     psS64 warp_id = -1;
    464     bool status = false;
    465     if ((warp_id = psMetadataLookupS64(&status, config->args, "-warp_id"))) {
    466         if (!psMetadataAddS64(config->where, PS_LIST_TAIL, "warp_id", 0, "==", warp_id)) {
    467             psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id");
    468             psFree(config);
    469             return NULL;
    470         }
    471     }
    472 }
    473     addWhereStr(skycell_id);
    474     addWhereStr(tess_id);
    475     addWhereStr(exp_id);
    476 
    477     // convert '-code' to 'fault'
    478     {
    479         psS16 fault = 0;
    480         bool status = false;
    481         if ((fault = psMetadataLookupS16(&status, config->args, "-code"))) {
    482             if (!psMetadataAddS16(config->where, PS_LIST_TAIL, "fault", 0, "==", fault)) {
    483                 psError(PS_ERR_UNKNOWN, false, "failed to add item fault");
    484                 psFree(config);
    485                 return NULL;
    486             }
    487         }
    488     }
    489 
    490     if (config->where->list->n < 1) {
    491         psFree(config->where);
    492         config->where = NULL;
    493     }
    494 
    495283    // define Database handle, if used
    496284    // do this last so we don't setup a connection before CLI options are
Note: See TracChangeset for help on using the changeset viewer.