IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 26981


Ignore:
Timestamp:
Feb 17, 2010, 4:40:03 PM (16 years ago)
Author:
Paul Price
Message:

Reworked all ippTools to put fault=2 (SYS_ERROR) when can't find SQL file (presumably due to NFS problems). Removed DATA_ERROR because ippTools don't work on data (astronomical images or catalogues). This should allow us to turn on revert for fault=2 only.

Location:
trunk/ippTools/src
Files:
37 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/addtool.c

    r26943 r26981  
    104104    if (!psListLength(where->list)) {
    105105        psFree(where);
    106         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     106        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    107107        return false;
    108108    }
    … …  
    122122    psString bare_query = pxDataGet("addtool_find_cam_id.sql");
    123123    if (!bare_query) {
    124         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     124        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    125125        psFree(where);
    126126        return false;
    127127    }
    128128
    129     // prevent queueing an addRun if a given exposure has already been added to 
     129    // prevent queueing an addRun if a given exposure has already been added to
    130130    // the given dvo database
    131131    psString dvodb_string = NULL;
    … …  
    238238        // queue the exp
    239239        if (!pxaddQueueByCamID(config,
    240                                row->cam_id,
    241                                workdir     ? workdir   : row->workdir,
    242                                reduction   ? reduction : row->reduction,
    243                                label       ? label     : row->label,
    244                                data_group  ? data_group : (row->data_group ? row->data_group :  (label ? label : row->label)),
    245                                dvodb       ? dvodb     : row->dvodb,
     240                               row->cam_id,
     241                               workdir     ? workdir   : row->workdir,
     242                               reduction   ? reduction : row->reduction,
     243                               label       ? label     : row->label,
     244                               data_group  ? data_group : (row->data_group ? row->data_group :  (label ? label : row->label)),
     245                               dvodb       ? dvodb     : row->dvodb,
    246246                               note        ? note      : NULL,
    247                                image_only
     247                               image_only
    248248        )) {
    249249            if (!psDBRollback(config->dbh)) {
    … …  
    283283    if (!psListLength(where->list)) {
    284284        psFree(where);
    285         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     285        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    286286        return false;
    287287    }
    … …  
    303303
    304304    if ((!state) && (!label)) {
    305         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
     305        psError(PXTOOLS_ERR_CONFIG, false, "parameters are required");
    306306        psFree(where);
    307307        return false;
    … …  
    346346    psString query = pxDataGet("addtool_find_pendingexp.sql");
    347347    if (!query) {
    348         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     348        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    349349        return false;
    350350    }
    … …  
    412412    psString query = pxDataGet("addtool_find_pendingexp.sql");
    413413    if (!query) {
    414         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     414        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    415415        return false;
    416416    }
    … …  
    454454        dtime_addstar,
    455455        path_base,
    456         fault
     456        fault
    457457        );
    458458
    … …  
    506506        !psMetadataLookupBool(NULL, config->args, "-all")) {
    507507        psFree(where);
    508         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     508        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    509509        return false;
    510510    }
    … …  
    512512    psString query = pxDataGet("addtool_find_processedexp.sql");
    513513    if (!query) {
    514         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     514        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    515515        return false;
    516516    }
    … …  
    520520        psStringAppend(&query, " WHERE %s", whereClause);
    521521        psFree(whereClause);
    522     } 
     522    }
    523523
    524524    // we either add AND (condition) or WHERE (condition):
    … …  
    526526        // list only faulted rows
    527527        psStringAppend(&query, " %s", " AND addProcessedExp.fault != 0");
    528     } 
     528    }
    529529    if (where->list && !faulted) {
    530530        // don't list faulted rows
    … …  
    534534        // list only faulted rows
    535535        psStringAppend(&query, " %s", " WHERE addProcessedExp.fault != 0");
    536     } 
     536    }
    537537    if (!where->list && !faulted) {
    538538        // don't list faulted rows
    … …  
    595595    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    596596        psFree(where);
    597         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     597        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    598598        return false;
    599599    }
    … …  
    608608        psString query = pxDataGet("addtool_reset_faulted_runs.sql");
    609609        if (!query) {
    610             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     610            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    611611            psFree(where);
    612612            return false;
    … …  
    640640                psError(PS_ERR_UNKNOWN, false, "database error");
    641641            }
    642             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     642            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    643643            psFree(where);
    644644            return false;

  • trunk/ippTools/src/camtool.c

    r26567 r26981  
    115115        !psMetadataLookupBool(NULL, config->args, "-all")) {
    116116        psFree(where);
    117         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     117        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    118118        return false;
    119119    }
    … …  
    133133    psString query = pxDataGet("camtool_find_chip_id.sql");
    134134    if (!query) {
    135         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     135        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    136136        psFree(where);
    137137        return false;
    … …  
    260260    if (!psListLength(where->list)) {
    261261        psFree(where);
    262         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     262        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    263263        return false;
    264264    }
    … …  
    268268    bool result = pxUpdateRun(config, where, &query, "camRun", true);
    269269    if (!result) {
    270         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     270        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    271271    }
    272272
    … …  
    293293    psString query = pxDataGet("camtool_find_pendingexp.sql");
    294294    if (!query) {
    295         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     295        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    296296        return false;
    297297    }
    … …  
    358358    psString query = pxDataGet("camtool_find_pendingimfile.sql");
    359359    if (!query) {
    360         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     360        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    361361        return false;
    362362    }
    … …  
    490490    psString query = pxDataGet("camtool_find_pendingexp.sql");
    491491    if (!query) {
    492         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     492        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    493493        return false;
    494494    }
    … …  
    691691        !psMetadataLookupBool(NULL, config->args, "-all")) {
    692692        psFree(where);
    693         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     693        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    694694        return false;
    695695    }
    … …  
    697697    psString query = pxDataGet("camtool_find_processedexp.sql");
    698698    if (!query) {
    699         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     699        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    700700        return false;
    701701    }
    … …  
    780780    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    781781        psFree(where);
    782         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     782        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    783783        return false;
    784784    }
    … …  
    793793        psString query = pxDataGet("camtool_reset_faulted_runs.sql");
    794794        if (!query) {
    795             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     795            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    796796            psFree(where);
    797797            return false;
    … …  
    825825                psError(PS_ERR_UNKNOWN, false, "database error");
    826826            }
    827             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     827            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    828828            psFree(where);
    829829            return false;
    … …  
    965965    psString query = pxDataGet("camtool_pendingcleanuprun.sql");
    966966    if (!query) {
    967         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     967        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    968968        return false;
    969969    }
    … …  
    10301030    psString query = pxDataGet("camtool_pendingcleanupexp.sql");
    10311031    if (!query) {
    1032         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1032        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10331033        return false;
    10341034    }
    … …  
    10911091    psString query = pxDataGet("camtool_donecleanup.sql");
    10921092    if (!query) {
    1093         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1093        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10941094        return false;
    10951095    }
    … …  
    11771177    psString query = pxDataGet(tables[i].sqlFilename);
    11781178    if (!query) {
    1179       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1179      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11801180      return false;
    11811181    }

  • trunk/ippTools/src/chiptool.c

    r26908 r26981  
    9595        MODECASE(CHIPTOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    9696        MODECASE(CHIPTOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
    97         MODECASE(CHIPTOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
     97        MODECASE(CHIPTOOL_MODE_TOSCRUBBEDIMFILE,        toscrubbedimfileMode);
    9898        MODECASE(CHIPTOOL_MODE_EXPORTRUN,               exportrunMode);
    9999        MODECASE(CHIPTOOL_MODE_IMPORTRUN,               importrunMode);
    … …  
    135135    if ((psListLength(where->list) <= 1) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    136136        psFree(where);
    137         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     137        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    138138        return false;
    139139    }
    … …  
    157157    psString query = pxDataGet("chiptool_find_rawexp.sql");
    158158    if (!query) {
    159         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     159        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    160160        psFree(where);
    161161        return false;
    … …  
    227227
    228228
    229 # define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
    230     PTYPE VALUE;                                                        \
    231     { bool status;                                                      \
    232         VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
    233         if (!status) {                                                  \
    234             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
    235             psFree(output);                                             \
    236             return false;                                               \
    237         } }
     229# define GET_VALUE(PTYPE,CTYPE,VALUE,NAME)                              \
     230    PTYPE VALUE;                                                        \
     231    { bool status;                                                      \
     232        VALUE = psMetadataLookup##CTYPE(&status, md, NAME);             \
     233        if (!status) {                                                  \
     234            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", NAME); \
     235            psFree(output);                                             \
     236            return false;                                               \
     237        } }
    238238
    239239    // loop over our list of exp_ids
    … …  
    248248        }
    249249
    250         GET_VALUE (psS64,    S64, exp_id,        "exp_id");
    251         GET_VALUE (psString, Str, raw_workdir,   "workdir");
    252         GET_VALUE (psString, Str, raw_label,     "label");
     250        GET_VALUE (psS64,    S64, exp_id,        "exp_id");
     251        GET_VALUE (psString, Str, raw_workdir,   "workdir");
     252        GET_VALUE (psString, Str, raw_label,     "label");
    253253        GET_VALUE (psString, Str, raw_reduction, "reduction");
    254254        // GET_VALUE (psString, Str, raw_expgroup,  "expgroup");
    … …  
    264264
    265265        // queue the exp
    266         if (!pxchipQueueByExpTag(config, 
    267                                  exp_id,
    268                                 workdir     ? workdir   : raw_workdir,
    269                                 label       ? label     : raw_label,
     266        if (!pxchipQueueByExpTag(config,
     267                                 exp_id,
     268                                workdir     ? workdir   : raw_workdir,
     269                                label       ? label     : raw_label,
    270270                                 data_group  ? data_group : (label ? label : raw_label),
    271271                                 dist_group,
    272                                 reduction   ? reduction : raw_reduction,
    273                                 // expgroup    ? expgroup  : raw_expgroup,
    274                                 // XXX how does expgroup get defined?
    275                                 expgroup,
    276                                 dvodb       ? dvodb     : raw_dvodb,
    277                                 tess_id     ? tess_id   : raw_tess_id,
    278                                 end_stage   ? end_stage : raw_end_stage,
     272                                reduction   ? reduction : raw_reduction,
     273                                // expgroup    ? expgroup  : raw_expgroup,
     274                                // XXX how does expgroup get defined?
     275                                expgroup,
     276                                dvodb       ? dvodb     : raw_dvodb,
     277                                tess_id     ? tess_id   : raw_tess_id,
     278                                end_stage   ? end_stage : raw_end_stage,
    279279                                 note
    280                                 )) {
     280                                )) {
    281281            if (!psDBRollback(config->dbh)) {
    282282                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    314314    if (!psListLength(where->list)) {
    315315        psFree(where);
    316         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     316        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    317317        return false;
    318318    }
    … …  
    322322    bool result = pxUpdateRun(config, where, &query, "chipRun", true);
    323323    if (!result) {
    324         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     324        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    325325    }
    326326
    … …  
    346346    psString query = pxDataGet("chiptool_pendingimfile.sql");
    347347    if (!query) {
    348         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     348        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    349349        return false;
    350350    }
    … …  
    601601    // add cuts on ra and decl if supplied
    602602    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    603         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     603        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    604604        return false;
    605605    }
    … …  
    607607    psString query = pxDataGet("chiptool_processedimfile.sql");
    608608    if (!query) {
    609         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     609        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    610610        return false;
    611611    }
    … …  
    619619    } else {
    620620        psFree(where);
    621         psError(PXTOOLS_ERR_DATA, false, "search parameters (or -all) are required");
     621        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
    622622        return false;
    623623    }
    … …  
    684684        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    685685        psFree(where);
    686         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     686        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    687687        return false;
    688688    }
    … …  
    690690    psString query = pxDataGet("chiptool_revertprocessedimfile.sql");
    691691    if (!query) {
    692         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     692        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    693693        psFree(where);
    694694        return false;
    … …  
    725725        return false;
    726726    }
    727        
     727
    728728    if (!state) {
    729729      PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    730      
     730
    731731      if (!pxSetFaultCode(config->dbh, "chipProcessedImfile", where, fault)) {
    732732        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    … …  
    737737    else {
    738738      if (!pxchipProcessedImfileSetStateByQuery(config,where,state)) {
    739         psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
    740         return(false);
     739        psError(PS_ERR_UNKNOWN, false, "failed to set chipProcessedImfile state");
     740        return(false);
    741741      }
    742742    }
    743743
    744      
     744
    745745    return true;
    746746}
    … …  
    844844    psString query = pxDataGet("chiptool_unmasked.sql");
    845845    if (!query) {
    846         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     846        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    847847        return false;
    848848    }
    … …  
    922922    psString query = pxDataGet("chiptool_pendingcleanuprun.sql");
    923923    if (!query) {
    924         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     924        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    925925        return false;
    926926    }
    … …  
    986986    psString query = pxDataGet("chiptool_pendingcleanupimfile.sql");
    987987    if (!query) {
    988         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     988        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    989989        return false;
    990990    }
    … …  
    10471047    psString query = pxDataGet("chiptool_donecleanup.sql");
    10481048    if (!query) {
    1049         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1049        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10501050        return false;
    10511051    }
    … …  
    11051105    // make sure that the state string is valid
    11061106    if (!pxIsValidState(state)) {
    1107         psError(PXTOOLS_ERR_DATA, false, "%s is not a valid state", state);
     1107        psError(PXTOOLS_ERR_CONFIG, false, "%s is not a valid state", state);
    11081108        return false;
    11091109    }
    … …  
    11181118    psString query = pxDataGet("chiptool_run.sql");
    11191119    if (!query) {
    1120         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1120        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11211121        return false;
    11221122    }
    … …  
    11801180    psString query = pxDataGet("chiptool_completely_processed_exp.sql");
    11811181    if (!query) {
    1182         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1182        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11831183        return false;
    11841184    }
    … …  
    14081408    psString query = pxDataGet(tables[i].sqlFilename);
    14091409    if (!query) {
    1410       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1410      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14111411      return false;
    14121412    }
    … …  
    14441444
    14451445    if (clean) {
    1446         bool success = true; 
     1446        bool success = true;
    14471447        if (!strcmp(tables[i].tableName, "chipRun")) {
    14481448            success = pxSetStateCleaned("chipRun", "state", output);
    … …  
    15481548    psString query = pxDataGet("chiptool_runstate.sql");
    15491549    if (!query) {
    1550         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1550        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15511551        return false;
    15521552    }
    … …  
    15571557        psFree(whereClause);
    15581558    } else {
    1559         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1559        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    15601560        return false;
    15611561    }

  • trunk/ippTools/src/detselect.c

    r23998 r26981  
    135135    psString query = pxDataGet("detselect_search.sql");
    136136    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    138         return false;
    139     }
    140 
    141     // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
    142     if (where && psListLength(where->list)) {
    143         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    144         psStringAppend(&query, " AND %s", whereClause);
    145         psFree(whereClause);
    146     }
    147     psFree(where);
    148 
    149     // we choose the single detrend image which matches all criteria and has
    150     // the latest insertion date
    151 
    152     // unless explicitly specified by the user, list all possible matches
    153     if (!unlimit) {
    154         psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
    155     }
    156 
    157     if (!p_psDBRunQuery(config->dbh, query)) {
    158         psError(PS_ERR_UNKNOWN, false, "database error");
    159         psFree(query);
    160         return false;
    161     }
    162     psFree(query);
    163 
    164     psArray *output = p_psDBFetchResult(config->dbh);
    165     if (!output) {
    166         psError(PS_ERR_UNKNOWN, false, "database error");
    167         return false;
    168     }
    169     if (!psArrayLength(output)) {
    170         // XXX check psError here
    171         psError(PS_ERR_UNKNOWN, false, "no detrend exposures found");
    172         psFree(output);
    173         return true;
    174     }
    175 
    176     // negate simple so the default is true
    177     if (!ippdbPrintMetadatas(stdout, output, "detExp", !simple)) {
    178         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    179         psFree(output);
    180         return false;
    181     }
    182 
    183     psFree(output);
    184 
    185     return true;
    186 }
    187 
    188 static bool selectMode(pxConfig *config)
    189 {
    190     PS_ASSERT_PTR_NON_NULL(config, false);
    191 
    192     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    193 
    194     psMetadata *where = psMetadataAlloc();
    195     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    196     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    197     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    198 
    199     psString query = pxDataGet("detselect_select.sql");
    200     if (!query) {
    201         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    202138        return false;
    203139    }
    … …  
    211147    psFree(where);
    212148
     149    // we choose the single detrend image which matches all criteria and has
     150    // the latest insertion date
     151
     152    // unless explicitly specified by the user, list all possible matches
     153    if (!unlimit) {
     154        psStringAppend(&query, " ORDER BY registered DESC LIMIT 1");
     155    }
     156
     157    if (!p_psDBRunQuery(config->dbh, query)) {
     158        psError(PS_ERR_UNKNOWN, false, "database error");
     159        psFree(query);
     160        return false;
     161    }
     162    psFree(query);
     163
     164    psArray *output = p_psDBFetchResult(config->dbh);
     165    if (!output) {
     166        psError(PS_ERR_UNKNOWN, false, "database error");
     167        return false;
     168    }
     169    if (!psArrayLength(output)) {
     170        // XXX check psError here
     171        psError(PS_ERR_UNKNOWN, false, "no detrend exposures found");
     172        psFree(output);
     173        return true;
     174    }
     175
     176    // negate simple so the default is true
     177    if (!ippdbPrintMetadatas(stdout, output, "detExp", !simple)) {
     178        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     179        psFree(output);
     180        return false;
     181    }
     182
     183    psFree(output);
     184
     185    return true;
     186}
     187
     188static bool selectMode(pxConfig *config)
     189{
     190    PS_ASSERT_PTR_NON_NULL(config, false);
     191
     192    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     193
     194    psMetadata *where = psMetadataAlloc();
     195    PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     196    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
     197    PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
     198
     199    psString query = pxDataGet("detselect_select.sql");
     200    if (!query) {
     201        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     202        return false;
     203    }
     204
     205    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     206    if (where && psListLength(where->list)) {
     207        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     208        psStringAppend(&query, " AND %s", whereClause);
     209        psFree(whereClause);
     210    }
     211    psFree(where);
     212
    213213    if (!p_psDBRunQuery(config->dbh, query)) {
    214214        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/dettool.c

    r26815 r26981  
    9494        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpMode);
    9595        MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpMode);
    96         MODECASE(DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedMode);
     96        MODECASE(DETTOOL_MODE_UPDATESTATE_PROCESSED, updatestateprocessedMode);
    9797        // stacked
    9898        MODECASE(DETTOOL_MODE_TOSTACKED,        tostackedMode);
    … …  
    143143        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpMode);
    144144        MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpMode);
    145         MODECASE(DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidMode);
     145        MODECASE(DETTOOL_MODE_UPDATESTATE_RESID, updatestateresidMode);
    146146        // detrunsummary
    147147        MODECASE(DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryMode);
    … …  
    152152        MODECASE(DETTOOL_MODE_UPDATEDETRUN,     updatedetrunMode);
    153153        MODECASE(DETTOOL_MODE_RERUN,            rerunMode);
    154         MODECASE(DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryMode);
     154        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_DETRUNSUMMARY, pendingcleanup_detrunsummaryMode);
    155155        // register
    156156        MODECASE(DETTOOL_MODE_REGISTER_DETREND, register_detrendMode);
    … …  
    187187    psString query = pxDataGet("dettool_pending.sql");
    188188    if (!query) {
    189         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    190         return false;
    191     }
    192    
     189        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     190        return false;
     191    }
     192
    193193    psMetadata *where = psMetadataAlloc();
    194194    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    … …  
    260260        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    261261        return false;
    262     } 
     262    }
    263263    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    264264        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    265265        return false;
    266     } 
    267        
     266    }
     267
    268268    PXOPT_LOOKUP_STR(camera, config->args, "-inst", false, false);
    269269    PXOPT_LOOKUP_STR(telescope, config->args, "-telescope", false, false);
    … …  
    310310        psMetadataItem *mItem = NULL;
    311311        while ((mItem = psListGetAndIncrement(iter))) {
    312             psS64 exp_id = mItem->data.S64;
     312            psS64 exp_id = mItem->data.S64;
    313313            if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    314314                psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    319319        }
    320320        psFree(iter);
    321     } 
     321    }
    322322    if (item->type == PS_DATA_S64) {
    323         psS64 exp_id = item->data.S64;
    324         if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
    325             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    326             psFree(where);
    327             return false;
    328         }
    329     } 
     323        psS64 exp_id = item->data.S64;
     324        if (!psMetadataAddS64(where, PS_LIST_TAIL, "exp_id", PS_META_DUPLICATE_OK, "==", exp_id)) {
     325            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     326            psFree(where);
     327            return false;
     328        }
     329    }
    330330
    331331    if (psListLength(where->list) < 1) {
    … …  
    507507        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    508508        return false;
    509     } 
     509    }
    510510    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    511511        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    512512        return false;
    513     } 
     513    }
    514514
    515515    PXOPT_LOOKUP_STR(filelevel, config->args, "-filelevel", false, false);
    … …  
    676676                 label,
    677677                 ref_det_id,
    678                 ref_iter
     678                ref_iter
    679679        );
    680680    psS64 det_id = psDBLastInsertID(config->dbh);
    … …  
    745745{
    746746    PS_ASSERT_PTR_NON_NULL(config, false);
    747    
     747
    748748    // XXX this mode is not well-tested: probably need to specify iteration here
    749749    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    … …  
    762762        psError(PS_ERR_UNKNOWN, false, "verify mode requires both -ref_det_id and -ref_iter");
    763763        return false;
    764     } 
     764    }
    765765    if (strcmp(mode, "verify") && ((ref_det_id != 0) || (ref_iter != -1))) {
    766766        psError(PS_ERR_UNKNOWN, false, "master mode cannot have -ref_det_id or -ref_iter set");
    767767        return false;
    768     } 
     768    }
    769769
    770770    // the new detRun may have different values for these limits:
    … …  
    820820
    821821    if (iteration < 0) {
    822         iteration = detRun->iteration;
     822        iteration = detRun->iteration;
    823823    }
    824824
    … …  
    980980    psString query = pxDataGet("dettool_definebydetrun.sql");
    981981    if (!query) {
    982         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     982        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    983983        return false;
    984984    }
    … …  
    992992
    993993    if (only_accepted) {
    994         psStringAppend(&query, " AND accept = 1");
     994        psStringAppend(&query, " AND accept = 1");
    995995    }
    996996
    … …  
    10711071    psString query = pxDataGet("dettool_runs.sql");
    10721072    if (!query) {
    1073         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1073        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10741074        return false;
    10751075    }
    … …  
    11411141    psString query = pxDataGet("dettool_childlessrun.sql");
    11421142    if (!query) {
    1143         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1143        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11441144        psFree(where);
    11451145        return false;
    … …  
    12151215    psString query = pxDataGet("dettool_input.sql");
    12161216    if (!query) {
    1217         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1217        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12181218        psFree(where);
    12191219        return false;
    … …  
    12671267    psString query = pxDataGet("dettool_raw.sql");
    12681268    if (!query) {
    1269         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12701270        return false;
    12711271    }
    … …  
    13411341}
    13421342
    1343 // used by updatedetrunMode 
     1343// used by updatedetrunMode
    13441344bool startNewIteration(pxConfig *config, psS64 det_id)
    13451345{
    … …  
    13481348    psString query = pxDataGet("dettool_start_new_iteration.sql");
    13491349    if (!query) {
    1350         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1350        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13511351        return false;
    13521352    }
    … …  
    15671567        }
    15681568        detInputExpRow *newInputExp = detInputExpRowAlloc(
    1569             det_id,
     1569            det_id,
    15701570            newIteration,
    15711571            inputExp->exp_id,
    … …  
    16651665                      solang_max,
    16661666                      label,
    1667                       ref_det_id,
    1668                       ref_iter
     1667                      ref_det_id,
     1668                      ref_iter
    16691669            )) {
    16701670        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17161716{
    17171717    PS_ASSERT_PTR_NON_NULL(config, false);
    1718    
     1718
    17191719    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    17201720    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    … …  
    17311731
    17321732    if (!detRegisteredImfileInsert(config->dbh,
    1733                                    det_id,
    1734                                    0,  // the iteration is fixed at 0
    1735                                    class_id,
    1736                                    uri,
    1737                                    bg,
    1738                                    bg_stdev,
    1739                                    bg_mean_stdev,
    1740                                    user_1,
    1741                                    user_2,
    1742                                    user_3,
    1743                                    user_4,
    1744                                    user_5,
    1745                                    path_base,
    1746                                    "full",                                 
    1747                                    0       // fault code
    1748             )) {
     1733                                   det_id,
     1734                                   0,  // the iteration is fixed at 0
     1735                                   class_id,
     1736                                   uri,
     1737                                   bg,
     1738                                   bg_stdev,
     1739                                   bg_mean_stdev,
     1740                                   user_1,
     1741                                   user_2,
     1742                                   user_3,
     1743                                   user_4,
     1744                                   user_5,
     1745                                   path_base,
     1746                                   "full",
     1747                                   0       // fault code
     1748            )) {
    17491749        psError(PS_ERR_UNKNOWN, false, "database error");
    17501750        return false;
    … …  
    19791979
    19801980    char *query = "UPDATE detStackedImfile SET data_state = '%s'"
    1981         " WHERE det_id = %" PRId64
    1982         " AND iteration = %" PRId32
    1983         " AND class_id = '%s'";
     1981        " WHERE det_id = %" PRId64
     1982        " AND iteration = %" PRId32
     1983        " AND class_id = '%s'";
    19841984    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    19851985        psError(PS_ERR_UNKNOWN, false,
    1986                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s", 
    1987                 det_id, iteration, class_id);
     1986                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s",
     1987                det_id, iteration, class_id);
    19881988        return false;
    19891989    }
    … …  
    20012001
    20022002    char *query = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
    2003         " WHERE det_id = %" PRId64
    2004         " AND iteration = %" PRId32
    2005         " AND class_id = '%s'";
     2003        " WHERE det_id = %" PRId64
     2004        " AND iteration = %" PRId32
     2005        " AND class_id = '%s'";
    20062006/*     fprintf(stderr,"DETTOOL SAYS: %s\n",query); */
    20072007    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration,class_id)) {
    20082008        psError(PS_ERR_UNKNOWN, false,
    2009                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    2010                 det_id, iteration);
     2009                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2010                det_id, iteration);
    20112011        return false;
    20122012    }
    … …  
    20242024
    20252025    char *query = "UPDATE detNormalizedImfile SET data_state = '%s'"
    2026         " WHERE det_id = %" PRId64
    2027         " AND iteration = %" PRId32
    2028         " AND class_id = '%s'";
     2026        " WHERE det_id = %" PRId64
     2027        " AND iteration = %" PRId32
     2028        " AND class_id = '%s'";
    20292029    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration, class_id)) {
    20302030        psError(PS_ERR_UNKNOWN, false,
    2031                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s", 
    2032                 det_id, iteration, class_id);
     2031                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s",
     2032                det_id, iteration, class_id);
    20332033        return false;
    20342034    }
    … …  
    20452045
    20462046    char *query = "UPDATE detNormalizedExp SET data_state = '%s'"
    2047         " WHERE det_id = %" PRId64
    2048         " AND iteration = %" PRId32;
     2047        " WHERE det_id = %" PRId64
     2048        " AND iteration = %" PRId32;
    20492049    if (!p_psDBRunQueryF(config->dbh, query, data_state, det_id, iteration)) {
    20502050        psError(PS_ERR_UNKNOWN, false,
    2051                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, 
    2052                 det_id, iteration);
     2051                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     2052                det_id, iteration);
    20532053        return false;
    20542054    }
    … …  
    20642064    char sqlFilename[80];
    20652065  } ExportTable;
    2066  
     2066
    20672067  int numExportTables = 12;
    20682068
    … …  
    21002100    psString query = pxDataGet(tables[i].sqlFilename);
    21012101    if (!query) {
    2102       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2102      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    21032103      return false;
    21042104    }
    … …  
    21422142    }
    21432143    psFree(output);
    2144  
     2144
    21452145  }
    21462146
    … …  
    21532153{
    21542154  unsigned int nFail;
    2155  
     2155
    21562156  int numImportTables = 11;
    2157  
     2157
    21582158  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
    21592159    "detNormalizedImfile", "detNormalizedStatImfile", "detProcessedExp",
    … …  
    21622162
    21632163  PS_ASSERT_PTR_NON_NULL(config, NULL);
    2164  
     2164
    21652165  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    21662166
    … …  
    21692169  fprintf (stdout, "---- input ----\n");
    21702170  psMetadataPrint (stderr, input, 1);
    2171  
     2171
    21722172  psMetadataItem *item = psMetadataLookup (input, "detRun");
    21732173  psAssert (item, "entry not in input?");
    … …  
    21792179  detRunRow *detRun = detRunObjectFromMetadata (entry->data.md);
    21802180  detRunInsertObject (config->dbh, detRun);
    2181  
     2181
    21822182  // fprintf (stdout, "---- det run ----\n");
    21832183  // psMetadataPrint (stderr, entry->data.md, 1);
    … …  
    21872187    psAssert (item, "entry not in input?");
    21882188    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    2189  
     2189
    21902190    switch (i) {
    21912191      case 0:
    … …  
    22012201        }
    22022202        break;
    2203  
     2203
    22042204      case 1:
    22052205        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22142214        }
    22152215        break;
    2216        
     2216
    22172217      case 2:
    22182218        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22272227        }
    22282228        break;
    2229  
     2229
    22302230      case 3:
    22312231        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22402240        }
    22412241        break;
    2242        
     2242
    22432243      case 4:
    22442244        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22532253        }
    22542254        break;
    2255        
     2255
    22562256      case 5:
    22572257        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22662266        }
    22672267        break;
    2268        
     2268
    22692269      case 6:
    22702270        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22792279        }
    22802280        break;
    2281        
     2281
    22822282      case 7:
    22832283        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    22922292        }
    22932293        break;
    2294        
     2294
    22952295      case 8:
    22962296        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    23052305        }
    23062306        break;
    2307        
     2307
    23082308      case 9:
    23092309        for (int i = 0; i < item->data.list->n; i++) {
    … …  
    23182318        }
    23192319        break;
    2320        
     2320
    23212321      case 10:
    23222322        for (int i = 0; i < item->data.list->n; i++) {

  • trunk/ippTools/src/dettool_correction.c

    r20377 r26981  
    3434    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    3535
    36     // build the needed where 
     36    // build the needed where
    3737    psMetadata *where = psMetadataAlloc();
    3838    psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", ref_det_id);
    … …  
    8888         detRun->solang_max,
    8989         use_label,
    90         detRun->det_id, // ref_det_id
    91         detRun->iteration // ref_iter
     90        detRun->det_id, // ref_det_id
     91        detRun->iteration // ref_iter
    9292    );
    9393    psFree(runs);
    … …  
    140140    psString query = pxDataGet("dettool_tocorrectimfile.sql");
    141141    if (!query) {
    142         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     142        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    143143        return false;
    144144    }
    145145
    146146    if (psListLength(where->list)) {
    147         // NOTE the SQL uses an intermediate table 'det1' for this query
    148         psString whereClause = psDBGenerateWhereConditionSQL(where, "det1"); 
     147        // NOTE the SQL uses an intermediate table 'det1' for this query
     148        psString whereClause = psDBGenerateWhereConditionSQL(where, "det1");
    149149        psStringAppend(&query, " AND %s", whereClause);
    150150        psFree(whereClause);
    … …  
    198198    psString query = pxDataGet("dettool_tocorrectexp.sql");
    199199    if (!query) {
    200         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     200        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    201201        return false;
    202202    }
    … …  
    248248        return false;
    249249    }
    250    
     250
    251251    // automatically stop completed 'correct' detRuns
    252252    psString query = pxDataGet("dettool_stop_completed_correct_runs.sql");
    253253    if (!query) {
    254         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    255255        return false;
    256256    }

  • trunk/ippTools/src/dettool_detrunsummary.c

    r25324 r26981  
    3535    psString query = pxDataGet("dettool_todetrunsummary.sql");
    3636    if (!query) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3838        return false;
    3939    }
    … …  
    135135    psString query = pxDataGet("dettool_find_completed_runs.sql");
    136136    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    138138        return false;
    139139    }
    … …  
    241241    psString query = pxDataGet("dettool_detrunsummary.sql");
    242242    if (!query) {
    243         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     243        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    244244        psFree(where);
    245245        return false;
    … …  
    310310    psString query = pxDataGet("dettool_revertdetrunsummary.sql");
    311311    if (!query) {
    312         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     312        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    313313        return false;
    314314    }
    … …  
    348348  psString query = pxDataGet("dettool_pendingcleanup_detrunsummary.sql");
    349349  if (!query) {
    350     psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     350    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    351351    return(false);
    352352  }
    353  
     353
    354354  if (psListLength(where->list)) {
    355355    psString whereClause = psDBGenerateWhereConditionSQL(where, "detRunSummary");
    … …  
    429429
    430430/*       if (!isValidDataState(data_state)) return false; */
    431      
    432      
    433      
     431
     432
     433
    434434      char *query_detRunSummary = "UPDATE detRunSummary SET data_state = '%s'"
    435         " WHERE det_id = %" PRId64
    436         " AND iteration = %" PRId32;
     435        " WHERE det_id = %" PRId64
     436        " AND iteration = %" PRId32;
    437437      if (!p_psDBRunQueryF(config->dbh, query_detRunSummary, data_state, det_id,iteration)) {
    438         psError(PS_ERR_UNKNOWN, false,
    439                 "failed to change state for det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    440         return false;
     438        psError(PS_ERR_UNKNOWN, false,
     439                "failed to change state for det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     440        return false;
    441441      }
    442442
    443443      /* This check allows the one update to flag everything for cleanup.  The check for full is only temporary while I test for bugs. */
    444444      if ((!strncmp(data_state,"goto_",5)
    445            //      || (!strcmp(data_state,"full"))
    446            //      || (!strcmp(data_state,"cleaned"))
    447            ))   {
    448         char *query_detProcessedImfile = "UPDATE detProcessedImfile SET data_state = '%s'"
    449           " WHERE det_id = %" PRId64;
    450         if (!p_psDBRunQueryF(config->dbh, query_detProcessedImfile,data_state,det_id)) {
    451           psError(PS_ERR_UNKNOWN, false,
    452                   "failed to change state for detProcessedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    453           return(false);
    454         }
    455        
    456         char *query_detProcessedExp = "UPDATE detProcessedExp SET data_state = '%s'"
    457           " WHERE det_id = %" PRId64;
    458         if (!p_psDBRunQueryF(config->dbh, query_detProcessedExp,data_state,det_id)) {
    459           psError(PS_ERR_UNKNOWN, false,
    460                   "failed to change state for detProcessedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    461           return(false);
    462         }
    463        
    464         char *query_detNormalizedImfile = "UPDATE detNormalizedImfile SET data_state = '%s'"
    465           " WHERE det_id = %" PRId64
    466           " AND iteration = %" PRId32;
    467         if (!p_psDBRunQueryF(config->dbh, query_detNormalizedImfile,data_state,det_id,iteration)) {
    468           psError(PS_ERR_UNKNOWN, false,
    469                   "failed to change state for detNormalizedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    470           return(false);
    471         }
    472        
    473         char *query_detNormalizedStatImfile = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
    474           " WHERE det_id = %" PRId64
    475           " AND iteration = %" PRId32;
    476         if (!p_psDBRunQueryF(config->dbh, query_detNormalizedStatImfile,data_state,det_id,iteration)) {
    477           psError(PS_ERR_UNKNOWN, false,
    478                   "failed to change state for detNormalizedStatImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    479           return(false);
    480         }
    481 
    482         char *query_detNormalizedExp = "UPDATE detNormalizedExp SET data_state = '%s'"
    483           " WHERE det_id = %" PRId64
    484           " AND iteration = %" PRId32;
    485         if (!p_psDBRunQueryF(config->dbh, query_detNormalizedExp,data_state,det_id,iteration)) {
    486           psError(PS_ERR_UNKNOWN, false,
    487                   "failed to change state for detNormalizedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    488           return(false);
    489         }
    490        
    491         char *query_detResidImfile = "UPDATE detResidImfile SET data_state = '%s'"
    492           " WHERE det_id = %" PRId64
    493           " AND iteration = %" PRId32;
    494         if (!p_psDBRunQueryF(config->dbh, query_detResidImfile,data_state,det_id,iteration)) {
    495           psError(PS_ERR_UNKNOWN, false,
    496                   "failed to change state for detResidImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    497           return(false);
    498         }
    499        
    500         char *query_detResidExp = "UPDATE detResidExp SET data_state = '%s'"
    501           " WHERE det_id = %" PRId64
    502           " AND iteration = %" PRId32;
    503         if (!p_psDBRunQueryF(config->dbh, query_detResidExp,data_state,det_id,iteration)) {
    504           psError(PS_ERR_UNKNOWN, false,
    505                   "failed to change state for detResidExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    506           return(false);
    507         }
    508        
    509         char *query_detStackedImfile = "UPDATE detStackedImfile SET data_state = '%s'"
    510           " WHERE det_id = %" PRId64
    511           " AND iteration = %" PRId32;
    512         if (!p_psDBRunQueryF(config->dbh, query_detStackedImfile,data_state,det_id,iteration)) {
    513           psError(PS_ERR_UNKNOWN, false,
    514                   "failed to change state for detStackedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
    515           return(false);
    516         }
     445           //      || (!strcmp(data_state,"full"))
     446           //      || (!strcmp(data_state,"cleaned"))
     447           ))   {
     448        char *query_detProcessedImfile = "UPDATE detProcessedImfile SET data_state = '%s'"
     449          " WHERE det_id = %" PRId64;
     450        if (!p_psDBRunQueryF(config->dbh, query_detProcessedImfile,data_state,det_id)) {
     451          psError(PS_ERR_UNKNOWN, false,
     452                  "failed to change state for detProcessedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     453          return(false);
     454        }
     455
     456        char *query_detProcessedExp = "UPDATE detProcessedExp SET data_state = '%s'"
     457          " WHERE det_id = %" PRId64;
     458        if (!p_psDBRunQueryF(config->dbh, query_detProcessedExp,data_state,det_id)) {
     459          psError(PS_ERR_UNKNOWN, false,
     460                  "failed to change state for detProcessedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     461          return(false);
     462        }
     463
     464        char *query_detNormalizedImfile = "UPDATE detNormalizedImfile SET data_state = '%s'"
     465          " WHERE det_id = %" PRId64
     466          " AND iteration = %" PRId32;
     467        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedImfile,data_state,det_id,iteration)) {
     468          psError(PS_ERR_UNKNOWN, false,
     469                  "failed to change state for detNormalizedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     470          return(false);
     471        }
     472
     473        char *query_detNormalizedStatImfile = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
     474          " WHERE det_id = %" PRId64
     475          " AND iteration = %" PRId32;
     476        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedStatImfile,data_state,det_id,iteration)) {
     477          psError(PS_ERR_UNKNOWN, false,
     478                  "failed to change state for detNormalizedStatImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     479          return(false);
     480        }
     481
     482        char *query_detNormalizedExp = "UPDATE detNormalizedExp SET data_state = '%s'"
     483          " WHERE det_id = %" PRId64
     484          " AND iteration = %" PRId32;
     485        if (!p_psDBRunQueryF(config->dbh, query_detNormalizedExp,data_state,det_id,iteration)) {
     486          psError(PS_ERR_UNKNOWN, false,
     487                  "failed to change state for detNormalizedExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     488          return(false);
     489        }
     490
     491        char *query_detResidImfile = "UPDATE detResidImfile SET data_state = '%s'"
     492          " WHERE det_id = %" PRId64
     493          " AND iteration = %" PRId32;
     494        if (!p_psDBRunQueryF(config->dbh, query_detResidImfile,data_state,det_id,iteration)) {
     495          psError(PS_ERR_UNKNOWN, false,
     496                  "failed to change state for detResidImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     497          return(false);
     498        }
     499
     500        char *query_detResidExp = "UPDATE detResidExp SET data_state = '%s'"
     501          " WHERE det_id = %" PRId64
     502          " AND iteration = %" PRId32;
     503        if (!p_psDBRunQueryF(config->dbh, query_detResidExp,data_state,det_id,iteration)) {
     504          psError(PS_ERR_UNKNOWN, false,
     505                  "failed to change state for detResidExp det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     506          return(false);
     507        }
     508
     509        char *query_detStackedImfile = "UPDATE detStackedImfile SET data_state = '%s'"
     510          " WHERE det_id = %" PRId64
     511          " AND iteration = %" PRId32;
     512        if (!p_psDBRunQueryF(config->dbh, query_detStackedImfile,data_state,det_id,iteration)) {
     513          psError(PS_ERR_UNKNOWN, false,
     514                  "failed to change state for detStackedImfile det_id %" PRId64 ", iteration %" PRId32, det_id,iteration);
     515          return(false);
     516        }
    517517      }
    518518      /* End if */
    519      
     519
    520520    }
    521521

  • trunk/ippTools/src/dettool_normalizedexp.c

    r23688 r26981  
    2929    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    8989    psString query = pxDataGet("dettool_tonormalizedexp.sql");
    9090    if (!query) {
    91         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     91        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9292        return false;
    9393    }
    … …  
    156156    psString query = pxDataGet("dettool_normalizedexp.sql");
    157157    if (!query) {
    158         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     158        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    159159        return false;
    160160    }
    … …  
    225225    psString query = pxDataGet("dettool_revertnormalizedexp.sql");
    226226    if (!query) {
    227         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     227        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    228228        return false;
    229229    }
    … …  
    278278    psString query = pxDataGet("dettool_pendingcleanup_normalizedexp.sql");
    279279    if (!query) {
    280         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     280        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    281281        return false;
    282282    }
    … …  
    340340    psString query = pxDataGet("dettool_donecleanup_normalizedexp.sql");
    341341    if (!query) {
    342         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     342        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    343343        return false;
    344344    }

  • trunk/ippTools/src/dettool_normalizedimfile.c

    r23688 r26981  
    3030    psString query = pxDataGet("dettool_tonormalize.sql");
    3131    if (!query) {
    32         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     32        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3333        return false;
    3434    }
    … …  
    137137    psString query = pxDataGet("dettool_normalizedimfile.sql");
    138138    if (!query) {
    139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     139        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    140140        return false;
    141141    }
    … …  
    205205    psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    206206    if (!query) {
    207         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     207        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    208208        return false;
    209209    }
    … …  
    260260    psString query = pxDataGet("dettool_pendingcleanup_normalizedimfile.sql");
    261261    if (!query) {
    262         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     262        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    263263        return false;
    264264    }
    … …  
    323323    psString query = pxDataGet("dettool_donecleanup_normalizedimfile.sql");
    324324    if (!query) {
    325         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     325        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    326326        return false;
    327327    }

  • trunk/ippTools/src/dettool_normalizedstat.c

    r23688 r26981  
    2929    psString query = pxDataGet("dettool_tonormalizedstat.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    117117    psString query = pxDataGet("dettool_normalizedstat.sql");
    118118    if (!query) {
    119         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     119        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    120120        return false;
    121121    }
    … …  
    185185    psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    186186    if (!query) {
    187         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     187        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    188188        return false;
    189189    }
    … …  
    240240    psString query = pxDataGet("dettool_pendingcleanup_normalizedstat.sql");
    241241    if (!query) {
    242         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     242        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    243243        return false;
    244244    }
    … …  
    303303    psString query = pxDataGet("dettool_donecleanup_normalizedstat.sql");
    304304    if (!query) {
    305         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     305        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    306306        return false;
    307307    }

  • trunk/ippTools/src/dettool_processedexp.c

    r26815 r26981  
    2929    psString query = pxDataGet("dettool_toprocessedexp.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    101101    psString query = pxDataGet("dettool_addprocessedexp.sql");
    102102    if (!query) {
    103         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     103        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    104104        return false;
    105105    }
    … …  
    235235    psString query = pxDataGet("dettool_revertprocessedexp.sql");
    236236    if (!query) {
    237         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     237        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    238238        return false;
    239239    }
    … …  
    313313    psString query = pxDataGet("dettool_pendingcleanup_processedexp.sql");
    314314    if (!query) {
    315         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     315        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    316316        return false;
    317317    }
    … …  
    375375    psString query = pxDataGet("dettool_donecleanup_processedexp.sql");
    376376    if (!query) {
    377         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     377        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    378378        return false;
    379379    }

  • trunk/ippTools/src/dettool_processedimfile.c

    r26815 r26981  
    3434    psString query = pxDataGet("dettool_toprocessedimfile.sql");
    3535    if (!query) {
    36         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     36        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3737        return false;
    3838    }
    … …  
    180180    psString query = pxDataGet("dettool_processedimfile.sql");
    181181    if (!query) {
    182         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     182        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    183183        psFree(where);
    184184        return false;
    … …  
    267267    psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    268268    if (!query) {
    269         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     269        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    270270        return false;
    271271    }
    … …  
    299299    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    300300    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    301    
     301
    302302    psMetadata *where = psMetadataAlloc();
    303303
    … …  
    327327    psString query = pxDataGet("dettool_pendingcleanup_processedimfile.sql");
    328328    if (!query) {
    329         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     329        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    330330        return false;
    331331    }
    … …  
    356356    if (!output) {
    357357        psError(PS_ERR_UNKNOWN, false, "database error");
    358 /*      fprintf(stderr,"WTF !output?\n"); */
     358/*      fprintf(stderr,"WTF !output?\n"); */
    359359        return false;
    360360    }
    361361    if (!psArrayLength(output)) {
    362362        psTrace("dettool", PS_LOG_INFO, "no rows found");
    363 /*      fprintf(stderr,"WTF no rows??\n"); */
     363/*      fprintf(stderr,"WTF no rows??\n"); */
    364364        psFree(output);
    365365        return true;
    … …  
    397397    psString query = pxDataGet("dettool_donecleanup_processedimfile.sql");
    398398    if (!query) {
    399         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     399        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    400400        return false;
    401401    }

  • trunk/ippTools/src/dettool_residexp.c

    r26815 r26981  
    3535    psString query = pxDataGet("dettool_toresidexp.sql");
    3636    if (!query) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3838        return false;
    3939    }
    … …  
    119119    psString query = pxDataGet("dettool_toresidexp.sql");
    120120    if (!query) {
    121         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     121        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    122122        return false;
    123123    }
    … …  
    202202    psString query = pxDataGet("dettool_residexp.sql");
    203203    if (!query) {
    204         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     204        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    205205        return false;
    206206    }
    … …  
    277277    psString query = pxDataGet("dettool_revertresidexp.sql");
    278278    if (!query) {
    279         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     279        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    280280        return false;
    281281    }
    … …  
    387387    psString query = pxDataGet("dettool_pendingcleanup_residexp.sql");
    388388    if (!query) {
    389         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     389        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    390390        return false;
    391391    }
    … …  
    450450    psString query = pxDataGet("dettool_donecleanup_residexp.sql");
    451451    if (!query) {
    452         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     452        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    453453        return false;
    454454    }

  • trunk/ippTools/src/dettool_residimfile.c

    r26815 r26981  
    2929    psString query = pxDataGet("dettool_toresidimfile.sql");
    3030    if (!query) {
    31         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     31        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3232        return false;
    3333    }
    … …  
    165165    psString query = pxDataGet("dettool_residimfile.sql");
    166166    if (!query) {
    167         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     167        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    168168        return false;
    169169    }
    … …  
    253253    psString query = pxDataGet("dettool_revertresidimfile.sql");
    254254    if (!query) {
    255         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     255        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    256256        return false;
    257257    }
    … …  
    282282{
    283283    PS_ASSERT_PTR_NON_NULL(config, NULL);
    284    
     284
    285285    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    286286    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", true, false);
    … …  
    292292    PXOPT_COPY_S64(config->args,where,"-exp_id","exp_id","==");
    293293    PXOPT_COPY_STR(config->args,where,"-class_id","class_id","==");
    294    
     294
    295295    if (!setResidImfileDataState(config, where, data_state)) {
    296296        return false;
    … …  
    314314    psString query = pxDataGet("dettool_pendingcleanup_residimfile.sql");
    315315    if (!query) {
    316         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     316        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    317317        return false;
    318318    }
    … …  
    378378    psString query = pxDataGet("dettool_donecleanup_residimfile.sql");
    379379    if (!query) {
    380         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     380        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    381381        return false;
    382382    }

  • trunk/ippTools/src/dettool_stack.c

    r23688 r26981  
    3131    psString query = pxDataGet("dettool_tostacked.sql");
    3232    if (!query) {
    33         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     33        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    3434        return false;
    3535    }
    … …  
    220220    psString query = pxDataGet("dettool_stacked.sql");
    221221    if (!query) {
    222         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     222        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    223223        psFree(where);
    224224        return false;
    … …  
    290290    psString query = pxDataGet("dettool_revertstacked.sql");
    291291    if (!query) {
    292         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     292        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    293293        return false;
    294294    }
    … …  
    345345    psString query = pxDataGet("dettool_pendingcleanup_stacked.sql");
    346346    if (!query) {
    347         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     347        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    348348        return false;
    349349    }
    … …  
    408408    psString query = pxDataGet("dettool_donecleanup_stacked.sql");
    409409    if (!query) {
    410         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     410        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    411411        return false;
    412412    }

  • trunk/ippTools/src/difftool.c

    r26970 r26981  
    195195    if (!psListLength(where->list)) {
    196196        psFree(where);
    197         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     197        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    198198        return false;
    199199    }
    … …  
    383383    psString query = pxDataGet("difftool_inputskyfile.sql");
    384384    if (!query) {
    385         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     385        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    386386        return false;
    387387    }
    … …  
    471471    psString query = pxDataGet("difftool_todiffskyfile.sql");
    472472    if (!query) {
    473         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     473        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    474474        return false;
    475475    }
    … …  
    628628    psString query = pxDataGet("difftool_completed_runs.sql");
    629629    if (!query) {
    630         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     630        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    631631        return false;
    632632    }
    … …  
    748748    psString query = pxDataGet("difftool_skyfile.sql");
    749749    if (!query) {
    750         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     750        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    751751        return false;
    752752    }
    … …  
    759759        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
    760760    } else if (!all) {
    761         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     761        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    762762        return false;
    763763    }
    … …  
    825825    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    826826        psFree(where);
    827         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     827        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    828828        return false;
    829829    }
    … …  
    839839        psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
    840840        if (!query) {
    841             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     841            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    842842            if (!psDBRollback(config->dbh)) {
    843843                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    869869        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    870870        if (!query) {
    871             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     871            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    872872            if (!psDBRollback(config->dbh)) {
    873873                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    11771177    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    11781178    if (!query) {
    1179         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1179        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11801180        return false;
    11811181    }
    … …  
    15911591        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
    15921592        if (!tempCreate) {
    1593             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1593            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15941594            psFree(selectWhere);
    15951595            psFree(insertWhere);
    … …  
    16141614        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
    16151615        if (!tempInsert) {
    1616             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1616            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16171617            psFree(selectWhere);
    16181618            psFree(insertWhere);
    … …  
    16461646    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    16471647    if (!select) {
    1648         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1648        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16491649        psFree(selectWhere);
    16501650        psFree(insertWhere);
    … …  
    19021902  psString query = pxDataGet("difftool_definestackstack_part0.sql");
    19031903  if (!query) {
    1904     psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1904    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    19051905    return(false);
    19061906  }
    19071907  psTrace("difftool",1,query,stack2Query,stack1Query,diffQuery,stack1Query);
    19081908/*   exit(10); */
    1909          
     1909
    19101910  if (!psDBTransaction(config->dbh)) {
    19111911    psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    20932093        psFree(diffQuery);
    20942094        psFree(run);
    2095         psFree(list);
     2095        psFree(list);
    20962096        if (!psDBRollback(config->dbh)) {
    20972097            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    21082108    return false;
    21092109  }
    2110  
     2110
    21112111  if (!diffRunPrintObjects(stdout, list, !simple)) {
    21122112    psError(PS_ERR_UNKNOWN, false, "failed to print object");
    … …  
    21142114    return false;
    21152115  }
    2116  
     2116
    21172117  psFree(query);
    21182118  psFree(stack1Query);
    … …  
    21372137    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    21382138    if (!query) {
    2139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2139        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    21402140        return false;
    21412141    }
    … …  
    22122212    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    22132213    if (!query) {
    2214         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2214        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    22152215        return false;
    22162216    }
    … …  
    22722272    psString query = pxDataGet("difftool_donecleanup.sql");
    22732273    if (!query) {
    2274         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2274        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    22752275        return false;
    22762276    }
    … …  
    24582458    psString query = pxDataGet(tables[i].sqlFilename);
    24592459    if (!query) {
    2460       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2460      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    24612461      return false;
    24622462    }

  • trunk/ippTools/src/disttool.c

    r26925 r26981  
    144144    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
    145145    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    146    
     146
    147147    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    148148
    … …  
    165165        query = pxDataGet("disttool_definebyquery_raw.sql");
    166166        if (!query) {
    167             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     167            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    168168            psFree(where);
    169169            return false;
    … …  
    182182        query = pxDataGet("disttool_definebyquery_chip.sql");
    183183        if (!query) {
    184             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     184            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    185185            psFree(where);
    186186            return false;
    … …  
    198198        query = pxDataGet("disttool_definebyquery_camera.sql");
    199199        if (!query) {
    200             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     200            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    201201            psFree(where);
    202202            return false;
    … …  
    213213        query = pxDataGet("disttool_definebyquery_fake.sql");
    214214        if (!query) {
    215             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     215            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    216216            psFree(where);
    217217            return false;
    … …  
    231231        query = pxDataGet("disttool_definebyquery_warp.sql");
    232232        if (!query) {
    233             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     233            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    234234            psFree(where);
    235235            return false;
    … …  
    248248        query = pxDataGet("disttool_definebyquery_diff.sql");
    249249        if (!query) {
    250             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     250            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    251251            psFree(where);
    252252            return false;
    … …  
    264264        query = pxDataGet("disttool_definebyquery_stack.sql");
    265265        if (!query) {
    266             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     266            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    267267            psFree(where);
    268268            return false;
    … …  
    362362
    363363        psString outroot = NULL;
    364         psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage); 
     364        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
    365365
    366366        psString new_label;
    … …  
    436436    if (!psListLength(where->list)) {
    437437        psFree(where);
    438         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     438        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    439439        return false;
    440440    }
    … …  
    446446
    447447    if ((!state) && (!label) && (!fault)) {
    448         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state or -set_label) are required");
     448        psError(PXTOOLS_ERR_CONFIG, false, "parameters (-fault or -set_state or -set_label) are required");
    449449        psFree(where);
    450450        return false;
    … …  
    497497    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    498498        psFree(where);
    499         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     499        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    500500        return false;
    501501    }
    … …  
    503503    psString query = pxDataGet("disttool_revertrun.sql");
    504504    if (!query) {
    505         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     505        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    506506        if (!psDBRollback(config->dbh)) {
    507507            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    546546    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    547547        psFree(where);
    548         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     548        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    549549        return false;
    550550    }
    … …  
    552552    psString query = pxDataGet("disttool_revertcomponent.sql");
    553553    if (!query) {
    554         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     554        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    555555        psFree(where);
    556556        return false;
    … …  
    594594    psString query = pxDataGet(queryFile);
    595595    if (!query) {
    596         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     596        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    597597        return false;
    598598    }
    … …  
    693693    psString query = pxDataGet("disttool_toadvance.sql");
    694694    if (!query) {
    695         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     695        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    696696        return false;
    697697    }
    … …  
    764764    psString query = pxDataGet("disttool_processedcomponent.sql");
    765765    if (!query) {
    766         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     766        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    767767        return false;
    768768    }
    … …  
    838838    psString query = pxDataGet("disttool_pendingfileset.sql");
    839839    if (!query) {
    840         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     840        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    841841        return false;
    842842    }
    … …  
    908908    PXOPT_LOOKUP_STR(name, config->args, "-name", fault == 0, false);
    909909
    910     if (!rcDSFilesetInsert(config->dbh, 
     910    if (!rcDSFilesetInsert(config->dbh,
    911911            0,          // fs_id
    912912            dist_id,
    … …  
    938938    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    939939        psFree(where);
    940         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     940        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    941941        return false;
    942942    }
    … …  
    944944    psString query = pxDataGet("disttool_revertfileset.sql");
    945945    if (!query) {
    946         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     946        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    947947        psFree(where);
    948948        return false;
    … …  
    986986    psString query = pxDataGet("disttool_pendingdest.sql");
    987987    if (!query) {
    988         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     988        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    989989        return false;
    990990    }
    … …  
    10651065    psString query = pxDataGet("disttool_queuercrun.sql");
    10661066    if (!query) {
    1067         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1067        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10681068        return false;
    10691069    }
    … …  
    11111111    // We either need rc_id or (dest_id and fs_name) to identifiy the rcRun
    11121112    if ((!rc_id) && !(dest_id && fs_name)) {
    1113         psError(PXTOOLS_ERR_DATA, true, "either -rc_id or (-fs_name and -dest_id) are required");
     1113        psError(PXTOOLS_ERR_CONFIG, true, "either -rc_id or (-fs_name and -dest_id) are required");
    11141114        return false;
    11151115    }
    … …  
    11231123        // this can't happen because we checked above
    11241124        psFree(where);
    1125         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1125        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    11261126        return false;
    11271127    }
    … …  
    11331133
    11341134    if (!state && (fault < 0)) {
    1135         psError(PXTOOLS_ERR_DATA, false, "parameters (-fault or -set_state) are required");
     1135        psError(PXTOOLS_ERR_CONFIG, false, "parameters (-fault or -set_state) are required");
    11361136        psFree(where);
    11371137        return false;
    … …  
    11401140    psString query = pxDataGet("disttool_updatercrun.sql");
    11411141    if (!query) {
    1142         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1142        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11431143        return false;
    11441144    }
    … …  
    11971197    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    11981198        psFree(where);
    1199         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1199        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    12001200        return false;
    12011201    }
    … …  
    12031203    psString query = pxDataGet("disttool_revertrcrun.sql");
    12041204    if (!query) {
    1205         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1205        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12061206        if (!psDBRollback(config->dbh)) {
    12071207            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12561256            comment
    12571257            );
    1258            
     1258
    12591259    if (!row) {
    12601260        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
    … …  
    14221422            state ? state : "enabled"
    14231423            );
    1424            
     1424
    14251425    if (!row) {
    14261426        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
    … …  
    14591459    if (!(state || last_fileset)) {
    14601460        psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
    1461 # else 
     1461# else
    14621462    if (!state) {
    14631463#endif
    … …  
    17591759    } else if (!all) {
    17601760        psFree(where);
    1761         psError(PXTOOLS_ERR_DATA, false, "search parameters or -all are required");
     1761        psError(PXTOOLS_ERR_CONFIG, false, "search parameters or -all are required");
    17621762        return false;
    17631763    }
    … …  
    18261826    if (!psListLength(where->list)) {
    18271827        psFree(where);
    1828         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1828        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    18291829        return false;
    18301830    }
    … …  
    18821882    if (!psListLength(where->list)) {
    18831883        psFree(where);
    1884         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1884        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    18851885        return false;
    18861886    }
    … …  
    18941894
    18951895    if ((!state) && (!gotFault)) {
    1896         psError(PXTOOLS_ERR_DATA, true, "parameters (-fault or -set_state) is required");
     1896        psError(PXTOOLS_ERR_CONFIG, true, "parameters (-fault or -set_state) is required");
    18971897        psFree(where);
    18981898        return false;

  • trunk/ippTools/src/dqstatstool.c

    r26378 r26981  
    7171  PXOPT_LOOKUP_BOOL(force,      config->args, "-force", false);
    7272  PXOPT_LOOKUP_U64(limit,       config->args, "-limit", false, 0);
    73  
     73
    7474  // properties of the raw exposures
    7575  psMetadata *where = psMetadataAlloc();
    … …  
    7979  psString query = pxDataGet("dqstatstool_definebyquery.sql");
    8080  if (!query) {
    81     psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     81    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    8282    psFree(where);
    8383    return(false);
    … …  
    9696    psStringAppend(&query, " OR invalid = 0");
    9797  }
    98  
     98
    9999  psFree(where);
    100100  if (limit) {
    … …  
    103103    psFree(limitString);
    104104  }
    105    
     105
    106106  if (!p_psDBRunQuery(config->dbh, query)) {
    107107    psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    140140    return false;
    141141  }
    142  
     142
    143143  // Create the run entry and grab the dqstats_id
    144144  dqstatsRunRow *run = dqstatsRunRowAlloc(
    145                                           0,        // ID
    146                                           "new",    // state
    147                                           registered,
    148                                           set_label,
    149                                           0         // fault
    150                                           );
    151  
     145                                          0,        // ID
     146                                          "new",    // state
     147                                          registered,
     148                                          set_label,
     149                                          0         // fault
     150                                          );
     151
    152152  if (!dqstatsRunInsertObject(config->dbh, run)) {
    153153    if (!psDBRollback(config->dbh)) {
    … …  
    182182
    183183    if (!dqstatsContentInsert(config->dbh,
    184                               dqstats_id,
    185                               exp_id,
    186                               chip_id,
    187                               cam_id,
    188                               warp_id,
    189                               0 // do not create automatically invalid contents
    190                               )) {
     184                              dqstats_id,
     185                              exp_id,
     186                              chip_id,
     187                              cam_id,
     188                              warp_id,
     189                              0 // do not create automatically invalid contents
     190                              )) {
    191191      psError(PS_ERR_UNKNOWN, false, "database error");
    192192      psFree(output);
    193193      if (!psDBRollback(config->dbh)) {
    194         psError(PS_ERR_UNKNOWN, false, "database error");
     194        psError(PS_ERR_UNKNOWN, false, "database error");
    195195      }
    196196      return(false);
    … …  
    210210static bool pendingbundleMode(pxConfig *config) {
    211211  PS_ASSERT_PTR_NON_NULL(config,false);
    212  
     212
    213213  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    214214  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    215  
    216  
     215
     216
    217217  psMetadata *where = psMetadataAlloc();
    218   //  pxdqstatsGetSearchArgs (config, where); 
     218  //  pxdqstatsGetSearchArgs (config, where);
    219219  PXOPT_COPY_S64(config->args, where, "-dqstats_id", "dqstatsRun.dqstats_id", "==");
    220220  PXOPT_COPY_STR(config->args, where, "-label", "dqstatsRun.label", "==");
    221  
     221
    222222  psString query = pxDataGet("dqstatstool_get_run.sql");           // query
    223223  if (!query) {
    224     psError(PXTOOLS_ERR_DATA, false, "Failed to retrieve sql statement (dqstatstool_get_run.sql)");
     224    psError(PXTOOLS_ERR_SYS, false, "Failed to retrieve sql statement (dqstatstool_get_run.sql)");
    225225    return(false);
    226226  }
    … …  
    239239    psFree(limitString);
    240240  }
    241  
     241
    242242  if (!p_psDBRunQuery(config->dbh, query)) {
    243243    psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    246246  }
    247247  psFree(query);                                                  // where whereClause
    248  
     248
    249249  psArray *output = p_psDBFetchResult(config->dbh);               // where whereClause output
    250250  if (!output) {
    … …  
    284284  psString runQuery = pxDataGet("dqstatstool_get_run.sql");
    285285  if (!runQuery) {
    286     psError(PXTOOLS_ERR_DATA, false, "Failed to retrieve sql statement (dqstatstool_get_run.sql)");
     286    psError(PXTOOLS_ERR_SYS, false, "Failed to retrieve sql statement (dqstatstool_get_run.sql)");
    287287    return(false);
    288288  }
    … …  
    292292  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);  // Save for content query
    293293  psStringAppend(&runQuery, " AND %s", whereClause);
    294   psFree(where); 
     294  psFree(where);
    295295
    296296  if (!p_psDBRunQuery(config->dbh, runQuery)) {
    … …  
    301301  }
    302302  psFree(runQuery);
    303  
     303
    304304  psArray *output = p_psDBFetchResult(config->dbh);
    305305  if (!output) {
    … …  
    333333    return(false);
    334334  }
    335  
     335
    336336  psMetadataIterator *iter = psMetadataIteratorAlloc(columns, PS_LIST_HEAD,NULL);
    337337
    … …  
    348348      psStringAppend(&columnlist, ", ");
    349349    }
    350    
     350
    351351    psStringAppend(&columnlist, "%s.%s",
    352                    psMetadataLookupStr(&status,coldef,"TABLE"),
    353                    psMetadataLookupStr(&status,coldef,"ENTRY"));
     352                   psMetadataLookupStr(&status,coldef,"TABLE"),
     353                   psMetadataLookupStr(&status,coldef,"ENTRY"));
    354354
    355355    psMetadataAddStr(colNames,PS_LIST_TAIL,
    356                      psMetadataLookupStr(&status,coldef,"ENTRY"),0,"",
    357                      psMetadataLookupStr(&status,coldef,"COLNAME"));
     356                     psMetadataLookupStr(&status,coldef,"ENTRY"),0,"",
     357                     psMetadataLookupStr(&status,coldef,"COLNAME"));
    358358    psMetadataAddStr(colTypes,PS_LIST_TAIL,
    359                      psMetadataLookupStr(&status,coldef,"ENTRY"),0,"",
    360                      psMetadataLookupStr(&status,coldef,"DATATYPE"));
     359                     psMetadataLookupStr(&status,coldef,"ENTRY"),0,"",
     360                     psMetadataLookupStr(&status,coldef,"DATATYPE"));
    361361  }
    362362  psFree(iter);
    363  
     363
    364364  if (!columnlist) {
    365365    psError(PS_ERR_UNKNOWN, false, "Failed to find a columnlist");
    … …  
    369369    return(false);
    370370  }
    371  
     371
    372372  // Find the contents that comprise this run
    373373  psString contentQuery = pxDataGet("dqstatstool_get_contents.sql");
    374374  if (!contentQuery) {
    375     psError(PXTOOLS_ERR_DATA, false, "Failed to retrieve sql statement (dqstatstool_get_contents.sql)");
     375    psError(PXTOOLS_ERR_SYS, false, "Failed to retrieve sql statement (dqstatstool_get_contents.sql)");
    376376    psFree(whereClause);
    377377    psFree(colNames);
    … …  
    414414  psString query = pxDataGet("dqstatstool_createbundle.sql");
    415415  if (!query) {
    416     psError(PXTOOLS_ERR_DATA, false, "Failed to retrieve sql statement");
     416    psError(PXTOOLS_ERR_SYS, false, "Failed to retrieve sql statement");
    417417    psFree(colNames);
    418418    psFree(colTypes);
    … …  
    448448      psMetadataAddS64(where,PS_LIST_TAIL, "warpRun.warp_id", 0, "==", psMetadataLookupS64(&status,row,"warp_id"));
    449449    }
    450    
     450
    451451    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    452     psStringAppend(&MYquery, " WHERE %s", whereClause);   
     452    psStringAppend(&MYquery, " WHERE %s", whereClause);
    453453    psFree(whereClause);
    454454    psFree(where);
    … …  
    466466    }
    467467    psFree(MYquery);
    468    
     468
    469469    psArray *statsoutput = p_psDBFetchResult(config->dbh);
    470470    if (!statsoutput) {
    … …  
    501501      psString colType = psMetadataLookupStr(&status,colTypes,rowItem->name);
    502502      if (!colType) {
    503         psError(PS_ERR_UNKNOWN,false, "Could not find type for %s",rowItem->name);
    504         return(false);
     503        psError(PS_ERR_UNKNOWN,false, "Could not find type for %s",rowItem->name);
     504        return(false);
    505505      }
    506506      psString colName = psMetadataLookupStr(&status,colNames,rowItem->name);
    507507      if (!colName) {
    508         psError(PS_ERR_UNKNOWN,false, "Could not find name for %s",rowItem->name);
    509         return(false);
     508        psError(PS_ERR_UNKNOWN,false, "Could not find name for %s",rowItem->name);
     509        return(false);
    510510      }
    511511
    512512      if (!strcmp(colType,"PS_DATA_BOOL")) {
    513         success = psMetadataAddBool(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.B);
     513        success = psMetadataAddBool(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.B);
    514514      }
    515515      else if (!strcmp(colType,"PS_DATA_S8")) {
    516         success = psMetadataAddS8(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S8);
     516        success = psMetadataAddS8(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S8);
    517517      }
    518518      else if (!strcmp(colType,"PS_DATA_S16")) {
    519         success = psMetadataAddS16(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S16);
     519        success = psMetadataAddS16(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S16);
    520520      }
    521521      else if (!strcmp(colType,"PS_DATA_S32")) {
    522         success = psMetadataAddS32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S32);
     522        success = psMetadataAddS32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S32);
    523523      }
    524524      else if (!strcmp(colType,"PS_DATA_S64")) {
    525         success = psMetadataAddS64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S64);
     525        success = psMetadataAddS64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.S64);
    526526      }
    527527      else if (!strcmp(colType,"PS_DATA_U8")) {
    528         success = psMetadataAddU8(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U8);
     528        success = psMetadataAddU8(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U8);
    529529      }
    530530      else if (!strcmp(colType,"PS_DATA_U16")) {
    531         success = psMetadataAddU16(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U16);
     531        success = psMetadataAddU16(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U16);
    532532      }
    533533      else if (!strcmp(colType,"PS_DATA_U32")) {
    534         success = psMetadataAddU32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U32);
     534        success = psMetadataAddU32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U32);
    535535      }
    536536      else if (!strcmp(colType,"PS_DATA_U64")) {
    537         success = psMetadataAddU64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U64);
     537        success = psMetadataAddU64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.U64);
    538538      }
    539539      else if (!strcmp(colType,"PS_DATA_F32")) {
    540         success = psMetadataAddF32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.F32);
     540        success = psMetadataAddF32(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.F32);
    541541      }
    542542      else if (!strcmp(colType,"PS_DATA_F64")) {
    543         success = psMetadataAddF64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.F64);
     543        success = psMetadataAddF64(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.F64);
    544544      }
    545545      else if (!strcmp(colType,"PS_DATA_STRING")) {
    546         success = psMetadataAddStr(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.str);
    547       }
    548      
     546        success = psMetadataAddStr(tableRow,PS_LIST_TAIL,colName,0,"",rowItem->data.str);
     547      }
     548
    549549      if (!success) {
    550         psError(PS_ERR_UNKNOWN,false, "Error constructing fits table row.");
    551         psFree(colNames);
    552         psFree(colTypes);
    553         psFree(contents);
    554         psFree(query);
    555         psFree(outTable);
    556         psFree(statsoutput);
    557         psFree(statIter);
    558         psFree(tableRow);
    559         psFree(colType);
    560         psFree(colName);
    561         return(false);
     550        psError(PS_ERR_UNKNOWN,false, "Error constructing fits table row.");
     551        psFree(colNames);
     552        psFree(colTypes);
     553        psFree(contents);
     554        psFree(query);
     555        psFree(outTable);
     556        psFree(statsoutput);
     557        psFree(statIter);
     558        psFree(tableRow);
     559        psFree(colType);
     560        psFree(colName);
     561        return(false);
    562562      }
    563563    }
    … …  
    571571  psFree(query);
    572572  // Define the fits table here.
    573  
     573
    574574  psFits *Table = psFitsOpen(bundleUri,"w");
    575575  if (!Table) {
    … …  
    577577    psFree(outTable);
    578578    return(false);
    579   } 
     579  }
    580580
    581581  psMetadata *header = psMetadataAlloc();
    582582  psMetadataAddS64(header, PS_LIST_TAIL, "DQSTATS_ID", 0, "ID number of DQSTATS run", dqstats_id);
    583  
     583
    584584  if (!psFitsWriteTable(Table,header,outTable,"DQSTATS")) {
    585585    psError(PS_ERR_UNKNOWN, false, "Unable to write table to fits file.");
    … …  
    594594  // Tear down, cleanup.
    595595  psFitsClose(Table);
    596   return(true); 
     596  return(true);
    597597}
    598  
     598
    599599
    600600static bool updaterunMode(pxConfig *config) {
    … …  
    603603  PXOPT_LOOKUP_STR(state,      config->args, "-set_state",      "state",                 "==");
    604604  PXOPT_LOOKUP_S16(fault,      config->args, "-fault",          "fault",                 "==");
    605  
     605
    606606  if (state && ! pxIsValidState(state)) {
    607     psError(PXTOOLS_ERR_DATA, false, "pxIsValidState failed");
    608     return(false);
    609   }
    610  
     607    psError(PXTOOLS_ERR_CONFIG, false, "pxIsValidState failed");
     608    return(false);
     609  }
     610
    611611  psMetadata *where = psMetadataAlloc();
    612612  PXOPT_COPY_S64(config->args, where, "-dqstats_id", "dqstats_id", "==");
    613613  PXOPT_COPY_S64(config->args, where, "-state", "state", "==");
    614  
     614
    615615  if (!psListLength(where->list)) {
    616616    psFree(where);
    617     psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    618     return(false);
    619   }
    620  
     617    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     618    return(false);
     619  }
     620
    621621  psString query = psStringCopy("UPDATE dqstatsRun ");
    622622  psStringAppend(&query," SET state = '%s' ", state);
    … …  
    626626  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    627627  psStringAppend(&query," WHERE %s ",whereClause);
    628  
     628
    629629  if (!p_psDBRunQuery(config->dbh, query)) {
    630630    psError(PS_ERR_UNKNOWN, false, "database error");
    631631    return(false);
    632632  }
    633  
     633
    634634  psFree(query);
    635635  psFree(where);
    636636  psFree(whereClause);
    637  
     637
    638638  return(true);
    639639}
    … …  
    648648  if (!psListLength(where->list)) {
    649649    psFree(where);
    650     psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     650    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    651651    return(false);
    652652  }
    … …  
    667667  return(true);
    668668}
    669    
    670  
    671  
    672    
    673 
    674    
    675    
     669
     670
     671
     672
     673
     674
     675

  • trunk/ippTools/src/faketool.c

    r26175 r26981  
    168168        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    169169        psFree(where);
    170         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     170        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    171171        return false;
    172172    }
    … …  
    190190    psString query = pxDataGet("faketool_find_camrun.sql");
    191191    if (!query) {
    192         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    193193        psFree(where);
    194194        return false;
    … …  
    341341        psFree(where);
    342342        where = NULL;
    343         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     343        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    344344        return false;
    345345    }
    … …  
    350350    bool result = pxUpdateRun(config, where, &query, "fakeRun", true);
    351351    if (!result) {
    352         psError(PXTOOLS_ERR_DATA, false, "pxUpdateRun failed");
     352        psError(psErrorCodeLast(), false, "pxUpdateRun failed");
    353353    }
    354354
    … …  
    375375    psString query = pxDataGet("faketool_find_pendingexp.sql");
    376376    if (!query) {
    377         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     377        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    378378        psFree(where);
    379379        return false;
    … …  
    442442    psString query = pxDataGet("faketool_pendingimfile.sql");
    443443    if (!query) {
    444         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     444        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    445445        return false;
    446446    }
    … …  
    563563    psString query = pxDataGet("faketool_processedimfile.sql");
    564564    if (!query) {
    565         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     565        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    566566        return false;
    567567    }
    … …  
    667667        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    668668        psFree(where);
    669         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     669        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    670670        return false;
    671671    }
    … …  
    673673    psString query = pxDataGet("faketool_revertprocessedimfile.sql");
    674674    if (!query) {
    675         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     675        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    676676        psFree(where);
    677677        return false;
    … …  
    814814    psString query = pxDataGet("faketool_unmasked.sql");
    815815    if (!query) {
    816         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     816        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    817817        return false;
    818818    }
    … …  
    891891    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
    892892    if (!query) {
    893         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     893        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    894894        return false;
    895895    }
    … …  
    956956    psString query = pxDataGet("faketool_pendingcleanupimfile.sql");
    957957    if (!query) {
    958         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     958        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    959959        return false;
    960960    }
    … …  
    10171017    psString query = pxDataGet("faketool_donecleanup.sql");
    10181018    if (!query) {
    1019         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1019        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10201020        return false;
    10211021    }
    … …  
    10791079    psString query = pxDataGet("faketool_completely_processed_exp.sql");
    10801080    if (!query) {
    1081         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1081        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10821082        return false;
    10831083    }
    … …  
    12871287    psString query = pxDataGet(tables[i].sqlFilename);
    12881288    if (!query) {
    1289       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1289      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12901290      return false;
    12911291    }

  • trunk/ippTools/src/flatcorr.c

    r26567 r26981  
    115115    if (!psListLength(where->list)) {
    116116        psFree(where);
    117         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    118         return false;
    119     }
    120 
    121     // require the camera to be defined: this analysis does not make sense 
     117        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     118        return false;
     119    }
     120
     121    // require the camera to be defined: this analysis does not make sense
    122122    // across multiple cameras
    123123    PXOPT_LOOKUP_STR(camera, config->args, "-inst", true, false);
    … …  
    142142    psString query = pxDataGet("chiptool_find_rawexp.sql");
    143143    if (!query) {
    144         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     144        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    145145        psFree(where);
    146146        return false;
    … …  
    173173
    174174    if (pretend) {
    175         for (long i = 0; i < psArrayLength(output); i++) {
    176             // negative simple so the default is true
    177             if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
    178                 psError(PS_ERR_UNKNOWN, false, "failed to print array");
    179                 psFree(output);
    180                 return false;
    181             }
    182         }
     175        for (long i = 0; i < psArrayLength(output); i++) {
     176            // negative simple so the default is true
     177            if (!ippdbPrintMetadataRaw(stdout, output->data[i], !simple)) {
     178                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     179                psFree(output);
     180                return false;
     181            }
     182        }
    183183        psFree(output);
    184184        return true;
    … …  
    195195    // create a new flatcorrRun
    196196    if (!flatcorrRunInsert(
    197             config->dbh,
     197            config->dbh,
    198198            0,      // corr_id
    199             det_type,
     199            det_type,
    200200            dvodb,
    201             camera,
    202             telescope,
    203             NULL,
     201            camera,
     202            telescope,
     203            NULL,
    204204            filter,
    205205            "reg",  // state
    206             make_correction,
     206            make_correction,
    207207            workdir,
    208208            label,
    209209            reduction,
    210             region,
    211             NULL,
    212             0
     210            region,
     211            NULL,
     212            0
    213213        )) {
    214214        if (!psDBRollback(config->dbh)) {
    … …  
    310310    // create a new flatcorrRun
    311311    flatcorrRunRow *row = flatcorrRunRowAlloc(
    312         0,      // corr_id
    313         det_type,
    314         dvodb,
    315         camera,
    316         telescope,
    317         NULL,
    318         filter,
    319         "reg",  // state
    320         make_correction,
    321         workdir,
    322         label,
    323         reduction,
    324         region,
    325         NULL, // hostname
    326         0 // fault
     312        0,      // corr_id
     313        det_type,
     314        dvodb,
     315        camera,
     316        telescope,
     317        NULL,
     318        filter,
     319        "reg",  // state
     320        make_correction,
     321        workdir,
     322        label,
     323        reduction,
     324        region,
     325        NULL, // hostname
     326        0 // fault
    327327        );
    328328
    … …  
    335335        return false;
    336336    }
    337    
     337
    338338    // figure out the ID of the flatcorrRun we just created
    339339    psS64 corr_id = psDBLastInsertID(config->dbh);
    … …  
    377377    psString query = pxDataGet("flatcorr_dropchip.sql");
    378378    if (!query) {
    379         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    380         return false;
     379        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     380        return false;
    381381    }
    382382
    … …  
    420420    psString query = pxDataGet("flatcorr_dropcamera.sql");
    421421    if (!query) {
    422         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    423         return false;
     422        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     423        return false;
    424424    }
    425425
    … …  
    448448    psString query = pxDataGet("flatcorr_chiprundone.sql");
    449449    if (!query) {
    450         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    451         return false;
     450        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     451        return false;
    452452    }
    453453
    … …  
    461461    // treat limit == 0 as "no limit"
    462462    if (limit) {
    463         psString limitString = psDBGenerateLimitSQL(limit);
    464         psStringAppend(&query, " %s", limitString);
    465         psFree(limitString);
     463        psString limitString = psDBGenerateLimitSQL(limit);
     464        psStringAppend(&query, " %s", limitString);
     465        psFree(limitString);
    466466    }
    467467
    … …  
    524524        // queue the exp
    525525        if (!pxcamQueueByChipID(
    526                 config,
    527                 row->chip_id,
    528                 row->workdir,
    529                 row->label,
    530                 row->data_group,
    531                 row->dist_group,
    532                 row->reduction,
    533                 row->expgroup,
    534                 row->dvodb,
    535                 row->tess_id,
    536                 "camera",
     526                config,
     527                row->chip_id,
     528                row->workdir,
     529                row->label,
     530                row->data_group,
     531                row->dist_group,
     532                row->reduction,
     533                row->expgroup,
     534                row->dvodb,
     535                row->tess_id,
     536                "camera",
    537537                row->magicked,
    538538                NULL // note does not propragate
    … …  
    548548        }
    549549
    550         // figure out the ID of the flatcorrRun we just created
    551         psS64 cam_id = psDBLastInsertID(config->dbh);
    552 
    553         // add the camRun entry to the flatcorrCamLink table (include is TRUE)
     550        // figure out the ID of the flatcorrRun we just created
     551        psS64 cam_id = psDBLastInsertID(config->dbh);
     552
     553        // add the camRun entry to the flatcorrCamLink table (include is TRUE)
    554554        if (!flatcorrCamLinkInsert(config->dbh, corr_id, row->chip_id, cam_id, 1)) {
    555555            if (!psDBRollback(config->dbh)) {
    … …  
    559559            return false;
    560560        }
    561        
     561
    562562        psFree(row);
    563563    }
    … …  
    587587    psString query = pxDataGet("flatcorr_camerarundone.sql");
    588588    if (!query) {
    589         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    590         return false;
     589        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     590        return false;
    591591    }
    592592
    … …  
    600600    // treat limit == 0 as "no limit"
    601601    if (limit) {
    602         psString limitString = psDBGenerateLimitSQL(limit);
    603         psStringAppend(&query, " %s", limitString);
    604         psFree(limitString);
     602        psString limitString = psDBGenerateLimitSQL(limit);
     603        psStringAppend(&query, " %s", limitString);
     604        psFree(limitString);
    605605    }
    606606
    … …  
    663663        // queue the exp : force image_only to be false (flatcorr is meaningless with just image info)
    664664        if (!pxaddQueueByCamID(
    665                 config,
    666                 row->cam_id,
    667                 row->workdir,
    668                 row->reduction,
    669                 row->label,
     665                config,
     666                row->cam_id,
     667                row->workdir,
     668                row->reduction,
     669                row->label,
    670670                row->data_group,
    671                 row->dvodb,
     671                row->dvodb,
    672672                NULL,       // note is not propagated
    673                 0)) {
     673                0)) {
    674674            if (!psDBRollback(config->dbh)) {
    675675                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    682682        }
    683683
    684         // figure out the ID of the flatcorrRun we just created
    685         psS64 add_id = psDBLastInsertID(config->dbh);
    686 
    687         // add the addRun entry to the flatcorrAddstarLink table (include is TRUE)
     684        // figure out the ID of the flatcorrRun we just created
     685        psS64 add_id = psDBLastInsertID(config->dbh);
     686
     687        // add the addRun entry to the flatcorrAddstarLink table (include is TRUE)
    688688        if (!flatcorrAddstarLinkInsert(config->dbh, corr_id, row->cam_id, add_id, 1)) {
    689689            if (!psDBRollback(config->dbh)) {
    … …  
    719719    psString query = pxDataGet("flatcorr_pendingprocess.sql");
    720720    if (!query) {
    721         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    722         return false;
     721        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     722        return false;
    723723    }
    724724
    … …  
    732732    // treat limit == 0 as "no limit"
    733733    if (limit) {
    734         psString limitString = psDBGenerateLimitSQL(limit);
    735         psStringAppend(&query, " %s", limitString);
    736         psFree(limitString);
     734        psString limitString = psDBGenerateLimitSQL(limit);
     735        psStringAppend(&query, " %s", limitString);
     736        psFree(limitString);
    737737    }
    738738
    … …  
    755755
    756756    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    757         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    758         psFree(output);
    759         return false;
     757        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     758        psFree(output);
     759        return false;
    760760    }
    761761
    … …  
    814814    // treat limit == 0 as "no limit"
    815815    if (limit) {
    816         psString limitString = psDBGenerateLimitSQL(limit);
    817         psStringAppend(&query, " %s", limitString);
    818         psFree(limitString);
     816        psString limitString = psDBGenerateLimitSQL(limit);
     817        psStringAppend(&query, " %s", limitString);
     818        psFree(limitString);
    819819    }
    820820
    … …  
    837837
    838838    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    839         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    840         psFree(output);
    841         return false;
     839        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     840        psFree(output);
     841        return false;
    842842    }
    843843
    … …  
    854854    PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple",  false);
    855855    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    856    
     856
    857857    psMetadata *where = psMetadataAlloc();
    858858    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipProcessedImfile.chip_id", "==");
    … …  
    860860    psString query = pxDataGet("flatcorr_inputimfile.sql");
    861861    if (!query) {
    862         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     862        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    863863        return false;
    864864    }
    … …  
    873873    // treat limit == 0 as "no limit"
    874874    if (limit) {
    875         psString limitString = psDBGenerateLimitSQL(limit);
    876         psStringAppend(&query, " %s", limitString);
    877         psFree(limitString);
     875        psString limitString = psDBGenerateLimitSQL(limit);
     876        psStringAppend(&query, " %s", limitString);
     877        psFree(limitString);
    878878    }
    879879
    … …  
    896896
    897897    if (!ippdbPrintMetadatas(stdout, output, "flatcorrPending", !simple)) {
    898         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    899         psFree(output);
    900         return false;
     898        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     899        psFree(output);
     900        return false;
    901901    }
    902902
    … …  
    910910
    911911    // check that state is a valid string value
    912     if (!strcmp(state, "reg") && 
    913         !strcmp(state, "new") &&
    914         !strcmp(state, "full"))
     912    if (!strcmp(state, "reg") &&
     913        !strcmp(state, "new") &&
     914        !strcmp(state, "full"))
    915915    {
    916916        psError(PS_ERR_UNKNOWN, false, "invalid state: %s", state);

  • trunk/ippTools/src/magicdstool.c

    r26960 r26981  
    151151    case IPP_STAGE_FAKE:
    152152    case IPP_STAGE_STACK:
    153         psError(PXTOOLS_ERR_DATA, true, "%sRuns do not need to be destreaked", stage);
     153        psError(PXTOOLS_ERR_CONFIG, true, "%sRuns do not need to be destreaked", stage);
    154154        return false;
    155155    case IPP_STAGE_NONE:
    156         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     156        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
    157157        return false;
    158158    default:
    … …  
    163163
    164164    if (!query) {
    165         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    166166        return false;
    167167    }
    … …  
    377377        return false;
    378378      case IPP_STAGE_STACK:
    379         psError(PXTOOLS_ERR_DATA, true, "Stacks do not need to be destreaked");
     379        psError(PXTOOLS_ERR_CONFIG, true, "Stacks do not need to be destreaked");
    380380        return false;
    381381      case IPP_STAGE_NONE:
    382         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     382        psError(PXTOOLS_ERR_CONFIG, true, "%s is not a valid stage", stage);
    383383        return false;
    384384      default:
    … …  
    389389
    390390    if (!query) {
    391         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     391        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    392392        return false;
    393393    }
    … …  
    610610    psString query = pxDataGet(sql_file);
    611611    if (!query) {
    612         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", sql_file);
     612        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", sql_file);
    613613        psFree(sql_file);
    614614        return false;
    … …  
    895895    psString query = pxDataGet("magicdstool_completed_runs.sql");
    896896    if (!query) {
    897         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     897        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    898898        return false;
    899899    }
    … …  
    10261026
    10271027    if (!new_state) {
    1028         if (!strcmp(state, "failed_revert")) { 
     1028        if (!strcmp(state, "failed_revert")) {
    10291029            new_state = "new";
    10301030        } else if (!strcmp(state, "failed_cleanup")) {
    … …  
    11341134    psString query = pxDataGet("magicdstool_getskycells.sql");
    11351135    if (!query) {
    1136         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1136        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11371137        return false;
    11381138    }
    … …  
    12521252    psString query = pxDataGet("magicdstool_toremove.sql");
    12531253    if (!query) {
    1254         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1254        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12551255        return false;
    12561256    }
    … …  
    13301330    psString query = pxDataGet(sql_file);
    13311331    if (!query) {
    1332         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", sql_file);
     1332        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", sql_file);
    13331333        psFree(sql_file);
    13341334        return false;
    … …  
    14081408    psString query = pxDataGet("magicdstool_tocleanup.sql");
    14091409    if (!query) {
    1410         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1410        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14111411        return false;
    14121412    }

  • trunk/ippTools/src/magictool.c

    r26851 r26981  
    135135        psString query = pxDataGet("magictool_definebyquery_select.sql");
    136136        if (!query) {
    137             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    138138            return false;
    139139        }
    … …  
    434434    psString query = pxDataGet("magictool_inputskyfile.sql");
    435435    if (!query) {
    436         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     436        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    437437        return false;
    438438    }
    … …  
    507507    psString query = pxDataGet("magictool_totree.sql");
    508508    if (!query) {
    509         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     509        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    510510        return false;
    511511    }
    … …  
    645645    psString query = pxDataGet("magictool_inputs.sql");
    646646    if (!query) {
    647         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     647        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    648648        return false;
    649649    }
    … …  
    815815    psString query = pxDataGet("magictool_toprocess_inputs.sql");
    816816    if (!query) {
    817         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    818818        return false;
    819819    }
    … …  
    881881    query = pxDataGet("magictool_toprocess_runs.sql");
    882882    if (!query) {
    883         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     883        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    884884        return false;
    885885    }
    … …  
    929929    query = pxDataGet("magictool_toprocess_tree.sql");
    930930    if (!query) {
    931         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     931        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    932932        return false;
    933933    }
    … …  
    10651065    psString query = pxDataGet("magictool_revertnode.sql");
    10661066    if (!query) {
    1067         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1067        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10681068        return false;
    10691069    }
    … …  
    11021102    psString query = pxDataGet("magictool_tomask.sql");
    11031103    if (!query) {
    1104         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1104        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11051105        return false;
    11061106    }
    … …  
    11901190    psString query = pxDataGet("magictool_addmask.sql");
    11911191    if (!query) {
    1192         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1192        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11931193        if (!psDBRollback(config->dbh)) {
    11941194            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    12971297    psString query = pxDataGet("magictool_mask.sql");
    12981298    if (!query) {
    1299         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1299        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13001300        return false;
    13011301    }

  • trunk/ippTools/src/pstamptool.c

    r26565 r26981  
    146146    psString query = pxDataGet("pstamptool_datastore.sql");
    147147    if (!query) {
    148         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     148        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    149149        return false;
    150150    }
    … …  
    199199    char *query = psStringCopy ("UPDATE pstampDataStore SET");
    200200    bool needComma = false;
    201    
     201
    202202    if (lastFileset) {
    203203        psStringAppend(&query, " lastFileset = '%s'", lastFileset);
    … …  
    209209        needComma = true; // be ready in case we add another field
    210210    }
    211                
     211
    212212    psStringAppend(&query, " WHERE ds_id = %" PRId64, ds_id);
    213213
    … …  
    220220    psU64 affected = psDBAffectedRows(config->dbh);
    221221    if (affected != 1) {
    222         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     222        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    223223                                        PRIu64 " rows were modified", affected);
    224224        return false;
    … …  
    245245        label,
    246246        NULL,   // outProduct
    247         uri,   
    248         0       // fault 
     247        uri,
     248        0       // fault
    249249        )) {
    250250        psError(PS_ERR_UNKNOWN, false, "failed to insert request");
    … …  
    271271    psString query = pxDataGet("pstamptool_pendingreq.sql");
    272272    if (!query) {
    273         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     273        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    274274        return false;
    275275    }
    … …  
    342342    psFree(whereClause);
    343343    psFree(where);
    344    
     344
    345345    // treat limit == 0 as "no limit"
    346346    if (limit) {
    … …  
    365365        psTrace("pstamptool", PS_LOG_INFO, "request not found");
    366366        // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
    367         psError(PXTOOLS_ERR_DATA, true, "request not found");
     367        psError(PXTOOLS_ERR_CONFIG, true, "request not found");
    368368        psFree(output);
    369369        // we return false so that the caller can determine that a request does not exist
    … …  
    436436    PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
    437437    PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
    438     PXOPT_LOOKUP_STR(fault,     config->args, "-fault",      false, false);
    439     PXOPT_LOOKUP_STR(uri,       config->args, "-uri",        false, false);
    440     PXOPT_LOOKUP_STR(name,      config->args, "-name",       false, false);
     438    PXOPT_LOOKUP_STR(fault,     config->args, "-fault",      false, false);
     439    PXOPT_LOOKUP_STR(uri,       config->args, "-uri",        false, false);
     440    PXOPT_LOOKUP_STR(name,      config->args, "-name",       false, false);
    441441    PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    442442
    … …  
    485485    // note zero is not an error
    486486    if (affected > 1) {
    487         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     487        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    488488                                        PRIu64 " rows were modified", affected);
    489489        return false;
    … …  
    505505    if (!psListLength(where->list)) {
    506506        psFree(where);
    507         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     507        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    508508        return false;
    509509    }
    … …  
    525525    query = pxDataGet("pstamptool_revertreq.sql");
    526526    psStringAppend(&query, " AND %s", whereClause);
    527    
     527
    528528    psFree(whereClause);
    529529
    … …  
    555555    // unless the job is being inserted with stop state require outputBase
    556556    if (strcmp(stateString, "stop") && !outputBase) {
    557         psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
    558         return false;
     557        psError(PS_ERR_UNKNOWN, true, "-outputBase is required");
     558        return false;
    559559    }
    560560
    561561    // default value for job_type is defined in pstamptoolConfig.c
    562562    if (!strcmp(job_type, "get_image") || !strcmp(job_type, "detect_query") || !strcmp(job_type, "none")) {
    563         stampJob = false;
     563        stampJob = false;
    564564    } else if (!strcmp(job_type, "stamp")) {
    565         stampJob = true;
     565        stampJob = true;
    566566    } else {
    567         psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
    568         return false;
    569     }
    570     if (!pstampJobInsert(config->dbh, 
     567        psError(PS_ERR_UNKNOWN, false, "unknown value for -job_type: %s", job_type);
     568        return false;
     569    }
     570    if (!pstampJobInsert(config->dbh,
    571571            0, // job_id
    572572            req_id,
    573             rownum, 
    574             stateString, 
    575             job_type, 
    576             fault, 
    577             exp_id, 
     573            rownum,
     574            stateString,
     575            job_type,
     576            fault,
     577            exp_id,
    578578            outputBase,
    579579            options,
    … …  
    586586    psU64 affected = psDBAffectedRows(config->dbh);
    587587    if (affected != 1) {
    588         psError(PS_ERR_UNKNOWN, false, 
     588        psError(PS_ERR_UNKNOWN, false,
    589589            "should have affected one row but %" PRIu64 " rows were modified",
    590590            affected);
    … …  
    617617    psString query = pxDataGet("pstamptool_listjob.sql");
    618618    if (!query) {
    619         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     619        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    620620        return false;
    621621    }
    … …  
    679679    psString query = pxDataGet("pstamptool_pendingjob.sql");
    680680    if (!query) {
    681         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     681        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    682682        return false;
    683683    }
    … …  
    744744
    745745    char *query ="UPDATE pstampJob"
    746         " SET state = '%s' %s"
    747         " WHERE job_id = %" PRId64;
    748    
     746        " SET state = '%s' %s"
     747        " WHERE job_id = %" PRId64;
     748
    749749    if (!p_psDBRunQueryF(config->dbh, query, state, faultStr, job_id)) {
    750750        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    756756    psU64 affected = psDBAffectedRows(config->dbh);
    757757    if (affected != 1) {
    758         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     758        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    759759                                        PRIu64 " rows were modified", affected);
    760760        return false;
    … …  
    790790    if (!psListLength(where->list) && !all) {
    791791        psFree(where);
    792         psError(PXTOOLS_ERR_DATA, false, "search parameters or -all are required");
     792        psError(PXTOOLS_ERR_CONFIG, false, "search parameters or -all are required");
    793793        return false;
    794794    }
    … …  
    799799    }
    800800    psFree(where);
    801    
     801
    802802    if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
    803803        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    847847    psString query = pxDataGet("pstamptool_project.sql");
    848848    if (!query) {
    849         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     849        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    850850        return false;
    851851    }
    … …  
    893893
    894894    char *query = psStringCopy ("UPDATE pstampProject SET");
    895    
     895
    896896    psStringAppend(&query, " state = '%s'", state);
    897                
     897
    898898    psStringAppend(&query, " WHERE proj_id = %" PRId64, proj_id);
    899899
    … …  
    906906    psU64 affected = psDBAffectedRows(config->dbh);
    907907    if (affected != 1) {
    908         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     908        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    909909                                        PRIu64 " rows were modified", affected);
    910910        return false;
    … …  
    938938    psString query = pxDataGet("pstamptool_pendingdependent.sql");
    939939    if (!query) {
    940         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     940        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    941941        return false;
    942942    }
    … …  
    986986    }
    987987    // no existing dependent that matches, insert one
    988     // Since we have multiple processes running jobs we have a 
     988    // Since we have multiple processes running jobs we have a
    989989    // race condition here so that's why we need to lock the table
    990990
    … …  
    10321032    psString query = pxDataGet("pstamptool_pendingdependent.sql");
    10331033    if (!query) {
    1034         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1034        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10351035        return false;
    10361036    }
    … …  
    10871087
    10881088    char *query ="UPDATE pstampDependent"
    1089         " SET state = '%s'"
    1090         " WHERE dep_id = %" PRId64;
    1091    
     1089        " SET state = '%s'"
     1090        " WHERE dep_id = %" PRId64;
     1091
    10921092    if (!p_psDBRunQueryF(config->dbh, query, state, dep_id)) {
    10931093        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    10981098    psU64 affected = psDBAffectedRows(config->dbh);
    10991099    if (affected != 1) {
    1100         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %" 
     1100        psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    11011101                                        PRIu64 " rows were modified", affected);
    11021102        return false;

  • trunk/ippTools/src/pubtool.c

    r26956 r26981  
    160160    psString query = pxDataGet("pubtool_definerun.sql"); // Query to run
    161161    if (!query) {
    162         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     162        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    163163        psFree(where);
    164164        return false;
    … …  
    248248    psString query = pxDataGet("pubtool_pending.sql");
    249249    if (!query) {
    250         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     250        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    251251        psFree(where);
    252252        return false;
    … …  
    358358    psString query = pxDataGet("pubtool_revert.sql");
    359359    if (!query) {
    360         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     360        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    361361        psFree(where);
    362362        return false;

  • trunk/ippTools/src/pxadd.c

    r25835 r26981  
    124124bool pxaddQueueByCamID(pxConfig *config,
    125125                       psS64 cam_id,
    126                        char *workdir,
    127                        char *reduction,
    128                        char *label,
     126                       char *workdir,
     127                       char *reduction,
     128                       char *label,
    129129                       char *data_group,
    130                        char *dvodb,
     130                       char *dvodb,
    131131                       char *note,
    132                        bool image_only)
     132                       bool image_only)
    133133{
    134134    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    140140        psMemSetPersistent(query, true);
    141141        if (!query) {
    142             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     142            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    143143            return false;
    144144        }
    … …  
    149149    // on 32/64
    150150    if (!p_psDBRunQueryF(config->dbh, query,
    151                         "new", // state
    152                         workdir  ? workdir   : "NULL",
    153                         "dirty", //workdir_state
    154                         reduction? reduction : "NULL",
    155                         label    ? label     : "NULL",
    156                         data_group ? data_group     : "NULL",
    157                         dvodb    ? dvodb     : "NULL",
    158                         note     ? note     : "NULL",
    159                         image_only,
    160                         (long long) cam_id
     151                        "new", // state
     152                        workdir  ? workdir   : "NULL",
     153                        "dirty", //workdir_state
     154                        reduction? reduction : "NULL",
     155                        label    ? label     : "NULL",
     156                        data_group ? data_group     : "NULL",
     157                        dvodb    ? dvodb     : "NULL",
     158                        note     ? note     : "NULL",
     159                        image_only,
     160                        (long long) cam_id
    161161    )) {
    162162        psError(PS_ERR_UNKNOWN, false, "database error");

  • trunk/ippTools/src/pxadmin.c

    r26194 r26981  
    9494    psString query = pxDataGet("pxadmin_create_tables.sql");
    9595    if (!query) {
    96         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     96        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9797        return false;
    9898    }
    … …  
    135135    psString query = pxDataGet("pxadmin_create_mirror_tables.sql");
    136136    if (!query) {
    137         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     137        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    138138        return false;
    139139    }
    … …  
    220220    psString query = pxDataGet("pxadmin_drop_tables.sql");
    221221    if (!query) {
    222         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     222        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    223223        return false;
    224224    }

  • trunk/ippTools/src/pxcam.c

    r26567 r26981  
    7676bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where) {
    7777
    78     PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",     "==");
    79     PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",       "==");
    80     PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",     "==");
    81     PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",       "==");
    82     PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",    "==");
    83     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",      ">=");
    84     PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",      "<=");
    85     PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",      "==");
    86     PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",     "==");
    87     PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",      "LIKE");
    88     PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",    "==");
     78    PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",     "==");
     79    PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",       "==");
     80    PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",     "==");
     81    PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",       "==");
     82    PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",    "==");
     83    PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",      ">=");
     84    PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",      "<=");
     85    PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",      "==");
     86    PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",     "==");
     87    PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",      "LIKE");
     88    PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",    "==");
    8989    PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "==");
    9090    PXOPT_COPY_F64(config->args,   where, "-airmass_min",        "rawExp.airmass",        ">=");
    … …  
    163163        psMemSetPersistent(query, true);
    164164        if (!query) {
    165             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     165            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    166166            return false;
    167167        }

  • trunk/ippTools/src/pxerrors.c

    r23487 r26981  
    2929    switch (err) {
    3030      case PXTOOLS_ERR_SYS:
    31     return PS_EXIT_SYS_ERROR;
     31        return PS_EXIT_SYS_ERROR;
    3232      case PXTOOLS_ERR_CONFIG:
    33     return PS_EXIT_CONFIG_ERROR;
     33        return PS_EXIT_CONFIG_ERROR;
    3434      case PXTOOLS_ERR_PROG:
    35     return PS_EXIT_PROG_ERROR;
    36       case PXTOOLS_ERR_DATA:
    37     return PS_EXIT_DATA_ERROR;
     35        return PS_EXIT_PROG_ERROR;
    3836      default:
    39     return PS_EXIT_UNKNOWN_ERROR;
     37        return PS_EXIT_UNKNOWN_ERROR;
    4038    }
    4139    return PS_EXIT_UNKNOWN_ERROR;

  • trunk/ippTools/src/pxfake.c

    r25835 r26981  
    7474        psMemSetPersistent(query, true);
    7575        if (!query) {
    76             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     76            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    7777            return false;
    7878        }

  • trunk/ippTools/src/pxmagic.c

    r26569 r26981  
    3535    psString query_temp = pxDataGet(queryFile);
    3636    if (!query_temp) {
    37         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     37        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement from %s", queryFile);
    3838        psFree(queryFile);
    3939        if (!psDBRollback(config->dbh)) {
    … …  
    7575    if (not_destreaked) {
    7676        if (destreaked) {
    77             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -destreaked makes no sense");
     77            psError(PXTOOLS_ERR_CONFIG, true, "providing -not_destreaked and -destreaked makes no sense");
    7878            return false;
    7979        }
    8080        if (magicked) {
    81             psError(PXTOOLS_ERR_DATA, true, "providing -not_destreaked and -magicked makes no sense");
     81            psError(PXTOOLS_ERR_CONFIG, true, "providing -not_destreaked and -magicked makes no sense");
    8282            return false;
    8383        }

  • trunk/ippTools/src/pxtools.c

    r25928 r26981  
    120120    PXOPT_LOOKUP_STR(where_state, config->args, "-state", false, false);
    121121    if (where_state && (psListLength(where->list) < 2)) {
    122         psError(PXTOOLS_ERR_DATA, true, "selection by -state alone is not allowed");
     122        psError(PXTOOLS_ERR_CONFIG, true, "selection by -state alone is not allowed");
    123123        return false;
    124124    }
    … …  
    136136
    137137    if ((!state) && (!label) && (!data_group) && (has_dist_group && !dist_group) && !(note)) {
    138         psError(PXTOOLS_ERR_DATA, false, "parameters are required");
     138        psError(PXTOOLS_ERR_CONFIG, false, "parameters are required");
    139139        return false;
    140140    }
    141141
    142142    if (state && ! pxIsValidState(state)) {
    143         psError(PXTOOLS_ERR_DATA, false, "pxIsValidState failed");
     143        psError(PXTOOLS_ERR_CONFIG, false, "pxIsValidState failed");
    144144        return false;
    145145    }

  • trunk/ippTools/src/pxtoolsErrorCodes.dat

    r23695 r26981  
    88CONFIG                  Problem in configure files
    99PROG                    Programming error
    10 DATA                    invalid data

  • trunk/ippTools/src/pztool.c

    r26378 r26981  
    118118            uri,
    119119            NULL,  // epoch
    120             0      // use_compress                         
     120            0      // use_compress
    121121        )) {
    122122        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    305305    psArray *cameras = pzGetPendingCameras(config);
    306306    if (!cameras) {
    307         psError(PXTOOLS_ERR_DATA, false, "failed to find any cameras");
     307        psError(PXTOOLS_ERR_CONFIG, false, "failed to find any cameras");
    308308        return false;
    309309    }
    … …  
    315315        psString query = pxDataGet("pztool_pendingimfile.sql");
    316316        if (!query) {
    317             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     317            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    318318            psFree(cameraImfiles);
    319319            return false;
    … …  
    493493    psString query = pxDataGet("pztool_find_completed_exp.sql");
    494494    if (!query) {
    495         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     495        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    496496        return false;
    497497    }
    … …  
    815815    psString query = pxDataGet("pztool_revertcopied.sql");
    816816    if (!query) {
    817         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     817        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    818818        return false;
    819819    }
    … …  
    849849    psString query = pxDataGet("pztool_revert_downloadimfile_faults.sql");
    850850    if (!query) {
    851         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     851        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    852852        return false;
    853853    }
    … …  
    864864    psString query = pxDataGet("pztool_revert_fileset_faults.sql");
    865865    if (!query) {
    866         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     866        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    867867        return false;
    868868    }

  • trunk/ippTools/src/receivetool.c

    r26444 r26981  
    136136    psString query = pxDataGet("receivetool_list.sql");
    137137    if (!query) {
    138         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     138        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    139139        psFree(where);
    140140        return false;
    … …  
    195195    psString query = pxDataGet("receivetool_addfileset.sql");
    196196    if (!query) {
    197         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     197        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    198198        return false;
    199199    }
    … …  
    302302    psString query = pxDataGet("receivetool_pendingfileset.sql");
    303303    if (!query) {
    304         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     304        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    305305        psFree(where);
    306306        return false;
    … …  
    381381        psString file_type = psMetadataLookupStr(NULL, md, "file_type");
    382382        psString component = psMetadataLookupStr(NULL, md, "component");
    383        
     383
    384384        if (!file) {
    385385            psError(PS_ERR_UNKNOWN, false, "failed to find value for file");
    … …  
    431431    psString query = pxDataGet("receivetool_pendingfile.sql");
    432432    if (!query) {
    433         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     433        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    434434        psFree(where);
    435435        return false;
    … …  
    514514    psString query = pxDataGet("receivetool_revert.sql");
    515515    if (!query) {
    516         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     516        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    517517        psFree(where);
    518518        return false;
    … …  
    547547    psString query = pxDataGet("receivetool_toadvance.sql");
    548548    if (!query) {
    549         psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     549        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    550550        psFree(where);
    551551        return false;
    … …  
    613613    psString query = NULL;              // Query to execute
    614614    psStringAppend(&query, "UPDATE receiveFileset SET ");
    615    
     615
    616616    psString sep = "";
    617617    if (fault) {
    … …  
    631631        sep = ",";
    632632    }
    633    
     633
    634634    psStringAppend(&query, " WHERE fileset_id = %" PRId64, fileset_id);
    635635

  • trunk/ippTools/src/regtool.c

    r25835 r26981  
    117117    psString query = pxDataGet("regtool_pendingimfile.sql");
    118118    if (!query) {
    119         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     119        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    120120        return false;
    121121    }
    … …  
    347347    psString where2 = NULL;
    348348    if (!pxmagicAddWhere(config, &where2, "rawImfile")) {
    349         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     349        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    350350        return false;
    351351    }
    352352    if (!pxspaceAddWhere(config, &where2, "rawImfile")) {
    353         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     353        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    354354        return false;
    355355    }
    … …  
    357357    psString query = pxDataGet("regtool_processedimfile.sql");
    358358    if (!query) {
    359         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     359        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    360360        psFree(where);
    361361        return false;
    … …  
    367367        psFree(whereClause);
    368368    } else if (!all && !where2) {
    369         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     369        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    370370        return false;
    371371    }
    … …  
    452452    psString query = pxDataGet("regtool_revertprocessedimfile.sql");
    453453    if (!query) {
    454         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     454        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    455455        psFree(where);
    456456        return false;
    … …  
    463463    } else {
    464464        psFree(where);
    465         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     465        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    466466        return false;
    467467    }
    … …  
    493493/*     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false); */
    494494    PXOPT_LOOKUP_S16(burntool_state, config->args, "-burntool_state", false, false);
    495    
    496     if ((fault == INT16_MAX) && !isfinite(burntool_state)) { 
     495
     496    if ((fault == INT16_MAX) && !isfinite(burntool_state)) {
    497497        psError(PS_ERR_UNKNOWN, false, "one of -fault or -burntool_state must be selected");
    498498        return false;
    499499    }
    500     if ((fault != INT16_MAX) && isfinite(burntool_state)) { 
     500    if ((fault != INT16_MAX) && isfinite(burntool_state)) {
    501501        psError(PS_ERR_UNKNOWN, false, "only one of -fault or -burntool_state must be selected");
    502502        return false;
    … …  
    508508
    509509    if (fault != INT16_MAX) {
    510         // this is fairly dangerous : can set all if the where is not set...
    511         if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
    512             psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    513             psFree (where);
    514             return false;
    515         }
     510        // this is fairly dangerous : can set all if the where is not set...
     511        if (!pxSetFaultCode(config->dbh, "rawImfile", where, fault)) {
     512            psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     513            psFree (where);
     514            return false;
     515        }
    516516    }
    517517
    518518    if (isfinite(burntool_state)) {
    519         psString query = pxDataGet("regtool_updateprocessedimfile.sql");
    520         if (!query) {
    521             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    522             return false;
    523         }
    524 
    525         if (!p_psDBRunQueryF(config->dbh, query, burntool_state, exp_id, class_id)) {
    526             psError(PS_ERR_UNKNOWN, false, "database error");
    527             psFree(query);
    528             return false;
    529         }
    530         psFree(query);
     519        psString query = pxDataGet("regtool_updateprocessedimfile.sql");
     520        if (!query) {
     521            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     522            return false;
     523        }
     524
     525        if (!p_psDBRunQueryF(config->dbh, query, burntool_state, exp_id, class_id)) {
     526            psError(PS_ERR_UNKNOWN, false, "database error");
     527            psFree(query);
     528            return false;
     529        }
     530        psFree(query);
    531531    }
    532532    psFree (where);
    … …  
    549549    psString query = pxDataGet("regtool_pendingexp.sql");
    550550    if (!query) {
    551         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     551        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    552552        return false;
    553553    }
    … …  
    687687    psString query = pxDataGet("regtool_pendingexp.sql");
    688688    if (!query) {
    689         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     689        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    690690        return false;
    691691    }
    … …  
    920920    psString query = pxDataGet("regtool_processedexp.sql");
    921921    if (!query) {
    922         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     922        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    923923        return false;
    924924    }
    … …  
    10431043    psString query = pxDataGet("regtool_revertprocessedexp.sql");
    10441044    if (!query) {
    1045         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1045        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10461046        psFree(where);
    10471047        return false;
    … …  
    10541054    } else {
    10551055        psFree(where);
    1056         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1056        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    10571057        return false;
    10581058    }
    … …  
    11111111            psError(PS_ERR_UNKNOWN, false, "database error");
    11121112        }
    1113         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1113        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11141114        return false;
    11151115    }
    … …  
    11371137            psError(PS_ERR_UNKNOWN, false, "database error");
    11381138        }
    1139         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1139        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11401140        return false;
    11411141    }
    … …  
    12291229    psString query = pxDataGet(tables[i].sqlFilename);
    12301230    if (!query) {
    1231       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1231      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12321232      return false;
    12331233    }

  • trunk/ippTools/src/stacktool.c

    r26910 r26981  
    169169    if (!psListLength(where->list)) {
    170170        psFree(where);
    171         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     171        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    172172        return false;
    173173    }
    … …  
    175175    psString select = pxDataGet("stacktool_definebyquery_select.sql");
    176176    if (!select) {
    177         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     177        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    178178        return false;
    179179    }
    … …  
    272272    }
    273273    if (!insert) {
    274         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     274        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    275275        psFree(where);
    276276        return false;
    … …  
    287287        psString part2 = pxDataGet("stacktool_definebyquery_insert_random_part2.sql");
    288288        if (!part2) {
    289             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     289            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    290290            psFree(insert);
    291291            return false;
    … …  
    593593    if (!psListLength(where->list)) {
    594594        psFree(where);
    595         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     595        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    596596        return false;
    597597    }
    … …  
    663663    psString query = pxDataGet("stacktool_inputskyfile.sql");
    664664    if (!query) {
    665         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     665        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    666666        return false;
    667667    }
    … …  
    737737    psString query = pxDataGet("stacktool_tosum.sql");
    738738    if (!query) {
    739         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     739        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    740740        return false;
    741741    }
    … …  
    923923    psString query = pxDataGet("stacktool_sumskyfile.sql");
    924924    if (!query) {
    925         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     925        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    926926        return false;
    927927    }
    … …  
    932932        psFree(whereClause);
    933933    } else if (!all) {
    934         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     934        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    935935        return false;
    936936    }
    … …  
    997997    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    998998        psFree(where);
    999         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     999        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    10001000        return false;
    10011001    }
    … …  
    10041004    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    10051005    if (!delete) {
    1006         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1006        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10071007        return false;
    10081008    }
    … …  
    10851085    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    10861086    if (!query) {
    1087         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1087        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10881088        return false;
    10891089    }
    … …  
    11491149    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    11501150    if (!query) {
    1151         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1151        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    11521152        return false;
    11531153    }
    … …  
    12101210    psString query = pxDataGet("stacktool_donecleanup.sql");
    12111211    if (!query) {
    1212         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1212        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12131213        return false;
    12141214    }
    … …  
    13141314    psString query = pxDataGet(tables[i].sqlFilename);
    13151315    if (!query) {
    1316       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1316      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13171317      return false;
    13181318    }

  • trunk/ippTools/src/warptool.c

    r26676 r26981  
    104104        MODECASE(WARPTOOL_MODE_TOCLEANEDSKYFILE,   tocleanedskyfileMode);
    105105        MODECASE(WARPTOOL_MODE_TOPURGEDSKYFILE,    topurgedskyfileMode);
    106         MODECASE(WARPTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
     106        MODECASE(WARPTOOL_MODE_TOSCRUBBEDSKYFILE,  toscrubbedskyfileMode);
    107107        MODECASE(WARPTOOL_MODE_TOFULLSKYFILE,      tofullskyfileMode);
    108108        MODECASE(WARPTOOL_MODE_UPDATESKYFILE,      updateskyfileMode);
    … …  
    252252        !psMetadataLookupBool(NULL, config->args, "-all")) {
    253253        psFree(where);
    254         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     254        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    255255        return false;
    256256    }
    … …  
    279279    psString query = pxDataGet("warptool_definebyquery.sql");
    280280    if (!query) {
    281         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     281        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    282282        psFree(where);
    283283        return false;
    … …  
    390390    if (!psListLength(where->list)) {
    391391        psFree(where);
    392         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
    393         return false;
    394     }
    395    
     392        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     393        return false;
     394    }
     395
    396396    psString query = psStringCopy("UPDATE warpRun JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
    397397
    … …  
    419419    psString query = pxDataGet("warptool_exp.sql");
    420420    if (!query) {
    421         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     421        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    422422        return false;
    423423    }
    … …  
    493493    psString query = pxDataGet("warptool_imfile.sql");
    494494    if (!query) {
    495         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     495        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    496496        return false;
    497497    }
    … …  
    567567    psString query = pxDataGet("warptool_tooverlap.sql");
    568568    if (!query) {
    569         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     569        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    570570        return false;
    571571    }
    … …  
    682682        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    683683        psFree(where);
    684         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     684        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    685685        return false;
    686686    }
    … …  
    690690        psString query = pxDataGet("warptool_revertoverlap.sql");
    691691        if (!query) {
    692             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     692            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    693693            if (!psDBRollback(config->dbh)) {
    694694                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    822822    psString query = pxDataGet("warptool_scmap.sql");
    823823    if (!query) {
    824         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     824        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    825825        return false;
    826826    }
    … …  
    895895    psString query = pxDataGet("warptool_towarped.sql");
    896896    if (!query) {
    897         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     897        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    898898        return false;
    899899    }
    … …  
    10391039    psString query = pxDataGet("warptool_finished_run_select.sql");
    10401040    if (!query) {
    1041         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1041        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    10421042        return false;
    10431043    }
    … …  
    11151115    psString query = pxDataGet("warptool_finished_run_select.sql");
    11161116    if (!query) {
    1117         psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1117        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    11181118        return false;
    11191119    }
    … …  
    12061206    psString query = pxDataGet("warptool_warped.sql");
    12071207    if (!query) {
    1208         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1208        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    12091209        return false;
    12101210    }
    … …  
    12141214    psString where2 = NULL;
    12151215    if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
    1216         psError(PXTOOLS_ERR_DATA, false, "pxMagicAddWhere failed");
     1216        psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
    12171217        return false;
    12181218    }
    12191219    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    1220         psError(PXTOOLS_ERR_DATA, false, "pxSpaceAddWhere failed");
     1220        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
    12211221        return false;
    12221222    }
    … …  
    12271227        psFree(whereClause);
    12281228    } else if (!all && !where2) {
    1229         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1229        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    12301230        return false;
    12311231    }
    … …  
    13001300        && !psMetadataLookupBool(NULL, config->args, "-all")) {
    13011301        psFree(where);
    1302         psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     1302        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    13031303        return false;
    13041304    }
    … …  
    13151315        psString query = pxDataGet("warptool_revertwarped_delete.sql");
    13161316        if (!query) {
    1317             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1317            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13181318            if (!psDBRollback(config->dbh)) {
    13191319                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    14351435    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    14361436    if (!query) {
    1437         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1437        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    14381438        return false;
    14391439    }
    … …  
    14981498    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    14991499    if (!query) {
    1500         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1500        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15011501        return false;
    15021502    }
    … …  
    15591559    psString query = pxDataGet("warptool_donecleanup.sql");
    15601560    if (!query) {
    1561         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1561        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    15621562        return false;
    15631563    }
    … …  
    17151715    if (!state) {
    17161716      psString query = pxDataGet("warptool_updateskyfile.sql");
    1717      
     1717
    17181718      if (!p_psDBRunQueryF(config->dbh, query, fault, warp_id, skycell_id)) {
    17191719        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    17241724    else {
    17251725      if (strcmp(state,"error_cleaned") == 0) {
    1726         change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
     1726        change_skyfile_data_state(config,"error_cleaned","goto_cleaned");
    17271727      }
    17281728      else if (strcmp(state, "error_scrubbed") == 0) {
    1729         change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
     1729        change_skyfile_data_state(config,"error_scrubbed","goto_scrubbed");
    17301730      }
    17311731      else if (strcmp(state, "error_purged") == 0) {
    1732         change_skyfile_data_state(config,"error_purged","goto_purged");
     1732        change_skyfile_data_state(config,"error_purged","goto_purged");
    17331733      }
    17341734      else {
    1735         psError(PS_ERR_UNKNOWN, false, "unhandled state given");
    1736         return(false);
     1735        psError(PS_ERR_UNKNOWN, false, "unhandled state given");
     1736        return(false);
    17371737      }
    17381738    }
    … …  
    17801780      psString query = pxDataGet(tables[i].sqlFilename);
    17811781      if (!query) {
    1782           psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1782          psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17831783          return false;
    17841784      }
    … …  
    19471947    psString query = pxDataGet("warptool_runstate.sql");
    19481948    if (!query) {
    1949         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1949        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    19501950        return false;
    19511951    }
    … …  
    19561956        psFree(whereClause);
    19571957    } else {
    1958         psError(PXTOOLS_ERR_DATA, true, "search parameters or -all are required");
     1958        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
    19591959        return false;
    19601960    }
Note: See TracChangeset for help on using the changeset viewer.