IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 28375 for trunk/ippTools/src


Ignore:
Timestamp:
Jun 16, 2010, 5:30:27 PM (16 years ago)
Author:
watersc1
Message:

merge of stack association and warp/stack/diff jpegs

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/ippTools/src/difftool.c

    r28056 r28375  
    4444static bool definewarpwarpMode(pxConfig *config);
    4545static bool definestackstackMode(pxConfig *config);
     46static bool tosummaryMode(pxConfig *config);
     47static bool addsummaryMode(pxConfig *config);
    4648static bool pendingcleanuprunMode(pxConfig *config);
    4749static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    9395        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
    9496        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
     97        MODECASE(DIFFTOOL_MODE_TOSUMMARY,             tosummaryMode);
     98        MODECASE(DIFFTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    9599        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    96100        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    22502254}
    22512255
     2256static bool tosummaryMode(pxConfig *config) {
     2257  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2258 
     2259  psMetadata *where = psMetadataAlloc();
     2260  PXOPT_COPY_S64(config->args, where, "-warp_id",    "diffSkyfile.warp_id", "==");
     2261  PXOPT_COPY_STR(config->args, where, "-tess_id",    "diffSkyfile.tess_id", "==");
     2262  PXOPT_COPY_STR(config->args, where, "-state",      "diffRun.state", "==");
     2263  PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     2264  PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     2265  PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     2266  PXOPT_COPY_S64(config->args, where, "-magicked", "diffSkyfile.magicked", "==");
     2267  pxAddLabelSearchArgs (config, where, "-label",   "diffRun.label", "LIKE");
     2268  pxAddLabelSearchArgs (config, where, "-data_group",   "diffRun.data_group", "LIKE");
     2269
     2270  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2271
     2272  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2273  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2274 
     2275  // find all rawImfiles matching the default query
     2276  psString query = pxDataGet("difftool_tosummary.sql");
     2277  if (!query) {
     2278    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2279    return false;
     2280  }
     2281
     2282  // generate where strings for arguments that require extra processing
     2283  // beyond PXOPT_COPY*
     2284  psString where2 = NULL;
     2285  if (!pxmagicAddWhere(config, &where2, "diffSkyfile")) {
     2286    psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     2287    return false;
     2288  }
     2289 
     2290  if (psListLength(where->list)) {
     2291    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2292    psStringAppend(&query, " AND %s", whereClause);
     2293    psFree(whereClause);
     2294  } else if (!all && !where2) {
     2295    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2296    return false;
     2297  }
     2298 
     2299  if (where2) {
     2300    if (psListLength(where->list)) {
     2301      psStringAppend(&query, " %s", where2);
     2302    } else {
     2303      psStringAppend(&query, " AND 1 %s", where2);
     2304    }
     2305  }
     2306  psFree(where);
     2307
     2308  // treat limit == 0 as "no limit"
     2309  if (limit) {
     2310    psString limitString = psDBGenerateLimitSQL(limit);
     2311    psStringAppend(&query, " %s", limitString);
     2312    psFree(limitString);
     2313  }
     2314 
     2315  if (!p_psDBRunQuery(config->dbh, query)) {
     2316    psError(PS_ERR_UNKNOWN, false, "database error");
     2317    psFree(query);
     2318    return false;
     2319  }
     2320  psFree(query);
     2321
     2322  psArray *output = p_psDBFetchResult(config->dbh);
     2323  if (!output) {
     2324    psErrorCode err = psErrorCodeLast();
     2325    switch (err) {
     2326    case PS_ERR_DB_CLIENT:
     2327      psError(PXTOOLS_ERR_SYS, false, "database error");
     2328    case PS_ERR_DB_SERVER:
     2329      psError(PXTOOLS_ERR_PROG, false, "database error");
     2330    default:
     2331      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2332    }
     2333   
     2334    return false;
     2335  }
     2336  if (!psArrayLength(output)) {
     2337    psTrace("difftool", PS_LOG_INFO, "no rows found");
     2338    psFree(output);
     2339    return true;
     2340  }
     2341 
     2342  if (psArrayLength(output)) {
     2343    // negative simple so the default is true
     2344    if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     2345      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2346      psFree(output);
     2347      return false;
     2348    }
     2349  }
     2350 
     2351  psFree(output);
     2352  return(true);
     2353}
     2354static bool addsummaryMode(pxConfig *config) {
     2355  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2356
     2357  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2358  PXOPT_LOOKUP_STR(projection_cell, config->args, "-projection_cell", true, false);
     2359  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     2360
     2361  psString query = pxDataGet("difftool_addsummary.sql");
     2362  if (!query) {
     2363    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2364    return(false);
     2365  }
     2366  if (!p_psDBRunQueryF(config->dbh, query, diff_id, projection_cell, path_base)) {
     2367    psError(PS_ERR_UNKNOWN, false, "database error");
     2368    psFree(query);
     2369    return(false);
     2370  }
     2371  psS64 numUpdated = psDBAffectedRows(config->dbh);
     2372 
     2373  if (numUpdated != 1) {
     2374    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     2375    psFree(query);
     2376    return false;
     2377  }
     2378 
     2379  psFree(query);
     2380
     2381  // Print anything here?
     2382 
     2383  return(true);
     2384}
     2385
     2386
    22522387static bool pendingcleanuprunMode(pxConfig *config)
    22532388{

  • trunk/ippTools/src/difftool.h

    r27794 r28375  
    3232    DIFFTOOL_MODE_ADDDIFFSKYFILE,
    3333    DIFFTOOL_MODE_ADVANCE,
     34    DIFFTOOL_MODE_TOSUMMARY,
     35    DIFFTOOL_MODE_ADDSUMMARY,
    3436    DIFFTOOL_MODE_DIFFSKYFILE,
    3537    DIFFTOOL_MODE_REVERTDIFFSKYFILE,

  • trunk/ippTools/src/difftoolConfig.c

    r28054 r28375  
    323323    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    324324
     325    // -tosummary
     326    psMetadata *tosummaryArgs = psMetadataAlloc();
     327    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     328    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     329    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     330    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-exp_id",  0,           "search by exposure ID", 0);
     331    psMetadataAddStr(tosummaryArgs , PS_LIST_TAIL, "-exp_name",  0,        "search by exposure name", NULL);
     332    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-warp_id", 0,         "search by warp ID", 0);
     333   
     334    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     335    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     336    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
     337    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-magicked", 0,         "search by magic id", 0);
     338    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     339    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     340    psMetadataAddStr(tosummaryArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     341    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL,  "-destreaked", 0, "search for runs that have been destreaked", false);
     342    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL,  "-not_destreaked", 0, "search for runs that have not been destreaked", false);
     343   
     344    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     345    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     346    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     347   
     348    // -addsummary
     349    psMetadata *addsummaryArgs = psMetadataAlloc();
     350    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     351    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-projection_cell", 0, "set projection cell", NULL);
     352    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0, "set summary path base", NULL);
     353
    325354    // -pendingcleanupskyfile
    326355    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
    … …  
    380409    psMetadata *importrunArgs = psMetadataAlloc();
    381410    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    382 
    383411
    384412
    … …  
    415443    PXOPT_ADD_MODE("-toscrubbedskyfile", "set skyfile as scrubbed", DIFFTOOL_MODE_TOSCRUBBEDSKYFILE, toscrubbedskyfileArgs);
    416444    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full", DIFFTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
     445    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", DIFFTOOL_MODE_TOSUMMARY, tosummaryArgs);
     446    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", DIFFTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    417447
    418448    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/stacktool.c

    r28043 r28375  
    3939static bool addsumskyfileMode(pxConfig *config);
    4040static bool sumskyfileMode(pxConfig *config);
     41static bool sassskyfileMode(pxConfig *config);
    4142static bool revertsumskyfileMode(pxConfig *config);
     43static bool tosummaryMode(pxConfig *config);
     44static bool addsummaryMode(pxConfig *config);
    4245static bool pendingcleanuprunMode(pxConfig *config);
    4346static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    7578        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,         addsumskyfileMode);
    7679        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
     80        MODECASE(STACKTOOL_MODE_SASSSKYFILE,            sassskyfileMode);
    7781        MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileMode);
     82        MODECASE(STACKTOOL_MODE_TOSUMMARY,             tosummaryMode);
     83        MODECASE(STACKTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    7884        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    7985        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    102108    exit(exit_status);
    103109}
     110//stackAssociationRow *association = pxStackAssociationDefine(data_group,tess_id,filter,skycell_id);
     111stackAssociationRow *pxStackAssociationDefine(pxConfig *config, psS64 stack_id) {
     112  psString select = pxDataGet("stacktool_associationdefine_select.sql");
     113  if (!select) {
     114    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     115    return false;
     116  }
     117
     118  psString idString = NULL;
     119  psStringAppend(&idString, "%" PRId64, stack_id);
     120  // Copy string to get around the issue with psStringSubstitute not believing
     121  // that select is a psString.
     122  psString rep = psStringCopy(select);
     123  psFree(select);
     124  select = rep;
     125  psStringSubstitute(&select, idString, "@STACK_ID@");
     126  psFree(idString);
     127
     128  if (!p_psDBRunQuery(config->dbh, select)) {
     129    psError(PS_ERR_UNKNOWN,false, "database error");
     130    psFree(select);
     131    return(NULL);
     132  }
     133  psFree(select);
     134  psArray *output = p_psDBFetchResult(config->dbh);
     135  if (!output) {
     136    psErrorCode err = psErrorCodeLast();
     137    switch (err) {
     138    case PS_ERR_DB_CLIENT:
     139      psError(PXTOOLS_ERR_SYS, false, "database error");
     140    case PS_ERR_DB_SERVER:
     141      psError(PXTOOLS_ERR_PROG, false, "database error");
     142    default:
     143      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     144    }
     145    return(NULL);
     146  }
     147  if (psArrayLength(output) != 1) {
     148    psWarning("stacktool: incorrect number of rows found");
     149    psFree(output);
     150    return(NULL);
     151  }
     152  psMetadata *outrow = psMetadataAlloc();
     153  for (long i = 0; i < output->n; i++) {
     154    psMetadata *row = output->data[i];
     155
     156    printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,row,"sass_id"),
     157           psMetadataLookupStr(NULL,row,"data_group"),
     158           psMetadataLookupStr(NULL,row,"tess_id"),
     159           psMetadataLookupStr(NULL,row,"filter"),
     160           psMetadataLookupStr(NULL,row,"projection_cell"));
     161
     162    if (psMetadataLookupS64(NULL,row,"sass_id") == PS_MAX_S64) {
     163      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",0);
     164    }
     165    else {
     166      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",psMetadataLookupS64(NULL,row,"sass_id"));
     167    }
     168    psMetadataAddStr(outrow,PS_LIST_TAIL,"data_group",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"data_group"));
     169    psMetadataAddStr(outrow,PS_LIST_TAIL,"tess_id",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"tess_id"));
     170    psMetadataAddStr(outrow,PS_LIST_TAIL,"filter",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"filter"));
     171    psMetadataAddStr(outrow,PS_LIST_TAIL,"projection_cell",PS_META_REPLACE,"",
     172                     psMetadataLookupStr(NULL,row,"projection_cell"));
     173  }
     174  printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,outrow,"sass_id"),
     175         psMetadataLookupStr(NULL,outrow,"data_group"),
     176         psMetadataLookupStr(NULL,outrow,"tess_id"),
     177         psMetadataLookupStr(NULL,outrow,"filter"),
     178         psMetadataLookupStr(NULL,outrow,"projection_cell"));
     179 
     180
     181  psFree(output);
     182  stackAssociationRow *sassRow = stackAssociationObjectFromMetadata(outrow);
     183  psFree(outrow);
     184  return(sassRow);
     185}
     186     
     187     
     188 
     189                                             
    104190
    105191
    … …  
    395481        psFree(run);
    396482
     483        //CZW Add an association entry here.
     484        // Define the requested association, and insert it if it doesn't already exist
     485        stackAssociationRow *association = pxStackAssociationDefine(config,stack_id);
     486        psS64 sass_id;
     487        if (!association->sass_id) {
     488          psTrace("stacktool.association",2,"No required Association found. Adding.");
     489
     490          if (!stackAssociationInsertObject(config->dbh,association)) {
     491            if (!psDBRollback(config->dbh)) {
     492              psError(PS_ERR_UNKNOWN, false, "database error");
     493            }
     494            psError(PS_ERR_UNKNOWN, false, "database error");
     495            psFree(output);
     496            psFree(run);
     497            psFree(insert);
     498            psFree(list);
     499            psFree(association);
     500            if (!psDBRollback(config->dbh)) {
     501              psError(PS_ERR_UNKNOWN, false, "database error");
     502            }
     503            return(false);
     504          }
     505          sass_id = psDBLastInsertID(config->dbh);
     506          association->sass_id = sass_id;
     507        }
     508        // Insert the map entry for this row.
     509        stackAssociationMapRow *maprow = stackAssociationMapRowAlloc(sass_id,stack_id);
     510        if (!stackAssociationMapInsertObject(config->dbh,maprow)) {
     511          if (!psDBRollback(config->dbh)) {
     512            psError(PS_ERR_UNKNOWN, false, "database error");
     513          }
     514          psError(PS_ERR_UNKNOWN, false, "database error");
     515          psFree(output);
     516          psFree(run);
     517          psFree(insert);
     518          psFree(list);
     519          psFree(association);
     520          if (!psDBRollback(config->dbh)) {
     521            psError(PS_ERR_UNKNOWN, false, "database error");
     522          }
     523          return(false);
     524        }
     525       
     526       
    397527        // Create a suitable insertion query for this run
    398528        psString thisInsert = psStringCopy(insert);
    … …  
    552682    run->stack_id = psDBLastInsertID(config->dbh);
    553683
     684    //CZW Add an association entry here.
     685   
    554686    // insert the stackInputSkyfile rows
    555687    psListIterator *iter = psListIteratorAlloc(warp_ids->data.list, 0, false);
    … …  
    603735#endif
    604736    psMetadata *where = psMetadataAlloc();
    605     PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
    606     PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
    607     PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     737    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stackRun.stack_id",   "==");
     738    PXOPT_COPY_STR(config->args, where, "-label",     "stackRun.label",     "==");
     739    PXOPT_COPY_STR(config->args, where, "-state",     "stackRun.state",     "==");
     740    PXOPT_COPY_STR(config->args, where, "-sass_id",   "stackAssociationMap.sass_id",  "==");
    608741    if (!psListLength(where->list)) {
    609742        psFree(where);
    … …  
    612745    }
    613746
     747    //CZW join against stackAssociationMap
    614748    psString query = psStringCopy("UPDATE stackRun");
    615749
    … …  
    10381172}
    10391173
    1040 
    1041 static bool revertsumskyfileMode(pxConfig *config)
     1174static bool sassskyfileMode(pxConfig *config)
    10421175{
    10431176    PS_ASSERT_PTR_NON_NULL(config, false);
    10441177
    10451178    psMetadata *where = psMetadataAlloc();
    1046     PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    1047     pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    1048     PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    1049 
    1050     if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    1051         psFree(where);
    1052         psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    1053         return false;
    1054     }
    1055 
    1056     // Delete product
    1057     psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    1058     if (!delete) {
     1179    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociation.sass_id", "==");
     1180    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackAssociation.tess_id", "==");
     1181    PXOPT_COPY_STR(config->args, where, "-projection_cell", "stackAssociation.projection_cell", "==");
     1182    PXOPT_COPY_STR(config->args, where, "-filter", "stackAssociation.filter", "LIKE");
     1183    PXOPT_COPY_STR(config->args, where, "-data_group", "stackAssociation.data_group", "LIKE");
     1184
     1185//  The following three selectors are incompatible with the sql so omit them
     1186//    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     1187//     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
     1188//    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     1189
     1190    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1191
     1192    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1193    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1194
     1195    psString query = pxDataGet("stacktool_sassskyfile.sql");
     1196    if (!query) {
    10591197        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10601198        return false;
    … …  
    10631201    if (psListLength(where->list)) {
    10641202        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1065         psStringAppend(&delete, " AND %s", whereClause);
     1203        psStringAppend(&query, " WHERE %s", whereClause);
    10661204        psFree(whereClause);
    1067     }
    1068 
    1069     if (!p_psDBRunQuery(config->dbh, delete)) {
    1070         psError(PS_ERR_UNKNOWN, false, "database error");
    1071         psFree(delete);
    1072         psFree(where);
    1073         return false;
    1074     }
    1075     psFree(delete);
    1076 
    1077     int numRows = psDBAffectedRows(config->dbh); // Number of row affected
    1078     psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
    1079 
    1080     psFree(where);
    1081 
    1082     return true;
    1083 }
    1084 
    1085 
    1086 static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
    1087 {
    1088     PS_ASSERT_PTR_NON_NULL(state, false);
    1089 
    1090     // check that state is a valid string value
    1091     if (!pxIsValidState(state)) {
    1092         psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    1093         return false;
    1094     }
    1095 
    1096     char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
    1097     if (!p_psDBRunQueryF(config->dbh, query, state, stack_id)) {
    1098         psError(PS_ERR_UNKNOWN, false,
    1099                 "failed to change state for stack_id %"PRId64, stack_id);
    1100         return false;
    1101     }
    1102 
    1103     return true;
    1104 }
    1105 
    1106 #ifdef notdef
    1107 static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
    1108 {
    1109     PS_ASSERT_PTR_NON_NULL(state, false);
    1110 
    1111     // check that state is a valid string value
    1112     if (!pxIsValidState(state)) {
    1113         psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    1114         return false;
    1115     }
    1116 
    1117     char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
    1118     if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
    1119         psError(PS_ERR_UNKNOWN, false,
    1120                 "failed to change state for label %s", label);
    1121         return false;
    1122     }
    1123 
    1124     return true;
    1125 }
    1126 #endif
    1127 
    1128 static bool pendingcleanuprunMode(pxConfig *config)
    1129 {
    1130     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1131 
    1132     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1133     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1134 
    1135     psMetadata *where = psMetadataAlloc();
    1136     pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    1137 
    1138     psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    1139     if (!query) {
    1140         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1141         return false;
    1142     }
    1143 
    1144     if (where && psListLength(where->list)) {
    1145         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1146         psStringAppend(&query, " AND %s", whereClause);
    1147         psFree(whereClause);
    1148     }
     1205    } else if (!all) {
     1206        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1207        return false;
     1208    }
     1209
    11491210    psFree(where);
    11501211
    … …  
    11651226    psArray *output = p_psDBFetchResult(config->dbh);
    11661227    if (!output) {
    1167         psError(PS_ERR_UNKNOWN, false, "database error");
     1228        psErrorCode err = psErrorCodeLast();
     1229        switch (err) {
     1230            case PS_ERR_DB_CLIENT:
     1231                psError(PXTOOLS_ERR_SYS, false, "database error");
     1232            case PS_ERR_DB_SERVER:
     1233                psError(PXTOOLS_ERR_PROG, false, "database error");
     1234            default:
     1235                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1236        }
     1237
    11681238        return false;
    11691239    }
    … …  
    11741244    }
    11751245
     1246    if (psArrayLength(output)) {
     1247        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     1248            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1249            psFree(output);
     1250            return false;
     1251        }
     1252    }
     1253
     1254    psFree(output);
     1255
     1256    return true;
     1257}
     1258
     1259
     1260static bool revertsumskyfileMode(pxConfig *config)
     1261{
     1262    PS_ASSERT_PTR_NON_NULL(config, false);
     1263
     1264    psMetadata *where = psMetadataAlloc();
     1265    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
     1266    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
     1267    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     1268
     1269    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1270        psFree(where);
     1271        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1272        return false;
     1273    }
     1274
     1275    // Delete product
     1276    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     1277    if (!delete) {
     1278        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1279        return false;
     1280    }
     1281
     1282    if (psListLength(where->list)) {
     1283        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1284        psStringAppend(&delete, " AND %s", whereClause);
     1285        psFree(whereClause);
     1286    }
     1287
     1288    if (!p_psDBRunQuery(config->dbh, delete)) {
     1289        psError(PS_ERR_UNKNOWN, false, "database error");
     1290        psFree(delete);
     1291        psFree(where);
     1292        return false;
     1293    }
     1294    psFree(delete);
     1295
     1296    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     1297    psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
     1298
     1299    psFree(where);
     1300
     1301    return true;
     1302}
     1303
     1304
     1305static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
     1306{
     1307    PS_ASSERT_PTR_NON_NULL(state, false);
     1308
     1309    // check that state is a valid string value
     1310    if (!pxIsValidState(state)) {
     1311        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1312        return false;
     1313    }
     1314
     1315    char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
     1316    if (!p_psDBRunQueryF(config->dbh, query, state, stack_id)) {
     1317        psError(PS_ERR_UNKNOWN, false,
     1318                "failed to change state for stack_id %"PRId64, stack_id);
     1319        return false;
     1320    }
     1321
     1322    return true;
     1323}
     1324
     1325#ifdef notdef
     1326static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
     1327{
     1328    PS_ASSERT_PTR_NON_NULL(state, false);
     1329
     1330    // check that state is a valid string value
     1331    if (!pxIsValidState(state)) {
     1332        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1333        return false;
     1334    }
     1335
     1336    char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
     1337    if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
     1338        psError(PS_ERR_UNKNOWN, false,
     1339                "failed to change state for label %s", label);
     1340        return false;
     1341    }
     1342
     1343    return true;
     1344}
     1345#endif
     1346static bool tosummaryMode(pxConfig *config) {
     1347  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1348 
     1349  psMetadata *where = psMetadataAlloc();
     1350  PXOPT_COPY_S64(config->args, where, "-stack_id",    "stackSumSkyfile.warp_id", "==");
     1351  PXOPT_COPY_S64(config->args, where, "-sass_id",     "stackAssociationMap.sass_id", "==");
     1352  PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackSumSkyfile.tess_id", "==");
     1353  PXOPT_COPY_STR(config->args, where, "-state",      "stackRun.state", "==");
     1354  PXOPT_COPY_STR(config->args, where, "-filter",    "stackRun.filter", "LIKE");
     1355  pxAddLabelSearchArgs (config, where, "-label",   "stackRun.label", "LIKE");
     1356  pxAddLabelSearchArgs (config, where, "-data_group",   "stackRun.data_group", "LIKE");
     1357 
     1358  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1359
     1360  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1361  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1362 
     1363  // find all rawImfiles matching the default query
     1364  psString query = pxDataGet("stacktool_tosummary.sql");
     1365  if (!query) {
     1366    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1367    return false;
     1368  }
     1369
     1370  // generate where strings for arguments that require extra processing
     1371  // beyond PXOPT_COPY*
     1372  if (psListLength(where->list)) {
     1373    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1374    psStringAppend(&query, " AND %s", whereClause);
     1375    psFree(whereClause);
     1376  } else if (!all) {
     1377    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1378    return false;
     1379  }
     1380 
     1381  psFree(where);
     1382
     1383  // treat limit == 0 as "no limit"
     1384  if (limit) {
     1385    psString limitString = psDBGenerateLimitSQL(limit);
     1386    psStringAppend(&query, " %s", limitString);
     1387    psFree(limitString);
     1388  }
     1389
     1390  if (!p_psDBRunQuery(config->dbh, query)) {
     1391    psError(PS_ERR_UNKNOWN, false, "database error");
     1392    psFree(query);
     1393    return false;
     1394  }
     1395  psFree(query);
     1396
     1397  psArray *output = p_psDBFetchResult(config->dbh);
     1398  if (!output) {
     1399    psErrorCode err = psErrorCodeLast();
     1400    switch (err) {
     1401    case PS_ERR_DB_CLIENT:
     1402      psError(PXTOOLS_ERR_SYS, false, "database error");
     1403    case PS_ERR_DB_SERVER:
     1404      psError(PXTOOLS_ERR_PROG, false, "database error");
     1405    default:
     1406      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1407    }
     1408   
     1409    return false;
     1410  }
     1411  if (!psArrayLength(output)) {
     1412    psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1413    psFree(output);
     1414    return true;
     1415  }
     1416 
     1417  if (psArrayLength(output)) {
    11761418    // negative simple so the default is true
    1177     if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) {
    1178         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1179         psFree(output);
    1180         return false;
    1181     }
    1182 
    1183     psFree(output);
    1184 
    1185     return true;
    1186 }
    1187 
    1188 static bool pendingcleanupskyfileMode(pxConfig *config)
     1419    if (!ippdbPrintMetadatas(stdout, output, "stackRun", !simple)) {
     1420      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1421      psFree(output);
     1422      return false;
     1423    }
     1424  }
     1425 
     1426  psFree(output);
     1427  return(true);
     1428}
     1429static bool addsummaryMode(pxConfig *config) {
     1430  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1431
     1432  PXOPT_LOOKUP_S64(sass_id, config->args, "-sass_id", true, false);
     1433  PXOPT_LOOKUP_STR(projection_cell, config->args, "-projection_cell", true, false);
     1434  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1435
     1436  psString query = pxDataGet("stacktool_addsummary.sql");
     1437  if (!query) {
     1438    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1439    return(false);
     1440  }
     1441  if (!p_psDBRunQueryF(config->dbh, query, sass_id, projection_cell, path_base)) {
     1442    psError(PS_ERR_UNKNOWN, false, "database error");
     1443    psFree(query);
     1444    return(false);
     1445  }
     1446  psS64 numUpdated = psDBAffectedRows(config->dbh);
     1447 
     1448  if (numUpdated != 1) {
     1449    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1450    psFree(query);
     1451    return false;
     1452  }
     1453 
     1454  psFree(query);
     1455
     1456  // Print anything here?
     1457 
     1458  return(true);
     1459}
     1460
     1461static bool pendingcleanuprunMode(pxConfig *config)
    11891462{
    11901463    PS_ASSERT_PTR_NON_NULL(config, NULL);
    11911464
    1192     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    11931465    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    11941466    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11951467
    11961468    psMetadata *where = psMetadataAlloc();
    1197     if (stack_id) {
    1198         PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    1199     }
     1469    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackRun.stack_id", "==");
     1470    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociationMap.sass_id", "==");
     1471   
    12001472    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    12011473
    1202     psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
     1474    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    12031475    if (!query) {
    12041476        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    12391511
    12401512    // negative simple so the default is true
    1241     if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) {
     1513    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) {
    12421514        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    12431515        psFree(output);
    … …  
    12501522}
    12511523
    1252 
    1253 static bool donecleanupMode(pxConfig *config)
     1524static bool pendingcleanupskyfileMode(pxConfig *config)
    12541525{
    12551526    PS_ASSERT_PTR_NON_NULL(config, NULL);
    12561527
     1528    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    12571529    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    12581530    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    12591531
    12601532    psMetadata *where = psMetadataAlloc();
    1261     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    1262 
    1263     psString query = pxDataGet("stacktool_donecleanup.sql");
     1533    if (stack_id) {
     1534        PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     1535    }
     1536    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
     1537
     1538    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    12641539    if (!query) {
    12651540        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    13001575
    13011576    // negative simple so the default is true
     1577    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) {
     1578        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1579        psFree(output);
     1580        return false;
     1581    }
     1582
     1583    psFree(output);
     1584
     1585    return true;
     1586}
     1587
     1588
     1589static bool donecleanupMode(pxConfig *config)
     1590{
     1591    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1592
     1593    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1594    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1595
     1596    psMetadata *where = psMetadataAlloc();
     1597    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1598    PXOPT_COPY_STR(config->args, where, "-sass_id", "sass_id", "==");
     1599
     1600    psString query = pxDataGet("stacktool_donecleanup.sql");
     1601    if (!query) {
     1602        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1603        return false;
     1604    }
     1605
     1606    if (where && psListLength(where->list)) {
     1607        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1608        psStringAppend(&query, " AND %s", whereClause);
     1609        psFree(whereClause);
     1610    }
     1611    psFree(where);
     1612
     1613    // treat limit == 0 as "no limit"
     1614    if (limit) {
     1615        psString limitString = psDBGenerateLimitSQL(limit);
     1616        psStringAppend(&query, " %s", limitString);
     1617        psFree(limitString);
     1618    }
     1619
     1620    if (!p_psDBRunQuery(config->dbh, query)) {
     1621        psError(PS_ERR_UNKNOWN, false, "database error");
     1622        psFree(query);
     1623        return false;
     1624    }
     1625    psFree(query);
     1626
     1627    psArray *output = p_psDBFetchResult(config->dbh);
     1628    if (!output) {
     1629        psError(PS_ERR_UNKNOWN, false, "database error");
     1630        return false;
     1631    }
     1632    if (!psArrayLength(output)) {
     1633        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1634        psFree(output);
     1635        return true;
     1636    }
     1637
     1638    // negative simple so the default is true
    13021639    if (!ippdbPrintMetadatas(stdout, output, "stackDoneCleanup", !simple)) {
    13031640        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    13291666}
    13301667
     1668//CZW I have not added sass information to the export/import run modes yet.
    13311669bool exportrunMode(pxConfig *config)
    13321670{

  • trunk/ippTools/src/stacktool.h

    r23310 r28375  
    3333    STACKTOOL_MODE_ADDSUMSKYFILE,
    3434    STACKTOOL_MODE_SUMSKYFILE,
     35    STACKTOOL_MODE_SASSSKYFILE,
    3536    STACKTOOL_MODE_REVERTSUMSKYFILE,
     37    STACKTOOL_MODE_TOSUMMARY,
     38    STACKTOOL_MODE_ADDSUMMARY,
    3639    STACKTOOL_MODE_PENDINGCLEANUPRUN,
    3740    STACKTOOL_MODE_PENDINGCLEANUPSKYFILE,

  • trunk/ippTools/src/stacktoolConfig.c

    r28043 r28375  
    197197    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
    198198
     199    // -sassskyfile
     200    psMetadata *sassskyfileArgs = psMetadataAlloc();
     201    psMetadataAddS64(sassskyfileArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
     202    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     203    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-projection_cell", 0,         "search by projection cell", 0);
     204
     205    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackAssociation.data_group (LIKE comparison)", NULL);
     206    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     207    psMetadataAddU64(sassskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     208    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     209    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
     210
    199211    // -revertsumskyfile
    200212    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    … …  
    204216    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    205217
     218    // -tosummary
     219    psMetadata *tosummaryArgs = psMetadataAlloc();
     220    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-stack_id", 0,  "search by stack ID", 0);
     221    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-sass_id", 0,  "search by stack association ID", 0);
     222    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-tess_id", 0,   "search by tessellation ID", NULL);
     223    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state", 0,     "search by state", NULL);
     224    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-filter", 0,    "search by filter", NULL);
     225    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison)", NULL);
     226    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison)", NULL);
     227    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-dist_group", PS_META_DUPLICATE_OK, "search by stackRun dist_group (LIKE comparison)", NULL);
     228
     229    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     230    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     231    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     232
     233    // -addsummary
     234    psMetadata *addsummaryArgs = psMetadataAlloc();
     235    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-sass_id", 0,      "set stack Association ID", 0);
     236    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-projection_cell", 0, "set projection cell", NULL);
     237    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,     "set summary path base", NULL);             
     238   
    206239    // -pendingcleanuprun
    207240    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    252285    PXOPT_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    253286    PXOPT_ADD_MODE("-sumskyfile",      "list results of stackRun", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     287    PXOPT_ADD_MODE("-sassskyfile",      "list results of stackAssociation", STACKTOOL_MODE_SASSSKYFILE,      sassskyfileArgs);
    254288    PXOPT_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
    255289    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", STACKTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    … …  
    257291    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     STACKTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    258292    PXOPT_ADD_MODE("-updatesumskyfile",      "update fault code for sumskyfile",     STACKTOOL_MODE_UPDATESUMSKYFILE,          updatesumskyfileArgs);
     293    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", STACKTOOL_MODE_TOSUMMARY, tosummaryArgs);
     294    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", STACKTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    259295    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", STACKTOOL_MODE_EXPORTRUN, exportrunArgs);
    260296    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           STACKTOOL_MODE_IMPORTRUN, importrunArgs);

  • trunk/ippTools/src/warptool.c

    r28202 r28375  
    4848static bool maskedMode(pxConfig *config);
    4949static bool unblockMode(pxConfig *config);
     50static bool tosummaryMode(pxConfig *config);
     51static bool addsummaryMode(pxConfig *config);
    5052static bool pendingcleanuprunMode(pxConfig *config);
    5153static bool pendingcleanupwarpMode(pxConfig *config);
    … …  
    101103        MODECASE(WARPTOOL_MODE_MASKED,             maskedMode);
    102104        MODECASE(WARPTOOL_MODE_UNBLOCK,            unblockMode);
     105        MODECASE(WARPTOOL_MODE_TOSUMMARY,          tosummaryMode);
     106        MODECASE(WARPTOOL_MODE_ADDSUMMARY,         addsummaryMode);
    103107        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPRUN,  pendingcleanuprunMode);
    104108        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupwarpMode);
    … …  
    15481552}
    15491553
     1554static bool tosummaryMode(pxConfig *config) {
     1555  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1556 
     1557  psMetadata *where = psMetadataAlloc();
     1558  PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
     1559  PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
     1560  PXOPT_COPY_STR(config->args, where, "-state",      "warpRun.state", "==");
     1561  PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     1562  PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     1563  PXOPT_COPY_S64(config->args, where, "-fake_id",    "fakeRun.fake_id", "==");
     1564  PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     1565  PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     1566  PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     1567  PXOPT_COPY_S64(config->args, where, "-magicked", "warpSkyfile.magicked", "==");
     1568  pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     1569  pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     1570
     1571  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1572
     1573  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1574  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1575 
     1576  // find all rawImfiles matching the default query
     1577  psString query = pxDataGet("warptool_tosummary.sql");
     1578  if (!query) {
     1579    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1580    return false;
     1581  }
     1582
     1583  // generate where strings for arguments that require extra processing
     1584  // beyond PXOPT_COPY*
     1585  psString where2 = NULL;
     1586  if (!pxmagicAddWhere(config, &where2, "warpSkyfile")) {
     1587    psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     1588    return false;
     1589  }
     1590 
     1591  if (psListLength(where->list)) {
     1592    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1593    psStringAppend(&query, " AND %s", whereClause);
     1594    psFree(whereClause);
     1595  } else if (!all && !where2) {
     1596    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1597    return false;
     1598  }
     1599 
     1600  if (where2) {
     1601    psStringAppend(&query, " %s", where2);
     1602  }
     1603  psFree(where);
     1604
     1605  // treat limit == 0 as "no limit"
     1606  if (limit) {
     1607    psString limitString = psDBGenerateLimitSQL(limit);
     1608    psStringAppend(&query, " %s", limitString);
     1609    psFree(limitString);
     1610  }
     1611 
     1612  if (!p_psDBRunQuery(config->dbh, query)) {
     1613    psError(PS_ERR_UNKNOWN, false, "database error");
     1614    psFree(query);
     1615    return false;
     1616  }
     1617  psFree(query);
     1618
     1619  psArray *output = p_psDBFetchResult(config->dbh);
     1620  if (!output) {
     1621    psErrorCode err = psErrorCodeLast();
     1622    switch (err) {
     1623    case PS_ERR_DB_CLIENT:
     1624      psError(PXTOOLS_ERR_SYS, false, "database error");
     1625    case PS_ERR_DB_SERVER:
     1626      psError(PXTOOLS_ERR_PROG, false, "database error");
     1627    default:
     1628      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1629    }
     1630   
     1631    return false;
     1632  }
     1633  if (!psArrayLength(output)) {
     1634    psTrace("warptool", PS_LOG_INFO, "no rows found");
     1635    psFree(output);
     1636    return true;
     1637  }
     1638 
     1639  if (psArrayLength(output)) {
     1640    // negative simple so the default is true
     1641    if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
     1642      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1643      psFree(output);
     1644      return false;
     1645    }
     1646  }
     1647 
     1648  psFree(output);
     1649  return(true);
     1650}
     1651static bool addsummaryMode(pxConfig *config) {
     1652  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1653
     1654  PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
     1655  PXOPT_LOOKUP_STR(projection_cell, config->args, "-projection_cell", true, false);
     1656  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1657
     1658  psString query = pxDataGet("warptool_addsummary.sql");
     1659  if (!query) {
     1660    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1661    return(false);
     1662  }
     1663  if (!p_psDBRunQueryF(config->dbh, query, warp_id, projection_cell, path_base)) {
     1664    psError(PS_ERR_UNKNOWN, false, "database error");
     1665    psFree(query);
     1666    return(false);
     1667  }
     1668  psS64 numUpdated = psDBAffectedRows(config->dbh);
     1669 
     1670  if (numUpdated != 1) {
     1671    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1672    psFree(query);
     1673    return false;
     1674  }
     1675 
     1676  psFree(query);
     1677
     1678  // Print anything here?
     1679 
     1680  return(true);
     1681}
     1682
    15501683static bool pendingcleanuprunMode(pxConfig *config)
    15511684{

  • trunk/ippTools/src/warptool.h

    r27737 r28375  
    4444    WARPTOOL_MODE_MASKED,
    4545    WARPTOOL_MODE_UNBLOCK,
     46    WARPTOOL_MODE_TOSUMMARY,
     47    WARPTOOL_MODE_ADDSUMMARY,
    4648    WARPTOOL_MODE_PENDINGCLEANUPRUN,
    4749    WARPTOOL_MODE_PENDINGCLEANUPSKYFILE,

  • trunk/ippTools/src/warptoolConfig.c

    r28054 r28375  
    321321    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    322322
     323    // -tosummary
     324    psMetadata *tosummaryArgs = psMetadataAlloc();
     325    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-warp_id", 0,         "search by warp ID", 0);
     326    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     327    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     328    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     329    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     330    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
     331    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     332    psMetadataAddTime(tosummaryArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     333    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
     334    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL,  "-magicked", 0,         "search by magic id", 0);
     335    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     336    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     337    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     338    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-destreaked", 0, "search for runs that have been destreaked", false);
     339    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-not_destreaked", 0, "search for runs that have not been destreaked", false);
     340   
     341    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     342    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     343    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     344
     345    // -addsummary
     346    psMetadata *addsummaryArgs = psMetadataAlloc();
     347    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-warp_id", 0,         "set warp ID", 0);
     348    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-projection_cell", 0,   "set projection cell", NULL);
     349    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,       "set summary path base", NULL);
     350   
    323351    // -pendingcleanuprun
    324352    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    430458    PXOPT_ADD_MODE("-updateskyfile", "update fault code for skyfile", WARPTOOL_MODE_UPDATESKYFILE, updateskyfileArgs);
    431459    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
     460    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", WARPTOOL_MODE_TOSUMMARY, tosummaryArgs);
     461    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", WARPTOOL_MODE_ADDSUMMARY, addsummaryArgs);
     462
    432463    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    433464    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.