IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 29835


Ignore:
Timestamp:
Nov 26, 2010, 10:33:51 AM (15 years ago)
Author:
eugene
Message:

merge updates from trunk

Location:
branches/eam_branches/ipp-20101103/ippTools
Files:
8 edited
9 copied

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20101103/ippTools

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

  • branches/eam_branches/ipp-20101103/ippTools/share/Makefile.am

    r29627 r29835  
    2121        bgtool_advancechip.sql \
    2222        bgtool_advancewarp.sql \
     23        bgtool_change_chiprun_state.sql \
     24        bgtool_change_imfile_data_state.sql \
     25        bgtool_change_warprun_state.sql \
     26        bgtool_change_skyfile_data_state.sql \
    2327        bgtool_chipinputs.sql \
    2428        bgtool_chip.sql \
    … …  
    2933        bgtool_listchip.sql \
    3034        bgtool_listwarp.sql \
     35        bgtool_pendingcleanupchiprun.sql \
     36        bgtool_pendingcleanupchipimfile.sql \
     37        bgtool_pendingcleanupwarprun.sql \
     38        bgtool_pendingcleanupwarpskyfile.sql \
    3139        bgtool_revertchip.sql \
    3240        bgtool_revertwarp.sql \
    … …  
    377385        warptool_tooverlap.sql \
    378386        warptool_towarped.sql \
     387        warptool_towarped_labels.sql \
    379388        warptool_updateskyfile.sql \
    380389        warptool_warped.sql \

  • branches/eam_branches/ipp-20101103/ippTools/share/magictool_definebyquery_select.sql

    r29363 r29835  
    44    MAX(diffWarps.diff_id) AS diff_id,
    55    -- The following trick pulls out the 'inverse' value for the maximum diff_id
    6     CONVERT(SUBSTRING_INDEX(GROUP_CONCAT(diffWarps.inverse ORDER BY diffWarps.diff_id), ',', 1), UNSIGNED) AS inverse,
     6    CONVERT(SUBSTRING_INDEX(GROUP_CONCAT(diffWarps.inverse ORDER BY diffWarps.diff_id DESC), ',', 1), UNSIGNED) AS inverse,
    77    diff_data_group
    88FROM (

  • branches/eam_branches/ipp-20101103/ippTools/share/warptool_definebyquery.sql

    r23618 r29835  
    2929JOIN chipRun USING(chip_id)
    3030JOIN rawExp USING(exp_id)
    31 WHERE camRun.state = 'full'
     31WHERE fakeRun.state = 'full'
     32AND camRun.state = 'full'
    3233AND chipRun.state = 'full'

  • branches/eam_branches/ipp-20101103/ippTools/src/bgtool.c

    r29493 r29835  
    4949static bool revertwarpMode(pxConfig *config);
    5050static bool listwarpMode(pxConfig *config);
    51 static bool tocleanchipMode(pxConfig *config);
    52 static bool cleanedchipMode(pxConfig *config);
    53 static bool tocleanwarpMode(pxConfig *config);
    54 static bool cleanedwarpMode(pxConfig *config);
     51
     52static bool pendingcleanupchiprunMode(pxConfig *config);
     53static bool pendingcleanupchipimfileMode(pxConfig *config);
     54static bool tocleanedchipimfileMode(pxConfig *config);
     55static bool updatechipimfileMode(pxConfig *config);
     56
     57static bool pendingcleanupwarprunMode(pxConfig *config);
     58static bool pendingcleanupwarpskyfileMode(pxConfig *config);
     59static bool tocleanedwarpskyfileMode(pxConfig *config);
     60
    5561static bool exportchipMode(pxConfig *config);
    5662static bool importchipMode(pxConfig *config);
    5763static bool exportwarpMode(pxConfig *config);
    5864static bool importwarpMode(pxConfig *config);
     65
     66static bool validDataState(psString data_state);
    5967
    6068// Tables to import/export
    … …  
    112120        MODECASE(BGTOOL_MODE_REVERTWARP,  revertwarpMode);
    113121        MODECASE(BGTOOL_MODE_LISTWARP,    listwarpMode);
    114         MODECASE(BGTOOL_MODE_TOCLEANCHIP, tocleanchipMode);
    115         MODECASE(BGTOOL_MODE_CLEANEDCHIP, cleanedchipMode);
    116         MODECASE(BGTOOL_MODE_TOCLEANWARP, tocleanwarpMode);
    117         MODECASE(BGTOOL_MODE_CLEANEDWARP, cleanedwarpMode);
     122        MODECASE(BGTOOL_MODE_PENDINGCLEANUPCHIPRUN, pendingcleanupchiprunMode);
     123        MODECASE(BGTOOL_MODE_PENDINGCLEANUPCHIPIMFILE, pendingcleanupchipimfileMode);
     124        MODECASE(BGTOOL_MODE_TOCLEANEDCHIPIMFILE, tocleanedchipimfileMode);
     125        MODECASE(BGTOOL_MODE_UPDATECHIPIMFILE, updatechipimfileMode);
     126        MODECASE(BGTOOL_MODE_PENDINGCLEANUPWARPRUN, pendingcleanupwarprunMode);
     127        MODECASE(BGTOOL_MODE_PENDINGCLEANUPWARPSKYFILE, pendingcleanupwarpskyfileMode);
     128        MODECASE(BGTOOL_MODE_TOCLEANEDWARPSKYFILE, tocleanedwarpskyfileMode);
    118129        MODECASE(BGTOOL_MODE_EXPORTCHIP,  exportchipMode);
    119130        MODECASE(BGTOOL_MODE_IMPORTCHIP,  importchipMode);
    … …  
    914925    return true;
    915926}
     927
    916928static bool listchipMode(pxConfig *config)
    917929{
    … …  
    978990}
    979991
    980 static bool tocleanchipMode(pxConfig *config)
     992static bool pendingcleanupchiprunMode(pxConfig *config)
    981993{
    982994    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    987999    psMetadata *where = psMetadataAlloc();
    9881000    pxAddLabelSearchArgs(config, where, "-label", "chipBackgroundRun.label", "==");
    989 
    990     psString query = pxDataGet("bgtool_tocleanchip.sql");
     1001    pxAddLabelSearchArgs(config, where, "-data_group", "chipBackgroundRun.data_group", "==");
     1002
     1003    psString query = pxDataGet("bgtool_pendingcleanupchiprun.sql");
    9911004    if (!query) {
    9921005        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
    … …  
    10351048    return true;
    10361049}
    1037 
    1038 static bool cleanedchipMode(pxConfig *config)
    1039 {
    1040     PS_ASSERT_PTR_NON_NULL(config, false);
    1041 
    1042     psMetadata *where = psMetadataAlloc();
     1050static bool pendingcleanupchipimfileMode(pxConfig *config)
     1051{
     1052    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1053
     1054    PXOPT_LOOKUP_S64(chip_bg_id, config->args, "-chip_bg_id", true, false);
     1055    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1056    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1057
     1058    psMetadata *where = psMetadataAlloc();
     1059
    10431060    PXOPT_COPY_S64(config->args, where, "-chip_bg_id", "chipBackgroundRun.chip_bg_id", "==");
    10441061
    1045     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    1046     if (!pxIsValidCleanedState(state)) {
    1047         psError(PXTOOLS_ERR_CONFIG, true, "Invalid state: %s", state);
    1048         return false;
    1049     }
    1050 
    1051     if (!psListLength(where->list)) {
    1052         psError(PXTOOLS_ERR_CONFIG, true, "No search restrictions set.");
    1053         return false;
    1054     }
    1055 
    1056     psString query = pxDataGet("bgtool_cleanedchip.sql");
     1062    psString query = pxDataGet("bgtool_pendingcleanupchipimfile.sql");
    10571063    if (!query) {
    10581064        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
    … …  
    10601066    }
    10611067
    1062     {
     1068    if (where && psListLength(where->list)) {
    10631069        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    10641070        psStringAppend(&query, " AND %s", whereClause);
    … …  
    10671073    psFree(where);
    10681074
    1069     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    1070         psError(psErrorCodeLast(), false, "database error");
     1075    if (limit) {
     1076        psString limitString = psDBGenerateLimitSQL(limit);
     1077        psStringAppend(&query, " %s", limitString);
     1078        psFree(limitString);
     1079    }
     1080
     1081    if (!p_psDBRunQuery(config->dbh, query)) {
     1082        psError(psErrorCodeLast(), false, "database error");
     1083        psFree(query);
     1084        return false;
     1085    }
     1086    psFree(query);
     1087
     1088    psArray *output = p_psDBFetchResult(config->dbh);
     1089    if (!output) {
     1090        psError(psErrorCodeLast(), false, "database error");
     1091        return false;
     1092    }
     1093    if (!psArrayLength(output)) {
     1094        psTrace("bgtool", PS_LOG_INFO, "no rows found");
     1095        psFree(output);
     1096        return true;
     1097    }
     1098
     1099    // negative simple so the default is true
     1100    if (!ippdbPrintMetadatas(stdout, output, "chipBackgroundImfile", !simple)) {
     1101        psError(psErrorCodeLast(), false, "failed to print array");
     1102        psFree(output);
     1103        return false;
     1104    }
     1105    psFree(output);
     1106
     1107    return true;
     1108}
     1109
     1110static bool change_imfile_data_state(pxConfig *config, psString data_state)
     1111{
     1112    PS_ASSERT_PTR_NON_NULL(config, false);
     1113
     1114    // chip_id, class_id are required
     1115    PXOPT_LOOKUP_S64(chip_bg_id, config->args, "-chip_bg_id", true, false);
     1116    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     1117
     1118    psString query = pxDataGet("bgtool_change_imfile_data_state.sql");
     1119
     1120    if (!psDBTransaction(config->dbh)) {
     1121        psError(PS_ERR_UNKNOWN, false, "database error");
     1122        return false;
     1123    }
     1124
     1125    if (!p_psDBRunQueryF(config->dbh, query, data_state, chip_bg_id, class_id)) {
     1126        psFree(query);
     1127        psError(PS_ERR_UNKNOWN, false, "database error");
     1128        // rollback
     1129        if (!psDBRollback(config->dbh)) {
     1130            psError(PS_ERR_UNKNOWN, false, "database error");
     1131        }
     1132        psError(PS_ERR_UNKNOWN, false, "database error");
     1133        return false;
     1134    }
     1135    psFree(query);
     1136    if (psDBAffectedRows(config->dbh) < 1) {
     1137        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     1138        return false;
     1139    }
     1140
     1141    query = pxDataGet("bgtool_change_chiprun_state.sql");
     1142    if (!p_psDBRunQueryF(config->dbh, query, data_state, chip_bg_id, data_state)) {
     1143        psFree(query);
     1144        // rollback
     1145        if (!psDBRollback(config->dbh)) {
     1146            psError(PS_ERR_UNKNOWN, false, "database error");
     1147        }
     1148        psError(PS_ERR_UNKNOWN, false, "database error");
     1149        return false;
     1150    }
     1151    psFree(query);
     1152
     1153    if (!psDBCommit(config->dbh)) {
     1154        psError(PS_ERR_UNKNOWN, false, "database error");
     1155        return false;
     1156    }
     1157
     1158    return true;
     1159}
     1160
     1161static bool tocleanedchipimfileMode(pxConfig *config)
     1162{
     1163    return change_imfile_data_state(config, "cleaned");
     1164}
     1165
     1166static bool updatechipimfileMode(pxConfig *config)
     1167{
     1168    PS_ASSERT_PTR_NON_NULL(config, false);
     1169
     1170    // required
     1171    PXOPT_LOOKUP_S64(chip_bg_id, config->args, "-chip_bg_id", true, false);
     1172    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
     1173
     1174    psMetadata *where = psMetadataAlloc();
     1175
     1176    PXOPT_COPY_S64(config->args, where, "-chip_bg_id", "chipBackgroundImfile.chip_bg_id", "==");
     1177    PXOPT_COPY_S64(config->args, where, "-class_id", "chipBackgroundImfile.class_id", "==");
     1178
     1179    // optional
     1180
     1181    PXOPT_LOOKUP_STR(data_state, config->args, "-set_data_state", false, false);
     1182    PXOPT_LOOKUP_S16(fault, config->args, "-set_fault", false, false);
     1183    if (!data_state && !fault) {
     1184        psError(PS_ERR_UNKNOWN, true, "must supply either -set_fault or -set_data_state");
     1185        return false;
     1186    }
     1187    char *sep = "";
     1188    psString query = psStringCopy("UPDATE chipBackgroundImfile SET ");
     1189    if (data_state) {
     1190        if (!validDataState(data_state)) {
     1191            return false;
     1192        }
     1193        psStringAppend(&query, "%s data_state = '%s'", sep, data_state);
     1194        sep = ", ";
     1195    }
     1196    if (fault) {
     1197        psStringAppend(&query, "%s fault = %d", sep, fault);
     1198        sep = ", ";
     1199    }
     1200    if (psListLength(where->list)) {
     1201        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1202        psStringAppend(&query, " WHERE %s", whereClause);
     1203        psFree(whereClause);
     1204    } else {
     1205        psFree(where);
     1206        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1207        return false;
     1208    }
     1209    psFree(where);
     1210    if (!p_psDBRunQuery(config->dbh, query)) {
     1211        psError(psErrorCodeLast(), false, "database error");
     1212        psFree(query);
    10711213        return false;
    10721214    }
    … …  
    14491591        return true;
    14501592    }
    1451     if (!ippdbPrintMetadatas(stdout, output, "chipBackgroundSkyfile", !simple)) {
     1593    if (!ippdbPrintMetadatas(stdout, output, "warpBackgroundSkyfile", !simple)) {
    14521594        psError(psErrorCodeLast(), false, "failed to print array");
    14531595        psFree(output);
    … …  
    18141956}
    18151957
    1816 static bool tocleanwarpMode(pxConfig *config)
     1958static bool pendingcleanupwarprunMode(pxConfig *config)
    18171959{
    18181960    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    18241966    pxAddLabelSearchArgs(config, where, "-label", "warpBackgroundRun.label", "==");
    18251967
    1826     psString query = pxDataGet("bgtool_tocleanwarp.sql");
     1968    psString query = pxDataGet("bgtool_pendingcleanupwarprun.sql");
    18271969    if (!query) {
    18281970        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
    … …  
    18712013    return true;
    18722014}
    1873 
    1874 static bool cleanedwarpMode(pxConfig *config)
    1875 {
    1876     PS_ASSERT_PTR_NON_NULL(config, false);
    1877 
    1878     psMetadata *where = psMetadataAlloc();
     2015static bool pendingcleanupwarpskyfileMode(pxConfig *config)
     2016{
     2017    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2018
     2019    PXOPT_LOOKUP_S64(warp_bg_id, config->args, "-warp_bg_id", true, false);
     2020    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2021    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2022
     2023    psMetadata *where = psMetadataAlloc();
     2024
    18792025    PXOPT_COPY_S64(config->args, where, "-warp_bg_id", "warpBackgroundRun.warp_bg_id", "==");
    18802026
    1881     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    1882     if (!pxIsValidCleanedState(state)) {
    1883         psError(PXTOOLS_ERR_CONFIG, true, "Invalid state: %s", state);
    1884         return false;
    1885     }
    1886 
    1887     if (!psListLength(where->list)) {
    1888         psError(PXTOOLS_ERR_CONFIG, true, "No search restrictions set.");
    1889         return false;
    1890     }
    1891 
    1892     psString query = pxDataGet("bgtool_cleanedwarp.sql");
     2027    psString query = pxDataGet("bgtool_pendingcleanupwarpskyfile.sql");
    18932028    if (!query) {
    18942029        psError(psErrorCodeLast(), false, "failed to retreive SQL statement");
    … …  
    18962031    }
    18972032
    1898     {
     2033    if (where && psListLength(where->list)) {
    18992034        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    19002035        psStringAppend(&query, " AND %s", whereClause);
    … …  
    19032038    psFree(where);
    19042039
    1905     if (!p_psDBRunQueryF(config->dbh, query, state)) {
    1906         psError(psErrorCodeLast(), false, "database error");
    1907         return false;
    1908     }
    1909     psFree(query);
    1910 
    1911     return true;
     2040    if (limit) {
     2041        psString limitString = psDBGenerateLimitSQL(limit);
     2042        psStringAppend(&query, " %s", limitString);
     2043        psFree(limitString);
     2044    }
     2045
     2046    if (!p_psDBRunQuery(config->dbh, query)) {
     2047        psError(psErrorCodeLast(), false, "database error");
     2048        psFree(query);
     2049        return false;
     2050    }
     2051    psFree(query);
     2052
     2053    psArray *output = p_psDBFetchResult(config->dbh);
     2054    if (!output) {
     2055        psError(psErrorCodeLast(), false, "database error");
     2056        return false;
     2057    }
     2058    if (!psArrayLength(output)) {
     2059        psTrace("bgtool", PS_LOG_INFO, "no rows found");
     2060        psFree(output);
     2061        return true;
     2062    }
     2063
     2064    // negative simple so the default is true
     2065    if (!ippdbPrintMetadatas(stdout, output, "warpBackgroundSkyfile", !simple)) {
     2066        psError(psErrorCodeLast(), false, "failed to print array");
     2067        psFree(output);
     2068        return false;
     2069    }
     2070    psFree(output);
     2071
     2072    return true;
     2073}
     2074
     2075static bool change_skyfile_data_state(pxConfig *config, psString data_state)
     2076{
     2077    PS_ASSERT_PTR_NON_NULL(config, false);
     2078
     2079    // warp_id, skycell_id are required
     2080    PXOPT_LOOKUP_S64(warp_bg_id, config->args, "-warp_bg_id", true, false);
     2081    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     2082
     2083    psString query = pxDataGet("bgtool_change_skyfile_data_state.sql");
     2084
     2085    if (!psDBTransaction(config->dbh)) {
     2086        psError(PS_ERR_UNKNOWN, false, "database error");
     2087        return false;
     2088    }
     2089
     2090    if (!p_psDBRunQueryF(config->dbh, query, data_state, warp_bg_id, skycell_id)) {
     2091        psFree(query);
     2092        psError(PS_ERR_UNKNOWN, false, "database error");
     2093        // rollback
     2094        if (!psDBRollback(config->dbh)) {
     2095            psError(PS_ERR_UNKNOWN, false, "database error");
     2096        }
     2097        psError(PS_ERR_UNKNOWN, false, "database error");
     2098        return false;
     2099    }
     2100    psFree(query);
     2101    if (psDBAffectedRows(config->dbh) < 1) {
     2102        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     2103        return false;
     2104    }
     2105
     2106    query = pxDataGet("bgtool_change_warprun_state.sql");
     2107    if (!p_psDBRunQueryF(config->dbh, query, data_state, warp_bg_id, data_state)) {
     2108        psFree(query);
     2109        // rollback
     2110        if (!psDBRollback(config->dbh)) {
     2111            psError(PS_ERR_UNKNOWN, false, "database error");
     2112        }
     2113        psError(PS_ERR_UNKNOWN, false, "database error");
     2114        return false;
     2115    }
     2116    psFree(query);
     2117
     2118    if (!psDBCommit(config->dbh)) {
     2119        psError(PS_ERR_UNKNOWN, false, "database error");
     2120        return false;
     2121    }
     2122
     2123    return true;
     2124}
     2125
     2126static bool tocleanedwarpskyfileMode(pxConfig *config)
     2127{
     2128    return change_skyfile_data_state(config, "cleaned");
    19122129}
    19132130
    … …  
    19352152    return importTables(config, infile, warpTables);
    19362153}
     2154
     2155static bool validDataState(psString data_state)
     2156{
     2157    // NOTE: can't use pxIsValidState because
     2158    // update, scrubbed and purged are not supported for the backround stages (yet?)
     2159    if (!strcmp(data_state, "new") ||
     2160        !strcmp(data_state, "full") ||
     2161        !strcmp(data_state, "drop") ||
     2162        !strcmp(data_state, "cleaned") ||
     2163        !strcmp(data_state, "goto_cleaned") ||
     2164        !strcmp(data_state, "error_cleaned")) {
     2165        return true;
     2166    } else {
     2167        psError(PS_ERR_UNKNOWN, true, "%s is not a valid value data_state", data_state);
     2168        return false;
     2169    }
     2170}

  • branches/eam_branches/ipp-20101103/ippTools/src/bgtool.h

    r28941 r29835  
    3535    BGTOOL_MODE_REVERTCHIP,
    3636    BGTOOL_MODE_LISTCHIP,
     37    BGTOOL_MODE_UPDATECHIPIMFILE,
    3738    // Warp stage
    3839    BGTOOL_MODE_DEFINEWARP,
    … …  
    4546    BGTOOL_MODE_REVERTWARP,
    4647    BGTOOL_MODE_LISTWARP,
     48    BGTOOL_MODE_UPDATEWARPSKYFILE,
    4749    // Cleanups
    48     BGTOOL_MODE_TOCLEANCHIP,
    49     BGTOOL_MODE_CLEANEDCHIP,
    50     BGTOOL_MODE_TOCLEANWARP,
    51     BGTOOL_MODE_CLEANEDWARP,
     50    BGTOOL_MODE_PENDINGCLEANUPCHIPRUN,
     51    BGTOOL_MODE_PENDINGCLEANUPCHIPIMFILE,
     52    BGTOOL_MODE_TOCLEANEDCHIPIMFILE,
     53    BGTOOL_MODE_PENDINGCLEANUPWARPRUN,
     54    BGTOOL_MODE_PENDINGCLEANUPWARPSKYFILE,
     55    BGTOOL_MODE_TOCLEANEDWARPSKYFILE,
    5256    // Exporting
    5357    BGTOOL_MODE_EXPORTCHIP,

  • branches/eam_branches/ipp-20101103/ippTools/src/bgtoolConfig.c

    r28941 r29835  
    192192    psMetadataAddU64(listchipArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    193193
    194     // -tocleanchip
    195     psMetadata *tocleanchipArgs = psMetadataAlloc();
    196     psMetadataAddStr(tocleanchipArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    197     psMetadataAddBool(tocleanchipArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    198     psMetadataAddU64(tocleanchipArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    199 
    200     // -cleanedchip
    201     psMetadata *cleanedchipArgs = psMetadataAlloc();
    202     psMetadataAddS64(cleanedchipArgs, PS_LIST_TAIL, "-chip_bg_id", 0, "search by chip_bg_id", 0);
    203     psMetadataAddStr(cleanedchipArgs, PS_LIST_TAIL, "-state", 0, "cleaned state to set", NULL);
     194    // -pendingcleanupchiprun
     195    psMetadata *pendingcleanupchiprunArgs = psMetadataAlloc();
     196    psMetadataAddStr(pendingcleanupchiprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list runs for specified label", NULL);
     197    psMetadataAddStr(pendingcleanupchiprunArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "list runs for specified data_group", NULL);
     198    psMetadataAddBool(pendingcleanupchiprunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     199    psMetadataAddU64(pendingcleanupchiprunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     200
     201    // -pendingcleanupchipimfile
     202    psMetadata *pendingcleanupchipimfileArgs = psMetadataAlloc();
     203    psMetadataAddS64(pendingcleanupchipimfileArgs, PS_LIST_TAIL, "-chip_bg_id", 0,          "search by chip_bg_id (required)", 0);
     204    psMetadataAddBool(pendingcleanupchipimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     205    psMetadataAddU64(pendingcleanupchipimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     206
     207    // -tocleanedchipimfile
     208    psMetadata *tocleanedchipimfileArgs = psMetadataAlloc();
     209    psMetadataAddS64(tocleanedchipimfileArgs, PS_LIST_TAIL, "-chip_bg_id", 0,          "search by chip ID (required)", 0);
     210    psMetadataAddStr(tocleanedchipimfileArgs, PS_LIST_TAIL, "-class_id",  0, "search by class_id", NULL);
     211    psMetadataAddBool(tocleanedchipimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     212    psMetadataAddU64(tocleanedchipimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     213
     214    // -updatechipimfile
     215    psMetadata *updatechipimfileArgs = psMetadataAlloc();
     216    psMetadataAddS64(updatechipimfileArgs, PS_LIST_TAIL, "-chip_bg_id", 0,          "search by chip ID (required)", 0);
     217    psMetadataAddStr(updatechipimfileArgs, PS_LIST_TAIL, "-class_id",  0, "search by class_id (required)", NULL);
     218    psMetadataAddStr(updatechipimfileArgs, PS_LIST_TAIL, "-set_data_state",  0, "new value for data_state", NULL);
     219    psMetadataAddS16(updatechipimfileArgs, PS_LIST_TAIL, "-set_fault",  0, "set fault code", 0);
    204220
    205221    // -exportchip
    … …  
    361377    psMetadataAddU64(listwarpArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    362378
    363     // -tocleanwarp
    364     psMetadata *tocleanwarpArgs = psMetadataAlloc();
    365     psMetadataAddStr(tocleanwarpArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
    366     psMetadataAddBool(tocleanwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    367     psMetadataAddU64(tocleanwarpArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    368 
    369     // -cleanedwarp
    370     psMetadata *cleanedwarpArgs = psMetadataAlloc();
    371     psMetadataAddS64(cleanedwarpArgs, PS_LIST_TAIL, "-warp_bg_id", 0, "search by warp_bg_id", 0);
    372     psMetadataAddStr(cleanedwarpArgs, PS_LIST_TAIL, "-state", 0, "cleaned state to set", NULL);
     379    // -pendingcleanupwarprun
     380    psMetadata *pendingcleanupwarprunArgs = psMetadataAlloc();
     381    psMetadataAddStr(pendingcleanupwarprunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "list blocks for specified label", NULL);
     382    psMetadataAddStr(pendingcleanupwarprunArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "list blocks for specified data_group", NULL);
     383    psMetadataAddBool(pendingcleanupwarprunArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     384    psMetadataAddU64(pendingcleanupwarprunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     385
     386    // -pendingcleanupwarpskyfile
     387    psMetadata *pendingcleanupwarpskyfileArgs = psMetadataAlloc();
     388    psMetadataAddS64(pendingcleanupwarpskyfileArgs, PS_LIST_TAIL, "-warp_bg_id", 0, "search by warp_bg_id (required)", 0);
     389    psMetadataAddBool(pendingcleanupwarpskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     390    psMetadataAddU64(pendingcleanupwarpskyfileArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     391   
     392    // -tocleanwarpskyfile
     393    psMetadata *tocleanedwarpskyfileArgs = psMetadataAlloc();
     394    psMetadataAddS64(tocleanedwarpskyfileArgs, PS_LIST_TAIL, "-warp_bg_id", 0, "search by warp_bg_id (required)", 0);
     395    psMetadataAddStr(tocleanedwarpskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell_id (required)", 0);
     396    psMetadataAddStr(tocleanedwarpskyfileArgs, PS_LIST_TAIL, "-state", 0, "cleaned state to set", NULL);
     397
     398    // -updatewarpskyfile
     399    psMetadata *updatewarpskyfileArgs = psMetadataAlloc();
     400    psMetadataAddS64(updatewarpskyfileArgs, PS_LIST_TAIL, "-warp_bg_id", 0,          "search by chip ID (required)", 0);
     401    psMetadataAddStr(updatewarpskyfileArgs, PS_LIST_TAIL, "-skycell_id",  0, "search by skycell_id (required)", NULL);
     402    psMetadataAddStr(updatewarpskyfileArgs, PS_LIST_TAIL, "-set_state",  0, "new value for data_state", NULL);
     403    psMetadataAddS16(updatewarpskyfileArgs, PS_LIST_TAIL, "-fault",  0, "set fault code", 0);
    373404
    374405    // -exportwarp
    … …  
    397428    PXOPT_ADD_MODE("-revertchip",  "", BGTOOL_MODE_REVERTCHIP,  revertchipArgs);
    398429    PXOPT_ADD_MODE("-listchip",    "", BGTOOL_MODE_LISTCHIP,    listchipArgs);
    399     PXOPT_ADD_MODE("-tocleanchip", "", BGTOOL_MODE_TOCLEANCHIP, tocleanchipArgs);
    400     PXOPT_ADD_MODE("-cleanedchip", "", BGTOOL_MODE_CLEANEDCHIP, cleanedchipArgs);
     430    PXOPT_ADD_MODE("-pendingcleanupchiprun", "", BGTOOL_MODE_PENDINGCLEANUPCHIPRUN, pendingcleanupchiprunArgs);
     431    PXOPT_ADD_MODE("-pendingcleanupchipimfile", "", BGTOOL_MODE_PENDINGCLEANUPCHIPIMFILE, pendingcleanupchipimfileArgs);
     432    PXOPT_ADD_MODE("-tocleanedchipimfile", "", BGTOOL_MODE_TOCLEANEDCHIPIMFILE, tocleanedchipimfileArgs);
     433    PXOPT_ADD_MODE("-updatechipimfile", "", BGTOOL_MODE_UPDATECHIPIMFILE, updatechipimfileArgs);
    401434    PXOPT_ADD_MODE("-exportchip",  "", BGTOOL_MODE_EXPORTCHIP,  exportchipArgs);
    402435    PXOPT_ADD_MODE("-importchip",  "", BGTOOL_MODE_IMPORTCHIP,  importchipArgs);
    … …  
    411444    PXOPT_ADD_MODE("-revertwarp",  "", BGTOOL_MODE_REVERTWARP,  revertwarpArgs);
    412445    PXOPT_ADD_MODE("-listwarp",    "", BGTOOL_MODE_LISTWARP,    listwarpArgs);
    413     PXOPT_ADD_MODE("-tocleanwarp", "", BGTOOL_MODE_TOCLEANWARP, tocleanwarpArgs);
    414     PXOPT_ADD_MODE("-cleanedwarp", "", BGTOOL_MODE_CLEANEDWARP, cleanedwarpArgs);
     446    PXOPT_ADD_MODE("-pendingcleanupwarprun", "", BGTOOL_MODE_PENDINGCLEANUPWARPRUN, pendingcleanupwarprunArgs);
     447    PXOPT_ADD_MODE("-pendingcleanupwarpskyfile", "", BGTOOL_MODE_PENDINGCLEANUPWARPSKYFILE, pendingcleanupwarpskyfileArgs);
     448    PXOPT_ADD_MODE("-tocleanedwarpskyfile", "", BGTOOL_MODE_TOCLEANEDWARPSKYFILE, tocleanedwarpskyfileArgs);
     449    PXOPT_ADD_MODE("-updatewarpskyfile", "", BGTOOL_MODE_UPDATEWARPSKYFILE, updatewarpskyfileArgs);
    415450    PXOPT_ADD_MODE("-exportwarp",  "", BGTOOL_MODE_EXPORTWARP,  exportwarpArgs);
    416451    PXOPT_ADD_MODE("-importwarp",  "", BGTOOL_MODE_IMPORTWARP,  importwarpArgs);

  • branches/eam_branches/ipp-20101103/ippTools/src/warptool.c

    r29416 r29835  
    924924
    925925    psMetadata *where = psMetadataAlloc();
     926
    926927    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpSkyCellMap.warp_id", "==");
    927     pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    928928
    929929    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    930930    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    931931
    932     // find all rawImfiles matching the default query
    933     psString query = pxDataGet("warptool_towarped.sql");
    934     if (!query) {
     932    // First find Label's with warpRuns in state new in priority order
     933    psMetadata *labelWhere = psMetadataAlloc();
     934    pxAddLabelSearchArgs (config, labelWhere, "-label", "warpRun.label", "==");
     935
     936    psString labelQuery = pxDataGet("warptool_towarped_labels.sql");
     937    if (!labelQuery) {
    935938        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    936939        return false;
    937940    }
    938 
    939     psString whereStr = psStringCopy("");
     941    psString labelWhereStr = psStringCopy("");
     942    if (psListLength(labelWhere->list)) {
     943        psString whereClause = psDBGenerateWhereConditionSQL(labelWhere, NULL);
     944        psStringAppend(&labelWhereStr, "\n AND %s", whereClause);
     945        psFree(whereClause);
     946    }
     947    psFree(labelWhere);
     948
     949    if (!p_psDBRunQueryF(config->dbh, labelQuery, labelWhereStr)) {
     950        psError(PS_ERR_UNKNOWN, false, "database error");
     951        psFree(labelQuery);
     952        return false;
     953    }
     954    psFree(labelQuery);
     955    psFree(labelWhereStr);
     956
     957    psArray *labelOutput = p_psDBFetchResult(config->dbh);
     958    if (psArrayLength(labelOutput) == 0) {
     959        psTrace("warptool", PS_LOG_INFO, "no labels with pending warps found.");
     960        return true;
     961    }
     962
     963    psString originalQuery = pxDataGet("warptool_towarped.sql");
     964    if (!originalQuery) {
     965        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     966        return false;
     967    }
     968
     969    psString whereStr = NULL;
    940970    if (psListLength(where->list)) {
    941971        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    945975    psFree(where);
    946976
    947     // treat limit == 0 as "no limit"
    948     psString limitString = psStringCopy("\nORDER BY priority DESC, warp_id");
    949     if (limit) {
    950         // We apply the limit to both sides of the UNION to avoid slow queries
    951         // and to the query itself to satisfy the user's requested limit
    952         psStringAppend(&limitString, "%s", psDBGenerateLimitSQL(limit));
    953         psStringAppend(&query, " %s", limitString);
    954     }
    955 
    956     if (!p_psDBRunQueryF(config->dbh, query, whereStr, limitString, whereStr,  limitString)) {
    957         psError(PS_ERR_UNKNOWN, false, "database error");
     977    // Now loop over the labels and query each individually
     978    for (long i = 0; i < psArrayLength(labelOutput); i++) {
     979        psMetadata *labelRow = labelOutput->data[i];
     980
     981        bool status;
     982        psString label = psMetadataLookupStr(&status, labelRow, "label");
     983
     984        psString query = psStringCopy(originalQuery);
     985
     986        // treat limit == 0 as "no limit"
     987        psString limitString = psStringCopy("");
     988        if (limit) {
     989            // We apply the limit to both sides of the UNION to avoid slow queries
     990            // and to the query itself to satisfy the user's requested limit
     991            psStringAppend(&limitString, "\n%s", psDBGenerateLimitSQL(limit));
     992            psStringAppend(&query, "%s", limitString);
     993        }
     994        psString thisWhere = NULL;
     995        if (whereStr) {
     996            psStringAppend(&thisWhere, whereStr);
     997        }
     998        psStringAppend(&thisWhere, "\nAND warpRun.label = '%s'", label);
     999
     1000        if (!p_psDBRunQueryF(config->dbh, query, thisWhere, limitString, thisWhere,  limitString)) {
     1001            psError(PS_ERR_UNKNOWN, false, "database error");
     1002            psFree(query);
     1003            return false;
     1004        }
     1005        psFree(limitString);
     1006        psFree(thisWhere);
    9581007        psFree(query);
    959         return false;
    960     }
    961     psFree(limitString);
     1008
     1009        psArray *output = p_psDBFetchResult(config->dbh);
     1010        if (!output) {
     1011            psErrorCode err = psErrorCodeLast();
     1012            switch (err) {
     1013                case PS_ERR_DB_CLIENT:
     1014                    psError(PXTOOLS_ERR_SYS, false, "database error");
     1015                    case PS_ERR_DB_SERVER:
     1016                    psError(PXTOOLS_ERR_PROG, false, "database error");
     1017                default:
     1018                    psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1019            }
     1020
     1021            return false;
     1022        }
     1023        long outputLength = psArrayLength(output);
     1024        if (outputLength) {
     1025            // negative simple so the default is true
     1026            if (!ippdbPrintMetadatas(stdout, output, "warpPendingSkyCell", !simple)) {
     1027                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1028                psFree(output);
     1029                return false;
     1030            }
     1031        } else {
     1032            psTrace("warptool", PS_LOG_INFO, "no rows found for %s", label);
     1033            psFree(output);
     1034            continue;
     1035        }
     1036        psFree(output);
     1037
     1038        if (limit) {
     1039            limit -= outputLength;
     1040            if (limit <= 0) {
     1041                // All done
     1042                break;
     1043            }
     1044        }
     1045    }
     1046    psFree(labelOutput);
    9621047    psFree(whereStr);
    963     psFree(query);
    964 
    965     psArray *output = p_psDBFetchResult(config->dbh);
    966     if (!output) {
    967         psErrorCode err = psErrorCodeLast();
    968         switch (err) {
    969             case PS_ERR_DB_CLIENT:
    970                 psError(PXTOOLS_ERR_SYS, false, "database error");
    971             case PS_ERR_DB_SERVER:
    972                 psError(PXTOOLS_ERR_PROG, false, "database error");
    973             default:
    974                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    975         }
    976 
    977         return false;
    978     }
    979     if (!psArrayLength(output)) {
    980         psTrace("warptool", PS_LOG_INFO, "no rows found");
    981         psFree(output);
    982         return true;
    983     }
    984 
    985     if (psArrayLength(output)) {
    986         // negative simple so the default is true
    987         if (!ippdbPrintMetadatas(stdout, output, "warpPendingSkyCell", !simple)) {
    988             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    989             psFree(output);
    990             return false;
    991         }
    992     }
    993 
    994     psFree(output);
     1048    psFree(originalQuery);
    9951049
    9961050    return true;
Note: See TracChangeset for help on using the changeset viewer.