IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 26, 2009, 1:59:32 PM (17 years ago)
Author:
beaumont
Message:

merged with trunk

Location:
branches/cnb_branches/cnb_branch_20090301
Files:
48 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/cnb_branches/cnb_branch_20090301

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src

    • Property svn:ignore

      •  

        old new  
        3333pstamptool
        3434disttool
         35receivetool

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/Makefile.am

    r23594 r24244  
    1919        regtool \
    2020        stacktool \
    21         warptool
     21        warptool \
     22        receivetool
    2223
    2324
    … …  
    212213    pxinjectConfig.c
    213214
     215
     216receivetool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     217receivetool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     218receivetool_SOURCES = \
     219    receivetool.c \
     220    receivetoolConfig.c
     221
    214222clean-local:
    215223        -rm -f TAGS

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/camtool.c

    r23594 r24244  
    109109    psMetadata *where = psMetadataAlloc();
    110110    pxcamGetSearchArgs (config, where);
    111     PXOPT_COPY_STR(config->args, where, "-label",     "chipRun.label",    "==");
    112     PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    113 
    114     if (!psListLength(where->list)
    115         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     111    pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
     112    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
     113
     114    if (!psListLength(where->list) &&
     115        !psMetadataLookupBool(NULL, config->args, "-all")) {
    116116        psFree(where);
    117117        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    … …  
    137137    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    138138    if (where && psListLength(where->list)) {
    139         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    140         psStringAppend(&query, "%s", whereClause);
     139        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     140        psStringAppend(&query, " AND %s", whereClause);
    141141        psFree(whereClause);
    142142    }
    … …  
    175175    // old values in place (i.e., passing the values through).
    176176
    177     // loop over our list of chipRun rows
     177    // if end_stage is warp (or NULL), check for valid tess_id
    178178    for (long i = 0; i < psArrayLength(output); i++) {
    179179        psMetadata *md = output->data[i];
    180180
    181         chipRunRow *row = chipRunObjectFromMetadata(md);
     181        bool status;
     182        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
     183        if (end_stage && strcasecmp(end_stage, "warp")) continue;
     184
     185        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
     186        if (raw_tess_id || tess_id) continue;
     187
     188        char *label  = psMetadataLookupStr(&status, md, "label");
     189        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     190
     191        if (!status) {
     192            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     193            psFree(output);
     194            return false;
     195        }
     196    }
     197
     198    // loop over our list of camRun rows
     199    for (long i = 0; i < psArrayLength(output); i++) {
     200        psMetadata *md = output->data[i];
     201
     202        camRunRow *row = camRunObjectFromMetadata(md);
    182203        if (!row) {
    183             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
     204            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into camRun");
    184205            psFree(output);
    185206            return false;
    … …  
    247268
    248269    if (state) {
    249         // set chipRun.state to state
     270        // set camRun.state to state
    250271        if (!pxcamRunSetStateByQuery(config, where, state)) {
    251272            psFree(where);
    … …  
    255276
    256277    if (label) {
    257         // set chipRun.label to label
     278        // set camRun.label to label
    258279        if (!pxcamRunSetLabelByQuery(config, where, label)) {
    259280            psFree(where);
    … …  
    275296    pxcamGetSearchArgs (config, where);
    276297    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id", "==");
    277     PXOPT_COPY_STR(config->args, where, "-label",    "camRun.label", "==");
     298    pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    278299    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
    279300
    … …  
    289310    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    290311    if (psListLength(where->list)) {
    291         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    292         psStringAppend(&query, "%s", whereClause);
     312        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     313        psStringAppend(&query, " AND %s", whereClause);
    293314        psFree(whereClause);
    294315    }
    … …  
    339360    pxcamGetSearchArgs (config, where);
    340361    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",                "==");
    341     PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label",                 "==");
     362    pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",                 "==");
    342363    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction",             "==");
    343     PXOPT_COPY_S64(config->args, where, "-chip_id",   "chipRun.chip_id",              "==");
    344     PXOPT_COPY_STR(config->args, where, "-class_id",  "chipProcessedImfile.class_id", "==");
    345 
    346     // XXX is this used? PXOPT_COPY_STR(config->args, where, "-class",    "class",         "==");
     364    PXOPT_COPY_S64(config->args, where, "-chip_id",   "camRun.chip_id",              "==");
     365    PXOPT_COPY_STR(config->args, where, "-class_id",  "camProcessedExp.class_id", "==");
    347366
    348367    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    356375    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    357376    if (psListLength(where->list)) {
    358         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    359         psStringAppend(&query, "%s", whereClause);
     377        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     378        psStringAppend(&query, " AND %s", whereClause);
    360379        psFree(whereClause);
    361380    }
    … …  
    381400
    382401    // negate simple so the default is true
    383     if (!ippdbPrintMetadatas(stdout, output, "chipProcessedImfile", !simple)) {
     402    if (!ippdbPrintMetadatas(stdout, output, "camProcessedExp", !simple)) {
    384403        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    385404        psFree(output);
    … …  
    470489
    471490    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    472     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     491    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     492    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    473493
    474494    // generate restrictions
    475495    psMetadata *where = psMetadataAlloc();
    476     PXOPT_COPY_S64(config->args, where, "-cam_id",   "cam_id",   "==");
     496    PXOPT_COPY_S64(config->args, where, "-cam_id",   "camRun.cam_id",   "==");
    477497
    478498    psString query = pxDataGet("camtool_find_pendingexp.sql");
    … …  
    484504    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    485505    if (psListLength(where->list)) {
    486         psString whereClaus = psDBGenerateWhereSQL(where, NULL);
    487         psStringAppend(&query, "%s", whereClaus);
     506        psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
     507        psStringAppend(&query, " AND %s", whereClaus);
    488508        psFree(whereClaus);
    489509    }
    … …  
    535555        zpt_lq,
    536556        zpt_uq,
    537         fwhm_major,
    538         fwhm_major_lq,
    539         fwhm_major_uq,
    540         fwhm_minor,
    541         fwhm_minor_lq,
    542         fwhm_minor_uq,
    543 
    544         iq_fwhm_major,
    545         iq_fwhm_major_err,
    546         iq_fwhm_minor,
    547         iq_fwhm_minor_err,
     557        fwhm_major,
     558        fwhm_major_lq,
     559        fwhm_major_uq,
     560        fwhm_minor,
     561        fwhm_minor_lq,
     562        fwhm_minor_uq,
     563
     564        iq_fwhm_major,
     565        iq_fwhm_major_err,
     566        iq_fwhm_minor,
     567        iq_fwhm_minor_err,
    548568
    549569        iq_m2,
    … …  
    578598        n_astrom,
    579599        path_base,
    580         code
     600        fault,
     601        quality
    581602        );
    582603
    … …  
    601622
    602623    // NULL for end_stage means go as far as possible
    603     // EAM : skip here if code != 0
     624    // EAM : skip here if fault != 0
    604625    // Also, we can run fake even if tess_id is not defined
    605     if (code || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
     626    if (fault || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
    606627        psFree(row);
    607628        psFree(pendingRow);
    … …  
    656677    pxcamGetSearchArgs (config, where);
    657678    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",    "==");
    658     PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label",     "==");
     679    pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
    659680    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction", "==");
     681
     682    if (!psListLength(where->list) &&
     683        !psMetadataLookupBool(NULL, config->args, "-all")) {
     684        psFree(where);
     685        psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     686        return false;
     687    }
    660688
    661689    psString query = pxDataGet("camtool_find_processedexp.sql");
    … …  
    669697        psStringAppend(&query, " WHERE %s", whereClause);
    670698        psFree(whereClause);
     699    }
     700
     701    // we either add AND (condition) or WHERE (condition):
     702    if (where->list && faulted) {
     703        // list only faulted rows
     704        psStringAppend(&query, " %s", " AND camProcessedExp.fault != 0");
     705    }
     706    if (where->list && !faulted) {
     707        // don't list faulted rows
     708        psStringAppend(&query, " %s", " AND camProcessedExp.fault = 0");
     709    }
     710    if (!where->list && faulted) {
     711        // list only faulted rows
     712        psStringAppend(&query, " %s", " WHERE camProcessedExp.fault != 0");
     713    }
     714    if (!where->list && !faulted) {
     715        // don't list faulted rows
     716        psStringAppend(&query, " %s", " WHERE camProcessedExp.fault = 0");
    671717    }
    672718    psFree(where);
    673 
    674     if (faulted) {
    675         // list only faulted rows
    676         psStringAppend(&query, " %s", "AND camProcessedExp.fault != 0");
    677     } else {
    678         // don't list faulted rows
    679         psStringAppend(&query, " %s", "AND camProcessedExp.fault = 0");
    680     }
    681719
    682720    // order by cam_id so that the postage stamp parser can easliy find the 'latest' astrometry
    … …  
    730768    PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label",          "==");
    731769    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction",      "==");
    732     PXOPT_COPY_S16(config->args, where, "-code",      "camProcessedExp.fault", "==");
     770    PXOPT_COPY_S16(config->args, where, "-fault", "camProcessedExp.fault", "==");
    733771
    734772    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    … …  
    818856    PS_ASSERT_PTR_NON_NULL(config, false);
    819857
    820     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
     858    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    821859
    822860    psMetadata *where = psMetadataAlloc();
    … …  
    826864    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    827865
    828     if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, code)) {
     866    if (!pxSetFaultCode(config->dbh, "camProcessedExp", where, fault)) {
    829867        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    830868        psFree (where);
    … …  
    915953
    916954    psMetadata *where = psMetadataAlloc();
    917     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     955    pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    918956
    919957    psString query = pxDataGet("camtool_pendingcleanuprun.sql");
    … …  
    9801018        PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    9811019    }
    982     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1020    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    9831021
    9841022    psString query = pxDataGet("camtool_pendingcleanupexp.sql");
    … …  
    10991137    char sqlFilename[80];
    11001138  } ExportTable;
    1101  
     1139
    11021140  int numExportTables = 2;
    11031141
    … …  
    11071145  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    11081146  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1147  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    11091148
    11101149  FILE *f = fopen (outfile, "w");
    … …  
    11551194    }
    11561195    if (!psArrayLength(output)) {
    1157       psTrace("regtool", PS_LOG_INFO, "no rows found");
     1196      psError(PS_ERR_UNKNOWN, true, "no rows found");
    11581197      psFree(output);
    1159       return true;
     1198      return false;
     1199    }
     1200
     1201    if (clean) {
     1202        if (!strcmp(tables[i].tableName, "camRun")) {
     1203            if (!pxSetStateCleaned("camRun", "state", output)) {
     1204                psFree(output);
     1205                psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1206                return false;
     1207            }
     1208        }
    11601209    }
    11611210
    … …  
    11791228
    11801229  PS_ASSERT_PTR_NON_NULL(config, NULL);
    1181  
     1230
    11821231  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    11831232
    … …  
    11901239  psAssert (item, "entry not in input?");
    11911240  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1192  
     1241
    11931242  psMetadataItem *entry = psListGet (item->data.list, 0);
    11941243  assert (entry);
    … …  
    11991248  // fprintf (stdout, "---- cam run ----\n");
    12001249  // psMetadataPrint (stderr, entry->data.md, 1);
    1201  
    1202   item = psMetadataLookup (input, "camProcessedImfile");
     1250
     1251  item = psMetadataLookup (input, "camProcessedExp");
    12031252  psAssert (item, "entry not in input?");
    12041253  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/camtoolConfig.c

    r23594 r24244  
    5252    psMetadata *definebyqueryArgs = psMetadataAlloc();
    5353    pxcamSetSearchArgs(definebyqueryArgs);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",              0, "search by chipRun label", NULL);
     54    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by chipRun label", NULL);
    5555    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by chipRun reduction class", NULL);
    5656
    … …  
    8282    pxcamSetSearchArgs(pendingexpArgs);
    8383    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id",            0, "search by cam_id", 0);
    84     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label",             0, "search by camRun label", NULL);
     84    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    8585    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-reduction",         0, "search by camRun reduction class", NULL);
    8686    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",             0, "limit result set to N items", 0);
    … …  
    9191    pxcamSetSearchArgs(pendingimfileArgs);
    9292    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by camtool ID", 0);
    93     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label",    0,            "search by camRun label", NULL);
     93    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    9494    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
    9595    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
    … …  
    164164
    165165    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
    166     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     166    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     167    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    167168    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    168169
    … …  
    171172    pxcamSetSearchArgs(processedexpArgs);
    172173    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    173     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label",    0,            "search by camRun label", NULL);
     174    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    174175    psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
    175176
    176     psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    177     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    178     psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     177    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);
     178    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-all",     0,            "list everything without restriction", false);
     179    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     180    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted", 0,            "only return imfiles with a fault status set", false);
    179181
    180182    // -revertprocessedexp
    … …  
    190192
    191193    psMetadataAddBool(revertprocessedexpArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     194    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    192195
    193196    // -updateprocessedexp
    … …  
    198201    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class",  0,            "search by class", NULL);
    199202    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    200     psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", INT16_MAX);
     203    psMetadataAddS16(updateprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", INT16_MAX);
    201204
    202205    // -block
    … …  
    215218    // XXX allow full search options?
    216219    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    217     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     220    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    218221    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    219222    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    222225    // XXX allow full search options?
    223226    psMetadata *pendingcleanupexpArgs = psMetadataAlloc();
    224     psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     227    psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    225228    psMetadataAddS64(pendingcleanupexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camera ID", 0);
    226229    psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
    … …  
    239242    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    240243    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     244    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "export tables as cleaned", false);
    241245
    242246    // -importrun

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/chiptool.c

    r23594 r24244  
    125125    psMetadata *where = psMetadataAlloc();
    126126    pxchipGetSearchArgs (config, where); // rawExp only
    127     PXOPT_COPY_STR(config->args, where, "-label", "rawExp.label", "LIKE");
     127    pxAddLabelSearchArgs (config, where, "-label", "newExp.label", "LIKE");
    128128
    129129    // psListLength(where->list) is at least 1 because exp_type defaults to "object"
    … …  
    198198    }
    199199
     200    // if end_stage is warp (or NULL), check for valid tess_id
     201    for (long i = 0; i < psArrayLength(output); i++) {
     202        psMetadata *md = output->data[i];
     203
     204        bool status;
     205        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
     206        if (end_stage && strcasecmp(end_stage, "warp")) continue;
     207
     208        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
     209        if (raw_tess_id || tess_id) continue;
     210
     211        char *label  = psMetadataLookupStr(&status, md, "label");
     212        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     213
     214        if (!status) {
     215            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     216            psFree(output);
     217            return false;
     218        }
     219    }
     220
     221
     222# define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
     223    PTYPE VALUE;                                                        \
     224    { bool status;                                                      \
     225        VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
     226        if (!status) {                                                  \
     227            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
     228            psFree(output);                                             \
     229            return false;                                               \
     230        } }
     231
    200232    // loop over our list of exp_ids
    201233    for (long i = 0; i < psArrayLength(output); i++) {
    202234        psMetadata *md = output->data[i];
    203235
    204         bool status;
    205         psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
    206         if (!status) {
    207             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for exp_id");
     236        rawExpRow *row = rawExpObjectFromMetadata(md);
     237        if (!row) {
     238            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into chipRun");
    208239            psFree(output);
    209240            return false;
    210241        }
    211         //
     242
     243        GET_VALUE (psS64,    S64, exp_id,        "exp_id");
     244        GET_VALUE (psString, Str, raw_workdir,   "workdir");
     245        GET_VALUE (psString, Str, raw_label,     "label");
     246        GET_VALUE (psString, Str, raw_reduction, "reduction");
     247        // GET_VALUE (psString, Str, raw_expgroup,  "expgroup");
     248        GET_VALUE (psString, Str, raw_dvodb,     "dvodb");
     249        GET_VALUE (psString, Str, raw_tess_id,   "tess_id");
     250        GET_VALUE (psString, Str, raw_end_stage, "end_stage");
     251
     252        if (!row->exp_id) {
     253            psError(PS_ERR_UNKNOWN, false, "failed to find value for exp_id");
     254            psFree(output);
     255            return false;
     256        }
     257
    212258        // queue the exp
    213         if (!pxchipQueueByExpTag(config, exp_id, workdir, label, reduction, expgroup, dvodb, tess_id, end_stage)) {
     259        if (!pxchipQueueByExpTag(config,
     260                                 exp_id,
     261                                 workdir     ? workdir   : raw_workdir,
     262                                 label       ? label     : raw_label,
     263                                 reduction   ? reduction : raw_reduction,
     264                                 // expgroup    ? expgroup  : raw_expgroup,
     265                                 // XXX how does expgroup get defined?
     266                                 expgroup,
     267                                 dvodb       ? dvodb     : raw_dvodb,
     268                                 tess_id     ? tess_id   : raw_tess_id,
     269                                 end_stage   ? end_stage : raw_end_stage
     270                                 )) {
    214271            if (!psDBRollback(config->dbh)) {
    215272                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    239296    pxchipGetSearchArgs (config, where); // rawExp, chipRun
    240297    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chipRun.chip_id", "==");
     298    // we only allow a single label to match (do not use pxAddLabelSearchArgs here)
    241299    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
    242300    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    243301
    244     if (!psListLength(where->list)
    245         && !psMetadataLookupBool(NULL, config->args, "-all")) {
     302    if (!psListLength(where->list) &&
     303        !psMetadataLookupBool(NULL, config->args, "-all")) {
    246304        psFree(where);
    247305        where = NULL;
    … …  
    291349    pxchipGetSearchArgs (config, where); //chipRun, rawExp
    292350    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
    293     PXOPT_COPY_STR(config->args, where, "-label", "chipRun.label", "==");
     351    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "==");
    294352
    295353    psString query = pxDataGet("chiptool_pendingimfile.sql");
    … …  
    409467    PXOPT_LOOKUP_F32(dtime_script, config->args,   "-dtime_script", false, false);
    410468    PXOPT_LOOKUP_STR(hostname, config->args,       "-hostname", false, false);
    411     PXOPT_LOOKUP_F32(n_stars, config->args,        "-n_stars", false, false);
    412     PXOPT_LOOKUP_F32(n_psfstars, config->args,     "-n_psfstars", false, false);
    413     PXOPT_LOOKUP_F32(n_iqstars, config->args,      "-n_iqstars", false, false);
    414     PXOPT_LOOKUP_F32(n_extended, config->args,     "-n_extended", false, false);
    415     PXOPT_LOOKUP_F32(n_cr, config->args,           "-n_cr", false, false);
    416     PXOPT_LOOKUP_STR(path_base, config->args,      "-path_base", false, false);
    417     PXOPT_LOOKUP_BOOL(magicked, config->args,      "-magicked", false);
     469    PXOPT_LOOKUP_F32(n_stars, config->args,        "-n_stars", false, false);
     470    PXOPT_LOOKUP_F32(n_psfstars, config->args,     "-n_psfstars", false, false);
     471    PXOPT_LOOKUP_F32(n_iqstars, config->args,      "-n_iqstars", false, false);
     472    PXOPT_LOOKUP_F32(n_extended, config->args,     "-n_extended", false, false);
     473    PXOPT_LOOKUP_F32(n_cr, config->args,           "-n_cr", false, false);
     474    PXOPT_LOOKUP_STR(path_base, config->args,      "-path_base", false, false);
     475    PXOPT_LOOKUP_BOOL(magicked, config->args,      "-magicked", false);
    418476
    419477    // default values
    420     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     478    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     479    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    421480
    422481    if (!psDBTransaction(config->dbh)) {
    … …  
    449508                                   fwhm_minor_uq,
    450509
    451                                    iq_fwhm_major,
    452                                    iq_fwhm_major_err,
    453                                    iq_fwhm_minor,
    454                                    iq_fwhm_minor_err,
    455 
    456                                    iq_m2,
    457                                    iq_m2_err,
    458                                    iq_m2_lq,
    459                                    iq_m2_uq,
    460 
    461                                    iq_m2c,
    462                                    iq_m2c_err,
    463                                    iq_m2c_lq,
    464                                    iq_m2c_uq,
    465 
    466                                    iq_m2s,
    467                                    iq_m2s_err,
    468                                    iq_m2s_lq,
    469                                    iq_m2s_uq,
    470 
    471                                    iq_m3,
    472                                    iq_m3_err,
    473                                    iq_m3_lq,
    474                                    iq_m3_uq,
    475 
    476                                    iq_m4,
    477                                    iq_m4_err,
    478                                    iq_m4_lq,
    479                                    iq_m4_uq,
     510                                   iq_fwhm_major,
     511                                   iq_fwhm_major_err,
     512                                   iq_fwhm_minor,
     513                                   iq_fwhm_minor_err,
     514
     515                                   iq_m2,
     516                                   iq_m2_err,
     517                                   iq_m2_lq,
     518                                   iq_m2_uq,
     519
     520                                   iq_m2c,
     521                                   iq_m2c_err,
     522                                   iq_m2c_lq,
     523                                   iq_m2c_uq,
     524
     525                                   iq_m2s,
     526                                   iq_m2s_err,
     527                                   iq_m2s_lq,
     528                                   iq_m2s_uq,
     529
     530                                   iq_m3,
     531                                   iq_m3_err,
     532                                   iq_m3_lq,
     533                                   iq_m3_uq,
     534
     535                                   iq_m4,
     536                                   iq_m4_err,
     537                                   iq_m4_lq,
     538                                   iq_m4_uq,
    480539
    481540                                   dtime_detrend,
    … …  
    490549                                   n_cr,
    491550                                   path_base,
    492                                    code,
     551                                   fault,
     552                                   quality,
    493553                                   magicked
    494554            )) {
    … …  
    540600    PXOPT_COPY_STR(config->args, where, "-class_id", "chipProcessedImfile.class_id", "==");
    541601    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    542     PXOPT_COPY_STR(config->args, where, "-label", "chipRun.label", "LIKE");
     602    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
    543603    PXOPT_COPY_S32(config->args, where, "-magicked", "chipRun.magicked", "==");
     604
     605    if (!psListLength(where->list) &&
     606        !psMetadataLookupBool(NULL, config->args, "-all")) {
     607        psFree(where);
     608        psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     609        return false;
     610    }
    544611
    545612    psString query = pxDataGet("chiptool_processedimfile.sql");
    … …  
    609676    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
    610677    PXOPT_COPY_STR(config->args, where, "-class_id", "chipProcessedImfile.class_id", "==");
    611     PXOPT_COPY_STR(config->args, where, "-label", "chipRun.label", "LIKE");
     678    // require a single label
     679    PXOPT_COPY_STR(config->args, where, "-label", "chipRun.label", "==");
    612680    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    613     PXOPT_COPY_S16(config->args, where, "-code", "chipProcessedImfile.fault", "==");
     681    PXOPT_COPY_S16(config->args, where, "-fault", "chipProcessedImfile.fault", "==");
    614682
    615683    if (!psListLength(where->list)
    … …  
    652720    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    653721    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    654     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    655 
    656     if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, code)) {
     722    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     723
     724    if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
    657725        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    658726        return false;
    … …  
    835903
    836904    psMetadata *where = psMetadataAlloc();
    837     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     905    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    838906
    839907    psString query = pxDataGet("chiptool_pendingcleanuprun.sql");
    … …  
    899967        PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    900968    }
    901     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     969    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    902970
    903971    psString query = pxDataGet("chiptool_pendingcleanupimfile.sql");
    … …  
    10271095
    10281096    psMetadata *where = psMetadataAlloc();
    1029     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1097    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    10301098    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    10311099
    … …  
    10881156
    10891157    psMetadata *where = psMetadataAlloc();
    1090     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1158    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    10911159
    10921160    // look for completed chipPendingExp
    … …  
    12731341    char sqlFilename[80];
    12741342  } ExportTable;
    1275  
     1343
    12761344  int numExportTables = 3;
    12771345
    12781346  PS_ASSERT_PTR_NON_NULL(config, NULL);
    12791347
    1280   PXOPT_LOOKUP_S64(det_id, config->args, "-chip_id", true,  false);
     1348  PXOPT_LOOKUP_S64(dummy, config->args, "-chip_id", true,  false);
    12811349  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    12821350  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1351  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1352
    12831353
    12841354  FILE *f = fopen (outfile, "w");
    … …  
    13311401    }
    13321402    if (!psArrayLength(output)) {
    1333       psTrace("regtool", PS_LOG_INFO, "no rows found");
     1403      psTrace("chiptool", PS_LOG_INFO, "no rows found");
    13341404      psFree(output);
    1335       return true;
     1405      return false;
     1406    }
     1407
     1408    if (clean) {
     1409        bool success = true;
     1410        if (!strcmp(tables[i].tableName, "chipRun")) {
     1411            success = pxSetStateCleaned("chipRun", "state", output);
     1412        } else if (!strcmp(tables[i].tableName, "chipProcessedImfile")) {
     1413            success = pxSetStateCleaned("chipProcessedImfile", "data_state", output);
     1414        }
     1415        if (!success) {
     1416            psFree(output);
     1417            psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1418            return false;
     1419        }
    13361420    }
    13371421
    … …  
    13521436bool importrunMode(pxConfig *config)
    13531437{
    1354   unsigned int nFail;
    1355  
    1356   int numImportTables = 2;
    1357  
    1358   char tables[2] [80] = {"chipImfile", "chipProcessedImfile"};
    1359 
    1360   PS_ASSERT_PTR_NON_NULL(config, NULL);
    1361  
    1362   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    1363 
    1364   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    1365 
    1366   fprintf (stdout, "---- input ----\n");
    1367   psMetadataPrint (stderr, input, 1);
    1368 
    1369   psMetadataItem *item = psMetadataLookup (input, "chipRun");
    1370   psAssert (item, "entry not in input?");
    1371   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1372 
    1373   psMetadataItem *entry = psListGet (item->data.list, 0);
    1374   assert (entry);
    1375   assert (entry->type == PS_DATA_METADATA);
    1376   chipRunRow *chipRun = chipRunObjectFromMetadata (entry->data.md);
    1377   chipRunInsertObject (config->dbh, chipRun);
    1378 
    1379   // fprintf (stdout, "---- chip run ----\n");
    1380   // psMetadataPrint (stderr, entry->data.md, 1);
    1381  
    1382   for (int i = 0; i < numImportTables; i++) {
    1383     psMetadataItem *item = psMetadataLookup (input, tables[i]);
    1384     psAssert (item, "entry not in input?");
    1385     psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1386  
    1387     switch (i) {
    1388       case 0:
    1389         for (int i = 0; i < item->data.list->n; i++) {
    1390           psMetadataItem *entry = psListGet (item->data.list, i);
    1391           assert (entry);
    1392           assert (entry->type == PS_DATA_METADATA);
    1393           chipImfileRow *chipImfile = chipImfileObjectFromMetadata (entry->data.md);
    1394           chipImfileInsertObject (config->dbh, chipImfile);
    1395 
    1396           // fprintf (stdout, "---- row %d ----\n", i);
    1397           // psMetadataPrint (stderr, entry->data.md, 1);
    1398         }
    1399         break;
    1400        
    1401       case 1:
    1402         for (int i = 0; i < item->data.list->n; i++) {
    1403           psMetadataItem *entry = psListGet (item->data.list, i);
    1404           assert (entry);
    1405           assert (entry->type == PS_DATA_METADATA);
    1406           chipProcessedImfileRow *chipProcessedImfile = chipProcessedImfileObjectFromMetadata (entry->data.md);
    1407           chipProcessedImfileInsertObject (config->dbh, chipProcessedImfile);
    1408 
    1409           // fprintf (stdout, "---- row %d ----\n", i);
    1410           // psMetadataPrint (stderr, entry->data.md, 1);
    1411         }
    1412         break;
    1413     }
    1414   }
    1415 
    1416   return true;
    1417 }
    1418 
    1419 
     1438    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1439
     1440    PXOPT_LOOKUP_STR(infile, config->args, "-infile", true, false);
     1441    unsigned int nFail = 0;               // Number of failed lines
     1442    psMetadata *input = psMetadataConfigRead(NULL, &nFail, infile, false);
     1443    if (nFail) {
     1444        psError(PS_ERR_IO, false, "%d failed lines in input", nFail);
     1445        psFree(input);
     1446        return false;
     1447    }
     1448
     1449    psVector *identifiers = psVectorAllocEmpty(16, PS_TYPE_U64); // Identifiers inserted
     1450
     1451    if (!psDBTransaction(config->dbh)) {
     1452        psError(PS_ERR_UNKNOWN, false, "database error");
     1453        return false;
     1454    }
     1455
     1456    psMetadataIterator *iter = psMetadataIteratorAlloc(input, PS_LIST_HEAD, NULL);       // Iterator
     1457    psMetadataItem *item;               // Item from iteration
     1458    while ((item = psMetadataGetAndIncrement(iter))) {
     1459        PXMIRROR_PRIMARY(item, "chipRun", chipRunRow, chipRunObjectFromMetadata, identifiers, chip_id,
     1460                         chipRunInsertObject, config->dbh,
     1461                         { psFree(iter); psFree(identifiers); psFree(input); });
     1462
     1463        PXMIRROR_OTHER(item, "chipImfile", chipImfileRow, chipImfileObjectFromMetadata, identifiers, chip_id,
     1464                       chipImfileInsertObject, config->dbh,
     1465                       { psFree(iter); psFree(identifiers); psFree(input); });
     1466
     1467        PXMIRROR_OTHER(item, "chipProcessedImfile", chipProcessedImfileRow,
     1468                       chipProcessedImfileObjectFromMetadata, identifiers, chip_id,
     1469                       chipProcessedImfileInsertObject, config->dbh,
     1470                       { psFree(iter); psFree(identifiers); psFree(input); });
     1471    }
     1472    psFree(iter);
     1473    psFree(input);
     1474
     1475    if (!psDBCommit(config->dbh)) {
     1476        psError(PS_ERR_UNKNOWN, false, "database error");
     1477        return false;
     1478    }
     1479
     1480    psLogMsg("chiptool", PS_LOG_INFO, "%ld chipRuns added", identifiers->n);
     1481    psFree(identifiers);
     1482
     1483    return true;
     1484}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/chiptoolConfig.c

    r23594 r24244  
    4747    psMetadata *definebyqueryArgs = psMetadataAlloc();
    4848    pxchipSetSearchArgs (definebyqueryArgs);
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",              0, "search by rawExp label (LIKE comparison)", NULL);
     49    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by rawExp label (LIKE comparison)", NULL);
    5050
    5151    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_type",          PS_META_REPLACE, "search by exp_type", "object");
    … …  
    7575    psMetadata *pendingimfileArgs = psMetadataAlloc();
    7676    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
    77     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label",  0, "search by label", 0);
     77    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", 0);
    7878    pxchipSetSearchArgs(pendingimfileArgs);
    7979    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    146146
    147147    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    148     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     148    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     149    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    149150    psMetadataAddBool(addprocessedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "define magicked status", false);
    150151
    151152    // -processedimfile
    152153    psMetadata *processedimfileArgs = psMetadataAlloc();
     154    pxchipSetSearchArgs(processedimfileArgs);
    153155    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,         "search by  chip ID", 0);
    154156    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-chip_imfile_id",  0,  "search by chip_file_id", 0);
    155157    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID", NULL);
    156158    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    157     psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-label",              0, "search by chipRun label (LIKE comparison)", NULL);
     159    psMetadataAddStr(processedimfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
    158160    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-magicked",  0,        "search by magicked status", false);
    159     pxchipSetSearchArgs(processedimfileArgs);
    160     psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
     161    psMetadataAddU64(processedimfileArgs,  PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
     162    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
    161163    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,        "only return imfiles with a fault status set", false);
    162164    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
    … …  
    170172    pxchipSetSearchArgs(revertprocessedimfileArgs);
    171173    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    172     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     174    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    173175
    174176    // -updateprocessedimfile
    … …  
    176178    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,            "search by chip ID", 0);
    177179    psMetadataAddStr(updateprocessedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID", NULL);
    178     psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
    179 
    180     // -advanceexp
    181     psMetadata *advanceexpArgs = psMetadataAlloc();
    182     psMetadataAddS64(advanceexpArgs, PS_LIST_TAIL, "-chip_id",  0,          "search by chip ID", 0);
    183     psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label",  0,            "advance exposures for specified label", NULL);
    184     psMetadataAddU64(advanceexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     180    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
    185181
    186182    // -block
    … …  
    206202    // -pendingcleanuprun
    207203    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    208     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     204    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    209205    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    210206    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    212208    // -pendingcleanupimfile
    213209    psMetadata *pendingcleanupimfileArgs = psMetadataAlloc();
    214     psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     210    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    215211    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-chip_id", 0,          "search by chip ID", 0);
    216212    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
    … …  
    226222    // -run
    227223    psMetadata *runArgs = psMetadataAlloc();
    228     psMetadataAddStr(runArgs, PS_LIST_TAIL, "-label",  0,      "search by label", NULL);
     224    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    229225    psMetadataAddBool(runArgs, PS_LIST_TAIL, "-simple",  0,     "use the simple output format", false);
    230226    psMetadataAddU64(runArgs, PS_LIST_TAIL, "-limit",  0,       "limit result set to N items", 0);
    231227    psMetadataAddStr(runArgs, PS_LIST_TAIL, "-state", 0,        "search by state (required)", NULL);
     228
     229    // -advanceexp
     230    psMetadata *advanceexpArgs = psMetadataAlloc();
     231    psMetadataAddS64(advanceexpArgs, PS_LIST_TAIL, "-chip_id",  0,          "search by chip ID", 0);
     232    psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "advance exposures for specified label", NULL);
     233    psMetadataAddU64(advanceexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    232234
    233235    // -tocleanedimfile
    … …  
    251253    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-chip_id", 0,          "export this chip ID (required)", 0);
    252254    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     255    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "mark tables as cleaned", false);
    253256    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
    254257

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/detselect.c

    r18561 r24244  
    7171}
    7272
     73# define PXOPT_COPY_NULLTEST_F32(from, to, oldname, newname, comment) \
     74{ \
     75    bool status = false; \
     76    psF32 var = psMetadataLookupF32(&status, from, oldname); \
     77    if (!status) { \
     78        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     79        return false; \
     80    } \
     81    if (!isnan(var)) { \
     82        if (!psMetadataAddF32(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
     83            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     84            psFree(to); \
     85            return false; \
     86        } \
     87        if (!psMetadataAddTime(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, "==", NULL)) { \
     88            psError(PS_ERR_UNKNOWN, false, "failed to add NULL test " newname); \
     89            psFree(to); \
     90            return false; \
     91        } \
     92    } \
     93}
     94
    7395static bool searchMode(pxConfig *config)
    7496{
    … …  
    89111
    90112    // airmass_min  < airmass  < airmass_max
    91     PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_min", "<=");
    92     PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_max", ">=");
     113    PXOPT_COPY_NULLTEST_F32(config->args, where, "-airmass", "airmass_min", "<=");
     114    PXOPT_COPY_NULLTEST_F32(config->args, where, "-airmass", "airmass_max", ">=");
    93115
    94116    // exp_time_min < exp_time < exp_time_max
    95     PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
    96     PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
     117    PXOPT_COPY_NULLTEST_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
     118    PXOPT_COPY_NULLTEST_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
    97119
    98120    // ccd_temp_min < ccd_temp < ccd_temp_max
    99     PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
    100     PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
     121    PXOPT_COPY_NULLTEST_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
     122    PXOPT_COPY_NULLTEST_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
    101123
    102124    PXOPT_COPY_F64(config->args, where, "-posang", "posang_min", "<=");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool.c

    r23352 r24244  
    20342034
    20352035  ExportTable tables [] = {
     2036    {"detRun", "dettool_export_run.sql"},
    20362037    {"detInputExp", "dettool_export_input_exp.sql"},
    20372038    {"detNormalizedExp", "dettool_export_normalized_exp.sql"},
    … …  
    20432044    {"detResidExp", "dettool_export_resid_exp.sql"},
    20442045    {"detResidImfile", "dettool_export_resid_imfile.sql"},
    2045     {"detRun", "dettool_export_run.sql"},
    20462046    {"detRunSummary", "dettool_export_run_summary.sql"},
    20472047    {"detStackedImfile", "dettool_export_stacked_imfile.sql"},
    … …  
    21082108 
    21092109  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
    2110     "detNormalizedStatImfile", "detProcessedExp", "detProcessedImfile",
    2111     "detRegisteredImfile", "detResidExp", "detResidImfile",
    2112     "detNormalizedImfile", "detRunSummary", "detStackedImfile"};
     2110    "detNormalizedImfile", "detNormalizedStatImfile", "detProcessedExp",
     2111    "detProcessedImfile", "detRegisteredImfile", "detResidExp",
     2112    "detResidImfile", "detRunSummary", "detStackedImfile"};
    21132113
    21142114  PS_ASSERT_PTR_NON_NULL(config, NULL);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettoolConfig.c

    r23352 r24244  
    254254    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID (required)", 0);
    255255    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    256     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     256    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    257257    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
    258258    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    … …  
    287287    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    288288    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    289     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     289    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    290290
    291291    // -updateprocessedimfile
    … …  
    334334    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-user_5",  0,            "define user statistic (5)", NAN);
    335335    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    336     psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     336    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    337337
    338338    // -proccessedexp
    … …  
    348348    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", 0);
    349349    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    350     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     350    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    351351
    352352    // -updateprocessedexp
    … …  
    380380    psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number (required)", 0);
    381381    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    382     psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     382    psMetadataAddS16(addstackedArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    383383    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-uri",  0,            "define URI", NULL);
    384384    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    … …  
    407407    psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    408408    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    409     psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     409    psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    410410
    411411    // -updatestacked
    … …  
    443443    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    444444    psMetadataAddF32(addnormstatArgs, PS_LIST_TAIL, "-norm",  0,            "define normal value (required)", NAN);
    445     psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     445    psMetadataAddS16(addnormstatArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    446446
    447447    // -normalizedstat
    … …  
    459459    psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    460460    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    461     psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     461    psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    462462
    463463    // -updatenormalizedstat
    … …  
    494494    psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "define iteration number", 0);
    495495    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "define class ID (required)", NULL);
    496     psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     496    psMetadataAddS16(addnormalizedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    497497    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI", NULL);
    498498    psMetadataAddF64(addnormalizedimfileArgs, PS_LIST_TAIL, "-bg", 0,            "define exposure background", NAN);
    … …  
    521521    psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    522522    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
    523     psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     523    psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    524524
    525525    // -updatenormalizedimfile
    … …  
    555555    psMetadataAddS64(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    556556    psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    557     psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     557    psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    558558    psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
    559559    psMetadataAddF64(addnormalizedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    580580    psMetadataAddS64(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    581581    psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    582     psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     582    psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    583583
    584584    // -updatenormalizedexp
    … …  
    616616    psMetadataAddS64(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", 0);
    617617    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,          "define class ID (required)", NULL);
    618     psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,              "set fault code", 0);
     618    psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-fault",  0,              "set fault code", 0);
    619619    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-uri",  0,               "define resid file URI", NULL);
    620620    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-recip",  0,             "define recipe", NULL);
    … …  
    658658    psMetadataAddS64(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,         "search by detrend ID", 0);
    659659    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,       "search for class ID", NULL);
    660     psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,           "search by fault code", 0);
     660    psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-fault",  0,           "search by fault code", 0);
    661661
    662662    // -updateresidimfile
    … …  
    696696    psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    697697    psMetadataAddS64(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", 0);
    698     psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     698    psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    699699    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    700700    psMetadataAddF64(addresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    734734    psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    735735    psMetadataAddS64(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
    736     psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     736    psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    737737
    738738    // -updateresidexp
    … …  
    777777    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_stdev",  0,            "define exposure background stdev", NAN);
    778778    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg_mean_stdev",  0,            "define exposure background mean stdev", NAN);
    779     psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     779    psMetadataAddS16(adddetrunsummaryArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    780780    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
    781781    psMetadataAddBool(adddetrunsummaryArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
    … …  
    794794    psMetadataAddS64(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    795795    psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    796     psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     796    psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    797797
    798798    // -updatedetrunsummary
    … …  
    886886    PXOPT_ADD_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
    887887
    888     PXOPT_ADD_MODE("-toprocessedimfile", "",              DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
    889     PXOPT_ADD_MODE("-addprocessedimfile", "",             DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
    890     PXOPT_ADD_MODE("-processedimfile", "",                DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    891     PXOPT_ADD_MODE("-revertprocessedimfile", "",          DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
    892     PXOPT_ADD_MODE("-updateprocessedimfile", "",          DETTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     888    PXOPT_ADD_MODE("-toprocessedimfile", "",              DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
     889    PXOPT_ADD_MODE("-addprocessedimfile", "",             DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
     890    PXOPT_ADD_MODE("-processedimfile", "",                DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     891    PXOPT_ADD_MODE("-revertprocessedimfile", "",          DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
     892    PXOPT_ADD_MODE("-updateprocessedimfile", "",          DETTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
    893893    PXOPT_ADD_MODE("-pendingcleanup_processedimfile", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE, pendingcleanup_processedimfileArgs);
    894894    PXOPT_ADD_MODE("-donecleanup_processedimfile", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE, donecleanup_processedimfileArgs);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_detrunsummary.c

    r21402 r24244  
    101101
    102102    // default values
    103     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     103    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    104104    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    105105
    … …  
    107107            det_id,
    108108            iteration,
    109             "full",
     109            "full",
    110110            bg,
    111111            bg_stdev,
    112112            bg_mean_stdev,
    113113            accept,
    114             code
     114            fault
    115115        );
    116116}
    … …  
    120120{
    121121    PS_ASSERT_PTR_NON_NULL(config, false);
    122    
     122
    123123    // build a query to search by det_id, iteration, exp_id
    124124    psMetadata *where = psMetadataAlloc();
    … …  
    129129    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
    130130
    131     // The values supplied as arguments on the command (eg, -bg) are parsed 
    132     // by mdToDetRunSummary below. 
     131    // The values supplied as arguments on the command (eg, -bg) are parsed
     132    // by mdToDetRunSummary below.
    133133    // XXX why is there ever more than one?
    134134
    … …  
    141141    if (psListLength(where->list)) {
    142142        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    143         psStringAppend(&query, " WHERE %s", whereClause);
    144         psFree(whereClause);
     143        psStringAppend(&query, " WHERE %s", whereClause);
     144        psFree(whereClause);
    145145    }
    146146    psFree(where);
    … …  
    199199    psFree(output);
    200200
    201     // XXX this logic does not deal with the case of -code being set
    202     // XXX it should be an error for -again and -code to both be set
     201    // XXX this logic does not deal with the case of -fault being set
     202    // XXX it should be an error for -again and -fault to both be set
    203203    if (again) {
    204204        if (!startNewIteration(config, det_id)) {
    … …  
    306306    PXOPT_COPY_S64(config->args, where, "-det_id",    "det_id", "==");
    307307    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    308     PXOPT_COPY_STR(config->args, where, "-code",      "fault", "==");
     308    PXOPT_COPY_STR(config->args, where, "-fault",      "fault", "==");
    309309
    310310    psString query = pxDataGet("dettool_revertdetrunsummary.sql");
    … …  
    340340{
    341341    PS_ASSERT_PTR_NON_NULL(config, false);
    342    
     342
    343343    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    344344    PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    … …  
    355355    }
    356356
    357     char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64; 
     357    char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64;
    358358    if (!p_psDBRunQueryF(config->dbh, query, accept, det_id)) {
    359359        psError(PS_ERR_UNKNOWN, false, "database error");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_normalizedexp.c

    r19092 r24244  
    7272{
    7373    PS_ASSERT_PTR_NON_NULL(config, false);
    74    
     74
    7575    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    7676    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    77     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    78     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
     77    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     78    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false); // Required if fault == 0
    7979    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    8080    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    117117    // insert the new row into the detProcessedImfile table
    118118    if (!detNormalizedExpInsert(
    119             config->dbh,
    120             det_id,
    121             iteration,
    122             recipe,
    123             bg,
    124             bg_stdev,
    125             bg_mean_stdev,
    126             user_1,
    127             user_2,
    128             user_3,
    129             user_4,
    130             user_5,
    131             path_base,
    132             "full",
    133             code
    134             )) {
     119            config->dbh,
     120            det_id,
     121            iteration,
     122            recipe,
     123            bg,
     124            bg_stdev,
     125            bg_mean_stdev,
     126            user_1,
     127            user_2,
     128            user_3,
     129            user_4,
     130            user_5,
     131            path_base,
     132            "full",
     133            fault
     134            )) {
    135135        psError(PS_ERR_UNKNOWN, false, "database error");
    136136        return false;
    … …  
    221221    PXOPT_COPY_S64(config->args, where, "-det_id",    "det_id", "==");
    222222    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    223     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     223    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    224224
    225225    psString query = pxDataGet("dettool_revertnormalizedexp.sql");
    … …  
    260260
    261261    if (!setNormExpDataState(config, det_id, iteration, data_state)) {
    262         return false;
     262        return false;
    263263    }
    264264    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_normalizedimfile.c

    r19092 r24244  
    8080    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    8181
    82     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    83 
    84     // Required if code == 0
    85     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
     82    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     83
     84    // Required if fault == 0
     85    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false);
    8686
    8787    // optional
    … …  
    9797
    9898    if (!detNormalizedImfileInsert(
    99             config->dbh,
    100             det_id,
    101             iteration,
    102             class_id,
    103             uri,
    104             bg,
    105             bg_stdev,
    106             bg_mean_stdev,
    107             user_1,
    108             user_2,
    109             user_3,
    110             user_4,
    111             user_5,
    112             path_base,
    113             "full",
    114             code
    115             )) {
     99            config->dbh,
     100            det_id,
     101            iteration,
     102            class_id,
     103            uri,
     104            bg,
     105            bg_stdev,
     106            bg_mean_stdev,
     107            user_1,
     108            user_2,
     109            user_3,
     110            user_4,
     111            user_5,
     112            path_base,
     113            "full",
     114            fault
     115            )) {
    116116        psError(PS_ERR_UNKNOWN, false, "database error");
    117117        return false;
    … …  
    201201    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    202202    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    203     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     203    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    204204
    205205    psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    … …  
    241241
    242242    if (!setNormImfileDataState(config, det_id, iteration, class_id, data_state)) {
    243         return false;
     243        return false;
    244244    }
    245245    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_normalizedstat.c

    r19092 r24244  
    8383    // default
    8484    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    85     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     85    PXOPT_LOOKUP_S16(code, config->args, "-fault", false, false);
    8686
    8787    detNormalizedStatImfileRow *row = detNormalizedStatImfileRowAlloc
    88         (det_id,
    89         iteration,
    90         class_id,
    91         norm,
    92         "full",
    93         code);
    94                                                                          
     88        (det_id,
     89        iteration,
     90        class_id,
     91        norm,
     92        "full",
     93        code);
     94
    9595    if (!detNormalizedStatImfileInsertObject(config->dbh, row)) {
    96         psError(PS_ERR_UNKNOWN, false, "database error");
    97         return false;
     96        psError(PS_ERR_UNKNOWN, false, "database error");
     97        return false;
    9898    }
    9999
    … …  
    181181    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    182182    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    183     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     183    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    184184
    185185    psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    … …  
    221221
    222222    if (!setNormStatImfileDataState(config, det_id, iteration, class_id, data_state)) {
    223         return false;
     223        return false;
    224224    }
    225225    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_processedexp.c

    r21402 r24244  
    8080
    8181    // default values
    82     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    83 
    84     // Required if code == 0
    85     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
     82    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     83
     84    // Required if fault == 0
     85    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false);
    8686
    8787    // optional
    … …  
    141141        user_5,
    142142        path_base,
    143         "full",
    144         code
     143        "full",
     144        fault
    145145    );
    146146
    … …  
    231231    PXOPT_COPY_S64(config->args, where, "-det_id", "det_id", "==");
    232232    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    233     PXOPT_COPY_S16(config->args, where, "-code",   "fault", "==");
     233    PXOPT_COPY_S16(config->args, where, "-fault",   "fault", "==");
    234234
    235235    psString query = pxDataGet("dettool_revertprocessedexp.sql");
    … …  
    269269    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    270270    if (!setProcessedExpDataState(config, det_id, exp_id, data_state)) {
    271         return false;
     271        return false;
    272272    }
    273273    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_processedimfile.c

    r23352 r24244  
    9292
    9393    // default values
    94     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    95 
    96     // Required if code == 0
    97     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    98     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
     94    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     95
     96    // Required if fault == 0
     97    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false);
     98    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false);
    9999
    100100    // optional
    … …  
    144144        user_5,
    145145        path_base,
    146         "full",
    147         code
     146        "full",
     147        fault
    148148    );
    149149    psFree(rawImfiles);
    … …  
    190190        psStringAppend(&query, " %s", whereClause);
    191191        psFree(whereClause);
    192         hasWhere = true;
     192        hasWhere = true;
    193193    }
    194194    psFree (where);
    … …  
    196196    // restrict search to included imfiles
    197197    if (included) {
    198         if (hasWhere) {
    199             psStringAppend(&query, " AND detInputExp.include = 1");
    200         } else {
    201             psStringAppend(&query, " WHERE detInputExp.include = 1");
    202         }
    203         hasWhere = true;
     198        if (hasWhere) {
     199            psStringAppend(&query, " AND detInputExp.include = 1");
     200        } else {
     201            psStringAppend(&query, " WHERE detInputExp.include = 1");
     202        }
     203        hasWhere = true;
    204204    }
    205205
    206206    if (hasWhere) {
    207         psStringAppend(&query, " AND");
     207        psStringAppend(&query, " AND");
    208208    } else {
    209         psStringAppend(&query, " WHERE");
     209        psStringAppend(&query, " WHERE");
    210210    }
    211211
    212212    if (faulted) {
    213213        // list only faulted rows
    214         psStringAppend(&query, " %s", " detProcessedImfile.fault != 0");
     214        psStringAppend(&query, " %s", " detProcessedImfile.fault != 0");
    215215    } else {
    216216        // don't list faulted rows
    … …  
    263263    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    264264    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    265     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     265    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    266266
    267267    psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    … …  
    303303
    304304    if (!setProcessedImfileDataState(config, det_id, exp_id, class_id, data_state)) {
    305         return false;
     305        return false;
    306306    }
    307307    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_residexp.c

    r19092 r24244  
    9595    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    9696    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false); // required
    97     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    98     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
     97    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     98    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false); // Required if fault == 0
    9999    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    100100    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    124124
    125125    if (psListLength(where->list)) {
    126         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    127         psStringAppend(&query, " WHERE %s", whereClause);
    128         psFree(whereClause);
     126        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     127        psStringAppend(&query, " WHERE %s", whereClause);
     128        psFree(whereClause);
    129129    }
    130130    psFree(where);
    … …  
    151151
    152152    if (!detResidExpInsert(
    153             config->dbh,
     153            config->dbh,
    154154            det_id,
    155155            iteration,
    … …  
    174174            user_5,
    175175            path_base,
    176             "full",
     176            "full",
    177177            !reject,
    178             code
     178            fault
    179179        )) {
    180180        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    225225    if (reject) {
    226226        psStringAppend(&query, " %s", "AND detResidExp.accept != 0");
    227     } 
     227    }
    228228
    229229    // treat limit == 0 as "no limit"
    … …  
    273273    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    274274    PXOPT_COPY_S64(config->args, where, "-exp_id",    "exp_id", "==");
    275     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     275    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    276276
    277277    psString query = pxDataGet("dettool_revertresidexp.sql");
    … …  
    330330    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", false, false);
    331331    if (data_state) {
    332         if (!isValidDataState (data_state)) return false;
     332        if (!isValidDataState (data_state)) return false;
    333333    }
    334334

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_residimfile.c

    r23352 r24244  
    7575    PS_ASSERT_PTR_NON_NULL(config, false);
    7676
    77    
     77
    7878    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    7979    PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    … …  
    8484    PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", true, false); // required
    8585    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    86     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    87     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false); // Required if code == 0
    88     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
     86    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     87    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false); // Required if fault == 0
     88    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false); // Required if fault == 0
    8989    PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    9090    PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    … …  
    107107
    108108    if (!detResidImfileInsert(
    109             config->dbh,
     109            config->dbh,
    110110            det_id,
    111111            iteration,
    … …  
    134134            user_5,
    135135            path_base,
    136             "full",
    137             code
     136            "full",
     137            fault
    138138    )) {
    139139        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    174174        psStringAppend(&query, " %s", whereClause);
    175175        psFree(whereClause);
    176         hasWhere = true;
     176        hasWhere = true;
    177177    }
    178178    psFree(where);
    … …  
    180180    // restrict search to included imfiles
    181181    if (included) {
    182         if (hasWhere) {
    183             psStringAppend(&query, " AND detInputExp.include = 1");
    184         } else {
    185             psStringAppend(&query, " WHERE detInputExp.include = 1");
    186         }
    187         hasWhere = true;
     182        if (hasWhere) {
     183            psStringAppend(&query, " AND detInputExp.include = 1");
     184        } else {
     185            psStringAppend(&query, " WHERE detInputExp.include = 1");
     186        }
     187        hasWhere = true;
    188188    }
    189189
    190190    if (hasWhere) {
    191         psStringAppend(&query, " AND");
     191        psStringAppend(&query, " AND");
    192192    } else {
    193         psStringAppend(&query, " WHERE");
     193        psStringAppend(&query, " WHERE");
    194194    }
    195195
    … …  
    249249    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "==");
    250250    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    251     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     251    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    252252
    253253    psString query = pxDataGet("dettool_revertresidimfile.sql");
    … …  
    289289    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    290290    if (!setResidImfileDataState(config, det_id, iteration, exp_id, class_id, data_state)) {
    291         return false;
     291        return false;
    292292    }
    293293    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_stack.c

    r19092 r24244  
    127127    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    128128
    129     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    130 
    131     // Required if code == 0
    132     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    133     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
     129    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     130
     131    // Required if fault == 0
     132    PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false);
     133    PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (fault == 0), false);
    134134
    135135    // optional
    … …  
    188188            user_4,
    189189            user_5,
    190             "full",
    191             code
     190            "full",
     191            fault
    192192        );
    193193
    … …  
    286286    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    287287    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    288     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
     288    PXOPT_COPY_S16(config->args, where, "-fault",      "fault", "==");
    289289
    290290    psString query = pxDataGet("dettool_revertstacked.sql");
    … …  
    326326
    327327    if (!setStackedImfileDataState(config, det_id, iteration, class_id, data_state)) {
    328         return false;
     328        return false;
    329329    }
    330330    return true;

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftool.c

    r23594 r24244  
    4040static bool revertdiffskyfileMode(pxConfig *config);
    4141static bool definepoprunMode(pxConfig *config);
    42 static bool definebyqueryMode(pxConfig *config);
     42static bool definewarpstackMode(pxConfig *config);
    4343static bool definewarpwarpMode(pxConfig *config);
    4444static bool pendingcleanuprunMode(pxConfig *config);
    … …  
    7979        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE,     revertdiffskyfileMode);
    8080        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,          definepoprunMode);
    81         MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY,         definebyqueryMode);
     81        MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,         definewarpstackMode);
    8282        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
    8383        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    … …  
    116116    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    117117    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
     118    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
     119    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    118120    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    119121    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    120     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    121122
    122123    // default
    … …  
    133134            registered,
    134135            tess_id,
    135             exp_id,
     136            bothways,
     137            exposure,
    136138            false
    137139    );
    138140    if (!run) {
    139141        psError(PS_ERR_UNKNOWN, false, "failed to alloc diffRun object");
    140         return true;
     142        return false;
    141143    }
    142144    if (!diffRunInsertObject(config->dbh, run)) {
    143145        psError(PS_ERR_UNKNOWN, false, "database error");
    144146        psFree(run);
    145         return true;
     147        return false;
    146148    }
    147149
    … …  
    150152
    151153    if (!diffRunPrintObject(stdout, run, !simple)) {
    152             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    153             psFree(run);
    154             return false;
     154        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     155        psFree(run);
     156        return false;
    155157    }
    156158
    … …  
    412414    psMetadata *where = psMetadataAlloc();
    413415    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
    414     PXOPT_COPY_STR(config->args, where, "-label", "diffRun.label", "==");
     416    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    415417
    416418    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    485487    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false); // required
    486488    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    487     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    488     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    489     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (code == 0), false);
     489    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     490    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
     491    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (fault == 0), false);
    490492
    491493    // optional
    … …  
    506508    PXOPT_LOOKUP_F32(kernel_xy, config->args, "-kernel_xy", false, false);
    507509    PXOPT_LOOKUP_F32(kernel_yy, config->args, "-kernel_yy", false, false);
     510    PXOPT_LOOKUP_F32(deconv_max, config->args, "-deconv_max", false, false);
    508511    PXOPT_LOOKUP_S32(sources, config->args, "-sources", false, false);
    509512    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    … …  
    519522                           diff_id,
    520523                           skycell_id,
    521                            uri,
    522524                           path_base,
     525                           "full",
    523526                           bg,
    524527                           bg_stdev,
    … …  
    533536                           kernel_xy,
    534537                           kernel_yy,
     538                           deconv_max,
    535539                           sources,
    536540                           dtime_diff,
    … …  
    540544                           hostname,
    541545                           good_frac,
    542                            code,
     546                           fault,
     547                           quality,
    543548                           magicked
    544549          )) {
    … …  
    578583    PXOPT_COPY_S64(config->args, where,  "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
    579584    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffSkyfile.tess_id", "==");
    580     PXOPT_COPY_S16(config->args, where, "-code", "diffSkyfile.fault", "==");
     585    PXOPT_COPY_S16(config->args, where, "-fault", "diffSkyfile.fault", "==");
    581586    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    582587    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
    … …  
    655660    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    656661    PXOPT_COPY_STR(config->args, where,  "-label", "diffRun.label", "==");
    657     PXOPT_COPY_S16(config->args, where, "-code",     "fault", "==");
     662    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
    658663
    659664    if (!psDBTransaction(config->dbh)) {
    … …  
    690695        psFree(query);
    691696
    692         psLogMsg("diftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     697        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    693698    }
    694699
    … …  
    766771                         psS64 template_warp_id, // Warp identifier for template image, PS_MAX_S64 for none
    767772                         psS64 template_stack_id, // Stack identifier for template image, PS_MAX_S64 for none
    768                          psS64 exp_id, // exposure id for input_warp_id (if defined)
    769773                         pxConfig *config // Configuration
    770774                         )
    … …  
    797801            registered,
    798802            tess_id,
    799             exp_id,
     803            false,
     804            false,
    800805            false       // magicked
    801806    );
    … …  
    877882    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
    878883    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    879     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    880884    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    881885
    … …  
    897901        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    898902                "No input has been defined (-input_stack_id or -input_warp_id)");
    899         return false;
    900     }
    901     if (input_warp_id && !exp_id) {
    902         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    903                 "-exp_id is required with -input_warp_id.");
    904903        return false;
    905904    }
    … …  
    912911                      template_warp_id ? template_warp_id : PS_MAX_S64,
    913912                      template_stack_id ? template_stack_id : PS_MAX_S64,
    914                       exp_id ? exp_id : PS_MAX_S64,
    915913                      config)) {
    916914        psError(PS_ERR_UNKNOWN, false, "failed to create populated diffRun");
    … …  
    930928
    931929
    932 static bool definebyqueryMode(pxConfig *config)
     930static bool definewarpstackMode(pxConfig *config)
    933931{
    934932    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    955953    PXOPT_LOOKUP_BOOL(reRun, config->args, "-rerun", false);
    956954    PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
     955    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    957956
    958957    // find all things to queue
    959     psString query = pxDataGet("difftool_definebyquery_part1.sql");
     958    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    960959    if (!query) {
    961960        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    10521051    }
    10531052
     1053    if (pretend) {
     1054        // negative simple so the default is true
     1055        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     1056            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1057            psFree(output);
     1058            return false;
     1059        }
     1060        psFree(output);
     1061        return true;
     1062    }
     1063
    10541064    // create temporary table
    1055     query = pxDataGet("difftool_definebyquery_temp_create.sql");
     1065    query = pxDataGet("difftool_definewarpstack_temp_create.sql");
    10561066    if (!p_psDBRunQuery(config->dbh, query)) {
    10571067        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    10651075    query = NULL;
    10661076
    1067     psString skycell_query = pxDataGet("difftool_definebyquery_part2.sql");
     1077    psString skycell_query = pxDataGet("difftool_definewarpstack_part2.sql");
    10681078
    10691079    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    … …  
    11781188                registered,
    11791189                tess_id,
    1180                 exp_id,
     1190                false,                  // bothways
     1191                true,                   // exposure
    11811192                false       // magicked
    11821193        );
    … …  
    12691280    PXOPT_COPY_S64(config->args, selectWhere, "-exp_id", "inputRawExp.exp_id", "==");
    12701281    PXOPT_COPY_STR(config->args, selectWhere, "-filter", "inputRawExp.filter", "==");
     1282    PXOPT_COPY_STR(config->args, selectWhere, "-obs_mode", "inputRawExp.obs_mode", "==");
     1283    PXOPT_COPY_STR(config->args, selectWhere, "-obs_mode", "templateRawExp.obs_mode", "==");
    12711284    PXOPT_COPY_STR(config->args, selectWhere, "-input_label", "inputWarpRun.label", "==");
    12721285    PXOPT_COPY_STR(config->args, selectWhere, "-template_label", "templateWarpRun.label", "==");
     1286    PXOPT_COPY_F32(config->args, selectWhere, "-rotdiff", "ABS(inputRawExp.posang - templateRawExp.posang)", "<=");
    12731287    PXOPT_COPY_F32(config->args, selectWhere, "-timediff",
    12741288                   "ABS(TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs)))", "<=");
    1275     PXOPT_COPY_F32(config->args, selectWhere, "-rotdiff", "ABS(inputRawExp.posang - templateRawExp.posang)", "<=");
     1289
     1290    // Haversine formula for great circle distance
     1291    PXOPT_COPY_F32(config->args, selectWhere, "-distance",
     1292                   "DEGREES(2*ASIN(SQRT(POW(SIN(inputRawExp.decl - templateRawExp.decl),2) + "
     1293                   "COS(inputRawExp.decl)*COS(templateRawExp.decl)*"
     1294                   "POW(SIN(inputRawExp.ra - templateRawExp.ra),2))))", "<=");
     1295
     1296    PXOPT_LOOKUP_BOOL(backwards, config->args, "-backwards", false);
     1297
     1298    psMetadataAddF32(selectWhere, PS_LIST_TAIL,
     1299                     "TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs))",
     1300                     PS_META_DUPLICATE_OK, backwards ? "<" : ">", 0.0);
    12761301
    12771302    // Restrictions for inserting skycells
    … …  
    12891314    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    12901315    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1291 
    1292 
     1316    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1317
     1318    if (!psDBTransaction(config->dbh)) {
     1319        psError(PS_ERR_UNKNOWN, false, "database error");
     1320        psFree(selectWhere);
     1321        psFree(insertWhere);
     1322        return false;
     1323    }
     1324
     1325    if (!rerun) {
     1326        // Need to build table of exposures with diffs
     1327        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
     1328        if (!tempCreate) {
     1329            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1330            psFree(selectWhere);
     1331            psFree(insertWhere);
     1332            if (!psDBRollback(config->dbh)) {
     1333                psError(PS_ERR_UNKNOWN, false, "database error");
     1334            }
     1335            return false;
     1336        }
     1337
     1338        if (!p_psDBRunQuery(config->dbh, tempCreate)) {
     1339            psError(PS_ERR_UNKNOWN, false, "Unable to create temp table: %s", tempCreate);
     1340            psFree(tempCreate);
     1341            psFree(selectWhere);
     1342            psFree(insertWhere);
     1343            if (!psDBRollback(config->dbh)) {
     1344                psError(PS_ERR_UNKNOWN, false, "database error");
     1345            }
     1346            return false;
     1347        }
     1348        psFree(tempCreate);
     1349
     1350        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
     1351        if (!tempInsert) {
     1352            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1353            psFree(selectWhere);
     1354            psFree(insertWhere);
     1355            if (!psDBRollback(config->dbh)) {
     1356                psError(PS_ERR_UNKNOWN, false, "database error");
     1357            }
     1358            return false;
     1359        }
     1360
     1361        psString where = psStringCopy(""); // WHERE for insertion
     1362        if (label) {
     1363            psStringAppend(&where, "\nAND diffRun.label = '%s'", label);
     1364        }
     1365
     1366        if (!p_psDBRunQueryF(config->dbh, tempInsert, where, where)) {
     1367            psError(PS_ERR_UNKNOWN, false, "Unable to insert into temp table: %s", tempInsert);
     1368            psFree(tempInsert);
     1369            psFree(where);
     1370            psFree(selectWhere);
     1371            psFree(insertWhere);
     1372            if (!psDBRollback(config->dbh)) {
     1373                psError(PS_ERR_UNKNOWN, false, "database error");
     1374            }
     1375            return false;
     1376        }
     1377        psFree(where);
     1378        psFree(tempInsert);
     1379    }
     1380
     1381    // Get list of warps to diff
    12931382    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    12941383    if (!select) {
    12951384        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1385        psFree(selectWhere);
     1386        psFree(insertWhere);
     1387        if (!psDBRollback(config->dbh)) {
     1388            psError(PS_ERR_UNKNOWN, false, "database error");
     1389        }
    12961390        return false;
    12971391    }
    … …  
    13061400    psFree(selectWhere);
    13071401
     1402    if (!available) {
     1403        psStringAppend(&whereClause,
     1404                       "\n%s inputWarpRun.state = 'full'"
     1405                       "AND templateWarpRun.state = 'full'",
     1406                       whereClause ? "AND" : "WHERE");
     1407    }
     1408
    13081409    if (!rerun) {
    1309         psStringAppend(&whereClause, "\n%s diffRun.diff_id IS NULL", whereClause ? "AND" : "WHERE");
    1310     }
    1311 
    1312     if (!available) {
    1313         psStringAppend(&whereClause, "\n%s inputWarpRun.state = 'full'", whereClause ? "AND" : "WHERE");
    1314     }
    1315 
    1316     if (!psDBTransaction(config->dbh)) {
    1317         psError(PS_ERR_UNKNOWN, false, "database error");
    1318         psFree(select);
    1319         psFree(whereClause);
    1320         psFree(insertWhere);
    1321         return false;
     1410        psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
    13221411    }
    13231412
    13241413    if (!p_psDBRunQueryF(config->dbh, select,
    1325                          !rerun ? "\n" : "", // Activate LEFT JOIN against diffRun?
     1414                         !rerun ? "\n" : "", // Activate LEFT JOIN against diffs?
    13261415                         whereClause)) {
    13271416        psError(PS_ERR_UNKNOWN, false, "Unable to run query: %s [WITH] %s", select, whereClause);
    … …  
    13681457    }
    13691458
     1459    if (pretend) {
     1460        // negative simple so the default is true
     1461        if (!ippdbPrintMetadatas(stdout, results, "diffRun", !simple)) {
     1462            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1463            psFree(results);
     1464            return false;
     1465        }
     1466        psFree(results);
     1467        return true;
     1468    }
     1469
    13701470    psString insert = pxDataGet("difftool_definewarpwarp_insert.sql"); // Insertion for each new run
    13711471
    13721472    if (psListLength(insertWhere->list)) {
    13731473        psString whereClause = psDBGenerateWhereConditionSQL(insertWhere, NULL);
    1374         psStringAppend(&insert, "\n%s", whereClause);
     1474        psStringAppend(&insert, "\nAND %s", whereClause);
    13751475        psFree(whereClause);
    13761476    }
    … …  
    13821482        psMetadata *row = results->data[i]; // Result row from query
    13831483
    1384         psS64 exp_id = psMetadataLookupS64(NULL, row, "input_exp_id");
    13851484        psS64 input_id = psMetadataLookupS64(NULL, row, "input_warp_id");
    1386         psS64 template_id = psMetadataLookupS64(NULL, row, "template_warp_id");
     1485        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    13871486        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
    1388         if (!exp_id || !input_id || !template_id || !tess_id) {
     1487        if (!input_id || !template || !tess_id) {
    13891488            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    13901489            psFree(list);
    … …  
    13981497
    13991498        diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1400                                           tess_id, exp_id, false); // Run to insert
     1499                                          tess_id, true, true, false); // Run to insert
    14011500        if (!diffRunInsertObject(config->dbh, run)) {
    14021501            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    14131512
    14141513        // Convert identifiers to string, for insertion into query
    1415         psString diff = NULL, input = NULL, template = NULL; // String versions of identifiers
     1514        psString diff = NULL, input = NULL; // String versions of identifiers
    14161515        psStringAppend(&diff, "%" PRId64, run->diff_id);
    14171516        psStringAppend(&input, "%" PRId64, input_id);
    1418         psStringAppend(&template, "%" PRId64, template_id);
    14191517
    14201518        if (!p_psDBRunQueryF(config->dbh, insert, diff, input, template, input, template)) {
    14211519            psError(PS_ERR_UNKNOWN, false, "database error");
    14221520            psFree(input);
    1423             psFree(template);
    14241521            psFree(diff);
    14251522            psFree(run);
    … …  
    14331530        }
    14341531        psFree(input);
    1435         psFree(template);
    14361532        psFree(diff);
    14371533
    … …  
    14821578
    14831579    psMetadata *where = psMetadataAlloc();
    1484     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1580    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    14851581
    14861582    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    … …  
    15471643        PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    15481644    }
    1549     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1645    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    15501646
    15511647    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    … …  
    16621758    PS_ASSERT_PTR_NON_NULL(config, false);
    16631759
    1664     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
     1760    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    16651761
    16661762    psMetadata *where = psMetadataAlloc();
    16671763    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
    16681764
    1669     if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, code)) {
     1765    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    16701766        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    16711767        psFree (where);
    … …  
    17371833  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    17381834  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1835  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    17391836
    17401837  FILE *f = fopen (outfile, "w");
    … …  
    17821879    psArray *output = p_psDBFetchResult(config->dbh);
    17831880    if (!output) {
    1784       psError(PS_ERR_UNKNOWN, false, "database error");
    17851881      return false;
    17861882    }
    17871883    if (!psArrayLength(output)) {
    1788       psTrace("regtool", PS_LOG_INFO, "no rows found");
     1884      psError(PS_ERR_UNKNOWN, true, "no rows found");
    17891885      psFree(output);
    1790       return true;
     1886      return false;
     1887    }
     1888
     1889    if (clean) {
     1890        bool success = true;
     1891        if (!strcmp(tables[i].tableName, "diffRun")) {
     1892            success = pxSetStateCleaned("diffRun", "state", output);
     1893#ifdef notyet
     1894        // diffSkyfile doesn't have dataState yet
     1895        } else if (!strcmp(tables[i].tableName, "diffSkyfile")) {
     1896            success = pxSetStateCleaned("diffSkyfile", "data_state", output);
     1897#endif
     1898        }
     1899        if (!success) {
     1900            psFree(output);
     1901            psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1902            return false;
     1903        }
    17911904    }
    17921905

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftool.h

    r23594 r24244  
    3434    DIFFTOOL_MODE_REVERTDIFFSKYFILE,
    3535    DIFFTOOL_MODE_DEFINEPOPRUN,
    36     DIFFTOOL_MODE_DEFINEBYQUERY,
     36    DIFFTOOL_MODE_DEFINEWARPSTACK,
    3737    DIFFTOOL_MODE_DEFINEWARPWARP,
    3838    DIFFTOOL_MODE_PENDINGCLEANUPRUN,

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftoolConfig.c

    r23594 r24244  
    4949    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
    5050    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     51    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,            "do the subtraction both ways?", false);
     52    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,            "subtraction for entire exposure?", false);
    5153    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label",  0,            "define label", NULL);
    5254    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    … …  
    8082    psMetadata *todiffskyfileArgs = psMetadataAlloc();
    8183    psMetadataAddS64(todiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
    82     psMetadataAddStr(todiffskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
     84    psMetadataAddStr(todiffskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
    8385    psMetadataAddU64(todiffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    8486    psMetadataAddBool(todiffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    8890    psMetadataAddS64(adddiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define warp ID (required)", 0);
    8991    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,       "define skycell of file (required)", 0);
    90     psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    91     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
     92    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     93    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    9294    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
    9395    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    107109    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-kernel_xy",  0, "define kernel xy moment", NAN);
    108110    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-kernel_yy",  0, "define kernel yy moment", NAN);
     111    psMetadataAddF32(adddiffskyfileArgs, PS_LIST_TAIL, "-deconv_max",  0, "define maximum deconvolution fraction", NAN);
    109112    psMetadataAddS32(adddiffskyfileArgs, PS_LIST_TAIL, "-sources",  0,   "define number of sources", 0);
    110113    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-hostname", 0,   "define hostname", 0);
    … …  
    123126    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    124127    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    125     psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "deifine fault code", 0);
     128    psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "define fault code", 0);
    126129
    127130    // -revertdiffskyfile
    … …  
    129132    psMetadataAddS64(revertdiffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by diff ID", 0);
    130133    psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    131     psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     134    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    132135
    133136    // -definepoprun
    … …  
    140143    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    141144    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    142     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-exp_id", 0,              "define exposure ID for template", 0);
    143145    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,            "define warp ID for template", 0);
    144146    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,            "define stack ID for template", 0);
    … …  
    146148    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,            "define stack ID for input", 0);
    147149
    148     // -definebyquery
    149     psMetadata *definebyqueryArgs = psMetadataAlloc();
    150     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-warp_id", 0, "search by warp ID", 0);
    151     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
    152     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
    153     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
    154     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
    155     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
    156     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    157     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    158     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    159     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    160     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    161     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    162     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    163     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    164     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    165     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     150    // -definewarpstack
     151    psMetadata *definewarpstackArgs = psMetadataAlloc();
     152    psMetadataAddS64(definewarpstackArgs, PS_LIST_TAIL, "-warp_id", 0, "search by warp ID", 0);
     153    psMetadataAddS64(definewarpstackArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
     154    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
     155    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
     156    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     157    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
     158    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
     159    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
     160    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
     161    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
     162    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
     163    psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     164    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
     165    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
     166    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
     167    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     168    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    166169
    167170    // -definewarpwarp
    … …  
    170173    psMetadataAddS64(definewarpwarpArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
    171174    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     175    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-distance", 0, "limit distance between input and template (deg)", NAN);
     176    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-obs_mode", 0, "search by observation mode", NULL);
    172177    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-timediff", 0, "limit time difference between input and template", NAN);
     178    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-backwards", 0, "Template comes after input?", false);
    173179    psMetadataAddF32(definewarpwarpArgs, PS_LIST_TAIL, "-rotdiff", 0, "limit rotator difference between input and template", NAN);
    174180    psMetadataAddStr(definewarpwarpArgs, PS_LIST_TAIL, "-input_label", 0, "search by warp label for input", NULL);
    … …  
    182188    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    183189    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     190    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    184191
    185192    // -pendingcleanuprun
    186193    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    187     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     194    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    188195    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    189196    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    191198    // -pendingcleanupskyfile
    192199    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
    193     psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     200    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    194201    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,          "search by diff ID", 0);
    195202    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    204211    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    205212    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    206     psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-code", 0,         "set fault code (required)", 0);
     213    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,         "set fault code (required)", 0);
    207214
    208215    // -exportrun
    … …  
    211218    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    212219    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     220    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "mark tables as cleaned", false);
    213221
    214222    // -importrun
    … …  
    232240    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    233241    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    234     PXOPT_ADD_MODE("-definebyquery",    "", DIFFTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
     242    PXOPT_ADD_MODE("-definewarpstack",  "", DIFFTOOL_MODE_DEFINEWARPSTACK,   definewarpstackArgs);
    235243    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
    236244    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/disttool.c

    r23594 r24244  
    3939static bool processedcomponentMode(pxConfig *config);
    4040static bool toadvanceMode(pxConfig *config);
     41static bool pendingfilesetMode(pxConfig *config);
     42static bool addfilesetMode(pxConfig *config);
     43static bool revertfilesetMode(pxConfig *config);
     44static bool queuercrunMode(pxConfig *config);
     45static bool updatercrunMode(pxConfig *config);
     46static bool revertrcrunMode(pxConfig *config);
     47static bool pendingdestMode(pxConfig *config);
     48
     49static bool definetargetMode(pxConfig *config);
     50static bool updatetargetMode(pxConfig *config);
     51static bool listtargetMode(pxConfig *config);
     52
     53static bool definedsproductMode(pxConfig *config);
     54static bool updatedsproductMode(pxConfig *config);
     55
     56static bool definedestinationMode(pxConfig *config);
     57static bool updatedestinationMode(pxConfig *config);
     58
     59static bool defineinterestMode(pxConfig *config);
     60static bool updateinterestMode(pxConfig *config);
    4161
    4262# define MODECASE(caseName, func) \
    … …  
    6787        MODECASE(DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentMode);
    6888        MODECASE(DISTTOOL_MODE_TOADVANCE, toadvanceMode);
     89        MODECASE(DISTTOOL_MODE_PENDINGFILESET, pendingfilesetMode);
     90        MODECASE(DISTTOOL_MODE_ADDFILESET, addfilesetMode);
     91        MODECASE(DISTTOOL_MODE_REVERTFILESET, revertfilesetMode);
     92        MODECASE(DISTTOOL_MODE_QUEUERCRUN, queuercrunMode);
     93        MODECASE(DISTTOOL_MODE_UPDATERCRUN, updatercrunMode);
     94        MODECASE(DISTTOOL_MODE_REVERTRCRUN, revertrcrunMode);
     95        MODECASE(DISTTOOL_MODE_PENDINGDEST, pendingdestMode);
     96        MODECASE(DISTTOOL_MODE_DEFINETARGET, definetargetMode);
     97        MODECASE(DISTTOOL_MODE_UPDATETARGET, updatetargetMode);
     98        MODECASE(DISTTOOL_MODE_LISTTARGET, listtargetMode);
     99        MODECASE(DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductMode);
     100        MODECASE(DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductMode);
     101        MODECASE(DISTTOOL_MODE_DEFINEDESTINATION, definedestinationMode);
     102        MODECASE(DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationMode);
     103        MODECASE(DISTTOOL_MODE_DEFINEINTEREST, defineinterestMode);
     104        MODECASE(DISTTOOL_MODE_UPDATEINTEREST, updateinterestMode);
    69105        default:
    70106            psAbort("invalid option (this should not happen)");
    … …  
    92128    PS_ASSERT_PTR_NON_NULL(config, false);
    93129
     130    // required
    94131    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
    95132    PXOPT_LOOKUP_S64(stage_id, config->args, "-stage_id",  true, false);
    96133    PXOPT_LOOKUP_STR(outroot, config->args, "-outroot", true, false);
     134    PXOPT_LOOKUP_S64(target_id, config->args, "-target_id",  true, false);
     135
     136    // optional
    97137    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     138    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    98139    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    99140
    … …  
    101142    // XXX: all of the following concerns will be managed properly by definebyquery
    102143
    103     // TODO: check that stage_id actually exists for stage
    104     // in magicdstool we queue off of a magic_id so the stage_id, exp_id, and cam_id get looked up 
     144    // TODO: should we check that stage_id actually exists for stage
     145    // in magicdstool we queue off of a magic_id so the stage_id, exp_id, and cam_id get looked up
    105146    // when the run is queued
    106     // Should we also check here that the run is full or cleaned and that all of the images
    107     // are magicked. We need to do that at run time as well since the run and magic state can
    108     // change between the time that it is queued.
    109 
    110     if (!distRunInsert(config->dbh, 0, stage, stage_id, set_label, outroot, clean, "new", NULL, 0)) {
     147
     148    if (!distRunInsert(config->dbh,
     149            0,          // dist_id
     150            target_id,
     151            stage,
     152            stage_id,
     153            set_label,
     154            outroot,
     155            clean,
     156            no_magic,
     157            "new",
     158            NULL,       // time_stamp
     159            0           // fault
     160            )) {
    111161        psError(PS_ERR_UNKNOWN, false, "database error");
    112162        return false;
    … …  
    118168static bool definebyqueryMode(pxConfig *config)
    119169{
    120     psError(PS_ERR_PROGRAMMING, true, "-definebyquery is not implemented yet");
    121     return false;
     170    PS_ASSERT_PTR_NON_NULL(config, false);
     171
     172    // required
     173    PXOPT_LOOKUP_STR(stage, config->args,     "-stage", true, false);
     174    PXOPT_LOOKUP_STR(workdir, config->args,   "-workdir", true, false);
     175
     176    // optional
     177    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id",  false, false);
     178    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
     179    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     180    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
     181    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     182   
     183    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
     184
     185    // select arguments
     186    psMetadata *where = psMetadataAlloc();
     187
     188    PXOPT_COPY_S64(config->args, where, "-target_id", "distTarget.target_id",    "==");
     189    PXOPT_COPY_S64(config->args, where, "-exp_id",    "rawExp.exp_id",           "==");
     190    PXOPT_COPY_S64(config->args, where, "-chip_id",   "chipRun.chip_id",         "==");
     191    PXOPT_COPY_STR(config->args, where, "-obs_mode",  "rawExp.obs_mode",         "==");
     192
     193    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     194
     195    psString query = NULL;
     196    psString magicRunType = NULL;
     197    psString runJoinStr = NULL;
     198    if (!strcmp(stage, "raw")) {
     199        magicRunType = "rawExp";
     200        runJoinStr = "rawExp.exp_id";
     201        query = pxDataGet("disttool_definebyquery_raw.sql");
     202        if (!query) {
     203            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     204            psFree(where);
     205            return false;
     206        }
     207    } else if (!strcmp(stage, "chip")) {
     208        magicRunType = "chipRun";
     209        runJoinStr = "chipRun.chip_id";
     210        query = pxDataGet("disttool_definebyquery_chip.sql");
     211        if (!query) {
     212            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     213            psFree(where);
     214            return false;
     215        }
     216
     217        if (label) {
     218            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
     219        }
     220    } else if (!strcmp(stage, "camera")) {
     221        magicRunType = "chipRun";    // This is used below to set the magicked business
     222        query = pxDataGet("disttool_definebyquery_camera.sql");
     223        if (!query) {
     224            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     225            psFree(where);
     226            return false;
     227        }
     228
     229        if (label) {
     230            psStringAppend(&query, " AND (camRun.label = '%s')", label);
     231        }
     232    } else if (!strcmp(stage, "fake")) {
     233        magicRunType = "fakeRun";
     234        query = pxDataGet("disttool_definebyquery_fake.sql");
     235        if (!query) {
     236            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     237            psFree(where);
     238            return false;
     239        }
     240
     241        if (label) {
     242            psStringAppend(&query, " AND (fakeRun.label = '%s')", label);
     243        }
     244        // fake stage doesn't require magic
     245        no_magic = true;
     246    } else if (!strcmp(stage, "warp")) {
     247        magicRunType = "warpRun";
     248        runJoinStr = "warpRun.warp_id";
     249        query = pxDataGet("disttool_definebyquery_warp.sql");
     250        if (!query) {
     251            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     252            psFree(where);
     253            return false;
     254        }
     255
     256        if (label) {
     257            psStringAppend(&query, " AND (warpRun.label = '%s')", label);
     258        }
     259
     260    } else if (!strcmp(stage, "diff")) {
     261        magicRunType = "diffRun";
     262        runJoinStr = "diffRun.diff_id";
     263        query = pxDataGet("disttool_definebyquery_diff.sql");
     264        if (!query) {
     265            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     266            psFree(where);
     267            return false;
     268        }
     269
     270        if (label) {
     271            psStringAppend(&query, " AND (diffRun.label = '%s')", label);
     272        }
     273
     274    } else if (!strcmp(stage, "stack")) {
     275        magicRunType = "stackRun";
     276        query = pxDataGet("disttool_definebyquery_stack.sql");
     277        if (!query) {
     278            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     279            psFree(where);
     280            return false;
     281        }
     282
     283        if (label) {
     284            psStringAppend(&query, " AND (stackRun.label = '%s')", label);
     285        }
     286        // stack stage doesn't require magic (perhaps let the script do this?
     287        no_magic = true;
     288    } else {
     289        psError(PS_ERR_UNKNOWN, true, "unknown value for stage: %s", stage);
     290        psFree(where);
     291        return false;
     292    }
     293
     294    if (psListLength(where->list)) {
     295        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     296        psStringAppend(&query, " AND %s", whereClause);
     297        psFree(whereClause);
     298    }
     299    psFree(where);
     300
     301    psString joinHook = NULL;
     302
     303    if (!no_magic) {
     304        psStringAppend(&query, " AND (distTarget.clean OR %s.magicked)", magicRunType);
     305
     306        // is selecting by magic_ds_id really interesting?
     307        if (magic_ds_id) {
     308            if (strcmp(stage, "camera")) {
     309                // stage other than camera
     310                if (!runJoinStr) {
     311                    psError(PS_ERR_PROGRAMMING, true, "cannot select by magic_ds_id for stage: %s", stage);
     312                    psFree(query);
     313                    return false;
     314                }
     315                psStringAppend(&joinHook, "\nJOIN magicDSRun ON magicDSRun.stage = distTarget.stage"
     316                                              " AND magicDSRun.stage_id = %s", runJoinStr);
     317            } else {
     318                // camera masks are magicked when the chipRun is magicked
     319                // XXX: This is confusing. Is it dangerous?
     320                // Maybe I should add a magicked bit to camRun. Note this isn't
     321                psStringAppend(&joinHook, "\nJOIN magicDSRun ON magicDSRun.stage = 'chip'"
     322                                              " AND magicDSRun.stage_id = chipRun.chip_id");
     323            }
     324            psStringAppend(&query, " AND (magicDSRun.state = 'full' AND magicDSRun.re_place AND (magic_ds_id = %" PRId64 "))", magic_ds_id);
     325        }
     326    }
     327
     328    if (limit) {
     329        psString limitString = psDBGenerateLimitSQL(limit);
     330        psStringAppend(&query, " %s", limitString);
     331        psFree(limitString);
     332    }
     333
     334    if (!p_psDBRunQueryF(config->dbh, query, joinHook ? joinHook : "")) {
     335        psError(PS_ERR_UNKNOWN, false, "database error");
     336        psFree(query);
     337        return false;
     338    }
     339    psFree(query);
     340    psFree(joinHook);
     341
     342    psArray *output = p_psDBFetchResult(config->dbh);
     343    if (!output) {
     344        psError(PS_ERR_UNKNOWN, false, "database error");
     345        return false;
     346    }
     347    if (!psArrayLength(output)) {
     348        psTrace("disttool", PS_LOG_INFO, "no rows found");
     349        psFree(output);
     350        return true;
     351    }
     352
     353
     354    if (dry_run) {
     355        if (!ippdbPrintMetadatas(stdout, output, "newdistRuns", true)) {
     356            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     357            psFree(output);
     358            return false;
     359        }
     360        psFree(output);
     361        return true;
     362    }
     363
     364    if (!psDBTransaction(config->dbh)) {
     365        psError(PS_ERR_UNKNOWN, false, "database error");
     366        return false;
     367    }
     368
     369    psArray *list = psArrayAllocEmpty(limit);
     370    for (long i=0; i < psArrayLength(output); i++) {
     371        psMetadata *md = output->data[i];
     372        psString stage = psMetadataLookupStr(NULL, md, "stage");
     373        psString run_tag = psMetadataLookupStr(NULL, md, "run_tag");
     374        psS64 stage_id = psMetadataLookupS64(NULL, md, "stage_id");
     375        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
     376        bool clean = psMetadataLookupBool(NULL, md, "clean");
     377
     378        psString outroot = NULL;
     379        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
     380
     381        distRunRow *row = distRunRowAlloc(
     382                0,      // dist_id
     383                target_id,
     384                stage,
     385                stage_id,
     386                set_label,
     387                outroot,
     388                clean,
     389                no_magic,
     390                "new",
     391                NULL,   // time_stamp
     392                0       // fault
     393                );
     394
     395        if (!row) {
     396            psError(PS_ERR_UNKNOWN, false, "failed to allocate distRunRow");
     397            psFree(outroot);
     398            psFree(output);
     399            return false;
     400        }
     401        if (!distRunInsertObject(config->dbh, row)) {
     402            psError(PS_ERR_UNKNOWN, false, "database error");
     403            psFree(outroot);
     404            psFree(output);
     405            return false;
     406        }
     407        psFree(outroot);
     408        psS64 dist_id = psDBLastInsertID(config->dbh);
     409        row->dist_id = dist_id;
     410        psArrayAdd(list, list->n, row);
     411        psFree(row);
     412    }
     413
     414    if (!psDBCommit(config->dbh)) {
     415        psError(PS_ERR_UNKNOWN, false, "database error");
     416        return false;
     417    }
     418    if (!distRunPrintObjects(stdout, list, !simple)) {
     419        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     420        psFree(list);
     421        return false;
     422    }
     423
     424    psFree(list);
     425    psFree(output);
     426
     427    return true;
    122428}
    123429
    … …  
    138444    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    139445    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    140     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    141 
    142     if ((!state) && (!label) && (!code)) {
    143         psError(PXTOOLS_ERR_DATA, false, "parameters (-code or -set_state or -set_label) are required");
     446    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     447
     448    if ((!state) && (!label) && (!fault)) {
     449        psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state or -set_label) are required");
    144450        psFree(where);
    145451        return false;
    … …  
    156462    }
    157463
    158     if (code) {
    159         psStringAppend(&query, " , fault = %d", code);
     464    if (fault) {
     465        psStringAppend(&query, " , fault = %d", fault);
    160466    }
    161467
    … …  
    182488    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    183489    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    184     PXOPT_COPY_S16(config->args, where, "-code", "distComponent.fault", "==");
     490    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    185491
    186492    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    296602    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    297603    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    298     PXOPT_LOOKUP_BOOL(need_magic, config->args, "-need_magic", false);
    299604
    300605    // look for "inputs" that need to processed
    … …  
    319624    }
    320625
    321     psString    chip_magic = "";
     626    // the query has where hooks for each stage.
     627    // right now we aren't using them.
     628    // XXX: I think that I want to change the query from a union of selects on the various
     629    // stages to separate queries. As it is pending data at the later stages of the pipline
     630    // will get blocked by pending earlier stages
    322631    psString    raw_where = "";
     632    psString    raw_clean_where = "";
    323633    psString    chip_where = "";
    324634    psString    camera_where = "";
    … …  
    328638    psString    stack_where = "";
    329639
    330     if (need_magic) {
    331         chip_magic = psStringCopy("\nAND chipRun.magicked");
    332         raw_where  = psStringCopy("\nAND rawExp.magicked");
    333         chip_where = psStringCopy("\nAND (distRun.clean OR chipRun.magicked)");
    334         // chipRun must be magicked to allow release camera level masks
    335         camera_where = psStringCopy("\nAND (distRun.clean OR chipRun.magicked)");
    336         warp_where = psStringCopy("\nAND (distRun.clean OR warpRun.magicked)");
    337         diff_where = psStringCopy("\nAND (distRun.clean OR diffRun.magicked)");
    338     }
    339 
    340640    if (!p_psDBRunQueryF(config->dbh,
    341641            query,
    342             chip_magic,
    343642            raw_where,
     643            raw_clean_where,
    344644            chip_where,
    345645            camera_where,
    … …  
    397697    // unless fault code is set require filename, bytes, and md5sum
    398698    bool require_fileinfo = false;
    399     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    400     if (!code) {
     699    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     700    if (!fault) {
    401701        require_fileinfo = true;
    402702    }
    … …  
    405705    PXOPT_LOOKUP_STR(name, config->args, "-name", require_fileinfo, false);
    406706
    407     if (!distComponentInsert(config->dbh, dist_id, component, bytes, md5sum, "full", name, code)) {
     707    if (!distComponentInsert(config->dbh, dist_id, component, bytes, md5sum, "full", name, fault)) {
    408708        psError(PS_ERR_UNKNOWN, false, "database error");
    409709        return false;
    … …  
    419719    psMetadata *where = psMetadataAlloc();
    420720    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     721    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    421722
    422723    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    555856    return true;
    556857}
     858
     859static bool pendingfilesetMode(pxConfig *config)
     860{
     861    PS_ASSERT_PTR_NON_NULL(config, false);
     862
     863    psMetadata *where = psMetadataAlloc();
     864    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
     865    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     866
     867    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     868    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     869
     870    // look for "inputs" that need to processed
     871    psString query = pxDataGet("disttool_pendingfileset.sql");
     872    if (!query) {
     873        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     874        return false;
     875    }
     876
     877    if (psListLength(where->list)) {
     878        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     879        psStringAppend(&query, " AND %s", whereClause);
     880        psFree(whereClause);
     881    }
     882    psFree(where);
     883
     884    // treat limit == 0 as "no limit"
     885    if (limit) {
     886        psString limitString = psDBGenerateLimitSQL(limit);
     887        psStringAppend(&query, " %s", limitString);
     888        psFree(limitString);
     889    }
     890
     891    if (!p_psDBRunQuery(config->dbh, query)) {
     892        psError(PS_ERR_UNKNOWN, false, "database error");
     893        psFree(query);
     894        return false;
     895    }
     896    psFree(query);
     897
     898    psArray *output = p_psDBFetchResult(config->dbh);
     899    if (!output) {
     900        psErrorCode err = psErrorCodeLast();
     901        switch (err) {
     902            case PS_ERR_DB_CLIENT:
     903                psError(PXTOOLS_ERR_SYS, false, "database error");
     904            case PS_ERR_DB_SERVER:
     905                psError(PXTOOLS_ERR_PROG, false, "database error");
     906            default:
     907                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     908        }
     909
     910        return false;
     911    }
     912    if (!psArrayLength(output)) {
     913        psTrace("disttool", PS_LOG_INFO, "no rows found");
     914        psFree(output);
     915        return true;
     916    }
     917
     918    if (psArrayLength(output)) {
     919        // negative simple so the default is true
     920        if (!ippdbPrintMetadatas(stdout, output, "pendingfileset", !simple)) {
     921            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     922            psFree(output);
     923            return false;
     924        }
     925    }
     926
     927    psFree(output);
     928
     929    return true;
     930}
     931static bool addfilesetMode(pxConfig *config)
     932{
     933
     934    // required values
     935    PXOPT_LOOKUP_S64(dist_id, config->args, "-dist_id", true, false);
     936    PXOPT_LOOKUP_S64(prod_id, config->args, "-prod_id", true, false);
     937
     938    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     939
     940    // unless fault code is set require name
     941    PXOPT_LOOKUP_STR(name, config->args, "-name", fault == 0, false);
     942
     943    if (!rcDSFilesetInsert(config->dbh,
     944            0,          // fs_id
     945            dist_id,
     946            prod_id,
     947            name,
     948            "full",
     949            fault)) {
     950        psError(PS_ERR_UNKNOWN, false, "database error");
     951        return false;
     952    }
     953
     954    return true;
     955}
     956static bool revertfilesetMode(pxConfig *config)
     957{
     958    psMetadata *where = psMetadataAlloc();
     959    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
     960    PXOPT_COPY_S64(config->args, where, "-dist_id", "rcDSFileset.dist_id", "==");
     961    PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     962    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");;
     963    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     964    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     965    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     966    PXOPT_COPY_S16(config->args, where, "-fault", "rcDSFileset.fault", "==");
     967
     968    // It might be useful to be able to query by the parameters of the underlying runs
     969
     970    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     971        psFree(where);
     972        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     973        return false;
     974    }
     975
     976    psString query = pxDataGet("disttool_revertfileset.sql");
     977    if (!query) {
     978        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     979        psFree(where);
     980        return false;
     981    }
     982
     983    if (psListLength(where->list)) {
     984        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     985        psStringAppend(&query, " AND %s", whereClause);
     986        psFree(whereClause);
     987    }
     988
     989    if (!p_psDBRunQuery(config->dbh, query)) {
     990        psError(PS_ERR_UNKNOWN, false, "database error");
     991        psFree(query);
     992        if (!psDBRollback(config->dbh)) {
     993            psError(PS_ERR_UNKNOWN, false, "database error");
     994        }
     995        return false;
     996    }
     997    psFree(query);
     998
     999    int numUpdated = psDBAffectedRows(config->dbh);
     1000
     1001    psLogMsg("disttool", PS_LOG_INFO, "deleted %d rcDSFilesets", numUpdated);
     1002
     1003    return true;
     1004}
     1005
     1006static bool pendingdestMode(pxConfig *config)
     1007{
     1008    PS_ASSERT_PTR_NON_NULL(config, false);
     1009
     1010    psMetadata *where = psMetadataAlloc();
     1011    PXOPT_COPY_S64(config->args, where, "-dest_id", "dist_id", "==");
     1012//     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1013
     1014    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1015    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1016
     1017    // look for "inputs" that need to processed
     1018    psString query = pxDataGet("disttool_pendingdest.sql");
     1019    if (!query) {
     1020        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1021        return false;
     1022    }
     1023
     1024    psString whereString = NULL;
     1025    if (psListLength(where->list)) {
     1026        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1027        // where string gets added by hook, not at the end of the query
     1028        psStringAppend(&whereString, "\n AND %s", whereClause);
     1029        psFree(whereClause);
     1030    }
     1031    psFree(where);
     1032
     1033    // treat limit == 0 as "no limit"
     1034    if (limit) {
     1035        psString limitString = psDBGenerateLimitSQL(limit);
     1036        psStringAppend(&query, " %s", limitString);
     1037        psFree(limitString);
     1038    }
     1039
     1040    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString : "")) {
     1041        psError(PS_ERR_UNKNOWN, false, "database error");
     1042        psFree(whereString);
     1043        psFree(query);
     1044        return false;
     1045    }
     1046    psFree(query);
     1047
     1048    psArray *output = p_psDBFetchResult(config->dbh);
     1049    if (!output) {
     1050        psErrorCode err = psErrorCodeLast();
     1051        switch (err) {
     1052            case PS_ERR_DB_CLIENT:
     1053                psError(PXTOOLS_ERR_SYS, false, "database error");
     1054            case PS_ERR_DB_SERVER:
     1055                psError(PXTOOLS_ERR_PROG, false, "database error");
     1056            default:
     1057                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1058        }
     1059
     1060        return false;
     1061    }
     1062    if (!psArrayLength(output)) {
     1063        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1064        psFree(output);
     1065        return true;
     1066    }
     1067
     1068    if (psArrayLength(output)) {
     1069        // negative simple so the default is true
     1070        if (!ippdbPrintMetadatas(stdout, output, "pendingfileset", !simple)) {
     1071            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1072            psFree(output);
     1073            return false;
     1074        }
     1075    }
     1076
     1077    psFree(output);
     1078
     1079    return true;
     1080}
     1081
     1082static bool queuercrunMode(pxConfig *config)
     1083{
     1084    PS_ASSERT_PTR_NON_NULL(config, false);
     1085    psMetadata *where = psMetadataAlloc();
     1086
     1087    PXOPT_COPY_S64(config->args, where, "-dist_id",  "dist_id", "==");
     1088    PXOPT_COPY_S64(config->args, where, "-dest_id",  "dest_id", "==");
     1089    PXOPT_COPY_S64(config->args, where, "-prod_id",  "prod_id", "==");
     1090    PXOPT_COPY_S64(config->args, where, "-target_id","target_id", "==");
     1091    PXOPT_COPY_S64(config->args, where, "-fs_id",    "fs_id", "==");
     1092    PXOPT_COPY_STR(config->args, where, "-stage",    "stage", "==");;
     1093    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     1094    PXOPT_COPY_STR(config->args, where, "-label",    "label", "==");
     1095
     1096    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1097
     1098    psString query = pxDataGet("disttool_queuercrun.sql");
     1099    if (!query) {
     1100        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1101        return false;
     1102    }
     1103
     1104    if (psListLength(where->list)) {
     1105        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1106        psStringAppend(&query, " AND %s", whereClause);
     1107        psFree(whereClause);
     1108    }
     1109    psFree(where);
     1110
     1111    // treat limit == 0 as "no limit"
     1112    if (limit) {
     1113        psString limitString = psDBGenerateLimitSQL(limit);
     1114        psStringAppend(&query, " %s", limitString);
     1115        psFree(limitString);
     1116    }
     1117
     1118    if (!p_psDBRunQuery(config->dbh, query)) {
     1119        psError(PS_ERR_UNKNOWN, false, "database error");
     1120        psFree(query);
     1121        return false;
     1122    }
     1123    psFree(query);
     1124
     1125    long numUpdated = psDBAffectedRows(config->dbh);
     1126
     1127    psLogMsg("disttool", PS_LOG_INFO, "Inserted %ld rcRuns", numUpdated);
     1128
     1129    return true;
     1130}
     1131
     1132
     1133static bool updatercrunMode(pxConfig *config)
     1134{
     1135    PS_ASSERT_PTR_NON_NULL(config, false);
     1136
     1137    psMetadata *where = psMetadataAlloc();
     1138
     1139    PXOPT_LOOKUP_S64(rc_id, config->args, "-rc_id", false, false);
     1140    PXOPT_LOOKUP_STR(fs_name, config->args, "-fs_name", false, false);
     1141    PXOPT_LOOKUP_STR(status_fs_name, config->args, "-status_fs_name", false, false);
     1142    PXOPT_LOOKUP_S64(dest_id, config->args, "-dest_id", false, false);
     1143
     1144    // We either need rc_id or (dest_id and fs_name) to identifiy the rcRun
     1145    if ((!rc_id) && !(dest_id && fs_name)) {
     1146        psError(PXTOOLS_ERR_DATA, true, "either -rc_id or (-fs_name and -dest_id) are required");
     1147        return false;
     1148    }
     1149
     1150    // now that we have done the argument checking
     1151    PXOPT_COPY_S64(config->args, where, "-rc_id", "rc_id", "==");
     1152    PXOPT_COPY_STR(config->args, where, "-fs_name", "rcDSFileset.name", "==");
     1153    PXOPT_COPY_S64(config->args, where, "-dest_id", "rcRun.dest_id", "==");
     1154
     1155    if (!psListLength(where->list)) {
     1156        // this can't happen because we checked above
     1157        psFree(where);
     1158        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1159        return false;
     1160    }
     1161
     1162
     1163    PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
     1164    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1165    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     1166
     1167    if (!state && (fault < 0)) {
     1168        psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state) are required");
     1169        psFree(where);
     1170        return false;
     1171    }
     1172
     1173    psString query = pxDataGet("disttool_updatercrun.sql");
     1174    if (!query) {
     1175        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1176        return false;
     1177    }
     1178
     1179    psString setString = psStringCopy("\n");
     1180    psString separator = "";
     1181    if (state) {
     1182        psStringAppend(&setString, " rcRun.state = '%s'", state);
     1183        separator = ",";
     1184    }
     1185
     1186    // default for fault is -1, so set it if it's zero or higher. This allows clearing fault
     1187    // without forcing revert first
     1188    if (fault >= 0) {
     1189        psStringAppend(&setString, "%s rcRun.fault = %d", separator, fault);
     1190    }
     1191
     1192    if (status_fs_name) {
     1193        psStringAppend(&setString, ", rcRun.status_fs_name = '%s'", status_fs_name);
     1194    }
     1195
     1196    if (last_fileset) {
     1197        psStringAppend(&setString, ", rcDestination.last_fileset = '%s'", last_fileset);
     1198    }
     1199
     1200    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1201    psStringAppend(&query, " AND %s", whereClause);
     1202    psFree(whereClause);
     1203    psFree(where);
     1204
     1205    if (!p_psDBRunQueryF(config->dbh, query, setString)) {
     1206        psError(PS_ERR_UNKNOWN, false, "database error");
     1207        psFree(setString);
     1208        psFree(query);
     1209        return false;
     1210    }
     1211    psFree(setString);
     1212    psFree(query);
     1213
     1214    long numUpdated = psDBAffectedRows(config->dbh);
     1215
     1216    psLogMsg("disttool", PS_LOG_INFO, "Updated %ld rows", numUpdated);
     1217
     1218    return true;
     1219}
     1220
     1221static bool revertrcrunMode(pxConfig *config)
     1222{
     1223    PS_ASSERT_PTR_NON_NULL(config, false);
     1224    psMetadata *where = psMetadataAlloc();
     1225    PXOPT_COPY_S64(config->args, where, "-rc_id", "rc_id", "==");
     1226    PXOPT_COPY_S64(config->args, where, "-fs_id", "fs_id", "==");
     1227    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1228    PXOPT_COPY_S64(config->args, where, "-fault", "fault", "==");
     1229
     1230    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1231        psFree(where);
     1232        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1233        return false;
     1234    }
     1235
     1236    psString query = pxDataGet("disttool_revertrcrun.sql");
     1237    if (!query) {
     1238        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1239        if (!psDBRollback(config->dbh)) {
     1240            psError(PS_ERR_UNKNOWN, false, "database error");
     1241        }
     1242        return false;
     1243    }
     1244
     1245    if (psListLength(where->list)) {
     1246        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1247        psStringAppend(&query, " AND %s", whereClause);
     1248        psFree(whereClause);
     1249    }
     1250
     1251    if (!p_psDBRunQuery(config->dbh, query)) {
     1252        psError(PS_ERR_UNKNOWN, false, "database error");
     1253        psFree(query);
     1254        if (!psDBRollback(config->dbh)) {
     1255            psError(PS_ERR_UNKNOWN, false, "database error");
     1256        }
     1257        return false;
     1258    }
     1259    psFree(query);
     1260
     1261    long numUpdated = psDBAffectedRows(config->dbh);
     1262
     1263    psLogMsg("disttool", PS_LOG_INFO, "Updated %ld rcRuns", numUpdated);
     1264
     1265    return true;
     1266}
     1267
     1268static bool definetargetMode(pxConfig *config)
     1269{
     1270    PS_ASSERT_PTR_NON_NULL(config, false);
     1271
     1272    // required
     1273    PXOPT_LOOKUP_STR(obs_mode, config->args, "-obs_mode", true, false);
     1274    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     1275
     1276    // optional
     1277    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1278    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1279    PXOPT_LOOKUP_STR(comment, config->args, "-comment", false, false);
     1280
     1281    distTargetRow *row = distTargetRowAlloc(
     1282            0,          // target_id
     1283            obs_mode,
     1284            stage,
     1285            clean,
     1286            state ? state : "enabled",
     1287            comment
     1288            );
     1289           
     1290    if (!row) {
     1291        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
     1292        return false;
     1293    }
     1294   if (!distTargetInsertObject(config->dbh, row)) {
     1295        psError(PS_ERR_UNKNOWN, false, "database error");
     1296        psFree(row);
     1297        return false;
     1298    }
     1299
     1300    // get the assigned target_id
     1301    row->target_id = psDBLastInsertID(config->dbh);
     1302
     1303    if (!distTargetPrintObject(stdout, row, true)) {
     1304            psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1305            psFree(row);
     1306            return false;
     1307    }
     1308
     1309    psFree(row);
     1310
     1311    return true;
     1312}
     1313static bool updatetargetMode(pxConfig *config)
     1314{
     1315    PS_ASSERT_PTR_NON_NULL(config, false);
     1316
     1317    psMetadata *where = psMetadataAlloc();
     1318    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1319    PXOPT_COPY_STR(config->args, where, "-obs_mode", "obs_mode", "==");
     1320    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1321
     1322    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     1323
     1324    psString query = psStringCopy("UPDATE distTarget SET state = '%s'");
     1325
     1326    if (psListLength(where->list)) {
     1327        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1328        psStringAppend(&query, " WHERE %s", whereClause);
     1329        psFree(whereClause);
     1330    } else {
     1331        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1332        psFree(where);
     1333        psFree(query);
     1334        return false;
     1335    }
     1336    psFree(where);
     1337
     1338    if (!p_psDBRunQueryF(config->dbh, query, state)) {
     1339        psError(PS_ERR_UNKNOWN, false, "database error");
     1340        psFree(query);
     1341        return false;
     1342    }
     1343    psFree(query);
     1344
     1345    return true;
     1346}
     1347
     1348static bool listtargetMode(pxConfig *config)
     1349{
     1350    PS_ASSERT_PTR_NON_NULL(config, false);
     1351
     1352    psMetadata *where = psMetadataAlloc();
     1353    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1354    PXOPT_COPY_STR(config->args, where, "-obs_mode", "obs_mode", "==");
     1355    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1356    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1357
     1358    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1359    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1360
     1361    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1362    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1363
     1364    if (clean && full) {
     1365        psError(PS_ERR_UNKNOWN, false, "can't select both -clean and -full");
     1366        return false;
     1367    }
     1368
     1369    psString query = psStringCopy("SELECT * FROM distTarget");
     1370
     1371    if (psListLength(where->list)) {
     1372        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1373        psStringAppend(&query, " WHERE %s", whereClause);
     1374        psFree(whereClause);
     1375        if (clean) {
     1376            psStringAppend(&query, " (AND clean)");
     1377        } else if (full) {
     1378            psStringAppend(&query, " (AND !clean)");
     1379        }
     1380    } else if (clean) {
     1381        psStringAppend(&query, " WHERE clean");
     1382    } else if (full) {
     1383        psStringAppend(&query, " WHERE !clean");
     1384    }
     1385    psFree(where);
     1386
     1387    // treat limit == 0 as "no limit"
     1388    if (limit) {
     1389        psString limitString = psDBGenerateLimitSQL(limit);
     1390        psStringAppend(&query, " %s", limitString);
     1391        psFree(limitString);
     1392    }
     1393
     1394    if (!p_psDBRunQuery(config->dbh, query)) {
     1395        psError(PS_ERR_UNKNOWN, false, "database error");
     1396        psFree(query);
     1397        if (!psDBRollback(config->dbh)) {
     1398            psError(PS_ERR_UNKNOWN, false, "database error");
     1399        }
     1400        return false;
     1401    }
     1402    psFree(query);
     1403
     1404    psArray *output = p_psDBFetchResult(config->dbh);
     1405    if (!output) {
     1406        psError(PS_ERR_UNKNOWN, false, "database error");
     1407        return false;
     1408    }
     1409    if (!psArrayLength(output)) {
     1410        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1411        psFree(output);
     1412        return true;
     1413    }
     1414
     1415    if (!ippdbPrintMetadatas(stdout, output, "distTarget", !simple)) {
     1416        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1417        psFree(output);
     1418        return false;
     1419    }
     1420
     1421    psFree(output);
     1422
     1423    return true;
     1424}
     1425
     1426static bool definedsproductMode(pxConfig *config)
     1427{
     1428    PS_ASSERT_PTR_NON_NULL(config, false);
     1429
     1430    // required
     1431    PXOPT_LOOKUP_STR(name, config->args,   "-name", true, false);
     1432    PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", true, false);
     1433    PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", true, false);
     1434
     1435    // XXX: should we insure that these names do not contatin any whitespace?
     1436
     1437    rcDSProductRow *row = rcDSProductRowAlloc(
     1438            0,          // prod_id
     1439            name,
     1440            dbname,
     1441            dbhost
     1442            );
     1443           
     1444    if (!row) {
     1445        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDSProduct object");
     1446        return false;
     1447    }
     1448   if (!rcDSProductInsertObject(config->dbh, row)) {
     1449        psError(PS_ERR_UNKNOWN, false, "database error");
     1450        psFree(row);
     1451        return false;
     1452    }
     1453
     1454    // get the assigned target_id
     1455    row->prod_id = psDBLastInsertID(config->dbh);
     1456
     1457    if (!rcDSProductPrintObject(stdout, row, true)) {
     1458        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1459        psFree(row);
     1460        return false;
     1461    }
     1462
     1463    psFree(row);
     1464
     1465    return true;
     1466}
     1467static bool updatedsproductMode(pxConfig *config)
     1468{
     1469    PS_ASSERT_PTR_NON_NULL(config, false);
     1470
     1471    psMetadata *where = psMetadataAlloc();
     1472    PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     1473
     1474    PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", false, false);
     1475    PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", false, false);
     1476
     1477    if (!(dbname || dbhost)) {
     1478        psError(PS_ERR_UNKNOWN, true, "one or more of dbname or dbhost is required");
     1479        psFree(where);
     1480        return false;
     1481    }
     1482    psString query = psStringCopy("UPDATE rcDSProduct SET");
     1483    psString sep = "";
     1484    if (dbname) {
     1485        psStringAppend(&query, " dbname = '%s'", dbname);
     1486        sep = ",";
     1487    }
     1488    if (dbhost) {
     1489        psStringAppend(&query, " %s dbhost = '%s'", sep, dbhost);
     1490    }
     1491
     1492    if (psListLength(where->list)) {
     1493        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1494        psStringAppend(&query, " WHERE %s", whereClause);
     1495        psFree(whereClause);
     1496    } else {
     1497        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1498        psFree(where);
     1499        psFree(query);
     1500        return false;
     1501    }
     1502    psFree(where);
     1503
     1504    if (!p_psDBRunQuery(config->dbh, query)) {
     1505        psError(PS_ERR_UNKNOWN, false, "database error");
     1506        psFree(query);
     1507        return false;
     1508    }
     1509    psFree(query);
     1510
     1511    return true;
     1512}
     1513
     1514static bool definedestinationMode(pxConfig *config)
     1515{
     1516    PS_ASSERT_PTR_NON_NULL(config, false);
     1517
     1518    // required
     1519    PXOPT_LOOKUP_S64(prod_id, config->args,      "-prod_id", true, false);
     1520    PXOPT_LOOKUP_STR(name, config->args,         "-name", true, false);
     1521
     1522    // optional
     1523    PXOPT_LOOKUP_STR(status_uri, config->args,   "-status_uri", false, false);
     1524    PXOPT_LOOKUP_STR(comment, config->args,      "-comment", false, false);
     1525    PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
     1526    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1527
     1528    // XXX: should we insure that these names do not contatin any whitespace?
     1529
     1530    rcDestinationRow *row = rcDestinationRowAlloc(
     1531            0,          // dest_id
     1532            prod_id,
     1533            name,
     1534            status_uri,
     1535            comment,
     1536            last_fileset,
     1537            state ? state : "enabled"
     1538            );
     1539           
     1540    if (!row) {
     1541        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
     1542        return false;
     1543    }
     1544   if (!rcDestinationInsertObject(config->dbh, row)) {
     1545        psError(PS_ERR_UNKNOWN, false, "database error");
     1546        psFree(row);
     1547        return false;
     1548    }
     1549
     1550    // get the assigned target_id
     1551    row->dest_id = psDBLastInsertID(config->dbh);
     1552
     1553    if (!rcDestinationPrintObject(stdout, row, true)) {
     1554        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1555        psFree(row);
     1556        return false;
     1557    }
     1558
     1559    psFree(row);
     1560
     1561    return true;
     1562}
     1563
     1564static bool updatedestinationMode(pxConfig *config)
     1565{
     1566    PS_ASSERT_PTR_NON_NULL(config, false);
     1567
     1568    psMetadata *where = psMetadataAlloc();
     1569    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1570    PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     1571
     1572    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1573#ifdef ALLOW_UPDATE_LAST_FILESET
     1574    PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
     1575    if (!(state || last_fileset)) {
     1576        psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
     1577# else
     1578    if (!state) {
     1579#endif
     1580        psFree(where);
     1581        return false;
     1582    }
     1583    psString query = psStringCopy("UPDATE rcDestination SET");
     1584    psString sep = "";
     1585    if (state) {
     1586        psStringAppend(&query, " state = '%s'", state);
     1587        sep = ",";
     1588    }
     1589#ifdef ALLOW_UPDATE_LAST_FILESET
     1590    // last_fileset normally gets set by updatercrunMode
     1591    // Allowing it to be set here might cause problems
     1592    // especially since we are allowing selection by prod_id
     1593    if (last_fileset) {
     1594        psStringAppend(&query, " %s last_fileset = '%s'", sep, last_fileset);
     1595    }
     1596#endif
     1597
     1598    if (psListLength(where->list)) {
     1599        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1600        psStringAppend(&query, " WHERE %s", whereClause);
     1601        psFree(whereClause);
     1602    } else {
     1603        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1604        psFree(where);
     1605        psFree(query);
     1606        return false;
     1607    }
     1608    psFree(where);
     1609
     1610    if (!p_psDBRunQuery(config->dbh, query)) {
     1611        psError(PS_ERR_UNKNOWN, false, "database error");
     1612        psFree(query);
     1613        return false;
     1614    }
     1615    psFree(query);
     1616
     1617    return true;
     1618}
     1619
     1620static bool defineinterestMode(pxConfig *config)
     1621{
     1622    PS_ASSERT_PTR_NON_NULL(config, false);
     1623
     1624    // required
     1625    PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", true, false);
     1626    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", true, false);
     1627
     1628    // optional
     1629    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1630
     1631    // XXX: should we insure that these names do not contatin any whitespace?
     1632
     1633    rcInterestRow *row = rcInterestRowAlloc(
     1634            0,          // int_id
     1635            dest_id,
     1636            target_id,
     1637            state ? state : "enabled"
     1638            );
     1639           
     1640    if (!row) {
     1641        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcInterest object");
     1642        return false;
     1643    }
     1644   if (!rcInterestInsertObject(config->dbh, row)) {
     1645        psError(PS_ERR_UNKNOWN, false, "database error");
     1646        psFree(row);
     1647        return false;
     1648    }
     1649
     1650    // get the assigned target_id
     1651    row->int_id = psDBLastInsertID(config->dbh);
     1652
     1653    if (!rcInterestPrintObject(stdout, row, true)) {
     1654        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1655        psFree(row);
     1656        return false;
     1657    }
     1658
     1659    psFree(row);
     1660
     1661    return true;
     1662}
     1663
     1664static bool updateinterestMode(pxConfig *config)
     1665{
     1666    PS_ASSERT_PTR_NON_NULL(config, false);
     1667
     1668    psMetadata *where = psMetadataAlloc();
     1669    PXOPT_COPY_S64(config->args, where, "-int_id",    "int_id", "==");
     1670    PXOPT_COPY_S64(config->args, where, "-dest_id",   "dest_id", "==");
     1671    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1672
     1673    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1674    if (!state) {
     1675        psError(PS_ERR_UNKNOWN, true, "-set_state is required");
     1676        psFree(where);
     1677        return false;
     1678    }
     1679    psString query = NULL;
     1680    psStringAppend(&query, "UPDATE rcInterest SET state = '%s'", state);
     1681
     1682    if (psListLength(where->list)) {
     1683        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1684        psStringAppend(&query, " WHERE %s", whereClause);
     1685        psFree(whereClause);
     1686    } else {
     1687        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1688        psFree(where);
     1689        psFree(query);
     1690        return false;
     1691    }
     1692    psFree(where);
     1693
     1694    if (!p_psDBRunQuery(config->dbh, query)) {
     1695        psError(PS_ERR_UNKNOWN, false, "database error");
     1696        psFree(query);
     1697        return false;
     1698    }
     1699    psFree(query);
     1700
     1701    return true;
     1702}
     1703

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/disttool.h

    r23352 r24244  
    3333    DISTTOOL_MODE_PROCESSEDCOMPONENT,
    3434    DISTTOOL_MODE_TOADVANCE,
     35    DISTTOOL_MODE_PENDINGFILESET,
     36    DISTTOOL_MODE_ADDFILESET,
     37    DISTTOOL_MODE_REVERTFILESET,
     38    DISTTOOL_MODE_QUEUERCRUN,
     39    DISTTOOL_MODE_UPDATERCRUN,
     40    DISTTOOL_MODE_REVERTRCRUN,
     41    DISTTOOL_MODE_PENDINGDEST,
     42    DISTTOOL_MODE_DEFINEDESTINATION,
     43    DISTTOOL_MODE_UPDATEDESTINATION,
     44    DISTTOOL_MODE_DEFINEDSPRODUCT,
     45    DISTTOOL_MODE_UPDATEDSPRODUCT,
     46    DISTTOOL_MODE_DEFINETARGET,
     47    DISTTOOL_MODE_UPDATETARGET,
     48    DISTTOOL_MODE_LISTTARGET,
     49    DISTTOOL_MODE_DEFINEINTEREST,
     50    DISTTOOL_MODE_UPDATEINTEREST,
    3551} disttoolMode;
    3652

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/disttoolConfig.c

    r23594 r24244  
    4343    }
    4444
     45    // -definebyquery
     46    psMetadata *definebyqueryArgs = psMetadataAlloc();
     47    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stage",     0, "define stage for bundle (required)", NULL);
     48    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",   0, "define workdir (required)", NULL);
     49
     50    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
     52
     53    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be selected", false);
     54
     55    // select args
     56    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-target_id",     0, "define target_id", 0);
     57    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",        0, "define exp_id", 0);
     58    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",       0, "define chip_id", 0);
     59    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
     60    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by label", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",      0, "select by obs_mode", NULL);
     62
     63    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     64    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     65
    4566    // -definerun
    4667    psMetadata *definerunArgs = psMetadataAlloc();
    4768    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage",         0, "define stage for bundle (required)", NULL);
    48     psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id (required)", 0); 
     69    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id (required)", 0);
    4970    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot",  0, "define output destination (required)", NULL);
     71    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
    5072    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-clean", 0,   "build clean distribution bundle", false);
     73    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-no_magic", 0, "magic is not needed", false);
    5174    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label",    0, "define label for run", NULL);
    52    
     75
    5376    // -updaterun
    5477    psMetadata *updaterunArgs = psMetadataAlloc();
    55     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-dist_id",  0, "define dist_id", 0); 
     78    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-dist_id",  0, "define dist_id", 0);
    5679    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
    5780    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0, "new value for label", NULL);
    … …  
    5982    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",     0, "value for state", NULL);
    6083    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",     0, "limit updates to label", NULL);
    61     psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-code",      0, "define fault code", 0);
    62    
     84    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
     85
    6386    // -revertrun
    6487    psMetadata *revertrunArgs = psMetadataAlloc();
    65     psMetadataAddS64(revertrunArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0); 
     88    psMetadataAddS64(revertrunArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    6689    psMetadataAddStr(revertrunArgs, PS_LIST_TAIL, "-stage",    0, "define stage", NULL);
    67     psMetadataAddS64(revertrunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0); 
     90    psMetadataAddS64(revertrunArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage_id", 0);
    6891    psMetadataAddStr(revertrunArgs, PS_LIST_TAIL, "-state",    0, "define state", NULL);
    6992    psMetadataAddStr(revertrunArgs, PS_LIST_TAIL, "-label",    0, "define label", NULL);
    70     psMetadataAddS16(revertrunArgs, PS_LIST_TAIL, "-code", 0, "define fault code", 0);
     93    psMetadataAddS16(revertrunArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    7194    psMetadataAddBool(revertrunArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
    72    
     95
    7396    // -pendingcomponent
    7497    psMetadata *pendingcomponentArgs = psMetadataAlloc();
    75     psMetadataAddS64(pendingcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0); 
     98    psMetadataAddS64(pendingcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    7699    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage", NULL);
    77     psMetadataAddBool(pendingcomponentArgs, PS_LIST_TAIL, "-need_magic", 0, "magic is needed", false);
    78100    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    0, "limit results to label", NULL);
    79101    psMetadataAddU64(pendingcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    … …  
    83105    // -addprocessedcomponent
    84106    psMetadata *addprocessedcomponentArgs = psMetadataAlloc();
    85     psMetadataAddS64(addprocessedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0); 
     107    psMetadataAddS64(addprocessedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    86108    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-component", 0, "define component (required)", NULL);
    87109    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-name", 0, "define file name", NULL);
    88     psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-bytes", 0, "define file size", 0); 
     110    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-bytes", 0, "define file size", 0);
    89111    psMetadataAddStr(addprocessedcomponentArgs, PS_LIST_TAIL, "-md5sum", 0, "define stage for bundle", NULL);
    90     psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-code", 0, "define fault code", 0);
     112    psMetadataAddS32(addprocessedcomponentArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    91113
    92114    // -processedcomponent
    93115    psMetadata *processedcomponentArgs = psMetadataAlloc();
    94     psMetadataAddS64(processedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0); 
     116    psMetadataAddS64(processedcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    95117    psMetadataAddU64(processedcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    96118    psMetadataAddBool(processedcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    98120    // -toadvance
    99121    psMetadata *toadvanceArgs = psMetadataAlloc();
    100     psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    101     psMetadataAddU64(toadvanceArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     122    psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     123    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",   0, "limit updates to label", NULL);
     124    psMetadataAddU64(toadvanceArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    102125    psMetadataAddBool(toadvanceArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     126
     127    // -pendingfileset
     128    psMetadata *pendingfilesetArgs = psMetadataAlloc();
     129    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     130    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     131    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
     132    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
     133    psMetadataAddBool(pendingfilesetArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     134
     135    // -addfileset
     136    psMetadata *addfilesetArgs = psMetadataAlloc();
     137    psMetadataAddS64(addfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     138    psMetadataAddS64(addfilesetArgs, PS_LIST_TAIL, "-prod_id", 0, "define prod_id", 0);
     139    psMetadataAddStr(addfilesetArgs, PS_LIST_TAIL, "-name",    0, "define file name", NULL);
     140    psMetadataAddS32(addfilesetArgs, PS_LIST_TAIL, "-fault",   0, "define fault code", 0);
     141
     142    // -pendingdest
     143    psMetadata *pendingdestArgs = psMetadataAlloc();
     144    psMetadataAddS64(pendingdestArgs, PS_LIST_TAIL, "-dest_id", 0, "define dest_id", 0);
     145    psMetadataAddU64(pendingdestArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
     146    psMetadataAddBool(pendingdestArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     147    psMetadataAddStr(pendingdestArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     148
     149    // -revertfileset
     150    psMetadata *revertfilesetArgs = psMetadataAlloc();
     151    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-fs_id",   0, "define fs_id", 0);
     152    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
     153    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-prod_id", 0, "define dist_id", 0);
     154    psMetadataAddStr(revertfilesetArgs, PS_LIST_TAIL, "-stage",   0, "define stage", NULL);
     155    psMetadataAddS64(revertfilesetArgs, PS_LIST_TAIL, "-stage_id",0, "define stage_id", 0);
     156    psMetadataAddStr(revertfilesetArgs, PS_LIST_TAIL, "-state",   0, "define state", NULL);
     157    psMetadataAddStr(revertfilesetArgs, PS_LIST_TAIL, "-label",   0, "define label", NULL);
     158    psMetadataAddS16(revertfilesetArgs, PS_LIST_TAIL, "-fault",   0, "define fault code", 0);
     159    psMetadataAddBool(revertfilesetArgs, PS_LIST_TAIL, "-all",    0, "revert all faulted runs", NULL);
     160
     161    // -queuercrun
     162    psMetadata *queuercrunArgs = psMetadataAlloc();
     163    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-dist_id",   0, "define dist_id", 0);
     164    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
     165    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-prod_id",   0, "define prod_id", 0);
     166    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     167    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-fs_id",     0, "define fs_id", 0);
     168    psMetadataAddStr(queuercrunArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     169    psMetadataAddS64(queuercrunArgs, PS_LIST_TAIL, "-stage_id",  0, "define stage_id", 0);
     170    psMetadataAddStr(queuercrunArgs, PS_LIST_TAIL, "-state",     0, "define state", NULL);
     171    psMetadataAddStr(queuercrunArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     172    psMetadataAddU64(queuercrunArgs, PS_LIST_TAIL, "-limit",     0, "limit number of runs queued to N", 0);
     173
     174    // -updatercrun
     175    psMetadata *updatercrunArgs = psMetadataAlloc();
     176    psMetadataAddS64(updatercrunArgs, PS_LIST_TAIL, "-rc_id",    0, "define rc_id", 0);
     177    psMetadataAddS64(updatercrunArgs, PS_LIST_TAIL, "-dest_id",  0, "define dest_id", 0);
     178    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-fs_name",  0, "define fileset name", NULL);
     179    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-status_fs_name",  0, "define status fileset name", NULL);
     180    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-set_state",0, "new value for state", NULL);
     181    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-set_last_fileset",0, "new value for last_fileset", NULL);
     182    psMetadataAddS16(updatercrunArgs, PS_LIST_TAIL, "-fault",    0, "define fault code", -1);
     183
     184    // -revertrcrun
     185    psMetadata *revertrcrunArgs = psMetadataAlloc();
     186    psMetadataAddS64(revertrcrunArgs, PS_LIST_TAIL,  "-rc_id",   0, "define rc_id", 0);
     187    psMetadataAddS64(revertrcrunArgs, PS_LIST_TAIL,  "-fs_id",   0, "define fs_id", 0);
     188    psMetadataAddS64(revertrcrunArgs, PS_LIST_TAIL,  "-dest_id", 0, "define dest_id", 0);
     189    psMetadataAddS16(revertrcrunArgs, PS_LIST_TAIL,  "-fault",   0, "define fault code", 0);
     190    psMetadataAddBool(revertrcrunArgs, PS_LIST_TAIL, "-all",     0, "revert all faulted runs", NULL);
     191
     192    // -definedsproduct
     193    psMetadata *definedsproductArgs = psMetadataAlloc();
     194    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-name",  0, "define product name", NULL);
     195    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
     196    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
     197
     198    // -updatedsproduct
     199    // does this mode make sense?
     200    psMetadata *updatedsproductArgs = psMetadataAlloc();
     201    psMetadataAddS64(updatedsproductArgs, PS_LIST_TAIL, "-prod_id",   0, "select by prod_id", 0);
     202    // can't select by name because it isn't necssarily unique
     203    psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
     204    psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
     205
     206    // -definedestination
     207    psMetadata *definedestinationArgs = psMetadataAlloc();
     208    psMetadataAddS64(definedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id (required)", 0);
     209    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name (required)", NULL);
     210    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
     211    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
     212    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-last_fileset",0, "define last_fileset", NULL);
     213    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
     214
     215    // -updatedestination
     216    psMetadata *updatedestinationArgs = psMetadataAlloc();
     217    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-dest_id",     0, "define dest_id", 0);
     218    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id", 0);
     219    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name", NULL);
     220    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
     221    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
     222//  last_fileset gets updated by -updatercrun
     223//  psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_last_fileset",0, "define last_fileset", NULL);
     224    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
     225
     226    // -definetarget
     227    psMetadata *definetargetArgs = psMetadataAlloc();
     228    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-obs_mode",  0, "define obs_mode (required)", NULL);
     229    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage (required)", NULL);
     230    psMetadataAddBool(definetargetArgs, PS_LIST_TAIL,"-clean",     0, "define clean", false);
     231    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     232    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-comment",   0, "define comment", NULL);
     233
     234    // -updatetarget
     235    psMetadata *updatetargetArgs = psMetadataAlloc();
     236    psMetadataAddS64(updatetargetArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     237    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-obs_mode",  0, "define obs_mode", NULL);
     238    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     239    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     240
     241    // -listtarget
     242    psMetadata *listtargetArgs = psMetadataAlloc();
     243    psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
     244    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-obs_mode",  0, "list targets for obs_mode", NULL);
     245    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
     246    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
     247    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-full",      0, "list full targets", false);
     248    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-state",     0, "list tarets in state", NULL);
     249    psMetadataAddU64(listtargetArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
     250    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     251
     252    // -defineinterest
     253    psMetadata *defineinterestArgs = psMetadataAlloc();
     254    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id (required)", 0);
     255    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
     256    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     257
     258    // -updateinterest
     259    psMetadata *updateinterestArgs = psMetadataAlloc();
     260    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-int_id",    0, "define int_id", 0);
     261    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
     262    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     263    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state (required)", NULL);
    103264
    104265    psMetadata *argSets = psMetadataAlloc();
    105266    psMetadata *modes = psMetadataAlloc();
    106267
     268    PXOPT_ADD_MODE("-definebyquery",    "", DISTTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    107269    PXOPT_ADD_MODE("-definerun",    "", DISTTOOL_MODE_DEFINERUN, definerunArgs);
    108270    PXOPT_ADD_MODE("-updaterun",    "", DISTTOOL_MODE_UPDATERUN, updaterunArgs);
    … …  
    110272    PXOPT_ADD_MODE("-pendingcomponent",       "", DISTTOOL_MODE_PENDINGCOMPONENT,    pendingcomponentArgs);
    111273    PXOPT_ADD_MODE("-addprocessedcomponent",      "", DISTTOOL_MODE_ADDPROCESSEDCOMPONENT, addprocessedcomponentArgs);
    112     PXOPT_ADD_MODE("-processedcomponent",      "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
    113     PXOPT_ADD_MODE("-toadvance",      "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
     274    PXOPT_ADD_MODE("-processedcomponent", "", DISTTOOL_MODE_PROCESSEDCOMPONENT, processedcomponentArgs);
     275    PXOPT_ADD_MODE("-toadvance",          "", DISTTOOL_MODE_TOADVANCE, toadvanceArgs);
     276    PXOPT_ADD_MODE("-pendingfileset",     "", DISTTOOL_MODE_PENDINGFILESET, pendingfilesetArgs);
     277    PXOPT_ADD_MODE("-addfileset",         "", DISTTOOL_MODE_ADDFILESET, addfilesetArgs);
     278    PXOPT_ADD_MODE("-revertfileset",      "", DISTTOOL_MODE_REVERTFILESET, revertfilesetArgs);
     279    PXOPT_ADD_MODE("-queuercrun",         "", DISTTOOL_MODE_QUEUERCRUN, queuercrunArgs);
     280    PXOPT_ADD_MODE("-updatercrun",        "", DISTTOOL_MODE_UPDATERCRUN, updatercrunArgs);
     281    PXOPT_ADD_MODE("-revertrcrun",        "", DISTTOOL_MODE_REVERTRCRUN, revertrcrunArgs);
     282    PXOPT_ADD_MODE("-pendingdest",        "", DISTTOOL_MODE_PENDINGDEST, pendingdestArgs);
     283
     284    PXOPT_ADD_MODE("-definedsproduct",    "", DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductArgs);
     285    PXOPT_ADD_MODE("-updatedsproduct",    "", DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductArgs);
     286//  PXOPT_ADD_MODE("-listdsproduct",      "", DISTTOOL_MODE_LISTDSPRODUCT, updatedsproductArgs);
     287
     288    PXOPT_ADD_MODE("-definedestination",  "", DISTTOOL_MODE_DEFINEDESTINATION, definedestinationArgs);
     289    PXOPT_ADD_MODE("-updatedestination",  "", DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationArgs);
     290//  PXOPT_ADD_MODE("-listdestination",    "", DISTTOOL_MODE_LISTDESTINATION, listdestinationArgs);
     291
     292    PXOPT_ADD_MODE("-definetarget",       "", DISTTOOL_MODE_DEFINETARGET, definetargetArgs);
     293    PXOPT_ADD_MODE("-updatetarget",       "", DISTTOOL_MODE_UPDATETARGET, updatetargetArgs);
     294    PXOPT_ADD_MODE("-listtarget",         "", DISTTOOL_MODE_LISTTARGET, listtargetArgs);
     295
     296    PXOPT_ADD_MODE("-defineinterest",     "", DISTTOOL_MODE_DEFINEINTEREST, defineinterestArgs);
     297    PXOPT_ADD_MODE("-updateinterest",     "", DISTTOOL_MODE_UPDATEINTEREST, updateinterestArgs);
     298//  PXOPT_ADD_MODE("-listinterest",       "", DISTTOOL_MODE_LISTINTEREST, listinterestArgs);
    114299
    115300    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/faketool.c

    r23352 r24244  
    128128    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    129129    PXOPT_COPY_STR(config->args, where, "-exp_tag", "exp_tag", "==");
    130     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     130    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    131131    PXOPT_COPY_STR(config->args, where, "-filelevel", "filelevel", "==");
    132132    PXOPT_COPY_STR(config->args, where, "-reduction", "reduction", "==");
    … …  
    227227        psFree(output);
    228228        return false;
     229    }
     230
     231    // if end_stage is warp (or NULL), check for valid tess_id
     232    for (long i = 0; i < psArrayLength(output); i++) {
     233        psMetadata *md = output->data[i];
     234
     235        bool status;
     236        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
     237        if (end_stage && strcasecmp(end_stage, "warp")) continue;
     238
     239        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
     240        if (raw_tess_id || tess_id) continue;
     241
     242        char *label  = psMetadataLookupStr(&status, md, "label");
     243        psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id");
     244
     245        if (!status) {
     246            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     247            psFree(output);
     248            return false;
     249        }
    229250    }
    230251
    … …  
    355376
    356377    psMetadata *where = psMetadataAlloc();
     378    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    357379    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    358     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    359380    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
    360381    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    … …  
    421442    psMetadata *where = psMetadataAlloc();
    422443    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    423     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     444    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    424445    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    425446    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    … …  
    496517
    497518    // default values
    498     PXOPT_LOOKUP_S16(code, config->args,        "-code", false, false);
     519    PXOPT_LOOKUP_S16(fault, config->args,        "-fault", false, false);
    499520
    500521    if (!psDBTransaction(config->dbh)) {
    … …  
    513534                                   path_base,
    514535                                   "full",
    515                                    code,
     536                                   fault,
    516537                                   NULL         // epoch
    517538            )) {
    … …  
    542563
    543564    psMetadata *where = psMetadataAlloc();
    544     PXOPT_COPY_S64(config->args, where, "-fake_id", "fakeRun.fake_id", "==");
     565    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    545566    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    546567    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    … …  
    687708    PS_ASSERT_PTR_NON_NULL(config, false);
    688709
    689     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
     710    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    690711
    691712    psMetadata *where = psMetadataAlloc();
    … …  
    693714    PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    694715
    695     if (!pxSetFaultCode(config->dbh, "fakeProcessedImfile", where, code)) {
     716    if (!pxSetFaultCode(config->dbh, "fakeProcessedImfile", where, fault)) {
    696717        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    697718        psFree(where);
    … …  
    874895
    875896    psMetadata *where = psMetadataAlloc();
    876     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     897    pxAddLabelSearchArgs (config, where, "-label", "fakeRun.label", "==");
    877898
    878899    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
    … …  
    939960        PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    940961    }
    941     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     962    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    942963
    943964    psString query = pxDataGet("faketool_pendingcleanupimfile.sql");
    … …  
    10581079    psMetadata *where = psMetadataAlloc();
    10591080    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    1060     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1081    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    10611082
    10621083    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    12381259
    12391260  int numExportTables = 2;
    1240  
     1261
    12411262  PS_ASSERT_PTR_NON_NULL(config, NULL);
    12421263
    … …  
    12441265  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    12451266  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1267  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    12461268
    12471269  FILE *f = fopen (outfile, "w");
    … …  
    12921314    }
    12931315    if (!psArrayLength(output)) {
    1294       psTrace("regtool", PS_LOG_INFO, "no rows found");
     1316      psError(PS_ERR_UNKNOWN, true, "no rows found");
    12951317      psFree(output);
    1296       return true;
     1318      return false;
     1319    }
     1320
     1321    if (clean) {
     1322        if (!strcmp(tables[i].tableName, "fakeRun")) {
     1323            if(!pxSetStateCleaned("fakeRun", "state", output)) {
     1324                psFree(output);
     1325                psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1326                return false;
     1327            }
     1328        }
    12971329    }
    12981330
    … …  
    13161348
    13171349  PS_ASSERT_PTR_NON_NULL(config, NULL);
    1318  
     1350
    13191351  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    13201352

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/faketoolConfig.c

    r23352 r24244  
    5454    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
    5555    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
    56     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-label",  0,            "search by label", NULL);
     56    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    5757    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
    5858    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
    … …  
    148148    psMetadata *pendingexpArgs = psMetadataAlloc();
    149149    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by fake ID", 0);
    150     psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     150    psMetadataAddStr(pendingexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    151151    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
    152152    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
    … …  
    157157    psMetadata *pendingimfileArgs = psMetadataAlloc();
    158158    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake ID", 0);
    159     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     159    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    160160    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    161161    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    175175    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-hostname",  0,            "define hostname", NULL);
    176176    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    177     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     177    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    178178
    179179    // -processedimfile
    … …  
    193193    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    194194    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    195     psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
     195    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
    196196
    197197    // -revertprocessedimfile
    … …  
    239239
    240240    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    241     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     241    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    242242
    243243
    … …  
    245245    psMetadata *advanceexpArgs = psMetadataAlloc();
    246246    psMetadataAddS64(advanceexpArgs, PS_LIST_TAIL, "-fake_id", 0,      "search by fake ID", 0);
    247     psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label",  0,      "search by label ", NULL);
     247    psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label ", NULL);
    248248    psMetadataAddU64(advanceexpArgs, PS_LIST_TAIL, "-limit",  0,       "limit exposures to advance to N items", 0);
    249249
    … …  
    270270    // -pendingcleanuprun
    271271    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    272     psMetadataAddStr(pendingcleanuprunArgs,  PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     272    psMetadataAddStr(pendingcleanuprunArgs,  PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    273273    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    274274    psMetadataAddU64(pendingcleanuprunArgs,  PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    276276    // -pendingcleanupimfile
    277277    psMetadata *pendingcleanupimfileArgs = psMetadataAlloc();
    278     psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     278    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    279279    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-fake_id", 0,          "search by chip ID", 0);
    280280    psMetadataAddBool(pendingcleanupimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    306306    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    307307    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     308    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "mark tables as cleaned", false);
    308309
    309310    // -importrun

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/flatcorr.c

    r23352 r24244  
    535535    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    536536
     537    psMetadata *where = psMetadataAlloc();
     538    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     539
    537540    psString query = pxDataGet("flatcorr_pendingprocess.sql");
    538541    if (!query) {
    … …  
    540543        return false;
    541544    }
     545
     546    if (where && psListLength(where->list)) {
     547        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     548        psStringAppend(&query, " AND %s", whereClause);
     549        psFree(whereClause);
     550    }
     551    psFree(where);
    542552
    543553    // treat limit == 0 as "no limit"
    … …  
    761771
    762772  psMetadata *where = psMetadataAlloc();
    763   PXOPT_COPY_S64(config->args, where, "-coor_id", "corr_id", "==");
     773  PXOPT_COPY_S64(config->args, where, "-corr_id", "corr_id", "==");
    764774
    765775  ExportTable tables [] = {
    766     {"flatcorrRun", "flatcorrtool_export_run.sql"},
    767     {"flatcorrCamLink", "flatcorrtool_export_cam_link.sql"},
     776    {"flatcorrRun", "flatcorr_export_run.sql"},
     777    {"flatcorrCamLink", "flatcorr_export_cam_link.sql"},
    768778    {"flatcorrChipLink", "flatcorr_export_chip_link.sql"},
    769779  };

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/flatcorrConfig.c

    r23352 r24244  
    101101    psMetadataAddU64 (pendingprocessArgs, PS_LIST_TAIL, "-limit",  0, "limit result set to N items", 0);
    102102    psMetadataAddBool(pendingprocessArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     103    psMetadataAddStr(pendingprocessArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
    103104
    104105    // -addprocess (XXX need to add fault and stats)

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/magicdstool.c

    r23594 r24244  
    398398    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    399399    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    400     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     400    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    401401
    402402    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    599599
    600600    // default values
    601     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     601    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    602602    PXOPT_LOOKUP_STR(backup_path_base, config->args, "-backup_path_base", false, false);
    603603    PXOPT_LOOKUP_STR(recovery_path_base, config->args, "-recovery_path_base", false, false);
    604604    PXOPT_LOOKUP_BOOL(setmagicked, config->args, "-setmagicked", false);
    605605
    606     if (setmagicked && (code != 0)) {
     606    if (setmagicked && (fault != 0)) {
    607607        psError(PS_ERR_UNKNOWN, true, " cannot setmagicked for faulted file");
    608608        return false;
    … …  
    625625    }
    626626
    627     if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, code)) {
     627    if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault)) {
    628628            // rollback
    629629        if (!psDBRollback(config->dbh)) {
    … …  
    781781    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    782782    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");
    783     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     783    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    784784
    785785    psString query = psStringCopy("DELETE FROM magicDSFile WHERE fault != 0");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/magicdstoolConfig.c

    r23594 r24244  
    8888    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    8989    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    90     psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
     90    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    9191    psMetadataAddU64(todestreakArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    9292    psMetadataAddBool(todestreakArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    9999    psMetadataAddStr(adddestreakedfileArgs, PS_LIST_TAIL, "-recovery_path_base", 0, "define recovery pixels URI", NULL);
    100100    psMetadataAddBool(adddestreakedfileArgs, PS_LIST_TAIL, "-setmagicked", 0, "update the magicked state of the file", false);
    101     psMetadataAddS16(adddestreakedfileArgs, PS_LIST_TAIL, "-code", 0, "set fault code", 0);
     101    psMetadataAddS16(adddestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    102102
    103103    // -revertdestreakedfile
    … …  
    105105    psMetadataAddS64(revertdestreakedfileArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magictool de-streak ID", 0);
    106106    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-component", 0, "search by component", NULL);
    107     psMetadataAddS16(revertdestreakedfileArgs, PS_LIST_TAIL, "-code", 0, "search by fault code", 0);
     107    psMetadataAddS16(revertdestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    108108
    109109    // -getskycells
    … …  
    125125    PXOPT_ADD_MODE("-updaterun",           "update state of magic de-streak run",
    126126                    MAGICDSTOOL_MODE_UPDATERUN,         updaterunArgs);
    127     PXOPT_ADD_MODE("-todestreak",          "show pending files",   
     127    PXOPT_ADD_MODE("-todestreak",          "show pending files",
    128128                    MAGICDSTOOL_MODE_TODESTREAK,       todestreakArgs);
    129129    PXOPT_ADD_MODE("-adddestreakedfile",   "add a de-streaked file",

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/magictool.c

    r23594 r24244  
    127127    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    128128    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    129 
    130     psMetadata *where = psMetadataAlloc();
    131     PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    132     PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    133 
     129    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     130
     131    psMetadata *diffWhere = psMetadataAlloc(); // WHERE conditions for diffRuns
     132    PXOPT_COPY_STR(config->args, diffWhere, "-diff_label", "diffRun.label", "==");
     133    PXOPT_COPY_S64(config->args, diffWhere, "-diff_id", "diff_id", "==");
     134
     135    psMetadata *queryWhere = psMetadataAlloc(); // WHERE conditions for everything else
     136    PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "exp_id", "==");
    134137
    135138    // Get list of exposures ready to magic
    … …  
    146149        PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    147150
    148         psString queryWhere = NULL;     // WHERE conditions for entire query
     151        psString diffWhereStr = NULL;   // WHERE conditions for diffRuns
     152        psString queryWhereStr = NULL;  // WHERE conditions for entire query
    149153        if (!available) {
    150             psStringAppend(&queryWhere, " \nWHERE diffRun.state = 'full'");
    151         } else {
    152             // what if no skycells for the diff run completed?
    153         }
     154            psStringAppend(&diffWhereStr, "\nAND diffRun.state = 'full'");
     155        }
     156        // what if no skycells for the diff run completed?
     157
    154158        if (!rerun) {
    155             const char *newWhere = " magic_id IS NULL"; // String to add
    156             if (queryWhere) {
    157                 psStringAppend(&queryWhere, " AND %s", newWhere);
    158             } else {
    159                 psStringAppend(&queryWhere, "\nWHERE %s", newWhere);
    160             }
    161         }
     159            psStringAppend(&queryWhereStr, "\n%s magic_id IS NULL", queryWhereStr ? "AND" : "WHERE");
     160        }
     161
    162162        // now add the user specified qualifiers
    163         if (psListLength(where->list)) {
    164             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    165             psStringAppend(&queryWhere, "\n%s %s", queryWhere == NULL ? "WHERE" : "AND", whereClause);
     163        if (psListLength(diffWhere->list)) {
     164            psString whereClause = psDBGenerateWhereConditionSQL(diffWhere, NULL);
     165            psStringAppend(&diffWhereStr, "\nAND %s", whereClause);
    166166            psFree(whereClause);
    167167        }
    168         psFree(where);
    169         if (!queryWhere) {
    170             psStringAppend(&queryWhere, " ");
    171         }
    172 
    173         if (!p_psDBRunQueryF(config->dbh, query, queryWhere)) {
     168        if (psListLength(queryWhere->list)) {
     169            psString whereClause = psDBGenerateWhereConditionSQL(queryWhere, NULL);
     170            psStringAppend(&queryWhereStr, "\n%s %s", queryWhereStr ? "AND" : "WHERE", whereClause);
     171            psFree(whereClause);
     172        }
     173        psFree(diffWhere);
     174        psFree(queryWhere);
     175
     176        // Ensure the WHERE strings have something
     177        if (!diffWhereStr) {
     178            diffWhereStr = psStringCopy("");
     179        }
     180        if (!queryWhereStr) {
     181            queryWhereStr = psStringCopy("");
     182        }
     183
     184        if (!p_psDBRunQueryF(config->dbh, query, diffWhereStr, diffWhereStr, queryWhereStr)) {
    174185            psError(PS_ERR_UNKNOWN, false, "database error");
    175             psFree(queryWhere);
     186            psFree(diffWhereStr);
     187            psFree(queryWhereStr);
    176188            psFree(query);
    177189            return false;
    178190        }
    179         psFree(queryWhere);
     191        psFree(diffWhereStr);
     192        psFree(queryWhereStr);
    180193        psFree(query);
    181194    }
    … …  
    201214    }
    202215
     216
     217    if (pretend) {
     218        // negative simple so the default is true
     219        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     220            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     221            psFree(output);
     222            return false;
     223        }
     224        psFree(output);
     225        return true;
     226    }
     227
     228
    203229    // Parse the list of exposures ready to magic
    204 
    205230    if (!psDBTransaction(config->dbh)) {
    206231        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    215240        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id"); // Exposure identifier
    216241        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id"); // difference identifier
     242        bool inverse = psMetadataLookupU64(NULL, row, "inverse"); // Inverse subtraction? Note types!
    217243
    218244        // create a new magicRun for this group
    219         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, "new", workdir, "dirty", label, dvodb, registered, 0);
     245        magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
     246                                            dvodb, registered, 0);
    220247        if (!run) {
    221248            psAbort("failed to alloc magicRun object");
    … …  
    296323
    297324    // optional
     325    PXOPT_LOOKUP_BOOL(inverse, config->args, "-inverse", false);
    298326    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    299327    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    … …  
    305333            exp_id,
    306334            diff_id ? diff_id : PS_MAX_S64,
     335            inverse,
    307336            "reg",      // state
    308337            workdir,
    … …  
    363392    // required
    364393    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    365     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    366394    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
    367395
    … …  
    369397            config->dbh,
    370398            magic_id,
    371             diff_id,
    372399            node
    373400    );
    … …  
    457484    psMetadata *where = psMetadataAlloc();
    458485    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    459     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     486    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    460487
    461488    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    535562
    536563    // default values
    537     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    538 
    539     if (code > 0) {
     564    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     565
     566    if (fault > 0) {
    540567        char *query = "UPDATE magicRun SET fault = %d, state = 'full' WHERE magic_id = %" PRId64;
    541         if (!p_psDBRunQueryF(config->dbh, query, code, magic_id)) {
     568        if (!p_psDBRunQueryF(config->dbh, query, fault, magic_id)) {
    542569            psError(PS_ERR_UNKNOWN, false,
    543570                    "failed to set fault for magic_id %" PRId64, magic_id);
    … …  
    561588    psMetadata *where = psMetadataAlloc();
    562589    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    563     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
    564 
    565     psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'run' WHERE fault != 0");
     590    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     591
     592    psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
    566593
    567594    if (psListLength(where->list)) {
    … …  
    584611    PS_ASSERT_PTR_NON_NULL(config, false);
    585612
    586     psMetadata *where = psMetadataAlloc();
    587     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    588     PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
     613    // Regrettably, there are multiple WHERE hooks which call the same things different names
     614    psMetadata *templatesWhere = psMetadataAlloc(); // WHERE for selecting template
     615    psMetadata *magicWhere = psMetadataAlloc();     // WHERE for selecting magic runs
     616
     617    PXOPT_COPY_S64(config->args, templatesWhere, "-magic_id", "magicRun.magic_id", "==");
     618    PXOPT_COPY_STR(config->args, templatesWhere, "-node", "diffInputSkyfile.skycell_id", "==");
     619
     620    PXOPT_COPY_S64(config->args, magicWhere, "-magic_id", "magicRun.magic_id", "==");
     621    PXOPT_COPY_STR(config->args, magicWhere, "-node", "magicTree.node", "==");
    589622
    590623    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    597630    }
    598631
    599     if (psListLength(where->list)) {
    600         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    601         psStringAppend(&query, " AND %s", whereClause);
     632    psString templatesWhereStr = psStringCopy(""); // WHERE for selecting template
     633    psString magicWhereStr = psStringCopy("");     // WHERE for selecting magic runs
     634
     635    if (psListLength(templatesWhere->list)) {
     636        psString whereClause = psDBGenerateWhereConditionSQL(templatesWhere, NULL);
     637        psStringAppend(&templatesWhereStr, "\nAND %s", whereClause);
    602638        psFree(whereClause);
    603639    }
    604     psFree(where);
     640    psFree(templatesWhere);
     641
     642    if (psListLength(magicWhere->list)) {
     643        psString whereClause = psDBGenerateWhereConditionSQL(magicWhere, NULL);
     644        psStringAppend(&magicWhereStr, "\nWHERE %s", whereClause);
     645        psFree(whereClause);
     646    }
     647    psFree(magicWhere);
    605648
    606649    // treat limit == 0 as "no limit"
    … …  
    611654    }
    612655
    613     if (!p_psDBRunQuery(config->dbh, query)) {
    614         psError(PS_ERR_UNKNOWN, false, "database error");
     656    if (!p_psDBRunQueryF(config->dbh, query,
     657                         templatesWhereStr, templatesWhereStr,
     658                         magicWhereStr, magicWhereStr)) {
     659        psError(PS_ERR_UNKNOWN, false, "database error");
     660        psFree(templatesWhereStr);
     661        psFree(magicWhereStr);
    615662        psFree(query);
    616663        return false;
    617664    }
     665    psFree(templatesWhereStr);
     666    psFree(magicWhereStr);
    618667    psFree(query);
    619668
    … …  
    704753
    705754            bool status = false;
    706             psS32 done = psMetadataLookupS32(&status, data, "done");
     755            psS64 done = psMetadataLookupS64(&status, data, "done");
    707756            if (!status) {
    708757                psAbort("failed to lookup value for done column");
    709758            }
    710             psS16 bad = psMetadataLookupS16(&status, data, "bad");
     759            psS64 bad = psMetadataLookupS64(&status, data, "bad");
    711760            if (!status) {
    712761                psAbort("failed to lookup value for bad column");
    … …  
    738787
    739788    psMetadata *where = psMetadataAlloc();
    740     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    741     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     789    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     790    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    742791
    743792    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     793    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    744794
    745795    // look for "inputs" that need to processed
    … …  
    750800    }
    751801
    752     psString whereClause = NULL;
     802    psString whereString = NULL;
    753803    if (psListLength(where->list)) {
    754         whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    755         psStringAppend(&query, " AND %s", whereClause);
     804        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     805        psStringAppend(&whereString, "\nAND %s", whereClause);
     806        psFree(whereClause);
    756807    }
    757808    psFree(where);
    758809
    759     if (!p_psDBRunQuery(config->dbh, query)) {
    760         psError(PS_ERR_UNKNOWN, false, "database error");
     810    // treat limit == 0 as "no limit"
     811    if (limit) {
     812        psString limitString = psDBGenerateLimitSQL(limit);
     813        psStringAppend(&query, " %s", limitString);
     814        psFree(limitString);
     815    }
     816
     817    if (!p_psDBRunQueryF(config->dbh, query, whereString, whereString)) {
     818        psError(PS_ERR_UNKNOWN, false, "database error");
     819        psFree(whereString);
    761820        psFree(query);
    762821        return false;
    … …  
    782841    }
    783842
     843    if (limit) {
     844        if (psArrayLength(output) >= limit) {
     845            // we've found enough (note that limit was applied to the query so '> limit' won't happen)
     846            // negative simple so the default is true
     847            if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
     848                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     849                psFree(output);
     850                return false;
     851            }
     852            psFree(output);
     853            return true;
     854        }
     855    }
     856
    784857    // look for tree nodes that need to be processed
     858    // XXX: This gets all nodes from all magicRuns that are in 'new'state
     859    // That doens't seem particularly efficient
    785860    query = pxDataGet("magictool_toprocess_tree.sql");
    786861    if (!query) {
    … …  
    789864    }
    790865
    791     if (whereClause) {
    792         psString new  = NULL;
    793         psStringAppend(&new, "\n AND %s", whereClause);
    794         psFree(whereClause);
    795         whereClause = new;
    796     }
    797     if (!p_psDBRunQueryF(config->dbh, query, whereClause ? whereClause :  "")) {
    798         psError(PS_ERR_UNKNOWN, false, "database error");
    799         psFree(whereClause);
     866
     867    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString :  "")) {
     868        psError(PS_ERR_UNKNOWN, false, "database error");
     869        psFree(whereString);
    800870        psFree(query);
    801871        return false;
    802872    }
    803     psFree(whereClause);
     873    psFree(whereString);
    804874    psFree(query);
    805875
    … …  
    828898    while (index <  psArrayLength(magicTree)) {
    829899        bool status;
     900        if (limit && (psArrayLength(output) >= limit)) {
     901            break;
     902        }
    830903        psS64 current_magic_id = psMetadataLookupS64(&status, magicTree->data[index], "magic_id");
    831904        if (!status) {
    … …  
    879952
    880953    }
     954    psFree(magicTree);
    881955
    882956    if (psArrayLength(output)) {
     957        if (limit && (limit < psArrayLength(output))) {
     958            // truncate the array
     959            long arrayLength = psArrayLength(output);
     960            for (long i = arrayLength - 1; i >= limit; i--) {
     961                psArrayRemoveIndex(output, i);
     962            }
     963        }
    883964        // negative simple so the default is true
    884965        if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
    … …  
    889970    }
    890971
    891     psFree(magicTree);
    892972    psFree(output);
    893973
    … …  
    905985
    906986    // optional
    907     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     987    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    908988
    909989    // default values
    910     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     990    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    911991
    912992    if (!magicNodeResultInsert(config->dbh,
    913993                               magic_id,
    914994                               node,
    915                                uri,
    916                                code
     995                               path_base,
     996                               fault
    917997        )) {
    918998        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    9301010    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    9311011    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    932     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
    933 
    934     psString query = psStringCopy("DELETE FROM magicNodeResult WHERE fault != 0");
     1012    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1013    PXOPT_COPY_S16(config->args, where, "-fault", "magicNodeResult.fault", "==");
     1014
     1015    psString query = pxDataGet("magictool_revertnode.sql");
     1016    if (!query) {
     1017        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1018        return false;
     1019    }
    9351020
    9361021    if (psListLength(where->list)) {
    … …  
    9381023        psStringAppend(&query, " AND %s", whereClause);
    9391024        psFree(whereClause);
     1025    } else {
     1026        psError(PS_ERR_UNKNOWN, false, "search parameters are required");
     1027        psFree(where);
     1028        return false;
    9401029    }
    9411030    psFree(where);
    … …  
    9451034        return false;
    9461035    }
     1036
     1037    psS32 numUpdated = psDBAffectedRows(config->dbh);
     1038    psLogMsg("magictool", PS_LOG_INFO, "Updated %d magic nodes", numUpdated);
     1039
    9471040    return true;
    9481041}
    … …  
    10241117
    10251118    // default values
    1026     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     1119    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    10271120
    10281121    if (!psDBTransaction(config->dbh)) {
    … …  
    10351128                         uri,
    10361129                         streaks,
    1037                          code
     1130                         fault
    10381131        )) {
    10391132        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    10811174    psMetadata *where = psMetadataAlloc();
    10821175    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    1083     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
     1176    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    10841177
    10851178    if (!psDBTransaction(config->dbh)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/magictoolConfig.c

    r21099 r24244  
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    5454    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     55    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id", 0, "search diff_id", 0);
    5556    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    5657    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    … …  
    5859    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun", 0, "generate new run even if existing?", false);
    5960    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     61    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "list results but do not queue", false);
    6062
    6163    // -definerun
    … …  
    6567    // following argument is for compatability
    6668    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-diff_id", 0, "define diff_id", 0);
     69    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-inverse", 0, "use the inverse subtraction?", false);
    6770    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    6871    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    … …  
    7881    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    7982    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    80     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "define difftool ID (required)", 0);
    8183    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    8284
    … …  
    9395    psMetadataAddS64(totreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    9496    psMetadataAddU64(totreeArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    95     psMetadataAddStr(totreeArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     97    psMetadataAddStr(totreeArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "define label", NULL);
    9698    psMetadataAddBool(totreeArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    9799
    … …  
    100102    psMetadataAddS64(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    101103    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0, "order of operations dep. file", NULL);
    102     psMetadataAddS16(inputtreeArgs, PS_LIST_TAIL, "-code", 0, "set fault code", 0);
     104    psMetadataAddS16(inputtreeArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    103105
    104106    // -reverttree
    105107    psMetadata *reverttreeArgs = psMetadataAlloc();
    106108    psMetadataAddS64(reverttreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    107     psMetadataAddS16(reverttreeArgs, PS_LIST_TAIL, "-code", 0, "search by fault code", 0);
     109    psMetadataAddS16(reverttreeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    108110
    109111    // -inputs
    … …  
    118120    psMetadataAddS64(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    119121    psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    120     psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     122    psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-label",       PS_META_DUPLICATE_OK, "define label", NULL);
    121123    psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    122124
    … …  
    125127    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    126128    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    127     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
    128     psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-code", 0, "set fault code", 0);
     129    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base", NULL);
     130    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    129131
    130132    // -revertnode
    … …  
    132134    psMetadataAddS64(revertnodeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    133135    psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-node", 0, "search by node name", NULL);
    134     psMetadataAddS16(revertnodeArgs, PS_LIST_TAIL, "-code", 0, "search by fault code", 0);
     136    psMetadataAddStr(revertnodeArgs, PS_LIST_TAIL, "-label",0, "search by label", NULL);
     137    psMetadataAddS16(revertnodeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    135138
    136139    // -tomask
    … …  
    144147    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
    145148    psMetadataAddS32(addmaskArgs, PS_LIST_TAIL, "-streaks", 0, "define number of streaks", 0);
    146     psMetadataAddS16(addmaskArgs, PS_LIST_TAIL, "-code", 0, "set fault code", 0);
     149    psMetadataAddS16(addmaskArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    147150
    148151    // -revertmask
    149152    psMetadata *revertmaskArgs = psMetadataAlloc();
    150153    psMetadataAddS64(revertmaskArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    151     psMetadataAddS16(revertmaskArgs, PS_LIST_TAIL, "-code", 0, "search by fault code", 0);
     154    psMetadataAddS16(revertmaskArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    152155
    153156    // -mask

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxtools.c

    r23352 r24244  
    2929{
    3030    PS_ASSERT_PTR_NON_NULL(state, false);
    31    
     31
    3232    if (!strcmp(state, "new")) return true;
    3333    if (!strcmp(state, "reg")) return true;
    … …  
    5050// 'scrubbed' is a virtual state equivalent to cleaned, but allows files to be removed
    5151// even if the config files is missing
     52
     53
     54// change the value for tableName.columName from 'full' to 'cleaned' if necessary
     55bool pxSetStateCleaned(const psString tableName, const psString columnName, psArray *rows)
     56{
     57    for (long i = 0; i < psArrayLength(rows); i++) {
     58        psMetadata *row = rows->data[i];
     59        psString state = psMetadataLookupStr(NULL, row, columnName);
     60        if (!state) {
     61            psError(PS_ERR_PROGRAMMING, false, "%s not found in row %ld of table %s",
     62                    columnName, i, tableName);
     63            return false;
     64        }
     65        if (!strcmp("full", state)) {
     66            // change full to cleaned
     67            psMetadataAddStr(row, PS_LIST_TAIL, columnName, PS_META_REPLACE, "", "cleaned");
     68        } else if (strcmp("cleaned", state)) {
     69            // if state isn't cleaned or full we can't set it to cleaned
     70            psError(PS_ERR_PROGRAMMING, true, "%s with state %s may not be exported cleaned",
     71                    tableName, state);
     72            return false;
     73        }
     74    }
     75    return true;
     76}
     77
     78// XXX verify data type?
     79bool pxAddLabelSearchArgs (pxConfig *config, psMetadata *where, char *name, char *field, char *op) {
     80
     81    psMetadataItem *item = psMetadataLookup(config->args, name);
     82    if (!item) {
     83        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", name);
     84        return false;
     85    }
     86    psAssert (item->type == PS_DATA_METADATA_MULTI, "%s should be a multi container", name);
     87    psAssert (item->data.list->n, "%s should at least have a place-holder", name);
     88    psMetadataItem *entry = (psMetadataItem *)item->data.list->head->data;
     89    psAssert (entry, "%s should at least have a place-holder", name);
     90    if (entry->data.str) {
     91        psListIterator *iter = psListIteratorAlloc (item->data.list, PS_LIST_HEAD, true);
     92        psMetadataItem *item = NULL;
     93        while ((item = psListGetAndIncrement(iter))) {
     94            // need to change the name and comment
     95            psFree (item->name);
     96            item->name = psStringCopy (field);
     97            psFree (item->comment);
     98            item->comment = psStringCopy (op);
     99            if (!psMetadataAddItem(where, item, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
     100                psError(PS_ERR_UNKNOWN, false, "failed to add item %s", field);
     101                psFree(where);
     102                return false;
     103            }
     104        }
     105        psFree (iter);
     106    }
     107    return true;
     108}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxtools.h

    r23594 r24244  
    5050
    5151bool pxIsValidState(const char *state);
     52bool pxSetStateCleaned(const psString tableName, const psString columnName, psArray *rows);
     53bool pxAddLabelSearchArgs (pxConfig *config, psMetadata *where, char *field, char *name, char *op);
    5254
    5355bool pxSetFaultCode(psDB *dbh, const char *tableName, psMetadata *where, psS16 code);
    … …  
    478480}
    479481
     482
     483/// Add a primary item to the mirror database
     484///
     485/// ITEM: Item to add (if it is of the correct type)
     486/// NAME: Name for table, to match item name
     487/// ROWTYPE: Type of the row (type returned by PARSEFUNC)
     488/// PARSEFUNC: Function to parse ITEM and return a ROWTYPE
     489/// IDENTIFIERS: Vector (of type U64) to store identifiers
     490/// IDNAME: Element of the row with U64 identifier
     491/// INSERTFUNC: Function to insert a row into the database
     492/// DATABASE: Database handle
     493/// CLEANUP: Operation(s) to perform to cleanup in case of an error
     494#define PXMIRROR_PRIMARY(ITEM, NAME, ROWTYPE, PARSEFUNC, IDENTIFIERS, IDNAME, INSERTFUNC, DATABASE, CLEANUP) \
     495    if (strcmp((ITEM)->name, NAME) == 0) { \
     496        if ((ITEM)->type != PS_DATA_METADATA) { \
     497            psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Entry %s is not of type METADATA", (ITEM)->name); \
     498            CLEANUP; \
     499            return false; \
     500        } \
     501        ROWTYPE *row = PARSEFUNC((ITEM)->data.md); /* Row to insert */ \
     502        if (!row) { \
     503            psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to generate %s row from metadata", (ITEM)->name); \
     504            CLEANUP; \
     505            return false; \
     506        } \
     507        if (!INSERTFUNC(DATABASE, row)) { \
     508            psError(PS_ERR_UNKNOWN, false, "Unable to add %s %" PRIu64, (ITEM)->name, row->IDNAME); \
     509            psFree(row); \
     510            CLEANUP; \
     511            return false; \
     512        } \
     513        psVectorAppend((IDENTIFIERS), row->IDNAME); \
     514        psFree(row); \
     515    }
     516
     517/// Add a dependent item to the mirror database
     518///
     519/// ITEM: Item to add (if it is of the correct type)
     520/// NAME: Name for table, to match item name
     521/// ROWTYPE: Type of the row (type returned by PARSEFUNC)
     522/// PARSEFUNC: Function to parse ITEM and return a ROWTYPE
     523/// IDENTIFIERS: Vector (of type U64) to check identifiers
     524/// IDNAME: Element of the row with U64 identifier
     525/// INSERTFUNC: Function to insert a row into the database
     526/// DATABASE: Database handle
     527/// CLEANUP: Operation(s) to perform to cleanup in case of an error
     528#define PXMIRROR_OTHER(ITEM, NAME, ROWTYPE, PARSEFUNC, IDENTIFIERS, IDNAME, INSERTFUNC, DATABASE, CLEANUP) \
     529    if (strcmp((ITEM)->name, NAME) == 0) { \
     530        if ((ITEM)->type != PS_DATA_METADATA) { \
     531            psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Entry %s is not of type METADATA", (ITEM)->name); \
     532            CLEANUP; \
     533            return false; \
     534        } \
     535        ROWTYPE *row = PARSEFUNC(item->data.md); /* Row to insert */ \
     536        if (!row) { \
     537            psError(PS_ERR_UNEXPECTED_NULL, false, "Unable to generate %s row from metadata", (ITEM)->name); \
     538            CLEANUP; \
     539            return false; \
     540        } \
     541        bool found = false;         /* Found the identifier? */ \
     542        for (int i = 0; i < (IDENTIFIERS)->n && !found; i++) { \
     543            if (row->IDNAME == (IDENTIFIERS)->data.U64[i]) { \
     544                found = true; \
     545                break; \
     546            } \
     547        } \
     548        if (!found) { \
     549            psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Identifier not found for %s %" PRIu64, \
     550                    (ITEM)->name, row->IDNAME); \
     551            psFree(row); \
     552            CLEANUP; \
     553            return false; \
     554        } \
     555        if (!INSERTFUNC(DATABASE, row)) { \
     556            psError(PS_ERR_UNKNOWN, false, "Unable to add %s %" PRIu64, (ITEM)->name, row->IDNAME); \
     557            psFree(row); \
     558            CLEANUP; \
     559            return false; \
     560        } \
     561        psFree(row); \
     562    }
     563
    480564#endif // PXTOOLS_H

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxtoolsErrorCodes.dat

    r11268 r24244  
    22# This file is used to generate pxtoolsErrorCodes.h
    33#
    4 BASE = 1100             First value we use; lower values belong to psLib
    5 UNKNOWN                 Unknown PM error code
     4BASE = 9000             First value we use; lower values belong to psLib
     5UNKNOWN                 Unknown ippTools error code
    66ARGUMENTS               Incorrect arguments
    77SYS                     System error

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxtoolsErrorCodes.h.in

    r11037 r24244  
    99 */
    1010typedef enum {
    11     PXTOOLS_ERR_BASE = 512,
     11    PXTOOLS_ERR_BASE = 9000,
    1212    PXTOOLS_ERR_${ErrorCode},
    1313    PXTOOLS_ERR_NERROR

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxwarp.c

    r23594 r24244  
    2828#include "pxtools.h"
    2929#include "pxwarp.h"
    30 
    31 bool pxwarpSetSearchArgs (psMetadata *md) {
    32     psMetadataAddS64(md, PS_LIST_TAIL, "-fake_id",            0, "search by fake_id", 0);
    33     psMetadataAddS64(md, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
    34     psMetadataAddS64(md, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
    35     psMetadataAddS64(md, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
    36     psMetadataAddStr(md, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
    37     psMetadataAddStr(md, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
    38     psMetadataAddStr(md, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
    39     psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
    40     psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
    41     psMetadataAddStr(md, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
    42     psMetadataAddStr(md, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
    43     psMetadataAddStr(md, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
    44     psMetadataAddStr(md, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
    45     psMetadataAddF64(md, PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
    46     psMetadataAddF64(md, PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
    47     psMetadataAddF64(md, PS_LIST_TAIL, "-ra_min",             0, "search by min", NAN);
    48     psMetadataAddF64(md, PS_LIST_TAIL, "-ra_max",             0, "search by max", NAN);
    49     psMetadataAddF64(md, PS_LIST_TAIL, "-decl_min",           0, "search by min", NAN);
    50     psMetadataAddF64(md, PS_LIST_TAIL, "-decl_max",           0, "search by max", NAN);
    51     psMetadataAddF32(md, PS_LIST_TAIL, "-exp_time_min",       0, "search by min", NAN);
    52     psMetadataAddF32(md, PS_LIST_TAIL, "-exp_time_max",       0, "search by max", NAN);
    53     psMetadataAddF32(md, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by max fraction of saturated pixels", NAN);
    54     psMetadataAddF32(md, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by min fraction of saturated pixels", NAN);
    55     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_min",             0, "search by max", NAN);
    56     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_max",             0, "search by max", NAN);
    57     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_stdev_min",       0, "search by max", NAN);
    58     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max", NAN);
    59     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by max", NAN);
    60     psMetadataAddF64(md, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max", NAN);
    61     psMetadataAddF64(md, PS_LIST_TAIL, "-alt_min",            0, "search by min", NAN);
    62     psMetadataAddF64(md, PS_LIST_TAIL, "-alt_max",            0, "search by max", NAN);
    63     psMetadataAddF64(md, PS_LIST_TAIL, "-az_min",             0, "search by min", NAN);
    64     psMetadataAddF64(md, PS_LIST_TAIL, "-az_max",             0, "search by max", NAN);
    65     psMetadataAddF32(md, PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
    66     psMetadataAddF32(md, PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
    67     psMetadataAddF64(md, PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    68     psMetadataAddF64(md, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    69     psMetadataAddStr(md, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    70     psMetadataAddF32(md, PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    71     psMetadataAddF32(md, PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
    72     return true;
    73 }
    74 
    75 bool pxwarpGetSearchArgs (pxConfig *config, psMetadata *where) {
    76     PXOPT_COPY_S64(config->args, where, "-fake_id",            "fakeRun.fake_id",       "==");
    77     PXOPT_COPY_S64(config->args, where, "-cam_id",             "camRun.cam_id",         "==");
    78     PXOPT_COPY_S64(config->args, where, "-chip_id",            "chipRun.chip_id",       "==");
    79     PXOPT_COPY_S64(config->args, where, "-exp_id",             "newExp.exp_id",         "==");
    80     PXOPT_COPY_STR(config->args, where, "-exp_name",           "rawExp.exp_name",       "==");
    81     PXOPT_COPY_STR(config->args, where, "-inst",               "rawExp.camera",         "==");
    82     PXOPT_COPY_STR(config->args, where, "-telescope",          "rawExp.telescope",      "==");
    83     PXOPT_COPY_TIME(config->args, where, "-dateobs_begin",     "rawExp.dateobs",        ">=");
    84     PXOPT_COPY_TIME(config->args, where, "-dateobs_end",       "rawExp.dateobs",        "<=");
    85     PXOPT_COPY_STR(config->args, where, "-exp_tag",            "rawExp.exp_tag",        "==");
    86     PXOPT_COPY_STR(config->args, where, "-exp_type",           "rawExp.exp_type",       "==");
    87     PXOPT_COPY_STR(config->args, where, "-filelevel",          "rawExp.filelevel",      "==");
    88     PXOPT_COPY_STR(config->args, where, "-filter",             "rawExp.filter",         "==");
    89     PXOPT_COPY_F64(config->args, where, "-airmass_min",        "rawExp.airmass",        ">=");
    90     PXOPT_COPY_F64(config->args, where, "-airmass_max",        "rawExp.airmass",        "<");
    91     PXOPT_COPY_F64(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
    92     PXOPT_COPY_F64(config->args, where, "-ra_max",             "rawExp.ra",             "<");
    93     PXOPT_COPY_F64(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
    94     PXOPT_COPY_F64(config->args, where, "-decl_max",           "rawExp.decl",           "<");
    95     PXOPT_COPY_F32(config->args, where, "-exp_time_min",       "rawExp.exp_time",       ">=");
    96     PXOPT_COPY_F32(config->args, where, "-exp_time_max",       "rawExp.exp_time",       "<");
    97     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
    98     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
    99     PXOPT_COPY_F64(config->args, where, "-bg_min",             "rawExp.bg",             ">=");
    100     PXOPT_COPY_F64(config->args, where, "-bg_max",             "rawExp.bg",             "<");
    101     PXOPT_COPY_F64(config->args, where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
    102     PXOPT_COPY_F64(config->args, where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
    103     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
    104     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
    105     PXOPT_COPY_F64(config->args, where, "-alt_min",            "rawExp.alt",            ">=");
    106     PXOPT_COPY_F64(config->args, where, "-alt_max",            "rawExp.alt",            "<");
    107     PXOPT_COPY_F64(config->args, where, "-az_min",             "rawExp.az",             ">=");
    108     PXOPT_COPY_F64(config->args, where, "-az_max",             "rawExp.az",             "<");
    109     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
    110     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
    111     PXOPT_COPY_F64(config->args, where, "-posang_min",         "rawExp.posang",         ">=");
    112     PXOPT_COPY_F64(config->args, where, "-posang_max",         "rawExp.posang",         "<");
    113     PXOPT_COPY_STR(config->args, where, "-object",             "rawExp.object",         "==");
    114     PXOPT_COPY_F32(config->args, where, "-solang_min",         "rawExp.solang",         ">=");
    115     PXOPT_COPY_F32(config->args, where, "-solang_max",         "rawExp.solang",         "<");
    116     return true;
    117 }
    11830
    11931bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state)

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxwarp.h

    r23594 r24244  
    2525#include "pxtools.h"
    2626
    27 bool pxwarpGetSearchArgs (pxConfig *config, psMetadata *where);
    28 bool pxwarpSetSearchArgs (psMetadata *md);
    29 
    3027bool pxwarpRunSetState(pxConfig *config, psS64 warp_id, const char *state);
    3128bool pxwarpRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pztool.c

    r23594 r24244  
    338338        // a lot simplier than a complicated scheme (tried that) to attempt to
    339339        // request on the right number of rows for each camera
    340        
     340
    341341        // treat limit == 0 as "no limit"
    342342        if (limit) {
    … …  
    403403
    404404    // default values
    405     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     405    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    406406
    407407    // start a transaction early so it will contain any row level locks
    … …  
    410410        return false;
    411411    }
    412    
     412
    413413    // query to get an excluse lock on this exposure in
    414414    // pzDownloadExp
    … …  
    421421        PXOPT_COPY_STR(config->args, where,  "-inst", "camera", "==");
    422422        PXOPT_COPY_STR(config->args, where,  "-telescope", "telescope", "==");
    423        
     423
    424424        if (psListLength(where->list)) {
    425425            psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    455455            class_id,
    456456            uri,
    457             code,
     457            fault,
    458458            NULL,    // epoch
    459459            hostname
    … …  
    605605            psError(PS_ERR_UNKNOWN, false, "database error");
    606606            return false;
    607         } 
     607        }
    608608
    609609        // sanity check: we should have inserted at least one row
    … …  
    675675            // init
    676676            long counter = 0,   // the total number of elements zipped so far
    677             i = 0,              // which array in the set 
     677            i = 0,              // which array in the set
    678678            index = 0;          // the depth into each array
    679679            // test
    … …  
    782782    PXOPT_COPY_STR(config->args, where,  "-class_id", "class_id", "==");
    783783
    784     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    785 
    786     if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", where, code)) {
     784    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     785
     786    if (!pxSetFaultCode(config->dbh, "pzDownloadImfile", where, fault)) {
    787787        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    788         psFree (where);
    789         return false;
     788        psFree (where);
     789        return false;
    790790    }
    791791    psFree(where);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pztoolConfig.c

    r23594 r24244  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL); 
    48     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", 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);
    4949    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,            "define storage uri", NULL);
    50    
     50
    5151    // -datastore
    5252    psMetadata *datastoreArgs = psMetadataAlloc();
    … …  
    5555    // -seen
    5656    psMetadata *seenArgs = psMetadataAlloc();
    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); 
     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);
    6161    psMetadataAddBool(seenArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    62    
     62
    6363    // -pendingexp
    6464    psMetadata *pendingexpArgs = psMetadataAlloc();
    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); 
     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);
    6969    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
    7070    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    7373    // -pendingimfile
    7474    psMetadata *pendingimfileArgs = psMetadataAlloc();
    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); 
     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);
    7979    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-desc", 0,            "sort ouput in descending format", false);
    8080    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    8383    // -copydone
    8484    psMetadata *copydoneArgs = psMetadataAlloc();
    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); 
     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);
    8888    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
    8989    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
    … …  
    9595    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
    9696    psMetadataAddStr(copydoneArgs, PS_LIST_TAIL, "-hostname",  0,     "define the host that copied the image", NULL);
    97     psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     97    psMetadataAddS16(copydoneArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    9898    psMetadataAddBool(copydoneArgs, PS_LIST_TAIL, "-row_lock", 0,     "lock pzDownImfile rows while advancing an exposure", false);
    9999    // XXX: remove this once advance is fixed
    … …  
    102102    // -copied
    103103    psMetadata *copiedArgs = psMetadataAlloc();
    104     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL); 
    105     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL); 
    106     psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL); 
     104    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID", NULL);
     105    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID", NULL);
     106    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID", NULL);
    107107    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
    108108    psMetadataAddStr(copiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
    … …  
    113113    // -updatecopied
    114114    psMetadata *updatecopiedArgs = psMetadataAlloc();
    115     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL); 
    116     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL); 
    117     psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL); 
     115    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     116    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     117    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
    118118    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
    119119    psMetadataAddStr(updatecopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
    120     psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     120    psMetadataAddS16(updatecopiedArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    121121
    122122    // -revertcopied
    123123    psMetadata *revertcopiedArgs = psMetadataAlloc();
    124     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL); 
    125     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL); 
    126     psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL); 
     124    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-exp_name", 0,            "define exposure ID (required)", NULL);
     125    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-inst", 0,            "define camera ID (required)", NULL);
     126    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-telescope", 0,            "define telescope ID (required)", NULL);
    127127    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class", 0,            "define class", NULL);
    128128    psMetadataAddStr(revertcopiedArgs, PS_LIST_TAIL, "-class_id", 0,            "define class_id", NULL);
    129     psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     129    psMetadataAddS16(revertcopiedArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    130130
    131131    // -clearcommonfaults
    … …  
    134134    // -toadvance
    135135    psMetadata *toadvanceArgs = psMetadataAlloc();
    136     psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-exp_name", 0,      "define exposure ID", NULL); 
    137     psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-inst", 0,          "define camera ID", NULL); 
    138     psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-telescope", 0,     "define telescope ID", NULL); 
     136    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-exp_name", 0,      "define exposure ID", NULL);
     137    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-inst", 0,          "define camera ID", NULL);
     138    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-telescope", 0,     "define telescope ID", NULL);
    139139    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",  0,        "define the label for the chip stage", NULL);
    140140    psMetadataAddBool(toadvanceArgs, PS_LIST_TAIL, "-simple",  0,      "use the simple output format", false);
    … …  
    143143    // -advance
    144144    psMetadata *advanceArgs = psMetadataAlloc();
    145     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-exp_name", 0,   "define exposure ID (required)", NULL); 
    146     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-inst", 0,       "define camera ID (required)", NULL); 
    147     psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-telescope", 0,  "define telescope ID (required)", NULL); 
     145    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-exp_name", 0,   "define exposure ID (required)", NULL);
     146    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-inst", 0,       "define camera ID (required)", NULL);
     147    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-telescope", 0,  "define telescope ID (required)", NULL);
    148148    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-workdir",  0,   "define the \"default\" workdir for this exposure (required)", NULL);
    149149    psMetadataAddStr(advanceArgs, PS_LIST_TAIL, "-dvodb",  0,     "define the dvodb for the next processing step", NULL);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/regtool.c

    r23594 r24244  
    7878        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
    7979        MODECASE(REGTOOL_MODE_CLEARDUPEXP,           cleardupexpMode);
    80         MODECASE(CHIPTOOL_MODE_EXPORTRUN,            exportrunMode);
    81         MODECASE(CHIPTOOL_MODE_IMPORTRUN,            importrunMode);
     80        MODECASE(REGTOOL_MODE_EXPORTRUN,             exportrunMode);
     81        MODECASE(REGTOOL_MODE_IMPORTRUN,             importrunMode);
    8282        default:
    8383            psAbort("invalid option (this should not happen)");
    … …  
    238238    PXOPT_LOOKUP_TIME(dateobs, config->args, "-dateobs", false, false);
    239239    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    240     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     240
     241    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     242    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    241243
    242244    if (!rawImfileInsert(
    … …  
    302304        ignored,
    303305        hostname,
    304         code,
     306        fault,
     307        quality,
    305308        NULL,
    306309        0
    … …  
    408411    PXOPT_COPY_STR(config->args, where,  "-tmp_class_id", "tmp_class_id", "==");
    409412    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
    410     PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     413    PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    411414    PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    412415    PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    … …  
    452455    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    453456
    454     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     457    PXOPT_LOOKUP_S16(fault, config->args, "-fault",  false, false);
    455458    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    456459
    457     if ((code == INT16_MAX) && !isfinite(user_1)) {
    458         psError(PS_ERR_UNKNOWN, false, "one of -code or -user_1 must be selected");
    459         return false;
    460     }
    461     if ((code != INT16_MAX) && isfinite(user_1)) {
    462         psError(PS_ERR_UNKNOWN, false, "only one of -code or -user_1 must be selected");
     460    if ((fault == INT16_MAX) && !isfinite(user_1)) {
     461        psError(PS_ERR_UNKNOWN, false, "one of -fault or -user_1 must be selected");
     462        return false;
     463    }
     464    if ((fault != INT16_MAX) && isfinite(user_1)) {
     465        psError(PS_ERR_UNKNOWN, false, "only one of -fault or -user_1 must be selected");
    463466        return false;
    464467    }
    … …  
    468471    PXOPT_COPY_STR(config->args, where,  "-class_id",     "class_id", "==");
    469472
    470     if (code != INT16_MAX) {
     473    if (fault != INT16_MAX) {
    471474        // this is fairly dangerous : can set all if the where is not set...
    472         if (!pxSetFaultCode(config->dbh, "rawImfile", where, code)) {
     475        if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
    473476            psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    474477            psFree (where);
    … …  
    644647
    645648    // default
    646     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     649    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    647650
    648651    psString query = pxDataGet("regtool_pendingexp.sql");
    … …  
    801804        moon_phase,
    802805        hostname,
    803         code,
     806        fault,
    804807        NULL,
    805808        0
    … …  
    995998    psMetadata *where = psMetadataAlloc();
    996999    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    997     PXOPT_COPY_S16(config->args, where,  "-code",         "fault", "==");
     1000    PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    9981001    PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    9991002    PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    … …  
    10391042    PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    10401043
    1041     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
    1042 
    1043     if (!pxSetFaultCode(config->dbh, "rawExp", where, code)) {
     1044    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     1045
     1046    if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
    10441047        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    10451048        psFree(where);
    … …  
    11611164    char sqlFilename[80];
    11621165  } ExportTable;
    1163  
     1166
    11641167  int numExportTables = 2;
    11651168
    … …  
    11801183
    11811184  ExportTable tables [] = {
    1182     {"rawExp", "regtool_export_raw__exp.sql"},
    1183     {"rawImfile", "regtool_export_raw_imfile.sql"},
     1185    {"rawExp", "regtool_export_exp.sql"},
     1186    {"rawImfile", "regtool_export_imfile.sql"},
    11841187  };
    11851188
    … …  
    12411244
    12421245  PS_ASSERT_PTR_NON_NULL(config, NULL);
    1243  
     1246
    12441247  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    12451248
    … …  
    12521255  psAssert (item, "entry not in input?");
    12531256  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1254  
     1257
    12551258  psMetadataItem *entry = psListGet (item->data.list, 0);
    12561259  assert (entry);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/regtoolConfig.c

    r23594 r24244  
    122122    ADD_OPT(Time, addprocessedimfileArgs, "-dateobs",        "define observation time",         NULL);
    123123    ADD_OPT(Str,  addprocessedimfileArgs, "-hostname",       "define host name",                NULL);
    124     ADD_OPT(S16,  addprocessedimfileArgs, "-code",           "set fault code",                  0);
     124    ADD_OPT(S16,  addprocessedimfileArgs, "-fault",           "set fault code",                  0);
     125    ADD_OPT(S16,  addprocessedimfileArgs, "-quality",        "set quality flag", 0);
    125126
    126127    // -processedimfile
    … …  
    140141    ADD_OPT(Str, revertprocessedimfileArgs, "-tmp_class_id",  "searcy by temp. class ID", NULL);
    141142    ADD_OPT(Str, revertprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    142     ADD_OPT(S16, revertprocessedimfileArgs, "-code",          "search by fault code", 0);
     143    ADD_OPT(S16, revertprocessedimfileArgs, "-fault",          "search by fault code", 0);
    143144    ADD_OPT(S64, revertprocessedimfileArgs, "-exp_id_begin",  "search by exposure ID", 0);
    144145    ADD_OPT(S64, revertprocessedimfileArgs, "-exp_id_end",    "search by exposure ID", 0);
    … …  
    149150    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    150151    ADD_OPT(F64, updateprocessedimfileArgs, "-user_1",        "set user stat (1)", NAN);
    151     ADD_OPT(S16, updateprocessedimfileArgs, "-code",          "set fault code", INT16_MAX);
     152    ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code", INT16_MAX);
    152153
    153154    // -pendingexp
    … …  
    226227    ADD_OPT(Str,  addprocessedexpArgs, "-label",            "define label for chip stage (non-detrend data only)", NULL);
    227228    ADD_OPT(Str,  addprocessedexpArgs, "-hostname",         "define host name", NULL);
    228     ADD_OPT(S16,  addprocessedexpArgs, "-code",             "set fault code", 0);
     229    ADD_OPT(S16,  addprocessedexpArgs, "-fault",             "set fault code", 0);
    229230
    230231    // -processedexp
    … …  
    276277    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    277278    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",   0,            "search by exposure ID", 0);
    278     psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",     0,            "search by fault code", 0);
     279    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-fault",     0,            "search by fault code", 0);
    279280    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id_begin",   0,      "search by exposure ID", 0);
    280281    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id_end",   0,      "search by exposure ID", 0);
    … …  
    283284    psMetadata *updatedprocessedexpArgs = psMetadataAlloc();
    284285    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    285     psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-code",    0,            "set fault code (required)", INT16_MAX);
     286    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-fault",    0,            "set fault code (required)", INT16_MAX);
    286287
    287288    // -exportrun

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/stacktool.c

    r23352 r24244  
    617617    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    618618    PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    619     PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
     619    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    620620
    621621    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    718718
    719719    // default values
    720     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     720    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     721    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    721722
    722723    if (!psDBTransaction(config->dbh)) {
    … …  
    754755                               hostname,
    755756                               good_frac,
    756                                code
     757                               fault,
     758                               quality
    757759          )) {
    758760        if (!psDBRollback(config->dbh)) {
    … …  
    862864    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    863865    PXOPT_COPY_STR(config->args, where, "-label", "stackRun.label", "==");
    864     PXOPT_COPY_S16(config->args, where, "-code", "stackSumSkyfile.fault", "==");
     866    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    865867
    866868    if (!psDBTransaction(config->dbh)) {
    … …  
    989991
    990992    psMetadata *where = psMetadataAlloc();
    991     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     993    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    992994
    993995    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    … …  
    10531055        PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    10541056    }
    1055     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1057    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    10561058
    10571059    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    … …  
    11691171    PS_ASSERT_PTR_NON_NULL(config, false);
    11701172
    1171     PXOPT_LOOKUP_S16(code, config->args, "-code", true, false);
     1173    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    11721174
    11731175    psMetadata *where = psMetadataAlloc();
    11741176    PXOPT_COPY_S64(config->args, where, "-stack_id",   "stack_id",   "==");
    11751177
    1176     if (!pxSetFaultCode(config->dbh, "stackSumSkyfile", where, code)) {
     1178    if (!pxSetFaultCode(config->dbh, "stackSumSkyfile", where, fault)) {
    11771179        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    11781180        psFree (where);
    … …  
    11921194
    11931195  int numExportTables = 3;
    1194  
     1196
    11951197  PS_ASSERT_PTR_NON_NULL(config, NULL);
    11961198
    11971199  PXOPT_LOOKUP_S64(det_id, config->args, "-stack_id", true,  false);
    11981200  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1201  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
    11991202  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    12001203
    … …  
    12471250    }
    12481251    if (!psArrayLength(output)) {
    1249       psTrace("regtool", PS_LOG_INFO, "no rows found");
     1252      psError(PS_ERR_UNKNOWN, true, "no rows found");
    12501253      psFree(output);
    1251       return true;
    1252     }
     1254      return false;
     1255    }
     1256
     1257    if (clean) {
     1258        if (!strcmp(tables[i].tableName, "stackRun")) {
     1259            if (!pxSetStateCleaned("stackRun", "state", output)) {
     1260                psFree(output);
     1261                psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1262                return false;
     1263            }
     1264        }
     1265    }
     1266
     1267      // we must write the export table in non-simple (true) format
     1268    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1269        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1270        psFree(output);
     1271        return false;
     1272    }
     1273
    12531274    psFree(output);
    12541275  }
    … …  
    12621283{
    12631284  unsigned int nFail;
    1264  
     1285
    12651286  int numImportTables = 2;
    1266  
     1287
    12671288  char tables[2] [80] = {"stackInputSkyfile", "stackSumSkyfile"};
    12681289
    12691290  PS_ASSERT_PTR_NON_NULL(config, NULL);
    1270  
     1291
    12711292  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    12721293
    … …  
    12931314    psAssert (item, "entry not in input?");
    12941315    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1295  
     1316
    12961317    switch (i) {
    12971318      case 0:
    … …  
    13071328        }
    13081329        break;
    1309        
     1330
    13101331      case 1:
    13111332        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    13221343    }
    13231344  }
    1324  
     1345
    13251346  return true;
    13261347}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/stacktoolConfig.c

    r23352 r24244  
    114114    psMetadata *tosumArgs = psMetadataAlloc();
    115115    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    116     psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     116    psMetadataAddStr(tosumArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    117117    psMetadataAddS64(tosumArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
    118118    psMetadataAddU64(tosumArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    147147    psMetadataAddStr(addsumskyfileArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    148148    psMetadataAddF32(addsumskyfileArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    149     psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     149    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     150    psMetadataAddS16(addsumskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    150151
    151152    // -sumskyfile
    … …  
    162163    psMetadataAddS64(revertsumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    163164    psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
    164     psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     165    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    165166
    166167    // -pendingcleanuprun
    167168    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    168     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     169    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    169170    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    170171    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    172173    // -pendingcleanupskyfile
    173174    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
    174     psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     175    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    175176    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,          "search by stack ID", 0);
    176177    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    185186    psMetadata *updatesumskyfileArgs = psMetadataAlloc();
    186187    psMetadataAddS64(updatesumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "define stack ID (required)", 0);
    187     psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-code", 0,            "set fault code (required)", 0);
     188    psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-fault", 0,            "set fault code (required)", 0);
    188189
    189190    // -exportrun
    … …  
    192193    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    193194    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     195    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "mark tables as cleaned", false);
    194196
    195197    // -importrun

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptool.c

    r23594 r24244  
    3030#include "pxtools.h"
    3131#include "warptool.h"
    32 #include "pxwarp.h"
    3332
    3433static psS64 definerunMode(pxConfig *config);
    … …  
    4241static bool towarpedMode(pxConfig *config);
    4342static bool addwarpedMode(pxConfig *config);
     43static bool advancerunMode(pxConfig *config);
    4444static bool warpedMode(pxConfig *config);
    4545static bool revertwarpedMode(pxConfig *config);
    … …  
    8989        MODECASE(WARPTOOL_MODE_TOWARPED,           towarpedMode);
    9090        MODECASE(WARPTOOL_MODE_ADDWARPED,          addwarpedMode);
     91        MODECASE(WARPTOOL_MODE_ADVANCERUN,         advancerunMode);
    9192        MODECASE(WARPTOOL_MODE_WARPED,             warpedMode);
    9293        MODECASE(WARPTOOL_MODE_REVERTWARPED,       revertwarpedMode);
    … …  
    135136    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    136137    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    137     PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
     138    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
    138139    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    139140    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    191192
    192193    psMetadata *where = psMetadataAlloc();
    193     pxwarpGetSearchArgs (config, where);
    194     PXOPT_COPY_STR(config->args, where, "-reduction", "fakeRun.reduction", "==");
    195     PXOPT_COPY_STR(config->args, where, "-label",     "fakeRun.label",     "==");
     194    PXOPT_COPY_S64(config->args, where, "-fake_id",            "fakeRun.fake_id",       "==");
     195    PXOPT_COPY_S64(config->args, where, "-cam_id",             "camRun.cam_id",         "==");
     196    PXOPT_COPY_S64(config->args, where, "-chip_id",            "chipRun.chip_id",       "==");
     197    PXOPT_COPY_S64(config->args, where, "-exp_id",             "rawExp.exp_id",         "==");
     198    PXOPT_COPY_STR(config->args, where, "-exp_name",           "rawExp.exp_name",       "==");
     199    PXOPT_COPY_STR(config->args, where, "-inst",               "rawExp.camera",         "==");
     200    PXOPT_COPY_STR(config->args, where, "-telescope",          "rawExp.telescope",      "==");
     201    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin",     "rawExp.dateobs",        ">=");
     202    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",       "rawExp.dateobs",        "<=");
     203    PXOPT_COPY_STR(config->args, where, "-exp_tag",            "rawExp.exp_tag",        "==");
     204    PXOPT_COPY_STR(config->args, where, "-exp_type",           "rawExp.exp_type",       "==");
     205    PXOPT_COPY_STR(config->args, where, "-filelevel",          "rawExp.filelevel",      "==");
     206    PXOPT_COPY_STR(config->args, where, "-filter",             "rawExp.filter",         "==");
     207    PXOPT_COPY_F64(config->args, where, "-airmass_min",        "rawExp.airmass",        ">=");
     208    PXOPT_COPY_F64(config->args, where, "-airmass_max",        "rawExp.airmass",        "<");
     209    PXOPT_COPY_F64(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
     210    PXOPT_COPY_F64(config->args, where, "-ra_max",             "rawExp.ra",             "<");
     211    PXOPT_COPY_F64(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
     212    PXOPT_COPY_F64(config->args, where, "-decl_max",           "rawExp.decl",           "<");
     213    PXOPT_COPY_F32(config->args, where, "-exp_time_min",       "rawExp.exp_time",       ">=");
     214    PXOPT_COPY_F32(config->args, where, "-exp_time_max",       "rawExp.exp_time",       "<");
     215    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
     216    PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
     217    PXOPT_COPY_F64(config->args, where, "-bg_min",             "rawExp.bg",             ">=");
     218    PXOPT_COPY_F64(config->args, where, "-bg_max",             "rawExp.bg",             "<");
     219    PXOPT_COPY_F64(config->args, where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
     220    PXOPT_COPY_F64(config->args, where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
     221    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
     222    PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
     223    PXOPT_COPY_F64(config->args, where, "-alt_min",            "rawExp.alt",            ">=");
     224    PXOPT_COPY_F64(config->args, where, "-alt_max",            "rawExp.alt",            "<");
     225    PXOPT_COPY_F64(config->args, where, "-az_min",             "rawExp.az",             ">=");
     226    PXOPT_COPY_F64(config->args, where, "-az_max",             "rawExp.az",             "<");
     227    PXOPT_COPY_F32(config->args, where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
     228    PXOPT_COPY_F32(config->args, where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
     229    PXOPT_COPY_F64(config->args, where, "-posang_min",         "rawExp.posang",         ">=");
     230    PXOPT_COPY_F64(config->args, where, "-posang_max",         "rawExp.posang",         "<");
     231    PXOPT_COPY_STR(config->args, where, "-object",             "rawExp.object",         "==");
     232    PXOPT_COPY_F32(config->args, where, "-solang_min",         "rawExp.solang",         ">=");
     233    PXOPT_COPY_F32(config->args, where, "-solang_max",         "rawExp.solang",         "<");
     234    PXOPT_COPY_STR(config->args, where, "-reduction",          "fakeRun.reduction",     "==");
     235    pxAddLabelSearchArgs (config, where, "-label",             "fakeRun.label",         "==");
    196236
    197237    if (!psListLength(where->list) &&
    … …  
    227267
    228268    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
    229     if (where && psListLength(where->list)) {
    230         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    231         psStringAppend(&query, "%s", whereClause);
     269    if (psListLength(where->list)) {
     270        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     271        psStringAppend(&query, "AND %s", whereClause);
    232272        psFree(whereClause);
    233273    }
    … …  
    256296    // data out so we have the option of changing these values or leaving the
    257297    // old values in place (i.e., passing the values through).
     298
     299    // loop over our list of fakeRun rows to check the supplied and selected tess_id values:
     300    for (long i = 0; i < psArrayLength(output); i++) {
     301        psMetadata *md = output->data[i];
     302
     303        fakeRunRow *row = fakeRunObjectFromMetadata(md);
     304        if (!row) {
     305            psError(PS_ERR_UNKNOWN, false, "failed to convert metadata into fakeRun");
     306            psFree(output);
     307            return false;
     308        }
     309
     310        if (!tess_id  && !row->tess_id) {
     311            psError(PS_ERR_UNKNOWN, false, "cannot queue warp run without a defined tess id: label: %s, fake_id %" PRId64, row->label, row->fake_id);
     312            psFree(output);
     313            return false;
     314        }
     315
     316        psFree(row);
     317    }
     318    psFree(output);
    258319
    259320    // loop over our list of fakeRun rows
    … …  
    299360
    300361    psMetadata *where = psMetadataAlloc();
    301     pxwarpGetSearchArgs (config, where);
    302362    PXOPT_COPY_S64(config->args, where, "-warp_id",   "warpRun.warp_id",   "==");
    303363    PXOPT_COPY_STR(config->args, where, "-reduction", "warpRun.reduction", "==");
    304     PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
    305     PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
     364    PXOPT_COPY_STR(config->args, where, "-label",     "warpRun.label",     "==");
     365    PXOPT_COPY_STR(config->args, where, "-state",     "warpRun.state",     "==");
    306366
    307367    if (!psListLength(where->list)
    … …  
    498558    psMetadata *where = psMetadataAlloc();
    499559    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    500     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     560    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    501561
    502562    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    572632    PXOPT_LOOKUP_STR(mapfile, config->args, "-mapfile", false, false);
    573633    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
    574     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     634    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    575635
    576636    if (!psDBTransaction(config->dbh)) {
    … …  
    579639    }
    580640
    581     if (code == 0) {
     641    if (fault == 0) {
    582642        if (!parseAndInsertSkyCellMap(config, mapfile)) {
    583643            psError(PS_ERR_UNKNOWN, false, "failed to inject mapfile: %s into the database", mapfile);
    … …  
    594654            NULL,   // tess_id
    595655            NULL,   // class_id
    596             code    // fault
     656            fault    // fault
    597657        );
    598658    }
    … …  
    770830    psMetadata *where = psMetadataAlloc();
    771831    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpSkyCellMap.warp_id", "==");
    772     PXOPT_COPY_STR(config->args, where, "-label", "warpRun.label", "==");
     832    pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    773833
    774834    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    859919    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    860920    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    861     PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    862921    PXOPT_LOOKUP_BOOL(magicked, config->args, "-magicked", false);
    863922
    864923    // default values
    865     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     924    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
     925    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    866926
    867927    // we don't want to insert the last skyfile in a run but then not mark the
    … …  
    890950                           ymin,
    891951                           ymax,
    892                            !accept,
    893                            code,
     952                           fault,
     953                           quality,
    894954                           magicked
    895955        )) {
    … …  
    901961    }
    902962
    903     if (!warpCompletedRuns(config)) {
    904         if (!psDBRollback(config->dbh)) {
    905             psError(PS_ERR_UNKNOWN, false, "database error");
    906         }
    907         psError(PS_ERR_UNKNOWN, false, "database error");
    908         return false;
    909     }
    910 
    911963    // point of no return
    912964    if (!psDBCommit(config->dbh)) {
    … …  
    914966        return false;
    915967    }
     968
     969    return true;
     970}
     971
     972static bool advancerunMode(pxConfig *config)
     973{
     974    PS_ASSERT_PTR_NON_NULL(config, false);
     975
     976    psMetadata *where = psMetadataAlloc();
     977    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     978    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     979
     980    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     981
     982    psString query = pxDataGet("warptool_finished_run_select.sql");
     983    if (!query) {
     984        psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     985        return false;
     986    }
     987
     988    if (psListLength(where->list)) {
     989        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     990        psStringAppend(&query, " %s", whereClause);
     991        psFree(whereClause);
     992    }
     993    psFree(where);
     994
     995    if (!p_psDBRunQuery(config->dbh, query)) {
     996        psError(PS_ERR_UNKNOWN, false, "database error");
     997        psFree(query);
     998        return false;
     999    }
     1000    psFree(query);
     1001
     1002    psArray *output = p_psDBFetchResult(config->dbh);
     1003    if (!output) {
     1004        psError(PS_ERR_UNKNOWN, false, "database error");
     1005        return false;
     1006    }
     1007    if (!psArrayLength(output)) {
     1008        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1009        psFree(output);
     1010        return true;
     1011    }
     1012
     1013    query = pxDataGet("warptool_finish_run.sql");
     1014    for (long i = 0; i < psArrayLength(output); i++) {
     1015        psMetadata *row = output->data[i];
     1016
     1017        bool status;
     1018        psS64 warp_id = psMetadataLookupS64(&status, row, "warp_id");
     1019        if (!status) {
     1020            psError(PS_ERR_UNKNOWN, false, "failed to look up value for warp_id");
     1021            psFree(output);
     1022            psFree(query);
     1023            return false;
     1024        }
     1025        psS32 magicked = psMetadataLookupS64(&status, row, "magicked");
     1026        if (!status) {
     1027            psError(PS_ERR_UNKNOWN, false, "failed to look up value for magicked");
     1028            psFree(output);
     1029            psFree(query);
     1030            return false;
     1031        }
     1032        if (!p_psDBRunQueryF(config->dbh, query, magicked, warp_id)) {
     1033            psError(PS_ERR_UNKNOWN, false, "database error");
     1034            psFree(output);
     1035            psFree(query);
     1036            return false;
     1037        }
     1038
     1039        psS64 numUpdated = psDBAffectedRows(config->dbh);
     1040
     1041        if (numUpdated != 1) {
     1042            psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1043            psFree(query);
     1044            psFree(output);
     1045            return false;
     1046        }
     1047    }
     1048    psFree(output);
     1049    psFree(query);
    9161050
    9171051    return true;
    … …  
    10701204
    10711205    psMetadata *where = psMetadataAlloc();
    1072     pxwarpGetSearchArgs (config, where);
    10731206    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
    10741207    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    … …  
    10761209    PXOPT_COPY_STR(config->args, where, "-reduction",  "rawExp.reduction", "==");
    10771210    PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
    1078     PXOPT_COPY_S16(config->args, where, "-code",       "warpSkyfile.fault", "==");
     1211    PXOPT_COPY_S16(config->args, where, "-fault",       "warpSkyfile.fault", "==");
    10791212
    10801213    if (!psListLength(where->list)
    … …  
    10921225
    10931226
     1227#ifdef notdef
     1228    int numUpdated = 0;                     // Number updated
     1229    {
    10941230    // Update state to 'new'
    1095     int numUpdated;                     // Number updated
    1096     {
    10971231        // This query is no longer necessary because we do not set warpRun's to full statte
    10981232        // if they have faulted skyfiles.
    … …  
    11401274    psLogMsg("warptool", PS_LOG_INFO, "Updated %d warp runs", numUpdated);
    11411275
     1276#endif // notdef
     1277
    11421278    // Delete product
    11431279    int numDeleted;                     // Number deleted
    … …  
    12611397
    12621398    psMetadata *where = psMetadataAlloc();
    1263     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1399    pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    12641400
    12651401    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    … …  
    13241460    psMetadata *where = psMetadataAlloc();
    13251461    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    1326     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1462    pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    13271463
    13281464    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    … …  
    15241660    PS_ASSERT_PTR_NON_NULL(config, false);
    15251661
    1526     // warp_id, skycell_id, code are required
     1662    // warp_id, skycell_id, fault are required
    15271663    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
    15281664    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
    1529     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
     1665    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    15301666
    15311667    psString query = pxDataGet("warptool_updateskyfile.sql");
    15321668
    1533     if (!p_psDBRunQueryF(config->dbh, query, code, warp_id, skycell_id)) {
     1669    if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    15341670        psError(PS_ERR_UNKNOWN, false, "database error");
    15351671        return false;
    … …  
    15491685    PS_ASSERT_PTR_NON_NULL(config, NULL);
    15501686
    1551     PXOPT_LOOKUP_S64(det_id, config->args, "-warp_id", true,  false);
     1687    PXOPT_LOOKUP_S64(det_id,  config->args, "-warp_id", true,  false);
    15521688    PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    15531689    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1690    PXOPT_LOOKUP_BOOL(clean,  config->args, "-clean", false);
    15541691
    15551692    FILE *f = fopen (outfile, "w");
    … …  
    15661703      {"warpImfile", "warptool_export_imfile.sql"},
    15671704      {"warpSkyfile", "warptool_export_skyfile.sql"},
    1568       {"warpSkyCellMap", "warptool_export_sky_cell_map.sql"},
     1705      {"warpSkyCellMap", "warptool_export_skycell_map.sql"},
    15691706    };
    15701707
    1571 
    1572     for (int i=0; i < sizeof(tables); i++) {
     1708    int numTables = sizeof(tables)/sizeof(tables[0]);
     1709
     1710    for (int i=0; i < numTables; i++) {
    15731711      psString query = pxDataGet(tables[i].sqlFilename);
    15741712      if (!query) {
    … …  
    16031741      }
    16041742      if (!psArrayLength(output)) {
    1605         psTrace("regtool", PS_LOG_INFO, "no rows found");
     1743        psError(PS_ERR_UNKNOWN, true, "no rows found");
    16061744        psFree(output);
    1607         return true;
     1745        return false;
    16081746      }
     1747
     1748    if (clean) {
     1749        bool success = true;
     1750        if (!strcmp(tables[i].tableName, "warpRun")) {
     1751            success = pxSetStateCleaned("warpRun", "state", output);
     1752        } else if (!strcmp(tables[i].tableName, "warpSkyfile")) {
     1753            success = pxSetStateCleaned("warpSkyfile", "data_state", output);
     1754        }
     1755        if (!success) {
     1756            psFree(output);
     1757            psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     1758            return false;
     1759        }
     1760    }
    16091761
    16101762      // we must write the export table in non-simple (true) format
    … …  
    16271779
    16281780  int numImportTables = 3;
    1629  
     1781
    16301782  char tables[3] [80] = {"warpImfile", "warpSkyfile", "warpSkyCellMap"};
    16311783
    16321784  PS_ASSERT_PTR_NON_NULL(config, NULL);
    1633  
     1785
    16341786  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    16351787
    … …  
    16421794  psAssert (item, "entry not in input?");
    16431795  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1644  
     1796
    16451797  psMetadataItem *entry = psListGet (item->data.list, 0);
    16461798  assert (entry);
    … …  
    16561808    psAssert (item, "entry not in input?");
    16571809    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1658    
     1810
    16591811    switch (i) {
    1660       case 0: 
     1812      case 0:
    16611813        for (int i = 0; i < item->data.list->n; i++) {
    16621814          entry = psListGet (item->data.list, i);
    … …  
    16701822        }
    16711823        break;
    1672        
    1673       case 1: 
     1824
     1825      case 1:
    16741826        for (int i = 0; i < item->data.list->n; i++) {
    16751827          entry = psListGet (item->data.list, i);
    … …  
    16831835        }
    16841836        break;
    1685        
    1686       case 2: 
     1837
     1838      case 2:
    16871839        for (int i = 0; i < item->data.list->n; i++) {
    16881840          entry = psListGet (item->data.list, i);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptool.h

    r23352 r24244  
    3737    WARPTOOL_MODE_TOWARPED,
    3838    WARPTOOL_MODE_ADDWARPED,
     39    WARPTOOL_MODE_ADVANCERUN,
    3940    WARPTOOL_MODE_WARPED,
    4041    WARPTOOL_MODE_REVERTWARPED,

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptoolConfig.c

    r23594 r24244  
    5151    // XXX need to allow multiple exp_ids
    5252    psMetadata *definebyqueryArgs = psMetadataAlloc();
    53     pxwarpSetSearchArgs (definebyqueryArgs);
     53    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-fake_id",            0, "search by fake_id", 0);
     54    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-cam_id",             0, "search by cam_id", 0);
     55    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",            0, "search by chip_id", 0);
     56    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",             0, "search by exp_id", 0);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_name",           0, "search by exp_name", NULL);
     58    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-inst",               0, "search for camera", NULL);
     59    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
     60    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin",     0, "search for exposures by time (>=)", NULL);
     61    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-dateobs_end",       0, "search for exposures by time (<)", NULL);
     62    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
     63    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);
     64    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filelevel",          0, "search by filelevel", NULL);
     65    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter",             0, "search for filter", NULL);
     66    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
     67    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
     68    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_min",             0, "search by min", NAN);
     69    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_max",             0, "search by max", NAN);
     70    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_min",           0, "search by min", NAN);
     71    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_max",           0, "search by max", NAN);
     72    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",       0, "search by min", NAN);
     73    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",       0, "search by max", NAN);
     74    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by max fraction of saturated pixels", NAN);
     75    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by min fraction of saturated pixels", NAN);
     76    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_min",             0, "search by max", NAN);
     77    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_max",             0, "search by max", NAN);
     78    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "search by max", NAN);
     79    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max", NAN);
     80    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by max", NAN);
     81    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max", NAN);
     82    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_min",            0, "search by min", NAN);
     83    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_max",            0, "search by max", NAN);
     84    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_min",             0, "search by min", NAN);
     85    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_max",             0, "search by max", NAN);
     86    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
     87    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
     88    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
     89    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
     90    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
     91    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
     92    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
    5493    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    55     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",              0, "search on fakeRun label", NULL);
     94    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", NULL);
    5695    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_mode",           0, "define mode (warp, diff, stack, magic)", NULL);
    5796    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir",        0, "define workdir", NULL);
    … …  
    83122    // XXX need to allow multiple exp_ids
    84123    psMetadata *updaterunArgs = psMetadataAlloc();
    85     pxwarpSetSearchArgs (updaterunArgs);
    86124    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,    "search by warptool ID", 0);
    87125    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction", 0,  "search by warpRun reduction class", NULL);
    … …  
    109147    psMetadata *tooverlapArgs = psMetadataAlloc();
    110148    psMetadataAddS64(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
    111     psMetadataAddStr(tooverlapArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     149    psMetadataAddStr(tooverlapArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    112150    psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    113151    psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    117155    psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,            "path to skycell <-> imfile mapping file", NULL);
    118156    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,            "set warp ID", 0);
    119     psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     157    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    120158
    121159    // -scmap
    … …  
    131169    psMetadata *towarpedArgs = psMetadataAlloc();
    132170    psMetadataAddS64(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
    133     psMetadataAddStr(towarpedArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     171    psMetadataAddStr(towarpedArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    134172    psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    135173    psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    152190    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    153191    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    154     psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-accept",  0, "define if this skycell should be accepted", false);
    155192    psMetadataAddBool(addwarpedArgs, PS_LIST_TAIL, "-magicked",  0, "define if this skycell has been magicked", false);
    156     psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
     193    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     194    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    157195
    158196    // -warped
    … …  
    173211    // XXX need to allow multiple exp_ids
    174212    psMetadata *revertwarpedArgs = psMetadataAlloc();
    175     pxwarpSetSearchArgs(revertwarpedArgs); // XXX does this work here?
    176213    psMetadataAddS64(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
    177214    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "search by skycell ID", NULL);
    … …  
    179216    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,            "search by warpRun reduction class", NULL);
    180217    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-label",  0,            "search by warpRun label", NULL);
    181     psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     218    psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    182219    psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     220
     221    // -advancerun
     222    psMetadata *advancerunArgs = psMetadataAlloc();
     223    psMetadataAddS64(advancerunArgs, PS_LIST_TAIL, "-warp_id", 0,      "search by warp ID", 0);
     224    psMetadataAddStr(advancerunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label ", NULL);
     225    psMetadataAddU64(advancerunArgs, PS_LIST_TAIL, "-limit",  0,       "limit exposures to advance to N items", 0);
    183226
    184227    // -block
    … …  
    196239    // -pendingcleanuprun
    197240    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    198     psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     241    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    199242    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    200243    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    202245    // -pendingcleanupskyfile
    203246    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
    204     psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     247    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    205248    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,          "search by warp ID (required)", 0);
    206249    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    232275    psMetadataAddS64(updateskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    233276    psMetadataAddStr(updateskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    234     psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-code",  0,      "new fault code", 0);
     277    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-fault",  0,      "new fault code", 0);
    235278
    236279    // -exportrun
    … …  
    239282    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
    240283    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     284    psMetadataAddBool(exportrunArgs, PS_LIST_TAIL, "-clean",  0,          "export run in cleaned state", false);
    241285
    242286    // -importrun
    … …  
    259303    PXOPT_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
    260304    PXOPT_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
     305    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    261306    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    262307    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
Note: See TracChangeset for help on using the changeset viewer.