IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 30, 2013, 4:48:58 PM (13 years ago)
Author:
eugene
Message:

updates from trunk

Location:
branches/eam_branches/ipp-20130711/ippTools/src
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20130711/ippTools/src

  • branches/eam_branches/ipp-20130711/ippTools/src/camtool.c

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20130711/ippTools/src/camtoolConfig.c

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20130711/ippTools/src/difftool.c

    r35558 r36071  
    12531253  PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    12541254  PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1255  PXOPT_LOOKUP_STR(warp_data_group, config->args, "-data_group", false, false);
    12551256 
    12561257  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    12601261
    12611262
     1263  if (!data_group) {
     1264    if (warp_data_group) {
     1265      data_group = warp_data_group;
     1266    }
     1267  }
     1268 
    12621269  // Get query file
    12631270  psString query = pxDataGet("difftool_definewarpstack.sql");

  • branches/eam_branches/ipp-20130711/ippTools/src/disttool.c

    r35193 r36071  
    375375        }
    376376        if (dist_group) {
    377             psStringAppend(&query, " AND (sticskyRun.dist_group = '%s')", dist_group);
     377            psStringAppend(&query, " AND (staticskyRun.dist_group = '%s')", dist_group);
    378378        }
    379379        // (static)sky stage doesn't require magic
     380        magic = false;
     381    } else if (!strcmp(stage, "skycal")) {
     382        query = pxDataGet("disttool_definebyquery_skycal.sql");
     383        if (!query) {
     384            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     385            psFree(where);
     386            return false;
     387        }
     388
     389        if (label) {
     390            psStringAppend(&query, " AND (skycalRun.label = '%s')", label);
     391        }
     392        if (dist_group) {
     393            psStringAppend(&query, " AND (skycalRun.dist_group = '%s')", dist_group);
     394        }
     395        // skycal stage doesn't require magic
    380396        magic = false;
    381397    } else if (!strcmp(stage, "SSdiff")) {

  • branches/eam_branches/ipp-20130711/ippTools/src/magictool.c

    • Property svn:mergeinfo changed (with no actual effect on merging)

  • branches/eam_branches/ipp-20130711/ippTools/src/pstamptool.c

    r35673 r36071  
    14281428    psFree(where);
    14291429
    1430     psStringAppend(&query, " ORDER BY priority DESC, req_id, dep_id");
     1430    psStringAppend(&query, " GROUP BY dep_id ORDER BY priority DESC, MIN(req_id), dep_id");
    14311431
    14321432    // treat limit == 0 as "no limit"

  • branches/eam_branches/ipp-20130711/ippTools/src/releasetool.c

    r35795 r36071  
    4747static bool updaterelstackMode(pxConfig *config);
    4848static bool listrelstackMode(pxConfig *config);
     49static bool summaryMode(pxConfig *config);
    4950static bool definerelgroupMode(pxConfig *config);
    5051static bool pendingrelgroupMode(pxConfig *config);
    … …  
    8485        MODECASE(RELEASETOOL_MODE_UPDATERELSTACK,   updaterelstackMode);
    8586        MODECASE(RELEASETOOL_MODE_LISTRELSTACK,     listrelstackMode);
     87        MODECASE(RELEASETOOL_MODE_SUMMARY,          summaryMode);
    8688
    8789        MODECASE(RELEASETOOL_MODE_DEFINERELGROUP,   definerelgroupMode);
    … …  
    180182    PS_ASSERT_PTR_NON_NULL(config, false);
    181183
    182     PXOPT_LOOKUP_S32(surveyID,    config->args, "-set_surveyID", true, false);
    183     PXOPT_LOOKUP_STR(release_name, config->args, "-set_release_name", true, false);
     184    PXOPT_LOOKUP_S32(surveyID,    config->args,   "-set_surveyID", true, false);
     185    PXOPT_LOOKUP_STR(release_name, config->args,  "-set_release_name", true, false);
    184186    PXOPT_LOOKUP_STR(release_state, config->args, "-set_release_state",  true, false);
    185     PXOPT_LOOKUP_S32(dataRelease, config->args, "-set_dataRelease", false, false);
    186     PXOPT_LOOKUP_S32(priority,    config->args, "-set_priority", false, false);
     187    PXOPT_LOOKUP_S32(dataRelease, config->args,   "-set_dataRelease", false, false);
     188    PXOPT_LOOKUP_S32(priority,    config->args,   "-set_priority", false, false);
     189    PXOPT_LOOKUP_STR(dvodb, config->args,         "-set_dvodb",  false, false);
     190    PXOPT_LOOKUP_STR(ubercal_file, config->args,  "-set_ubercal_file",  false, false);
    187191
    188192    if (!ippReleaseInsert(config->dbh,
    … …  
    192196        release_state,
    193197        dataRelease,
    194         priority
     198        priority,
     199        dvodb,
     200        ubercal_file
    195201    )) {
    196202        psError(PS_ERR_UNKNOWN, false, "failed to insert ippRelease");
    … …  
    215221    PXOPT_LOOKUP_S32(priority,         config->args, "-set_priority",  false, false);
    216222    PXOPT_LOOKUP_S32(dataRelease,      config->args, "-set_dataRelease",  false, false);
    217     if (!release_state && priority == 0 && dataRelease == -1) {
    218         psError(PXTOOLS_ERR_CONFIG, true, "at least one of -set_release_state -set_priority and -set_dataRelease is required\n");
     223    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb",  false, false);
     224    PXOPT_LOOKUP_STR(ubercal_file, config->args, "-set_ubercal_file",  false, false);
     225    if (!release_state && priority == 0 && dataRelease == -1 && !dvodb && !ubercal_file) {
     226        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -set_release_state -set_priority -set_dvodb -set_ubercal_file and -set_dataRelease is required\n");
    219227        return false;
    220228    }
    … …  
    238246    if (dataRelease != -1) {
    239247        psStringAppend(&query, "%s dataRelease = %d", sep, dataRelease);
     248        sep = comma;
     249    }
     250    if (dvodb) {
     251        psStringAppend(&query, "%s dvodb = '%s'", sep, dvodb);
     252        sep = comma;
     253    }
     254    if (ubercal_file) {
     255        psStringAppend(&query, "%s ubercal_file = '%s'", sep, ubercal_file);
    240256        sep = comma;
    241257    }
    … …  
    366382    PXOPT_LOOKUP_F32(user_zpt_obs, config->args,   "-set_zpt_obs", false, false);
    367383    PXOPT_LOOKUP_F32(user_zpt_stdev, config->args, "-set_zpt_stdev", false, false);
     384    PXOPT_LOOKUP_F32(mcal,     config->args, "-set_mcal",  false, false);
     385    PXOPT_LOOKUP_S32(ubercal_dist, config->args, "-set_ubercal_dist", false, false);
    368386    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
    369387    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
    … …  
    456474            zpt_obs,
    457475            zpt_stdev,
     476            mcal,
     477            ubercal_dist,
    458478            path_base,
    459479            fault,
    … …  
    496516    PXOPT_LOOKUP_STR(state,    config->args, "-set_state",  false, false);
    497517    PXOPT_LOOKUP_U32(flags,    config->args, "-set_flags",  false, false);
    498     PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     518    PXOPT_LOOKUP_STR(path_base,config->args, "-set_path_base", false, false);
    499519    PXOPT_LOOKUP_F32(zpt_obs,  config->args, "-set_zpt_obs",  false, false);
    500520    PXOPT_LOOKUP_F32(zpt_stdev,config->args, "-set_zpt_stdev",  false, false);
     521    PXOPT_LOOKUP_F32(mcal,     config->args, "-set_mcal",  false, false);
    501522    PXOPT_LOOKUP_S16(fault,    config->args, "-set_fault",  false, false);
     523    PXOPT_LOOKUP_S32(ubercal_dist, config->args, "-set_ubercal_dist", false, false);
    502524    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault",  false);
    503     if (!state && !flags && !path_base && !isfinite(zpt_obs) && !isfinite(zpt_stdev) && !fault && !clearfault) {
     525    if (!state && !flags && !path_base && !isfinite(zpt_obs) && !isfinite(zpt_stdev) &&!isfinite(mcal)
     526        && !fault && !clearfault && !ubercal_dist) {
    504527        psError(PXTOOLS_ERR_CONFIG, true, "must set at least one column\n");
    505528        return false;
    … …  
    557580        sep = comma;
    558581    }
     582    if (isfinite(mcal)) {
     583        psStringAppend(&query, "%s relExp.mcal = %f", sep, mcal);
     584        sep = comma;
     585    }
     586    if (ubercal_dist) {
     587        psStringAppend(&query, "%s relExp.ubercal_dist = %d", sep, ubercal_dist);
     588        sep = comma;
     589    }
    559590
    560591    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    569600
    570601    psU64 affected = psDBAffectedRows(config->dbh);
    571     psLogMsg("releasetool", PS_LOG_INFO, "Updated %" PRIu64 " ippReleases", affected);
     602    psLogMsg("releasetool", PS_LOG_INFO, "Updated %" PRIu64 " relExp rows", affected);
    572603
    573604
    … …  
    10491080
    10501081    if (priority_order) {
    1051         psStringAppend(&query, "\nAND priority > 0 order by stack_id, priority DESC");
     1082        psStringAppend(&query, "\nAND priority > 0 order by priority DESC, stack_id");
     1083    }
     1084
     1085    if (limit) {
     1086        psString limitString = psDBGenerateLimitSQL(limit);
     1087        psStringAppend(&query, " %s", limitString);
     1088        psFree(limitString);
     1089    }
     1090
     1091    if (!p_psDBRunQuery(config->dbh, query)) {
     1092        psError(PS_ERR_UNKNOWN, false, "database error");
     1093        psFree(query);
     1094        return false;
     1095    }
     1096    psFree(query);
     1097
     1098    psArray *output = p_psDBFetchResult(config->dbh);
     1099    if (!output) {
     1100        psError(PS_ERR_UNKNOWN, false, "database error");
     1101        return false;
     1102    }
     1103
     1104    if (!psArrayLength(output)) {
     1105        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1106        psFree(output);
     1107        return true;
     1108    }
     1109
     1110    if (!ippdbPrintMetadatas(stdout, output, "relStack", !simple)) {
     1111        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1112        psFree(output);
     1113        return false;
     1114    }
     1115
     1116    psFree(output);
     1117
     1118    return true;
     1119}
     1120static bool summaryMode(pxConfig *config)
     1121{
     1122    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1123
     1124    psMetadata *where = psMetadataAlloc();
     1125
     1126    PXOPT_COPY_S64(config->args, where, "-sass_id",     "stackAssociation.sass_id", "==");
     1127    PXOPT_COPY_S64(config->args, where, "-relstack_id", "relStack.relstack_id", "==");
     1128    PXOPT_COPY_S64(config->args, where, "-stack_id",    "relStack.stack_id", "==");
     1129//    PXOPT_COPY_S64(config->args, where, "-skycal_id",   "relStack.skycal_id", "==");
     1130    PXOPT_COPY_S64(config->args, where, "-relstack_id", "relStack.relstack_id", "==");
     1131    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1132    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     1133//    PXOPT_COPY_STR(config->args, where, "-state",       "relStack.state", "==");
     1134    PXOPT_COPY_STR(config->args, where, "-filter",      "relStack.filter", "LIKE");
     1135//    PXOPT_COPY_F32(config->args, where, "-mjd_min",    "stackSumSkyfile.mjd_obs", ">=");
     1136//    PXOPT_COPY_F32(config->args, where, "-mjd_max",    "stackSumSkyfile.mjd_obs", "<=");
     1137    PXOPT_COPY_STR(config->args, where, "-tess_id",     "relStack.tess_id", "==");
     1138    PXOPT_COPY_STR(config->args, where, "-skycell_id",  "relStack.skycell_id", "LIKE");
     1139    PXOPT_COPY_STR(config->args, where, "-projection_cell",  "stackAssociation.projection_cell", "LIKE");
     1140    PXOPT_COPY_STR(config->args, where, "-stack_data_group",  "stackRun.data_group", "LIKE");
     1141    PXOPT_COPY_STR(config->args, where, "-data_group",  "stackAssociation.data_group", "LIKE");
     1142//    PXOPT_COPY_STR(config->args, where, "-skycal_data_group", "skycalRun.data_group", "LIKE");
     1143
     1144    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     1145    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1146    pxskycellAddWhere(config, where);
     1147
     1148//    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "IFNULL(skycalResult.fwhm_major, 999)", ">=");
     1149//    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "IFNULL(skycalResult.fwhm_major, 0)", "<=");
     1150
     1151    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     1152
     1153    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1154    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1155
     1156    pxAddLabelSearchArgs (config, where, "-stack_type", "relStack.stack_type", "==");
     1157
     1158    psString query = pxDataGet("releasetool_summary.sql");
     1159    if (!query) {
     1160        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1161        return false;
     1162    }
     1163
     1164    if (psListLength(where->list)) {
     1165        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1166        psStringAppend(&query, "\nWHERE %s", whereClause);
     1167        psFree(whereClause);
     1168    } else {
     1169        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1170        psFree(where);
     1171        return false;
     1172    }
     1173
     1174    if (priority_order) {
     1175        psStringAppend(&query, "\nAND priority > 0 order by priority DESC, stack_id");
    10521176    }
    10531177

  • branches/eam_branches/ipp-20130711/ippTools/src/releasetool.h

    r35213 r36071  
    3838    RELEASETOOL_MODE_TOCALIBSTACK,
    3939    RELEASETOOL_MODE_LISTRELSTACK,
     40    RELEASETOOL_MODE_SUMMARY,
    4041    RELEASETOOL_MODE_DEFINERELGROUP,
    4142    RELEASETOOL_MODE_PENDINGRELGROUP,

  • branches/eam_branches/ipp-20130711/ippTools/src/releasetoolConfig.c

    r35795 r36071  
    6464    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0, "define release state", NULL);
    6565    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,      "define release priority", 0);
     66    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_dvodb", 0,         "define dvo db name", NULL);
     67    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_ubercal_file", 0,  "define ubercal file name", NULL);
    6668
    6769    // -uptdaterelease
    … …  
    7577    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,       "define new release priority", 0);
    7678    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,    "define data release", -1);
     79    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_dvodb", 0,         "define new dvo db name", NULL);
     80    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_ubercal_file", 0,  "define new ubercal file name", NULL);
    7781
    7882
    … …  
    108112    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define zero point", NAN);
    109113    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define zero point stdev", NAN);
     114    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_mcal", 0,       "define mcal", NAN);
     115    psMetadataAddS32(definerelexpArgs,  PS_LIST_TAIL, "-set_ubercal_dist", 0,  "define ubercal dist", 0);
    110116    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state", NULL);
    111117    psMetadataAddS16(definerelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
    … …  
    126132    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define new zero point", NAN);
    127133    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define new zero point stdev", NAN);
     134    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_mcal", 0,       "define mcal", NAN);
     135    psMetadataAddS32(updaterelexpArgs,  PS_LIST_TAIL, "-set_ubercal_dist", 0, "define new ubercal dist", 0);
    128136    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define path_base", NULL);
    129137    psMetadataAddS16(updaterelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define new fault", 0);
    … …  
    240248    psMetadataAddBool(listrelstackArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false);
    241249
     250    // -summary
     251    psMetadata *summaryArgs = psMetadataAlloc();
     252    psMetadataAddS64(summaryArgs, PS_LIST_TAIL,  "-sass_id", 0,   "select by released SASS ID", 0);
     253    psMetadataAddS64(summaryArgs, PS_LIST_TAIL,  "-relstack_id", 0,   "select by released exposure ID", 0);
     254    psMetadataAddS64(summaryArgs, PS_LIST_TAIL,  "-stack_id", 0,   "select by stack ID", 0);
     255//    psMetadataAddS64(summaryArgs, PS_LIST_TAIL,  "-skycal_id", 0,   "select by skycal ID", 0);
     256    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
     257    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-release_state", PS_META_DUPLICATE_OK, "select by release state", NULL);
     258//    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-state", 0,        "select by released stack state", NULL);
     259
     260    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-filter", 0,       "select by filter name (LIKE comparison)", NULL);
     261
     262    pxskycellAddArguments(summaryArgs);
     263
     264    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-tess_id", 0, "select by tess_id", NULL);
     265    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-skycell_id", 0, "select by skycell_id (LIKE comparision)", NULL);
     266    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-projection_cell", 0, "select by projection_cell (LIKE comparision)", NULL);
     267    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-stack_type", PS_META_DUPLICATE_OK, "select by stack_type", NULL);
     268
     269    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-stack_data_group", 0, "select by stackRun.data_group (LIKE comparison)", NULL);
     270    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-data_group", 0, "select by stackAsociation.data_group (LIKE comparison)", NULL);
     271
     272    psMetadataAddStr(summaryArgs,  PS_LIST_TAIL, "-surveyName", 0, "select by survey name (LIKE comparision)", NULL);
     273    psMetadataAddS64(summaryArgs,  PS_LIST_TAIL, "-rel_id", 0, "select by release ID", 0);
     274
     275    psMetadataAddBool(summaryArgs, PS_LIST_TAIL, "-priority_order",   0, "order by release priority", false);
     276
     277    psMetadataAddU64(summaryArgs,  PS_LIST_TAIL, "-limit",       0, "limit result set to N items", 0);
     278    psMetadataAddBool(summaryArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false);
    242279
    243280    // -definerelgroup
    … …  
    314351    PXOPT_ADD_MODE("-definerelstack",     "define a released stack",    RELEASETOOL_MODE_DEFINERELSTACK,  definerelstackArgs);
    315352    PXOPT_ADD_MODE("-listrelstack",       "list released stacks",      RELEASETOOL_MODE_LISTRELSTACK,    listrelstackArgs);
     353    PXOPT_ADD_MODE("-summary",            "list stackSummaryes for released stacks", RELEASETOOL_MODE_SUMMARY,    summaryArgs);
    316354
    317355    PXOPT_ADD_MODE("-definerelgroup",     "define a group of exposures", RELEASETOOL_MODE_DEFINERELGROUP,  definerelgroupArgs);

  • branches/eam_branches/ipp-20130711/ippTools/src/stacktool.c

    r34800 r36071  
    4444static bool tosummaryMode(pxConfig *config);
    4545static bool addsummaryMode(pxConfig *config);
     46static bool summaryMode(pxConfig *config);
    4647static bool pendingcleanuprunMode(pxConfig *config);
    4748static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    8485        MODECASE(STACKTOOL_MODE_TOSUMMARY,             tosummaryMode);
    8586        MODECASE(STACKTOOL_MODE_ADDSUMMARY,            addsummaryMode);
     87        MODECASE(STACKTOOL_MODE_SUMMARY,               summaryMode);
    8688        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    8789        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    748750    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stackRun.stack_id",   "==");
    749751    PXOPT_COPY_STR(config->args, where, "-label",     "stackRun.label",     "==");
     752    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "==");
    750753    PXOPT_COPY_STR(config->args, where, "-state",     "stackRun.state",     "==");
    751754    PXOPT_COPY_S64(config->args, where, "-sass_id",   "stackAssociationMap.sass_id",  "==");
    … …  
    14751478  // generate where strings for arguments that require extra processing
    14761479  // beyond PXOPT_COPY*
     1480  psString whereClause;
    14771481  if (psListLength(where->list)) {
    1478     psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1479     psStringAppend(&query, " AND %s", whereClause);
    1480     psFree(whereClause);
     1482    whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1483    psStringPrepend(&whereClause, "\n AND ");
    14811484  } else if (!all) {
    14821485    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1486    psFree(whereClause);
    14831487    return false;
    14841488  }
    … …  
    14931497  }
    14941498
    1495   if (!p_psDBRunQuery(config->dbh, query)) {
     1499  if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    14961500    psError(PS_ERR_UNKNOWN, false, "database error");
     1501    psFree(whereClause);
    14971502    psFree(query);
    14981503    return false;
    14991504  }
     1505  psFree(whereClause);
    15001506  psFree(query);
    15011507
    … …  
    15641570}
    15651571
     1572static bool summaryMode(pxConfig *config)
     1573{
     1574    PS_ASSERT_PTR_NON_NULL(config, false);
     1575
     1576    psMetadata *where = psMetadataAlloc();
     1577    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackSummary.sass_id", "==");
     1578    PXOPT_COPY_STR(config->args, where, "-projection_cell", "stackAssociation.projection_cell", "==");
     1579    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackAssociation.tess_id", "LIKE");
     1580    PXOPT_COPY_STR(config->args, where, "-filter", "stackAssociation.filter", "LIKE");
     1581    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
     1582    pxAddLabelSearchArgs(config, where, "-data_group", "stackAssociation.data_group", "LIKE");
     1583    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "LIKE");
     1584//    PXOPT_COPY_STR(config->args, where, "-state", "stackRun.state", "==");
     1585    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "LIKE");
     1586//    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     1587//    PXOPT_COPY_F64(config->args, where, "-mjd_obs_begin", "stackSumSkyfile.mjd_obs", ">=");
     1588//    PXOPT_COPY_F64(config->args, where, "-mjd_obs_end", "stackSumSkyfile.mjd_obs", "<=");
     1589//    PXOPT_COPY_S16(config->args, where, "-background_model","stackSumSkyfile.background_model", "==");
     1590
     1591//    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1592
     1593    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1594    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1595
     1596    psString query = pxDataGet("stacktool_summary.sql");
     1597    if (!query) {
     1598        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1599        return false;
     1600    }
     1601
     1602    if (psListLength(where->list)) {
     1603        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1604        psStringAppend(&query, " WHERE %s", whereClause);
     1605        psFree(whereClause);
     1606    } else {
     1607        psError(PXTOOLS_ERR_CONFIG, true, "search parameters are required");
     1608        return false;
     1609    }
     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        psErrorCode err = psErrorCodeLast();
     1630        switch (err) {
     1631            case PS_ERR_DB_CLIENT:
     1632                psError(PXTOOLS_ERR_SYS, false, "database error");
     1633            case PS_ERR_DB_SERVER:
     1634                psError(PXTOOLS_ERR_PROG, false, "database error");
     1635            default:
     1636                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1637        }
     1638
     1639        return false;
     1640    }
     1641    if (!psArrayLength(output)) {
     1642        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1643        psFree(output);
     1644        return true;
     1645    }
     1646
     1647    if (psArrayLength(output)) {
     1648        if (!ippdbPrintMetadatas(stdout, output, "stackSummary", !simple)) {
     1649            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1650            psFree(output);
     1651            return false;
     1652        }
     1653    }
     1654
     1655    psFree(output);
     1656
     1657    return true;
     1658}
     1659
    15661660static bool pendingcleanuprunMode(pxConfig *config)
    15671661{

  • branches/eam_branches/ipp-20130711/ippTools/src/stacktool.h

    r34800 r36071  
    3838    STACKTOOL_MODE_TOSUMMARY,
    3939    STACKTOOL_MODE_ADDSUMMARY,
     40    STACKTOOL_MODE_SUMMARY,
    4041    STACKTOOL_MODE_PENDINGCLEANUPRUN,
    4142    STACKTOOL_MODE_PENDINGCLEANUPSKYFILE,

  • branches/eam_branches/ipp-20130711/ippTools/src/stacktoolConfig.c

    r35122 r36071  
    121121    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "search by state", NULL);
    122122    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "search by label", 0);
     123    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0,       "search by data_group", 0);
    123124    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",  0,           "search by fault code", 0);
    124125    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-sass_id", 0,          "search by stack association ID", 0);
    … …  
    264265    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,     "set summary path base", NULL);
    265266
     267    // -summary
     268    psMetadata *summaryArgs = psMetadataAlloc();
     269    psMetadataAddS64(summaryArgs, PS_LIST_TAIL, "-sass_id", 0,  "search by stack association ID", 0);
     270    psMetadataAddS64(summaryArgs, PS_LIST_TAIL, "-stack_id", 0,  "search by stack ID", 0);
     271    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-tess_id", 0,   "search by tessellation ID", NULL);
     272    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-projection_cell", 0,   "search by projection cell ID", NULL);
     273//    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-state", 0,     "search by state", NULL);
     274    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-filter", 0,    "search by filter (LIKE comparison)", NULL);
     275    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison)", NULL);
     276    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by stackAssociation data_group (LIKE comparison)", NULL);
     277    psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-skycell_id", 0,   "search by skycell ID", NULL);
     278//     psMetadataAddStr(summaryArgs, PS_LIST_TAIL, "-dist_group", PS_META_DUPLICATE_OK, "search by stackRun dist_group (LIKE comparison)", NULL);
     279
     280//    psMetadataAddBool(summaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     281    psMetadataAddU64(summaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     282    psMetadataAddBool(summaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     283
    266284    // -pendingcleanuprun
    267285    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    324342    PXOPT_ADD_MODE("-updatesumskyfile",      "update fault code for sumskyfile",     STACKTOOL_MODE_UPDATESUMSKYFILE,          updatesumskyfileArgs);
    325343    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", STACKTOOL_MODE_TOSUMMARY, tosummaryArgs);
     344    PXOPT_ADD_MODE("-summary",              "show runs that have been summarized", STACKTOOL_MODE_SUMMARY, summaryArgs);
    326345    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", STACKTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    327346    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", STACKTOOL_MODE_EXPORTRUN, exportrunArgs);

  • branches/eam_branches/ipp-20130711/ippTools/src/staticskytool.c

    r35194 r36071  
    5050static bool revertskycalresultMode(pxConfig *config);
    5151static bool updateskycalresultMode(pxConfig *config);
     52static bool exportskycalrunMode(pxConfig *config);
     53static bool importskycalrunMode(pxConfig *config);
    5254
    5355static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state);
    … …  
    8890        MODECASE(STATICSKYTOOL_MODE_REVERTSKYCALRESULT,revertskycalresultMode);
    8991        MODECASE(STATICSKYTOOL_MODE_SKYCALRESULT,      skycalresultMode);
     92        MODECASE(STATICSKYTOOL_MODE_EXPORTSKYCALRUN,   exportskycalrunMode);
     93        MODECASE(STATICSKYTOOL_MODE_IMPORTSKYCALRUN,   importskycalrunMode);
    9094        default:
    9195            psAbort("invalid option (this should not happen)");
    … …  
    895899bool importrunMode(pxConfig *config)
    896900{
    897 # if (0)
    898   unsigned int nFail;
    899 
    900   int numImportTables = 2;
    901 
    902   char tables[2] [80] = {"stackInputSkyfile", "stackSumSkyfile"};
     901  return false;
     902}
     903
     904bool exportskycalrunMode(pxConfig *config)
     905{
     906  typedef struct ExportTable {
     907    char tableName[80];
     908    char sqlFilename[80];
     909  } ExportTable;
     910
     911  int numExportTables = 2;
    903912
    904913  PS_ASSERT_PTR_NON_NULL(config, NULL);
    905914
    906   PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
    907 
    908   psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    909 
    910 #ifdef notdef
    911   fprintf (stderr, "---- input ----\n");
    912   psMetadataPrint (stderr, input, 1);
    913 #endif
    914 
    915   if (!pxCheckImportVersion(config, input)) {
    916       psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     915  // XXX unused PXOPT_LOOKUP_S64(det_id, config->args, "-sky_id", true,  false);
     916  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     917  PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     918  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     919
     920  FILE *f = fopen (outfile, "w");
     921  if (f == NULL) {
     922      psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    917923      return false;
    918924  }
    919   psMetadataItem *item = psMetadataLookup (input, "stackRun");
    920   psAssert (item, "entry not in input?");
    921   psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    922 
    923   psMetadataItem *entry = psListGet (item->data.list, 0);
    924   assert (entry);
    925   assert (entry->type == PS_DATA_METADATA);
    926   stackRunRow *stackRun = stackRunObjectFromMetadata (entry->data.md);
    927   stackRunInsertObject (config->dbh, stackRun);
    928 
    929   // fprintf (stdout, "---- stack run ----\n");
    930   // psMetadataPrint (stderr, entry->data.md, 1);
    931 
    932   for (int i = 0; i < numImportTables; i++) {
    933     psMetadataItem *item = psMetadataLookup (input, tables[i]);
    934     psAssert (item, "entry not in input?");
    935     psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    936 
    937     switch (i) {
    938       case 0:
    939         for (int i = 0; i < item->data.list->n; i++) {
    940           entry = psListGet (item->data.list, i);
    941           assert (entry);
    942           assert (entry->type == PS_DATA_METADATA);
    943           stackInputSkyfileRow *stackInputSkyfile = stackInputSkyfileObjectFromMetadata (entry->data.md);
    944           stackInputSkyfileInsertObject (config->dbh, stackInputSkyfile);
    945 
    946           // fprintf (stdout, "---- row %d ----\n", i);
    947           // psMetadataPrint (stderr, entry->data.md, 1);
    948         }
    949         break;
    950 
    951       case 1:
    952         for (int i = 0; i < item->data.list->n; i++) {
    953           entry = psListGet (item->data.list, i);
    954           assert (entry);
    955           assert (entry->type == PS_DATA_METADATA);
    956           stackSumSkyfileRow *stackSumSkyfile = stackSumSkyfileObjectFromMetadata (entry->data.md);
    957           stackSumSkyfileInsertObject (config->dbh, stackSumSkyfile);
    958 
    959           // fprintf (stdout, "---- row %d ----\n", i);
    960           // psMetadataPrint (stderr, entry->data.md, 1);
    961         }
    962         break;
    963     }
     925
     926  if (!pxExportVersion(config, f)) {
     927    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     928    return false;
    964929  }
    965 
    966 # endif
    967   return true;
     930  psMetadata *where = psMetadataAlloc();
     931  PXOPT_COPY_S64(config->args, where, "-skycal_id", "skycal_id", "==");
     932
     933  ExportTable tables [] = {
     934    {"skycalRun", "staticskytool_export_skycalrun.sql"},
     935    {"skycalResult", "staticskytool_export_skycalresult.sql"},
     936  };
     937
     938  for (int i=0; i < numExportTables; i++) {
     939    psString query = pxDataGet(tables[i].sqlFilename);
     940    if (!query) {
     941      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     942      return false;
     943    }
     944
     945    if (where && psListLength(where->list)) {
     946      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     947      psStringAppend(&query, " %s", whereClause);
     948      psFree(whereClause);
     949    }
     950
     951    // treat limit == 0 as "no limit"
     952    if (limit) {
     953      psString limitString = psDBGenerateLimitSQL(limit);
     954      psStringAppend(&query, " %s", limitString);
     955      psFree(limitString);
     956    }
     957
     958    if (!p_psDBRunQuery(config->dbh, query)) {
     959      psError(PS_ERR_UNKNOWN, false, "database error");
     960      psFree(query);
     961      return false;
     962    }
     963    psFree(query);
     964
     965    psArray *output = p_psDBFetchResult(config->dbh);
     966    if (!output) {
     967      psError(PS_ERR_UNKNOWN, false, "database error");
     968      return false;
     969    }
     970    if (!psArrayLength(output)) {
     971      psError(PS_ERR_UNKNOWN, true, "no rows found");
     972      psFree(output);
     973      return false;
     974    }
     975
     976    if (clean) {
     977        if (!strcmp(tables[i].tableName, "skycalRun")) {
     978            if (!pxSetStateCleaned("skycalRun", "state", output)) {
     979                psFree(output);
     980                psError(PS_ERR_UNKNOWN, false, "pxSetStateClean failed for table %s",  tables[i].tableName);
     981                return false;
     982            }
     983        }
     984    }
     985
     986      // we must write the export table in non-simple (true) format
     987    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     988        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     989        psFree(output);
     990        return false;
     991    }
     992
     993    psFree(output);
     994  }
     995
     996    fclose (f);
     997
     998    return true;
     999}
     1000
     1001bool importskycalrunMode(pxConfig *config)
     1002{
     1003  return false;
    9681004}
    9691005
    … …  
    9861022
    9871023}
    988 
    989 # if (0)
    990         // now we need to loop over all requested filters and check that each is found
    991         // XXX is this needed?  haven't we required that we only match the requested filters
    992         // and that N unique filters are found?
    993 
    994         psVector *found = psVectorAlloc(inputs->n, PS_TYPE_U8);
    995         psVectorInit (found, 0);
    996 
    997         psMetadataItem *filter = NULL;
    998         psListIterator *iter = psListIteratorAlloc (filters->data.list, PS_LIST_HEAD, false);
    999         while ((filter = psListGetAndIncrement(iter))) {
    1000 
    1001             bool foundOne = false;
    1002 
    1003             psAssert (filter->type == PS_DATA_STR, "filter is not a string?");
    1004             for (int j = 0; !foundOne && (j < inputs->n); j++) {
    1005                 if (found->data.U8[j]) continue;
    1006                 psMetadata *inputRow = inputs->data[j]; // Row from select
    1007 
    1008                 // pull out the skycell_id, tess_id, filter
    1009                 psString inFilter = psMetadataLookupStr(&status, row, "filter");
    1010                 psAssert (status);
    1011 
    1012                 found->data.U8[j] = true;
    1013                 foundOne = true;
    1014             }
    1015             if (!foundOne) {
    1016                 // this required filter was not found in the inputs, skip the entry
    1017                 skip();
    1018             }
    1019         }           
    1020 # endif
    10211024
    10221025static bool defineskycalrunMode(pxConfig *config)

  • branches/eam_branches/ipp-20130711/ippTools/src/staticskytool.h

    r32960 r36071  
    4343    STATICSKYTOOL_MODE_SKYCALRESULT,
    4444    STATICSKYTOOL_MODE_REVERTSKYCALRESULT,
     45    STATICSKYTOOL_MODE_EXPORTSKYCALRUN,
     46    STATICSKYTOOL_MODE_IMPORTSKYCALRUN,
    4547} staticskytoolMode;
    4648

  • branches/eam_branches/ipp-20130711/ippTools/src/staticskytoolConfig.c

    r35197 r36071  
    269269    psMetadataAddBool(skycalresultArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    270270
     271    // -exportskycalrun
     272    psMetadata *exportskycalrunArgs = psMetadataAlloc();
     273    psMetadataAddS64(exportskycalrunArgs, PS_LIST_TAIL, "-skycal_id", 0, "export this skycal ID (required)", 0);
     274    psMetadataAddStr(exportskycalrunArgs, PS_LIST_TAIL, "-outfile", 0, "export to this file (required)", NULL);
     275    psMetadataAddU64(exportskycalrunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     276    psMetadataAddBool(exportskycalrunArgs, PS_LIST_TAIL, "-clean", 0, "mark tables as cleaned", false);
     277
     278    // -importrun
     279    psMetadata *importskycalrunArgs = psMetadataAlloc();
     280    psMetadataAddStr(importskycalrunArgs, PS_LIST_TAIL, "-infile", 0, "import from this file (required)", NULL);
     281 
     282
    271283    psFree(now);
    272284
    … …  
    291303    PXOPT_ADD_MODE("-updateskycal",  "revert faulted skycal run", STATICSKYTOOL_MODE_UPDATESKYCALRESULT, updateskycalresultArgs);
    292304    PXOPT_ADD_MODE("-skycalresult",  "Get result of skycal run",  STATICSKYTOOL_MODE_SKYCALRESULT, skycalresultArgs);
     305    PXOPT_ADD_MODE("-exportskycalrun",     "Export skycal run",   STATICSKYTOOL_MODE_EXPORTSKYCALRUN, exportskycalrunArgs);
     306    PXOPT_ADD_MODE("-importskycalrun",     "Import skycal run",   STATICSKYTOOL_MODE_IMPORTSKYCALRUN, importskycalrunArgs);
    293307
    294308    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.