IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18496


Ignore:
Timestamp:
Jul 13, 2008, 11:21:45 AM (18 years ago)
Author:
eugene
Message:

cleanup command-line argument handling; deprecate config.where

Location:
branches/eam_branch_20080706/ippTools/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

  • branches/eam_branch_20080706/ippTools/src/guidetool.c

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

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

    r18468 r18496  
    5252    // -pending search
    5353    psMetadata *pendingArgs = psMetadataAlloc();
    54     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,
    55         "define exposure ID", NULL);
    56     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,
    57         "define camera of interest", NULL);
    58     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,
    59         "define telescope of interest", NULL);
    60     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,
    61         "define exposure type", NULL);
    62     psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-imfiles",  0,
    63         "define number of imfiles", 0);
    64     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,
    65         "define filter of interest", NULL);
    66     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-recipe",  0,
    67         "define recipe of interest", NULL);
    68     psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-guide_version",  0,
    69         "define guide_version of interest", 0);
     54    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,        "define exposure ID", NULL);
     55    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,        "define camera of interest", NULL);
     56    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-telescope",  0,        "define telescope of interest", NULL);
     57    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,        "define exposure type", NULL);
     58    psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-imfiles",  0,        "define number of imfiles", 0);
     59    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-filter",  0,        "define filter of interest", NULL);
     60    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-recipe",  0,        "define recipe of interest", NULL);
     61    psMetadataAddS32(pendingArgs, PS_LIST_TAIL, "-guide_version",  0,        "define guide_version of interest", 0);
    7062
    7163    // -define inputs
    7264    psMetadata *defineArgs = psMetadataAlloc();
    73     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_id",  0,
    74         "define class", NULL);
    75     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-inst",  0,
    76         "define camera of interest", NULL);
    77     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-telescope",  0,
    78         "define camera of interest", NULL);
    79     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_type",  0,
    80         "define class", NULL);
    81     psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-imfiles",  0,
    82         "define number of imfiles", 0);
    83     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-filter",  0,
    84         "define filter of interest", NULL);
     65    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_id",  0,        "define class", NULL);
     66    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-inst",  0,        "define camera of interest", NULL);
     67    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-telescope",  0,        "define camera of interest", NULL);
     68    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-exp_type",  0,        "define class", NULL);
     69    psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-imfiles",  0,        "define number of imfiles", 0);
     70    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-filter",  0,        "define filter of interest", NULL);
    8571    // these two are inputs NOT search parameters
    86     psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-recipe",  0,
    87         "define recipe of interest", NULL);
    88     psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-guide_version",  0,
    89         "define guide_version of interest", 0);
     72    psMetadataAddStr(defineArgs, PS_LIST_TAIL, "-recipe",  0,        "define recipe of interest", NULL);
     73    psMetadataAddS32(defineArgs, PS_LIST_TAIL, "-guide_version",  0,        "define guide_version of interest", 0);
    9074
    9175    // find which mode we're running under
    … …  
    146130    psFree(defineArgs);
    147131
    148     // generate SQL where clause
    149     config->where = psMetadataAlloc();
    150 
    151     PXOPT_ADD_WHERE_STR_ALIAS("-inst","camera");
    152     PXOPT_ADD_WHERE_STR(telescope);
    153     PXOPT_ADD_WHERE_STR(exp_type);
    154     PXOPT_ADD_WHERE_S32(imfiles);
    155     PXOPT_ADD_WHERE_STR(filter);
    156     PXOPT_ADD_WHERE_STR(stats);
    157     PXOPT_ADD_WHERE_STR(recipe);
    158     PXOPT_ADD_WHERE_S32(guide_version);
    159 
    160     if (config->where->list->n < 1) {
    161         psFree(config->where);
    162         config->where = NULL;
    163     }
    164 
    165132    // define Database handle, if used
    166133    config->dbh = psMemIncrRefCounter(pmConfigDB(config->modules));

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

    r18336 r18496  
    103103
    104104    // create warped skycells temp table
    105 {
    106     char *query =
    107         "CREATE TEMPORARY TABLE warpComplete\n"
    108         " (warp_id BIGINT, skycell_id VARCHAR(64), tess_id VARCHAR(64),\n"
    109         " PRIMARY KEY(warp_id, skycell_id, tess_id)) ENGINE=MEMORY\n";
    110 
    111     if (!p_psDBRunQuery(config->dbh, query)) {
    112         psError(PS_ERR_UNKNOWN, false, "database error");
    113         return false;
    114     }
    115 }
     105    {
     106        psString query = pxDataGet("magictool_create_tmp_warpcomplete.sql");
     107        if (!query) {
     108            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     109            return false;
     110        }
     111
     112        if (!p_psDBRunQuery(config->dbh, query)) {
     113            psError(PS_ERR_UNKNOWN, false, "database error");
     114            return false;
     115        }
     116    }
    116117
    117118    // find warped skycells
    118 {
    119     psString query = pxDataGet("magictool_find_complete_warpruns.sql");
    120     if (!query) {
    121         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    122         return false;
    123     }
    124 
    125     if (!p_psDBRunQuery(config->dbh, query)) {
    126         psError(PS_ERR_UNKNOWN, false, "database error");
    127         psFree(query);
    128         return false;
    129     }
    130     psFree(query);
    131 }
     119    {
     120        psString query = pxDataGet("magictool_find_complete_warpruns.sql");
     121        if (!query) {
     122            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     123            return false;
     124        }
     125
     126        if (!p_psDBRunQuery(config->dbh, query)) {
     127            psError(PS_ERR_UNKNOWN, false, "database error");
     128            psFree(query);
     129            return false;
     130        }
     131        psFree(query);
     132    }
    132133
    133134    // find the diff_id's of the warped skycells
    134 {
    135     psString query = pxDataGet("magictool_find_complete_diffed_exposures.sql");
    136     if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    138         return false;
    139     }
    140 
    141     if (!p_psDBRunQuery(config->dbh, query)) {
    142         psError(PS_ERR_UNKNOWN, false, "database error");
    143         psFree(query);
    144         return false;
    145     }
    146     psFree(query);
    147 }
     135    {
     136        psString query = pxDataGet("magictool_find_complete_diffed_exposures.sql");
     137        if (!query) {
     138            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     139            return false;
     140        }
     141
     142        if (!p_psDBRunQuery(config->dbh, query)) {
     143            psError(PS_ERR_UNKNOWN, false, "database error");
     144            psFree(query);
     145            return false;
     146        }
     147        psFree(query);
     148    }
    148149    psArray *output = p_psDBFetchResult(config->dbh);
    149150    if (!output) {
    150151        psErrorCode err = psErrorCodeLast();
    151152        switch (err) {
    152             case PS_ERR_DB_CLIENT:
    153                 psError(PXTOOLS_ERR_SYS, false, "database error");
    154             case PS_ERR_DB_SERVER:
    155                 psError(PXTOOLS_ERR_PROG, false, "database error");
    156             default:
    157                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
     153          case PS_ERR_DB_CLIENT:
     154            psError(PXTOOLS_ERR_SYS, false, "database error");
     155          case PS_ERR_DB_SERVER:
     156            psError(PXTOOLS_ERR_PROG, false, "database error");
     157          default:
     158            psError(PXTOOLS_ERR_PROG, false, "unknown error");
    158159        }
    159160
    … …  
    205206
    206207        magicRunRow *run = magicRunRowAlloc(
    207                 0,          // ID
    208                 "reg",      // state
    209                 NULL,       // workdir
    210                 "dirty",    // workdir_state
    211                 NULL,       // label
    212                 NULL,       // dvodb
    213                 NULL        // registered
    214         );
     208            0,          // ID
     209            "reg",      // state
     210            NULL,       // workdir
     211            "dirty",    // workdir_state
     212            NULL,       // label
     213            NULL,       // dvodb
     214            NULL        // registered
     215            );
    215216        if (!run) {
    216217            psAbort("failed to alloc magicRun object");
    … …  
    241242
    242243            if (!magicInputSkyfileInsert(config->dbh,
    243                 magic_id,
    244                 diff_id,
    245                 node)) {
     244                                        magic_id,
     245                                        diff_id,
     246                                        node)) {
    246247                psError(PS_ERR_UNKNOWN, false, "database error");
    247248                psFree(grouped);
    … …  
    268269    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    269270    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
     271    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    270272    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    271     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    272273
    273274    magicRunRow *run = magicRunRowAlloc(
    … …  
    348349    PS_ASSERT_PTR_NON_NULL(config, false);
    349350
     351    psMetadata *where = psMetadataAlloc();
     352    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     353    PXOPT_COPY_STR(config->args, where, "-diff_id", "diff_id", "==");
     354    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
     355
    350356    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    351357    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    358364    }
    359365
    360     if (config->where) {
    361         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "magicInputSkyfile");
     366    if (psListLength(where->list)) {
     367        psString whereClause = psDBGenerateWhereConditionSQL(where, "magicInputSkyfile");
    362368        psStringAppend(&query, " AND %s", whereClause);
    363369        psFree(whereClause);
    364370    }
     371    psFree(where);
    365372
    366373    // treat limit == 0 as "no limit"
    … …  
    500507    PS_ASSERT_PTR_NON_NULL(config, false);
    501508
    502     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", false, false);
     509    psMetadata *where = psMetadataAlloc();
     510    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     511
     512    psString whereClause = NULL;
     513    if (psListLength(where->list)) {
     514        whereClause = psDBGenerateWhereSQL(where, NULL);
     515    }
     516    psFree(where);
     517
    503518    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    504519
    … …  
    510525    }
    511526
    512     if (magic_id) {
    513         psMetadata *where = psMetadataAlloc();
    514         psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
    515         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    516         psFree(where);
     527    if (whereClause) {
    517528        psStringAppend(&query, " %s", whereClause);
    518         psFree(whereClause);
    519529    }
    520530
    … …  
    542552    if (!psArrayLength(output)) {
    543553        psTrace("magictool", PS_LOG_INFO, "no rows found");
    544 //        psFree(output);
    545 //        return true;
     554        // psFree(output);
     555        // return true;
    546556    }
    547557
    … …  
    553563    }
    554564
    555 
    556     if (magic_id) {
    557         psMetadata *where = psMetadataAlloc();
    558         psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
    559         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    560         psFree(where);
     565    if (whereClause) {
    561566        psStringAppend(&query, " %s", whereClause);
    562         psFree(whereClause);
    563567    }
    564568
    … …  
    613617    pxNode *root = psHashLookup(forest, "root");
    614618    psFree(forest);
    615 //    pxTreePrint(stdout, root);
     619    // pxTreePrint(stdout, root);
    616620
    617621    // crawl through the tree and looking for nodes with children that are all
    … …  
    630634
    631635    psFree(output);
     636    psFree(whereClause);
    632637
    633638    return true;
    … …  
    744749    PS_ASSERT_PTR_NON_NULL(config, false);
    745750
     751    psMetadata *where = psMetadataAlloc();
     752    PXOPT_COPY_STR(config->args, where, "-magic_id", "magic_id", "==");
     753
    746754    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    747755    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    752760        return false;
    753761    }
     762
     763    if (psListLength(where->list)) {
     764        psString whereClause = psDBGenerateWhereConditionSQL(where, "magicRun");
     765        psStringAppend(&query, " AND %s", whereClause);
     766        psFree(whereClause);
     767    }
     768    psFree(where);
    754769
    755770    // treat limit == 0 as "no limit"

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

    r18468 r18496  
    5252    // -definerun
    5353    psMetadata *definerunArgs = psMetadataAlloc();
    54     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    55             "define workdir (required)", NULL);
    56     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,
    57             "define label", NULL);
    58     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
    59             "define dvodb", NULL);
    60     psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    61             "time detrend run was registered", now);
    62     psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,
    63             "use the simple output format", false);
     54    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
     55    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
     56    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
     57    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
     58    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    6459
    6560    // -updaterun
    6661    psMetadata *updaterunArgs = psMetadataAlloc();
    67     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0,
    68             "define warptool ID (required)", NULL);
    69     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    70             "set state (required)", NULL);
    71 #if 0
    72     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-workdir", 0,
    73             "define workdir (required)", NULL);
    74     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-registered",  0,
    75             "time detrend run was registered", now);
    76 #endif
     62    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0,            "define warptool ID (required)", NULL);
     63    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state (required)", NULL);
    7764
    7865    // -addinputskyfile
    7966    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    80     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,
    81             "define magictool ID (required)", NULL);
    82     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    83             "define difftool ID (required)", NULL);
    84     psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node",  0,
    85             "define symbolic node name (required)", NULL);
     67    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     68    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "define difftool ID (required)", NULL);
     69    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node",  0,            "define symbolic node name (required)", NULL);
    8670
    8771    // -inputskyfile
    8872    psMetadata *inputskyfileArgs = psMetadataAlloc();
    89     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,
    90             "search by magictool ID", NULL);
    91     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    92             "search by difftool ID", NULL);
    93     psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-node",  0,
    94             "search by symbolic node name", NULL);
    95     psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    96             "limit result set to N items", 0);
    97     psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,
    98             "use the simple output format", false);
     73    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magictool ID", NULL);
     74    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,            "search by difftool ID", NULL);
     75    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-node",  0,            "search by symbolic node name", NULL);
     76    psMetadataAddU64(inputskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     77    psMetadataAddBool(inputskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    9978
    10079    // -inputtree
    10180    psMetadata *inputtreeArgs = psMetadataAlloc();
    102     psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0,
    103             "define magictool ID (required)", NULL);
    104     psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0,
    105             "order of operations dep. file (required)", NULL);
     81    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     82    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0,            "order of operations dep. file (required)", NULL);
    10683
    10784    // -tooprocess
    10885    psMetadata *toprocessArgs = psMetadataAlloc();
    109     psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0,
    110             "search by magic ID", NULL);
    111     psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit",  0,
    112             "limit result set to N items", 0);
    113     psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple",  0,
    114             "use the simple output format", false);
     86    psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magic ID", NULL);
     87    psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     88    psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    11589
    11690    // -addresult
    11791    psMetadata *addresultArgs = psMetadataAlloc();
    118     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-magic_id", 0,
    119             "define magictool ID (required)", NULL);
    120     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node",  0,
    121             "define symbolic node name (required)", NULL);
    122     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri",  0,
    123             "define URI (required)", NULL);
     92    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     93    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node",  0,            "define symbolic node name (required)", NULL);
     94    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri",  0,            "define URI (required)", NULL);
    12495
    12596    // -tomask
    12697    psMetadata *tomaskArgs = psMetadataAlloc();
    127     psMetadataAddU64(tomaskArgs, PS_LIST_TAIL, "-limit",  0,
    128             "limit result set to N items", 0);
    129     psMetadataAddBool(tomaskArgs, PS_LIST_TAIL, "-simple",  0,
    130             "use the simple output format", false);
     98    psMetadataAddU64(tomaskArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     99    psMetadataAddBool(tomaskArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    131100
    132101    // -addmask
    133102    psMetadata *addmaskArgs = psMetadataAlloc();
    134     psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0,
    135             "define magictool ID (required)", NULL);
    136     psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri",  0,
    137             "define URI (required)", NULL);
     103    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     104    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri",  0,            "define URI (required)", NULL);
    138105
    139106    // -toskyfilemask
    140107    psMetadata *toskyfilemaskArgs = psMetadataAlloc();
    141     psMetadataAddStr(toskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,
    142             "search by magic ID", NULL);
    143     psMetadataAddU64(toskyfilemaskArgs, PS_LIST_TAIL, "-limit",  0,
    144             "limit result set to N items", 0);
    145     psMetadataAddBool(toskyfilemaskArgs, PS_LIST_TAIL, "-simple",  0,
    146             "use the simple output format", false);
     108    psMetadataAddStr(toskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,            "search by magic ID", NULL);
     109    psMetadataAddU64(toskyfilemaskArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     110    psMetadataAddBool(toskyfilemaskArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    147111
    148112    // -addskyfilemask
    149113    psMetadata *addskyfilemaskArgs = psMetadataAlloc();
    150     psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,
    151             "define magictool ID (required)", NULL);
    152     psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-diff_id",  0,
    153             "define difftool ID (required)", NULL);
    154     psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-uri",  0,
    155             "define URI (required)", NULL);
     114    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,            "define magictool ID (required)", NULL);
     115    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-diff_id",  0,            "define difftool ID (required)", NULL);
     116    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-uri",  0,            "define URI (required)", NULL);
    156117
    157118    psFree(now);
    … …  
    184145    psFree(modes);
    185146
    186     // generate SQL where clause
    187     config->where = psMetadataAlloc();
    188 
    189     PXOPT_ADD_WHERE_S64(warp_id);
    190     PXOPT_ADD_WHERE_STR(skycell_id);
    191     PXOPT_ADD_WHERE_STR(tess_id);
    192     PXOPT_ADD_WHERE_STR(exp_id);
    193     PXOPT_ADD_WHERE_STR_ALIAS("-code", "fault");
    194 
    195     if (config->where->list->n < 1) {
    196         psFree(config->where);
    197         config->where = NULL;
    198     }
    199 
    200147    // define Database handle, if used
    201148    // do this last so we don't setup a connection before CLI options are

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

    r18377 r18496  
    100100    PS_ASSERT_PTR_NON_NULL(config, false);
    101101
    102     bool status = false;
    103     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    104     if (!status) {
    105         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    106         return false;
    107     }
    108     if (!uri) {
    109         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    110         return false;
    111     }
    112     psString outProduct = psMetadataLookupStr(&status, config->args, "-out_product");
    113     if (!status) {
    114         psError(PS_ERR_UNKNOWN, false, "failed to looku value for -out_product");
    115         return false;
    116     }
    117     if (!outProduct) {
    118         psError(PS_ERR_UNKNOWN, true, "-out_product is required");
    119         return false;
    120     }
    121 
    122     psString lastFileset = psMetadataLookupStr(&status, config->args, "-last_fileset");
    123     psString state = psMetadataLookupStr(&status, config->args, "-state");
    124     if (!state) {
    125         state = "enabled";
    126     }
     102    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
     103    PXOPT_LOOKUP_STR(outProduct,  config->args, "-out_product",   true, false);
     104    PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset", false, false);
     105    PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    127106
    128107    if (!pstampDataStoreInsert(config->dbh,
    … …  
    142121static bool datastoreMode(pxConfig *config)
    143122{
    144     bool status = false;
    145     PS_ASSERT_PTR_NON_NULL(config, false);
    146 
    147     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    148     if (!status) {
    149         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    150         return false;
    151     }
    152 
    153     psString query = NULL;
    154     psStringAppend(&query, "SELECT * FROM pstampDataStore");
    155     if (ds_id) {
    156         psStringAppend(&query, " WHERE ds_id = '%s'", ds_id);
    157     }
     123    PS_ASSERT_PTR_NON_NULL(config, false);
     124
     125    psMetadata *where = psMetadataAlloc();
     126    PXOPT_COPY_STR(config->args, where, "-ds_id", "ds_id", "==");
     127
     128    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     129
     130    psString query = pxDataGet("pstamptool_datastore.sql");
     131    if (!query) {
     132        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     133        return false;
     134    }
     135
     136    if (psListLength(where->list)) {
     137        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     138        psStringAppend(&query, " %s", whereClause);
     139        psFree(whereClause);
     140    }
     141    psFree(where);
     142
    158143    if (!p_psDBRunQuery(config->dbh, query)) {
    159144        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    170155        psFree(output);
    171156        return true;
    172     }
    173 
    174     bool simple = false;
    175     {
    176         bool status = false;
    177         simple = psMetadataLookupBool(&status, config->args, "-simple");
    178         if (!status) {
    179             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    180             return false;
    181         }
    182157    }
    183158
    … …  
    195170static bool moddatastoreMode(pxConfig *config)
    196171{
    197     bool    status;
    198 
    199     PS_ASSERT_PTR_NON_NULL(config, false);
    200 
    201     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    202     if (!status) {
    203         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    204         return false;
    205     }
    206     if (!ds_id) {
    207         psError(PS_ERR_UNKNOWN, true, "-ds_id is required");
    208         return false;
    209     }
    210     psString lastFileset = psMetadataLookupStr(&status, config->args, "-last_fileset");
    211     if (!status) {
    212         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -last_fileset");
    213         return false;
    214     }
    215     psString state = psMetadataLookupStr(&status, config->args, "-state");
    216     if (!status) {
    217         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    218         return false;
    219     }
     172    PS_ASSERT_PTR_NON_NULL(config, false);
     173
     174    PXOPT_LOOKUP_STR(ds_id,       config->args, "-ds_id",         true, false);
     175    PXOPT_LOOKUP_STR(lastFileset, config->args, "-last_fileset",  false, false);
     176    PXOPT_LOOKUP_STR(state,       config->args, "-state",         false, false);
    220177
    221178    if (!state && !lastFileset) {
    … …  
    224181    }
    225182
    226     char *query = NULL;
     183    char *query = psStringCopy ("UPDATE pstampDataStore SET");
    227184    bool needComma = false;
    228185   
    229     psStringAppend(&query, "UPDATE pstampDataStore SET");
    230 
    231186    if (lastFileset) {
    232187        psStringAppend(&query, " lastFileset = '%s'", lastFileset);
    … …  
    235190
    236191    if (state) {
    237         psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ",
    238             state);
     192        psStringAppend(&query, "%s state = '%s'", needComma ? "," : " ", state);
    239193        needComma = true; // be ready in case we add another field
    240194    }
    … …  
    261215
    262216// Replace $REQ_ID with the value of the request id if present in the outFileset
     217// XXX EAM : rewrite this using psStringSubstitute:
     218// word = psStringAppend (NULL, "%" PRId64, req_id;
     219// converted = psStringSubstitute (outFileset, word, MAGIC_STR);
    263220
    264221static bool
    … …  
    303260static bool addReqMode(pxConfig *config)
    304261{
    305     bool    status;
    306 
    307     PS_ASSERT_PTR_NON_NULL(config, false);
    308 
    309     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    310     if (!status) {
    311         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    312         return false;
    313     }
    314     if (!uri) {
    315         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    316         return false;
    317     }
    318     psString outFileset = psMetadataLookupStr(&status, config->args, "-out_fileset");
    319     if (!status) {
    320         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -out_fileset");
    321         return false;
    322     }
    323     if (!outFileset) {
    324         psError(PS_ERR_UNKNOWN, true, "-out_fileset is required");
    325         return false;
    326     }
    327 
    328     // Data Store ID is optional
    329     psString ds_id = psMetadataLookupStr(&status, config->args, "-ds_id");
    330     if (!status) {
    331         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ds_id");
    332         return false;
    333     }
    334     if (!ds_id) {
    335         ds_id = "0";
    336     }
     262    PS_ASSERT_PTR_NON_NULL(config, false);
     263
     264    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",           true, false);
     265    PXOPT_LOOKUP_STR(outFileset,  config->args, "-out_fileset",   true, false);
     266    PXOPT_LOOKUP_STR(ds_id,       config->args, "-ds_id",         false, false);
    337267
    338268    char *query ="INSERT INTO pstampRequest"
    … …  
    368298    PS_ASSERT_PTR_NON_NULL(config, false);
    369299
    370     bool status = false;
    371     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    372     if (!status) {
    373         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    374         return false;
    375     }
    376 
    377     psString query = psStringCopy(
    378             "SELECT"
    379             " *"
    380             " FROM pstampRequest"
    381             " WHERE state = 'new'"
    382         );
    383 
    384     if (config->where) {
    385         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pstampRequest");
     300    psMetadata *where = psMetadataAlloc();
     301    PXOPT_COPY_STR(config->args, where, "-ds_id", "ds_id", "==");
     302
     303    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     304    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     305
     306    psString query = pxDataGet("pstamptool_pendingreq.sql");
     307    if (!query) {
     308        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     309        return false;
     310    }
     311
     312    if (psListLength(where->list)) {
     313        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampRequest");
    386314        psStringAppend(&query, " AND %s", whereClause);
    387315        psFree(whereClause);
    388316    }
     317    psFree(where);
    389318
    390319    // treat limit == 0 as "no limit"
    … …  
    413342    }
    414343
    415     bool simple = false;
    416     {
    417         bool status = false;
    418         simple = psMetadataLookupBool(&status, config->args, "-simple");
    419         if (!status) {
    420             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    421             psFree(output);
    422             return false;
    423         }
    424     }
    425 
    426344    // negative simple so the default is true
    427345    if (!ippdbPrintMetadatas(stdout, output, "pstampRequest", !simple)) {
    … …  
    435353    return true;
    436354}
    437 static bool completedReqMode(pxConfig *config)
    438 {
    439     PS_ASSERT_PTR_NON_NULL(config, false);
    440 
    441     bool status = false;
    442     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    443     if (!status) {
    444         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    445         return false;
    446     }
    447 
    448     psString query =
    449         "SELECT * FROM pstampRequest WHERE state = 'run' AND "
    450             "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
    451             " AND pstampJob.state != 'stop') = 0" ;
     355
     356static bool listReqMode(pxConfig *config)
     357{
     358    PS_ASSERT_PTR_NON_NULL(config, false);
     359
     360    PXOPT_LOOKUP_STR(req_id,  config->args, "-req_id", true, false);
     361    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
     362    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     363
     364    psString query = NULL;
     365    psStringAppend(&query, "SELECT"
     366                   " *"
     367                   " FROM pstampRequest"
     368                   " WHERE req_id = %s", req_id);
    452369
    453370    // treat limit == 0 as "no limit"
    … …  
    463380        return false;
    464381    }
     382    psFree(query);
    465383
    466384    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    469387        return false;
    470388    }
    471 
    472389    if (!psArrayLength(output)) {
    473390        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    474391        psFree(output);
    475392        return true;
    476     }
    477 
    478     bool simple = false;
    479     {
    480         bool status = false;
    481         simple = psMetadataLookupBool(&status, config->args, "-simple");
    482         if (!status) {
    483             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    484             psFree(output);
    485             return false;
    486         }
    487393    }
    488394
    … …  
    499405}
    500406
    501 static bool listReqMode(pxConfig *config)
    502 {
    503     PS_ASSERT_PTR_NON_NULL(config, false);
    504 
    505     bool status = false;
    506     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    507     if (!status) {
    508         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    509         return false;
    510     }
    511 
    512     psString query = NULL;
    513 
    514     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    515    
    516     if (req_id) {
    517         psStringAppend(&query,
    518                 "SELECT"
    519                 " *"
    520                 " FROM pstampRequest"
    521                 " WHERE req_id = %s", req_id
    522             );
    523     } else {
    524         fprintf(stderr, "req_id must be specified\n");
    525         exit (1);
    526     }
     407static bool completedReqMode(pxConfig *config)
     408{
     409    PS_ASSERT_PTR_NON_NULL(config, false);
     410
     411    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     412    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     413
     414    psString query =
     415        "SELECT * FROM pstampRequest WHERE state = 'run' AND "
     416            "(SELECT count(*) FROM pstampJob WHERE pstampJob.req_id = pstampRequest.req_id "
     417            " AND pstampJob.state != 'stop') = 0" ;
    527418
    528419    // treat limit == 0 as "no limit"
    … …  
    538429        return false;
    539430    }
    540     psFree(query);
    541431
    542432    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    545435        return false;
    546436    }
     437
    547438    if (!psArrayLength(output)) {
    548439        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    549440        psFree(output);
    550441        return true;
    551     }
    552 
    553     bool simple = false;
    554     {
    555         bool status = false;
    556         simple = psMetadataLookupBool(&status, config->args, "-simple");
    557         if (!status) {
    558             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    559             psFree(output);
    560             return false;
    561         }
    562442    }
    563443
    … …  
    576456static bool processedReqMode(pxConfig *config)
    577457{
    578     bool    status;
    579 
    580     PS_ASSERT_PTR_NON_NULL(config, false);
    581 
    582     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    583     if (!status) {
    584         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -req_id");
    585         return false;
    586     }
    587     if (!req_id) {
    588         psError(PS_ERR_UNKNOWN, true, "-req_id is required");
    589         return false;
    590     }
    591     psString state = psMetadataLookupStr(&status, config->args, "-state");
    592     if (!status) {
    593         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    594         return false;
    595     }
    596     if (!state) {
    597         psError(PS_ERR_UNKNOWN, true, "-state is required");
    598         return false;
    599     }
     458    PS_ASSERT_PTR_NON_NULL(config, false);
     459
     460    PXOPT_LOOKUP_STR(req_id, config->args, "-req_id", true, false);
     461    PXOPT_LOOKUP_STR(state,  config->args, "-state",  true, false);
    600462
    601463    // XXX: check state for a legal value
    … …  
    620482    return true;
    621483}
     484
    622485static bool addJobMode(pxConfig *config)
    623486{
    624     bool    status;
    625487    bool    stampJob = false;
    626 
    627     PS_ASSERT_PTR_NON_NULL(config, false);
    628 
    629     psString job_type = psMetadataLookupStr(&status, config->args, "-job_type");
    630     if (!status) {
    631         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -job_type");
    632         return false;
    633     }
    634     if (job_type) {
    635         if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
    636             stampJob = false;
    637         } else if (!strcmp(job_type, "stamp")) {
    638             stampJob = true;
    639         } else {
    640             psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    641             return false;
    642         }
     488    char   *query = NULL;
     489
     490    PS_ASSERT_PTR_NON_NULL(config, false);
     491
     492    PXOPT_LOOKUP_STR(uri,         config->args, "-uri",        true, false);
     493    PXOPT_LOOKUP_STR(req_id,      config->args, "-req_id",     true, false);
     494    PXOPT_LOOKUP_STR(job_type,    config->args, "-job_type",   false, false);
     495    PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", true,  false);
     496    PXOPT_LOOKUP_STR(argString,   config->args, "-args",       true,  false);
     497    PXOPT_LOOKUP_STR(stateString, config->args, "-state",      false, false);
     498    PXOPT_LOOKUP_STR(result,      config->args, "-result",     false, false);
     499
     500    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query")) {
     501        stampJob = false;
     502    } else if (!strcmp(job_type, "stamp")) {
     503        stampJob = true;
    643504    } else {
    644         job_type = "stamp";
    645         stampJob = true;
    646     }
    647 
    648     psString uri = psMetadataLookupStr(&status, config->args, "-uri");
    649     if (!status) {
    650         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -uri");
    651         return false;
    652     }
    653     if (!uri) {
    654         psError(PS_ERR_UNKNOWN, true, "-uri is required");
    655         return false;
    656     }
    657 
    658     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    659     if (!status) {
    660         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -req_id");
    661         return false;
    662     }
    663     if (!req_id) {
    664         psError(PS_ERR_UNKNOWN, true, "-req_id is required");
    665         return false;
    666     }
    667 
    668     psString outputBase = psMetadataLookupStr(&status, config->args, "-outputBase");
    669     if (!status) {
    670         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -outputBase");
    671         return false;
    672     }
    673     if (!outputBase) {
    674         psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
    675         return false;
    676     }
    677 
    678     psString argString = psMetadataLookupStr(&status, config->args, "-args");
    679     if (!status) {
    680         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -args");
    681         return false;
    682     }
    683     if (!argString) {
    684         if (stampJob) {
    685             psError(PS_ERR_UNKNOWN, true, "-args is required");
    686             return false;
    687         }
    688     }
    689 
    690     psString stateString = psMetadataLookupStr(&status, config->args, "-state");
    691     if (!status) {
    692         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    693         return false;
    694     }
    695     if (!stateString) {
    696         stateString = "run";
    697     }
    698     psString result = psMetadataLookupStr(&status, config->args, "-result");
    699     if (!status) {
    700         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -result");
    701         return false;
    702     }
    703     if (!result) {
    704         result = "0";
    705     }
    706 
    707     char *query;
     505        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     506        return false;
     507    }
    708508   
    709509    if (stampJob) {
    710         query ="INSERT INTO pstampJob"
    711                  " (req_id, state, jobType, uri, outputBase, result, args)"
    712                  " VALUES( %s, '%s', '%s', '%s', '%s', %s, '%s')";
     510        query = pxDataGet("pstamptool_addjob_stampjob.sql");
    713511    } else {
    714         query ="INSERT INTO pstampJob"
    715                  " (req_id, state, jobType, uri, outputBase, result)"
    716                  " VALUES( %s, '%s', '%s', '%s', '%s', %s)";
     512        query = pxDataGet("pstamptool_addjob_otherjob.sql");
     513    }
     514    if (!query) {
     515        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     516        return false;
    717517    }
    718518
    … …  
    740540    PS_ASSERT_PTR_NON_NULL(config, false);
    741541
    742     bool status = false;
    743     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    744     if (!status) {
    745         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    746         return false;
    747     }
     542    PXOPT_LOOKUP_STR(req_id, config->args, "-req_id", false, false);
     543    PXOPT_LOOKUP_STR(job_id, config->args, "-job_id", false, false);
     544
     545    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     546    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    748547
    749548    psString query = NULL;
    750549
    751     psString req_id = psMetadataLookupStr(&status, config->args, "-req_id");
    752     psString job_id = psMetadataLookupStr(&status, config->args, "-job_id");
    753    
     550    if (!req_id && !job_id) {
     551        fprintf(stderr, "either req_id or job_id must be specified\n");
     552        exit (1);
     553    }
     554
    754555    if (req_id) {
    755556        psStringAppend(&query,
    … …  
    759560                " WHERE req_id = %s", req_id
    760561            );
    761     } else if (job_id) {
     562    } else {
    762563        psStringAppend(&query,
    763564                "SELECT"
    … …  
    766567                " WHERE job_id = %s", job_id
    767568            );
    768     } else {
    769         fprintf(stderr, "either req_id or job_id must be specified\n");
    770         exit (1);
    771     }
     569    }
    772570
    773571    // treat limit == 0 as "no limit"
    … …  
    796594    }
    797595
    798     bool simple = false;
    799     {
    800         bool status = false;
    801         simple = psMetadataLookupBool(&status, config->args, "-simple");
    802         if (!status) {
    803             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    804             psFree(output);
    805             return false;
    806         }
    807     }
    808 
    809596    // negative simple so the default is true
    810597    if (!ippdbPrintMetadatas(stdout, output, "pstampJob", !simple)) {
    … …  
    823610    PS_ASSERT_PTR_NON_NULL(config, false);
    824611
    825     bool status = false;
    826     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    827     if (!status) {
    828         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -limit");
    829         return false;
    830     }
    831 
    832     psString query = psStringCopy(
    833             "SELECT"
    834             " *"
    835             " FROM pstampJob"
    836             " WHERE state = 'run'"
    837         );
    838 
    839     if (config->where) {
    840         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "pstampJob");
     612    psMetadata *where = psMetadataAlloc();
     613    PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     614
     615    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     616    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     617
     618    psString query = pxDataGet("pstamptool_pendingjob.sql");
     619    if (!query) {
     620        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     621        return false;
     622    }
     623
     624    // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     625    if (psListLength(where->list)) {
     626        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampJob");
    841627        psStringAppend(&query, " AND %s", whereClause);
    842628        psFree(whereClause);
    843629    }
     630    psFree(where);
    844631
    845632    // treat limit == 0 as "no limit"
    … …  
    868655    }
    869656
    870     bool simple = false;
    871     {
    872         bool status = false;
    873         simple = psMetadataLookupBool(&status, config->args, "-simple");
    874         if (!status) {
    875             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    876             psFree(output);
    877             return false;
    878         }
    879     }
    880 
    881657    // negative simple so the default is true
    882658    if (!ippdbPrintMetadatas(stdout, output, "pstampJob", !simple)) {
    … …  
    894670{
    895671    bool    status;
    896 
    897     PS_ASSERT_PTR_NON_NULL(config, false);
    898 
    899     psString job_id = psMetadataLookupStr(&status, config->args, "-job_id");
     672    char *query = NULL;
     673
     674    PS_ASSERT_PTR_NON_NULL(config, false);
     675
     676    PXOPT_LOOKUP_STR(job_id,    config->args, "-job_id", true, false);
     677    PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
     678    PXOPT_LOOKUP_STR(jobResult, config->args, "-result", false, false);
     679    // XXX: check state for a legal value
     680
     681    if (jobResult) {
     682        query = psStringCopy ("UPDATE pstampJob"
     683                              " SET state = '%s', result = '%s'"
     684                              " WHERE job_id = '%s'");
     685        status = p_psDBRunQuery(config->dbh, query, state, jobResult, job_id);
     686    } else {
     687        query = psStringCopy ("UPDATE pstampJob"
     688                              " SET state = '%s'"
     689                              " WHERE job_id = '%s'");
     690        status = p_psDBRunQuery(config->dbh, query, state, job_id);
     691    }
     692
    900693    if (!status) {
    901         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -job_id");
    902         return false;
    903     }
    904     if (!job_id) {
    905         psError(PS_ERR_UNKNOWN, true, "-job_id is required");
    906         return false;
    907     }
    908     psString state = psMetadataLookupStr(&status, config->args, "-state");
    909     if (!status) {
    910         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -state");
    911         return false;
    912     }
    913     if (!state) {
    914         psError(PS_ERR_UNKNOWN, true, "-state is required");
    915         return false;
    916     }
    917     psString jobResult = psMetadataLookupStr(&status, config->args, "-result");
    918     if (!status) {
    919         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -result");
    920         return false;
    921     }
    922 
    923     psString resultStr = NULL;
    924     if (!jobResult) {
    925         resultStr = psStringCopy("");
    926     } else {
    927         psStringAppend(&resultStr, ", result = '%s'", jobResult);
    928     }
    929        
    930 
    931     // XXX: check state for a legal value
    932 
    933     char *query ="UPDATE pstampJob"
    934                  " SET state = '%s' %s"
    935                  " WHERE job_id = '%s'";
    936 
    937     if (!p_psDBRunQuery(config->dbh, query, state, resultStr, job_id)) {
    938694        psError(PS_ERR_UNKNOWN, false, "database error");
    939695        psFree(query);
    940696        return false;
    941697    }
    942     psFree(resultStr);
    943698
    944699    psU64 affected = psDBAffectedRows(config->dbh);

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

    r18468 r18496  
    4545    // -adddatastore
    4646    psMetadata *adddatastoreArgs = psMetadataAlloc();
    47     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri", 0,
    48             "define storage uri", NULL);
    49     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,
    50             "define last fileset seen", NULL);
    51     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-state", 0,
    52             "define datastore state", NULL);
    53     psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-out_product", 0,
    54             "define output product name", NULL);
     47    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-uri",          0, "define storage uri (required)", NULL);
     48    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-out_product",  0, "define output product name (required)", NULL);
     49    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0, "define last fileset seen", NULL);
     50    psMetadataAddStr(adddatastoreArgs, PS_LIST_TAIL, "-state",        0, "define datastore state", "enabled");
    5551   
    5652    // -datastore
    5753    psMetadata *datastoreArgs = psMetadataAlloc();
    58     psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,
    59             "use the simple output format", false);
    60     psMetadataAddStr(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,
    61             "define ds_id", NULL);
     54    psMetadataAddStr(datastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", NULL);
     55    psMetadataAddBool(datastoreArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    6256
    6357    // -moddatastore
    6458    psMetadata *moddatastoreArgs = psMetadataAlloc();
    65     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,
    66             "define ds_id", NULL);
    67     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,
    68             "define storage uri", NULL);
    69     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,
    70             "define storage uri", NULL);
    71     psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-out_product", 0,
    72             "define output product name", NULL);
    73 
     59    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-ds_id", 0,            "define ds_id", "0");
     60    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-last_fileset", 0,            "define storage uri", NULL);
     61    psMetadataAddStr(moddatastoreArgs, PS_LIST_TAIL, "-state", 0,            "define storage uri", NULL);
    7462
    7563    // -addreq
    7664    psMetadata *addreqArgs = psMetadataAlloc();
    77     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,
    78             "define request file uri", NULL);
    79     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,
    80             "define request ds_id", NULL);
    81     psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-out_fileset", 0,
    82             "define request output_fileset", NULL);
     65    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-uri", 0,            "define request file uri", NULL);
     66    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-ds_id", 0,            "define request ds_id", NULL);
     67    psMetadataAddStr(addreqArgs, PS_LIST_TAIL, "-out_fileset", 0,            "define request output_fileset", NULL);
    8368
    8469    // -pendingreq
    8570    psMetadata *pendingreqArgs = psMetadataAlloc();
    86     psMetadataAddStr(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,
    87             "define req_id", NULL);
    88     psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,
    89             "limit result set to N items", 0);
    90     psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,
    91             "use the simple output format", false);
     71    psMetadataAddStr(pendingreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", NULL);
     72    psMetadataAddU64(pendingreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     73    psMetadataAddBool(pendingreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    9274
    9375    // -listreq
    9476    psMetadata *listreqArgs = psMetadataAlloc();
    95     psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-req_id", 0,
    96             "define req_id", NULL);
    97     psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,
    98             "limit result set to N items", 0);
    99     psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,
    100             "use the simple output format", false);
     77    psMetadataAddStr(listreqArgs, PS_LIST_TAIL, "-req_id", 0,            "define req_id", NULL);
     78    psMetadataAddU64(listreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     79    psMetadataAddBool(listreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10180
    10281    // -completedreq
    10382    psMetadata *completedreqArgs = psMetadataAlloc();
    104     psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,
    105             "limit result set to N items", 0);
    106     psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,
    107             "use the simple output format", false);
     83    psMetadataAddU64(completedreqArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     84    psMetadataAddBool(completedreqArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    10885
    10986    // -processedreq
    11087    psMetadata *processedreqArgs = psMetadataAlloc();
    111     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-req_id", 0,
    112             "req_id for which to change state", NULL);
    113     psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-state", 0,
    114             "new state", NULL);
     88    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", NULL);
     89    psMetadataAddStr(processedreqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    11590
    11691    // -addjob
    11792    psMetadata *addjobArgs = psMetadataAlloc();
    118     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,
    119             "define job file uri", NULL);
    120     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-req_id", 0,
    121             "define job req_id", NULL);
    122     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,
    123             "define job job_type", NULL);
    124     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,
    125             "define job outputBase", NULL);
    126     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,
    127             "define job args", NULL);
    128     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,
    129             "new state", NULL);
    130     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-result", 0,
    131             "new result", NULL);
     93    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,            "define job file uri", NULL);
     94    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", NULL);
     95    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
     96    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
     97    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,            "define job args", NULL);
     98    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
     99    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-result", 0,            "new result", "0");
    132100
    133101    // -listjob
    134102    psMetadata *listjobArgs = psMetadataAlloc();
    135     psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-req_id", 0,
    136             "define request", NULL);
    137     psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-job_id", 0,
    138             "define job", NULL);
    139     psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,
    140             "limit result set to N items", 0);
    141     psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,
    142             "use the simple output format", false);
     103    psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define request", NULL);
     104    psMetadataAddStr(listjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", NULL);
     105    psMetadataAddU64(listjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     106    psMetadataAddBool(listjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    143107
    144108    // -pendingjob
    145109    psMetadata *pendingjobArgs = psMetadataAlloc();
    146     psMetadataAddStr(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,
    147             "define job", NULL);
    148     psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,
    149             "limit result set to N items", 0);
    150     psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,
    151             "use the simple output format", false);
     110    psMetadataAddStr(pendingjobArgs, PS_LIST_TAIL, "-job_id", 0,            "define job", NULL);
     111    psMetadataAddU64(pendingjobArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     112    psMetadataAddBool(pendingjobArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    152113
    153114    // -processedjob
    154115    psMetadata *processedjobArgs = psMetadataAlloc();
    155     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-job_id", 0,
    156             "req_id for which to change state", NULL);
    157     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-state", 0,
    158             "new state", NULL);
    159     psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-result", 0,
    160             "new result", NULL);
    161 
    162 #define PXTOOL_MODE(option, modeval, argset) \
    163 { \
    164     int N = 0; \
    165     if ((N = psArgumentGet (argc, argv, option))) { \
    166         psArgumentRemove (N, &argc, argv); \
    167         if (config->mode) { \
    168             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    169             psFree(config); \
    170             return NULL; \
    171         } \
    172         config->mode = modeval; \
    173         config->args = psMemIncrRefCounter(argset); \
    174     } \
    175     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    176         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    177     } \
    178     psFree(argset); \
    179 }
     116    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", NULL);
     117    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
     118    psMetadataAddStr(processedjobArgs, PS_LIST_TAIL, "-result", 0,            "new result", NULL);
    180119
    181120    psMetadata *argSets = psMetadataAlloc();
    … …  
    208147    psFree(modes);
    209148
    210     // generate SQL where clause
    211     config->where = psMetadataAlloc();
    212 
    213     PXOPT_ADD_WHERE_STR(req_id);
    214     PXOPT_ADD_WHERE_STR(job_id);
    215 
    216     if (config->where->list->n < 1) {
    217         psFree(config->where);
    218         config->where = NULL;
    219     }
    220 
    221149    // define Database handle, if used
    222150    // do this last so we don't setup a connection before CLI options are

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

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

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

    r18491 r18496  
    157157    psFree(modes);
    158158
    159     // generate SQL where clause
    160     config->where = psMetadataAlloc();
    161 
    162     PXOPT_ADD_WHERE_S64(warp_id);
    163     PXOPT_ADD_WHERE_S64(stack_id);
    164     PXOPT_ADD_WHERE_STR(skycell_id);
    165     PXOPT_ADD_WHERE_STR(tess_id);
    166     PXOPT_ADD_WHERE_S16_ALIAS("-code","fault");
    167 
    168     if (config->where->list->n < 1) {
    169         psFree(config->where);
    170         config->where = NULL;
    171     }
    172 
    173159    // define Database handle, if used
    174160    // do this last so we don't setup a connection before CLI options are
Note: See TracChangeset for help on using the changeset viewer.