IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 16050


Ignore:
Timestamp:
Jan 8, 2008, 4:36:07 PM (18 years ago)
Author:
jhoblitt
Message:

code cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/end_stage/ippTools/src/regtool.c

    r16049 r16050  
    4343static bool revertprocessedexpMode(pxConfig *config);
    4444static bool updateprocessedexpMode(pxConfig *config);
    45 
    46 
    47 // static guidePendingExpRow *newToP1PendingExp(newExpRow *newExp);
    48 //static chipPendingExpRow *newTochipPendingExp(pxConfig *config, newExpRow *newExp);
    49 //static chipInputImfileRow *rawImfileTochipInputImfile(pxConfig *config, psS64 chip_id, rawImfileRow *rawImfile);
    50 
    51 static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp);
    52 //static psU32 mapCodeStrToInt(const char *codeStr);
    53 
    5445
    5546# define MODECASE(caseName, func) \
    … …  
    822813
    823814    bool status = false;
     815    // required
     816    psString exp_name = psMetadataLookupStr(&status, config->args, "-exp_name");
     817    if (!status) {
     818        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_name");
     819        return false;
     820    }
     821    if (!exp_name) {
     822        psError(PS_ERR_UNKNOWN, true, "-exp_name is required");
     823        return false;
     824    }
     825
     826    psString camera = psMetadataLookupStr(&status, config->args, "-inst");
     827    if (!status) {
     828        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
     829        return false;
     830    }
     831    if (!camera) {
     832        psError(PS_ERR_UNKNOWN, true, "-inst is required");
     833        return false;
     834    }
     835
     836    psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
     837    if (!status) {
     838        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
     839        return false;
     840    }
     841    if (!telescope) {
     842        psError(PS_ERR_UNKNOWN, true, "-telescope is required");
     843        return false;
     844    }
     845
     846    psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
     847    if (!status) {
     848        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_tag");
     849        return false;
     850    }
     851    if (!exp_tag) {
     852        psError(PS_ERR_UNKNOWN, true, "-exp_tag is required");
     853        return false;
     854    }
     855
     856    // optional
     857    psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
     858    if (!status) {
     859        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
     860        return false;
     861    }
     862
     863    psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
     864    if (!status) {
     865        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
     866        return false;
     867    }
     868    if (!filelevel) {
     869        psError(PS_ERR_UNKNOWN, true, "-filelevel is required");
     870        return false;
     871    }
     872
     873    psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
     874    if (!status) {
     875        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
     876        return false;
     877    }
     878
     879    psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
     880    if (!status) {
     881        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
     882        return false;
     883    }
     884
     885    psString filter = psMetadataLookupStr(&status, config->args, "-filter");
     886    if (!status) {
     887        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
     888        return false;
     889    }
     890
     891    psString comment = psMetadataLookupStr(&status, config->args, "-comment");
     892    if (!status) {
     893        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -comment");
     894        return false;
     895    }
     896
     897    psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
     898    if (!status) {
     899        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
     900        return false;
     901    }
     902
     903    psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
     904    if (!status) {
     905        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
     906        return false;
     907    }
     908
     909    psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
     910    if (!status) {
     911        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
     912        return false;
     913    }
     914
     915    psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
     916    if (!status) {
     917        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
     918        return false;
     919    }
     920
     921    psF32 sat_pixel_frac = psMetadataLookupF32(&status, config->args, "-sat_pixel_frac");
     922    if (!status) {
     923        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sat_pixel_frac");
     924        return false;
     925    }
     926
     927    psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
     928    if (!status) {
     929        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
     930        return false;
     931    }
     932
     933    psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
     934    if (!status) {
     935        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
     936        return false;
     937    }
     938
     939    psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
     940    if (!status) {
     941        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
     942        return false;
     943    }
     944
     945    psF64 alt = psMetadataLookupF64(&status, config->args, "-alt");
     946    if (!status) {
     947        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -alt");
     948        return false;
     949    }
     950
     951    psF64 az = psMetadataLookupF64(&status, config->args, "-az");
     952    if (!status) {
     953        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -az");
     954        return false;
     955    }
     956
     957    psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
     958    if (!status) {
     959        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
     960        return false;
     961    }
     962
     963    psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
     964    if (!status) {
     965        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
     966        return false;
     967    }
     968
     969    psF32 m1_x = psMetadataLookupF32(&status, config->args, "-m1_x");
     970    if (!status) {
     971        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_x");
     972        return false;
     973    }
     974    psF32 m1_y = psMetadataLookupF32(&status, config->args, "-m1_y");
     975    if (!status) {
     976        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_y");
     977        return false;
     978    }
     979    psF32 m1_z = psMetadataLookupF32(&status, config->args, "-m1_z");
     980    if (!status) {
     981        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_z");
     982        return false;
     983    }
     984    psF32 m1_tip = psMetadataLookupF32(&status, config->args, "-m1_tip");
     985    if (!status) {
     986        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tip");
     987        return false;
     988    }
     989    psF32 m1_tilt = psMetadataLookupF32(&status, config->args, "-m1_tilt");
     990    if (!status) {
     991        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tilt");
     992        return false;
     993    }
     994
     995    psF32 m2_x = psMetadataLookupF32(&status, config->args, "-m2_x");
     996    if (!status) {
     997        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_x");
     998        return false;
     999    }
     1000    psF32 m2_y = psMetadataLookupF32(&status, config->args, "-m2_y");
     1001    if (!status) {
     1002        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_y");
     1003        return false;
     1004    }
     1005    psF32 m2_z = psMetadataLookupF32(&status, config->args, "-m2_z");
     1006    if (!status) {
     1007        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_z");
     1008        return false;
     1009    }
     1010    psF32 m2_tip = psMetadataLookupF32(&status, config->args, "-m2_tip");
     1011    if (!status) {
     1012        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tip");
     1013        return false;
     1014    }
     1015    psF32 m2_tilt = psMetadataLookupF32(&status, config->args, "-m2_tilt");
     1016    if (!status) {
     1017        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tilt");
     1018        return false;
     1019    }
     1020
     1021    psF32 env_temp = psMetadataLookupF32(&status, config->args, "-env_temperature");
     1022    if (!status) {
     1023        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_temperature");
     1024        return false;
     1025    }
     1026    psF32 env_humid = psMetadataLookupF32(&status, config->args, "-env_humidity");
     1027    if (!status) {
     1028        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_humidity");
     1029        return false;
     1030    }
     1031    psF32 env_wind = psMetadataLookupF32(&status, config->args, "-env_wind_speed");
     1032    if (!status) {
     1033        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_speed");
     1034        return false;
     1035    }
     1036    psF32 env_dir = psMetadataLookupF32(&status, config->args, "-env_wind_dir");
     1037    if (!status) {
     1038        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_dir");
     1039        return false;
     1040    }
     1041
     1042    psF32 teltemp_m1 = psMetadataLookupF32(&status, config->args, "-teltemp_m1");
     1043    if (!status) {
     1044        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1");
     1045        return false;
     1046    }
     1047    psF32 teltemp_m1cell = psMetadataLookupF32(&status, config->args, "-teltemp_m1cell");
     1048    if (!status) {
     1049        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1cell");
     1050        return false;
     1051    }
     1052    psF32 teltemp_m2 = psMetadataLookupF32(&status, config->args, "-teltemp_m2");
     1053    if (!status) {
     1054        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m2");
     1055        return false;
     1056    }
     1057    psF32 teltemp_spider = psMetadataLookupF32(&status, config->args, "-teltemp_spider");
     1058    if (!status) {
     1059        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_spider");
     1060        return false;
     1061    }
     1062    psF32 teltemp_truss = psMetadataLookupF32(&status, config->args, "-teltemp_truss");
     1063    if (!status) {
     1064        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_truss");
     1065        return false;
     1066    }
     1067    psF32 teltemp_extra = psMetadataLookupF32(&status, config->args, "-teltemp_extra");
     1068    if (!status) {
     1069        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_extra");
     1070        return false;
     1071    }
     1072
     1073    psF32 pon_time = psMetadataLookupF32(&status, config->args, "-pon_time");
     1074    if (!status) {
     1075        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pon_time");
     1076        return false;
     1077    }
     1078
     1079    psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
     1080    if (!status) {
     1081        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
     1082        return false;
     1083    }
     1084    psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
     1085    if (!status) {
     1086        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
     1087        return false;
     1088    }
     1089    psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
     1090    if (!status) {
     1091        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
     1092        return false;
     1093    }
     1094    psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
     1095    if (!status) {
     1096        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
     1097        return false;
     1098    }
     1099    psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
     1100    if (!status) {
     1101        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
     1102        return false;
     1103    }
     1104
     1105    psString object = psMetadataLookupStr(&status, config->args, "-object");
     1106    if (!status) {
     1107        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
     1108        return false;
     1109    }
     1110
     1111    psTime *dateobs = NULL;
     1112    {
     1113        psString dateobsStr = psMetadataLookupStr(&status, config->args, "-dateobs");
     1114        if (!status) {
     1115            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dateobs");
     1116            return false;
     1117        }
     1118        // pass through NULL as this is an optional field
     1119        if (dateobsStr) {
     1120            dateobs = psTimeFromISO(dateobsStr, PS_TIME_UTC);
     1121        } else {
     1122            dateobs = NULL;
     1123        }
     1124    }
     1125
     1126    // default
     1127    psS16 code = psMetadataLookupS16(&status, config->args, "-code");
     1128    if (!status) {
     1129        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1130        return false;
     1131    }
    8241132    psString exp_id = psMetadataLookupStr(&status, config->args, "-exp_id");
    8251133    if (!status) {
    … …  
    8651173        // build a query to search by exp_id
    8661174        psMetadata *where = psMetadataAlloc();
    867         if (exp_id) {
    868             if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
    869                 psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    870                 psFree(where);
    871                 psFree(query);
    872                 return false;
    873             }
    874         }
    875 
     1175        if (!psMetadataAddStr(where, PS_LIST_TAIL, "exp_id", 0, "==", exp_id)) {
     1176            psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
     1177            psFree(where);
     1178            psFree(query);
     1179            return false;
     1180        }
    8761181
    8771182        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    9091214        return false;
    9101215    }
     1216    // sanity check that we only got one row
     1217    if (psArrayLength(output) != 1) {
     1218        // rollback
     1219        if (!psDBRollback(config->dbh)) {
     1220            psError(PS_ERR_UNKNOWN, false, "database error");
     1221        }
     1222        psError(PS_ERR_UNKNOWN, false, "should have gotten 1 row but %lu rows were returned", psArrayLength(output));
     1223        psFree(output);
     1224        return NULL;
     1225    }
    9111226
    9121227    if (!psDBTransaction(config->dbh)) {
    … …  
    9171232
    9181233    // insert the exp into rawExp
    919     for (long i = 0; psArrayLength(output) > i; i++) {
    920         psMetadata *row = output->data[i];
    921         // convert metadata into a newExp object
    922         newExpRow *newExp = newExpObjectFromMetadata(row);
    923         // convert newExp object into a rawExp object
    924         rawExpRow *rawExp = newToRawExp(config, newExp);
    925         if (!rawExp) {
    926             // rollback
    927             if (!psDBRollback(config->dbh)) {
    928                 psError(PS_ERR_UNKNOWN, false, "database error");
    929             }
    930             psError(PS_ERR_UNKNOWN, false, "failed to convert newExp to rawExp");
    931             psFree(newExp);
    932             psFree(output);
    933             return false;
    934         }
    935         psFree(newExp);
    936 
    937         // insert the rawExp object into the database
    938         if (!rawExpInsertObject(config->dbh, rawExp)) {
    939             // rollback
    940             if (!psDBRollback(config->dbh)) {
    941                 psError(PS_ERR_UNKNOWN, false, "database error");
    942             }
    943             psError(PS_ERR_UNKNOWN, false, "database error");
    944             psFree(rawExp);
    945             psFree(output);
    946             return false;
    947         }
    948 
    949         // if this is a detrend image don't put it in the chip queue (and we're
    950         // done)
    951         if (detrend) {
    952             // set the state for the newExp to stop
    953             if (!pxnewExpSetState(config, exp_id, "stop")) {
    954                 // rollback
    955                 if (!psDBRollback(config->dbh)) {
    956                     psError(PS_ERR_UNKNOWN, false, "database error");
    957                 }
    958                 psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
    959                 psFree(rawExp);
    960                 psFree(output);
    961                 return false;
    962             }
    963             psFree(rawExp);
    964             continue;
    965         }
    966 
    967 
    968         // set the state for the newExp to stop
    969         if (!pxnewExpSetState(config, exp_id, "stop")) {
    970             // rollback
    971             if (!psDBRollback(config->dbh)) {
    972                 psError(PS_ERR_UNKNOWN, false, "database error");
    973             }
    974             psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
    975             psFree(rawExp);
    976             psFree(output);
    977             return false;
    978         }
    979 
    980         // insert an entry into the chipPendingExp table
    981         // this can only be run as the newExp's state has been set to stop
    982         if (!pxchipQueueByExpTag(config,
    983                     rawExp->exp_id,
    984                     rawExp->workdir,
    985                     NULL, // label
    986                     rawExp->reduction,
    987                     NULL, // expgroup
    988                     dvodb,
    989                     tess_id,
    990                     end_stage
    991         )) {
    992             // rollback
    993             if (!psDBRollback(config->dbh)) {
    994                 psError(PS_ERR_UNKNOWN, false, "database error");
    995             }
    996             psError(PS_ERR_UNKNOWN, false, "failed to queue chipPendingExp");
    997             psFree(rawExp);
    998             psFree(output);
    999             return false;
    1000         }
    1001         psFree(rawExp);
    1002     }
     1234    psMetadata *row = output->data[0];
     1235    // convert metadata into a newExp object
     1236    newExpRow *newExp = newExpObjectFromMetadata(row);
    10031237    psFree(output);
    10041238
    1005     if (!psDBCommit(config->dbh)) {
    1006         psError(PS_ERR_UNKNOWN, false, "database error");
    1007         return false;
    1008     }
    1009 
    1010     return true;
    1011 }
    1012 
    1013 
    1014 static bool processedexpMode(pxConfig *config)
    1015 {
    1016     PS_ASSERT_PTR_NON_NULL(config, false);
    1017 
    1018     bool status = false;
    1019     psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
    1020     if (!status) {
    1021         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
    1022         return false;
    1023     }
    1024 
    1025     bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
    1026     if (!status) {
    1027         psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
    1028         return false;
    1029     }
    1030 
    1031     psString query = pxDataGet("regtool_processedexp.sql");
    1032     if (!query) {
    1033         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1034         return false;
    1035     }
    1036 
    1037     if (config->where) {
    1038         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
    1039         psStringAppend(&query, " AND %s", whereClause);
    1040         psFree(whereClause);
    1041     }
    1042 
    1043     if (faulted) {
    1044         // list only faulted rows
    1045         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    1046     } else {
    1047         // don't list faulted rows
    1048         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    1049     }
    1050 
    1051     // treat limit == 0 as "no limit"
    1052     if (limit) {
    1053         psString limitString = psDBGenerateLimitSQL(limit);
    1054         psStringAppend(&query, " %s", limitString);
    1055         psFree(limitString);
    1056     }
    1057 
    1058     if (!p_psDBRunQuery(config->dbh, query)) {
    1059         psError(PS_ERR_UNKNOWN, false, "database error");
    1060         return false;
    1061     }
    1062     psFree(query);
    1063 
    1064     psArray *output = p_psDBFetchResult(config->dbh);
    1065     if (!output) {
    1066         psErrorCode err = psErrorCodeLast();
    1067         switch (err) {
    1068             case PS_ERR_DB_CLIENT:
    1069                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1070             case PS_ERR_DB_SERVER:
    1071                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1072             default:
    1073                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1074         }
    1075 
    1076         return false;
    1077     }
    1078     if (!psArrayLength(output)) {
    1079         psTrace("regtool", PS_LOG_INFO, "no rows found");
    1080         psFree(output);
    1081         return true;
    1082     }
    1083 
    1084     bool simple = false;
    1085     {
    1086         bool status = false;
    1087         simple = psMetadataLookupBool(&status, config->args, "-simple");
    1088         if (!status) {
    1089             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
    1090             return false;
    1091         }
    1092     }
    1093 
    1094     if (psArrayLength(output)) {
    1095         // negative simple so the default is true
    1096         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    1097             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1098             psFree(output);
    1099             return false;
    1100         }
    1101     }
    1102 
    1103     psFree(output);
    1104 
    1105     return true;
    1106 }
    1107 
    1108 static bool revertprocessedexpMode(pxConfig *config)
    1109 {
    1110     PS_ASSERT_PTR_NON_NULL(config, false);
    1111 
    1112     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1113     if (!query) {
    1114         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1115         return false;
    1116     }
    1117 
    1118     if (config->where) {
    1119         psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
    1120         psStringAppend(&query, " AND %s", whereClause);
    1121         psFree(whereClause);
    1122     }
    1123 
    1124     if (!p_psDBRunQuery(config->dbh, query)) {
    1125         psError(PS_ERR_UNKNOWN, false, "database error");
    1126         psFree(query);
    1127         return false;
    1128     }
    1129     psFree(query);
    1130 
    1131     if (psDBAffectedRows(config->dbh) < 1) {
    1132         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1133         return false;
    1134     }
    1135 
    1136     return true;
    1137 }
    1138 
    1139 
    1140 static bool updateprocessedexpMode(pxConfig *config)
    1141 {
    1142     bool status = false;
    1143     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    1144     if (!status) {
    1145         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    1146         return false;
    1147     }
    1148     if (code == INT16_MAX) {
    1149         psError(PS_ERR_UNKNOWN, true, "-code is required");
    1150         return false;
    1151     }
    1152 
    1153     if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
    1154         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1155         return false;
    1156     }
    1157 
    1158     return true;
    1159 }
    1160 
    1161 
    1162 # if 0
    1163 static guidePendingExpRow *newToP1PendingExp(newExpRow *newExp)
    1164 {
    1165     return guidePendingExpRowAlloc(
    1166         newExp->exp_id,
    1167         newExp->camera,
    1168         newExp->telescope,
    1169         newExp->exp_type,
    1170         newExp->imfiles,
    1171         "my filter",
    1172         0.1, // airmass
    1173         0.2, // ra
    1174         0.3, // dec
    1175         0.4, // exp time
    1176         0.5, // background
    1177         "my recipe",
    1178         0xff // XXX calc version number
    1179     );
    1180 }
    1181 #endif
    1182 
    1183 
    1184 #if 0
    1185 static chipPendingExpRow *newTochipPendingExp(pxConfig *config, newExpRow *exp)
    1186 {
    1187     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1188     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    1189 
    1190     // optional
    1191     bool status = false;
    1192     psString label = psMetadataLookupStr(&status, config->args, "-label");
    1193     if (!status) {
    1194         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -label");
    1195         return false;
    1196     }
    1197 
    1198     chipPendingExpRow *chipExp = chipPendingExpRowAlloc(
    1199             0,              // chip ID, assigned by db
    1200             exp->exp_id,
    1201             0xdeadbeef,     // guide version
    1202             label,
    1203             "my recipe",    // recipe
    1204             NULL,           // expgroup
    1205             NULL            // dvodb
    1206     );
    1207 
    1208     return chipExp;
    1209 }
    1210 
    1211 
    1212 static chipInputImfileRow *rawImfileTochipInputImfile(pxConfig *config, psS64 chip_id, rawImfileRow *rawImfile)
    1213 {
    1214     return chipInputImfileRowAlloc(
    1215             chip_id,
    1216             rawImfile->class_id,
    1217             rawImfile->uri
    1218     );
    1219 }
    1220 #endif
    1221 
    1222 
    1223 static rawExpRow *newToRawExp(pxConfig *config, newExpRow *exp)
    1224 {
    1225     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1226     PS_ASSERT_PTR_NON_NULL(exp, NULL);
    1227 
    1228     bool status = false;
    1229     // required
    1230     psString exp_name = psMetadataLookupStr(&status, config->args, "-exp_name");
    1231     if (!status) {
    1232         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_name");
    1233         return false;
    1234     }
    1235     if (!exp_name) {
    1236         psError(PS_ERR_UNKNOWN, true, "-exp_name is required");
    1237         return false;
    1238     }
    1239 
    1240     psString camera = psMetadataLookupStr(&status, config->args, "-inst");
    1241     if (!status) {
    1242         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -inst");
    1243         return false;
    1244     }
    1245     if (!camera) {
    1246         psError(PS_ERR_UNKNOWN, true, "-inst is required");
    1247         return false;
    1248     }
    1249 
    1250     psString telescope = psMetadataLookupStr(&status, config->args, "-telescope");
    1251     if (!status) {
    1252         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -telescope");
    1253         return false;
    1254     }
    1255     if (!telescope) {
    1256         psError(PS_ERR_UNKNOWN, true, "-telescope is required");
    1257         return false;
    1258     }
    1259 
    1260     psString exp_tag = psMetadataLookupStr(&status, config->args, "-exp_tag");
    1261     if (!status) {
    1262         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_tag");
    1263         return false;
    1264     }
    1265     if (!exp_tag) {
    1266         psError(PS_ERR_UNKNOWN, true, "-exp_tag is required");
    1267         return false;
    1268     }
    1269 
    1270     // optional
    1271     psString exp_type = psMetadataLookupStr(&status, config->args, "-exp_type");
    1272     if (!status) {
    1273         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_type");
    1274         return false;
    1275     }
    1276 
    1277     psString filelevel = psMetadataLookupStr(&status, config->args, "-filelevel");
    1278     if (!status) {
    1279         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filelevel");
    1280         return false;
    1281     }
    1282     if (!filelevel) {
    1283         psError(PS_ERR_UNKNOWN, true, "-filelevel is required");
    1284         return false;
    1285     }
    1286 
    1287     psString workdir = psMetadataLookupStr(&status, config->args, "-workdir");
    1288     if (!status) {
    1289         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -workdir");
    1290         return false;
    1291     }
    1292 
    1293     psString reduction = psMetadataLookupStr(&status, config->args, "-reduction");
    1294     if (!status) {
    1295         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -reduction");
    1296         return false;
    1297     }
    1298 
    1299     psString filter = psMetadataLookupStr(&status, config->args, "-filter");
    1300     if (!status) {
    1301         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -filter");
    1302         return false;
    1303     }
    1304 
    1305     psString comment = psMetadataLookupStr(&status, config->args, "-comment");
    1306     if (!status) {
    1307         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -comment");
    1308         return false;
    1309     }
    1310 
    1311     psF32 airmass = psMetadataLookupF32(&status, config->args, "-airmass");
    1312     if (!status) {
    1313         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -airmass");
    1314         return false;
    1315     }
    1316 
    1317     psF64 ra = psMetadataLookupF64(&status, config->args, "-ra");
    1318     if (!status) {
    1319         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ra");
    1320         return false;
    1321     }
    1322 
    1323     psF64 decl = psMetadataLookupF64(&status, config->args, "-decl");
    1324     if (!status) {
    1325         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -decl");
    1326         return false;
    1327     }
    1328 
    1329     psF32 exp_time = psMetadataLookupF32(&status, config->args, "-exp_time");
    1330     if (!status) {
    1331         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -exp_time");
    1332         return false;
    1333     }
    1334 
    1335     psF32 sat_pixel_frac = psMetadataLookupF32(&status, config->args, "-sat_pixel_frac");
    1336     if (!status) {
    1337         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -sat_pixel_frac");
    1338         return false;
    1339     }
    1340 
    1341     psF64 bg = psMetadataLookupF64(&status, config->args, "-bg");
    1342     if (!status) {
    1343         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg");
    1344         return false;
    1345     }
    1346 
    1347     psF64 bg_stdev = psMetadataLookupF64(&status, config->args, "-bg_stdev");
    1348     if (!status) {
    1349         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_stdev");
    1350         return false;
    1351     }
    1352 
    1353     psF64 bg_mean_stdev = psMetadataLookupF64(&status, config->args, "-bg_mean_stdev");
    1354     if (!status) {
    1355         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -bg_mean_stdev");
    1356         return false;
    1357     }
    1358 
    1359     psF64 alt = psMetadataLookupF64(&status, config->args, "-alt");
    1360     if (!status) {
    1361         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -alt");
    1362         return false;
    1363     }
    1364 
    1365     psF64 az = psMetadataLookupF64(&status, config->args, "-az");
    1366     if (!status) {
    1367         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -az");
    1368         return false;
    1369     }
    1370 
    1371     psF32 ccd_temp = psMetadataLookupF32(&status, config->args, "-ccd_temp");
    1372     if (!status) {
    1373         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -ccd_temp");
    1374         return false;
    1375     }
    1376 
    1377     psF64 posang = psMetadataLookupF32(&status, config->args, "-posang");
    1378     if (!status) {
    1379         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -posang");
    1380         return false;
    1381     }
    1382 
    1383     psF32 m1_x = psMetadataLookupF32(&status, config->args, "-m1_x");
    1384     if (!status) {
    1385         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_x");
    1386         return false;
    1387     }
    1388     psF32 m1_y = psMetadataLookupF32(&status, config->args, "-m1_y");
    1389     if (!status) {
    1390         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_y");
    1391         return false;
    1392     }
    1393     psF32 m1_z = psMetadataLookupF32(&status, config->args, "-m1_z");
    1394     if (!status) {
    1395         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_z");
    1396         return false;
    1397     }
    1398     psF32 m1_tip = psMetadataLookupF32(&status, config->args, "-m1_tip");
    1399     if (!status) {
    1400         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tip");
    1401         return false;
    1402     }
    1403     psF32 m1_tilt = psMetadataLookupF32(&status, config->args, "-m1_tilt");
    1404     if (!status) {
    1405         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m1_tilt");
    1406         return false;
    1407     }
    1408 
    1409     psF32 m2_x = psMetadataLookupF32(&status, config->args, "-m2_x");
    1410     if (!status) {
    1411         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_x");
    1412         return false;
    1413     }
    1414     psF32 m2_y = psMetadataLookupF32(&status, config->args, "-m2_y");
    1415     if (!status) {
    1416         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_y");
    1417         return false;
    1418     }
    1419     psF32 m2_z = psMetadataLookupF32(&status, config->args, "-m2_z");
    1420     if (!status) {
    1421         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_z");
    1422         return false;
    1423     }
    1424     psF32 m2_tip = psMetadataLookupF32(&status, config->args, "-m2_tip");
    1425     if (!status) {
    1426         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tip");
    1427         return false;
    1428     }
    1429     psF32 m2_tilt = psMetadataLookupF32(&status, config->args, "-m2_tilt");
    1430     if (!status) {
    1431         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -m2_tilt");
    1432         return false;
    1433     }
    1434 
    1435     psF32 env_temp = psMetadataLookupF32(&status, config->args, "-env_temperature");
    1436     if (!status) {
    1437         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_temperature");
    1438         return false;
    1439     }
    1440     psF32 env_humid = psMetadataLookupF32(&status, config->args, "-env_humidity");
    1441     if (!status) {
    1442         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_humidity");
    1443         return false;
    1444     }
    1445     psF32 env_wind = psMetadataLookupF32(&status, config->args, "-env_wind_speed");
    1446     if (!status) {
    1447         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_speed");
    1448         return false;
    1449     }
    1450     psF32 env_dir = psMetadataLookupF32(&status, config->args, "-env_wind_dir");
    1451     if (!status) {
    1452         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -env_wind_dir");
    1453         return false;
    1454     }
    1455 
    1456     psF32 teltemp_m1 = psMetadataLookupF32(&status, config->args, "-teltemp_m1");
    1457     if (!status) {
    1458         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1");
    1459         return false;
    1460     }
    1461     psF32 teltemp_m1cell = psMetadataLookupF32(&status, config->args, "-teltemp_m1cell");
    1462     if (!status) {
    1463         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m1cell");
    1464         return false;
    1465     }
    1466     psF32 teltemp_m2 = psMetadataLookupF32(&status, config->args, "-teltemp_m2");
    1467     if (!status) {
    1468         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_m2");
    1469         return false;
    1470     }
    1471     psF32 teltemp_spider = psMetadataLookupF32(&status, config->args, "-teltemp_spider");
    1472     if (!status) {
    1473         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_spider");
    1474         return false;
    1475     }
    1476     psF32 teltemp_truss = psMetadataLookupF32(&status, config->args, "-teltemp_truss");
    1477     if (!status) {
    1478         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_truss");
    1479         return false;
    1480     }
    1481     psF32 teltemp_extra = psMetadataLookupF32(&status, config->args, "-teltemp_extra");
    1482     if (!status) {
    1483         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -teltemp_extra");
    1484         return false;
    1485     }
    1486 
    1487     psF32 pon_time = psMetadataLookupF32(&status, config->args, "-pon_time");
    1488     if (!status) {
    1489         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -pon_time");
    1490         return false;
    1491     }
    1492 
    1493     psF64 user_1 = psMetadataLookupF64(&status, config->args, "-user_1");
    1494     if (!status) {
    1495         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_1");
    1496         return false;
    1497     }
    1498     psF64 user_2 = psMetadataLookupF64(&status, config->args, "-user_2");
    1499     if (!status) {
    1500         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_2");
    1501         return false;
    1502     }
    1503     psF64 user_3 = psMetadataLookupF64(&status, config->args, "-user_3");
    1504     if (!status) {
    1505         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_3");
    1506         return false;
    1507     }
    1508     psF64 user_4 = psMetadataLookupF64(&status, config->args, "-user_4");
    1509     if (!status) {
    1510         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_4");
    1511         return false;
    1512     }
    1513     psF64 user_5 = psMetadataLookupF64(&status, config->args, "-user_5");
    1514     if (!status) {
    1515         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -user_5");
    1516         return false;
    1517     }
    1518 
    1519     psString object = psMetadataLookupStr(&status, config->args, "-object");
    1520     if (!status) {
    1521         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -object");
    1522         return false;
    1523     }
    1524 
    1525     psTime *dateobs = NULL;
    1526     {
    1527         psString dateobsStr = psMetadataLookupStr(&status, config->args, "-dateobs");
    1528         if (!status) {
    1529             psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -dateobs");
    1530             return false;
    1531         }
    1532         // pass through NULL as this is an optional field
    1533         if (dateobsStr) {
    1534             dateobs = psTimeFromISO(dateobsStr, PS_TIME_UTC);
    1535         } else {
    1536             dateobs = NULL;
    1537         }
    1538     }
    1539 
    1540     // default
    1541     psS16 code = psMetadataLookupS16(&status, config->args, "-code");
    1542     if (!status) {
    1543         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
    1544         return false;
    1545     }
    1546 
    1547     rawExpRow *raw = rawExpRowAlloc(
    1548         exp->exp_id,
     1239    if (!rawExpInsert(
     1240        config->dbh,
     1241        (psS64)atoll(exp_id),
    15491242        exp_name,
    15501243        camera,
    … …  
    15541247        exp_type,
    15551248        filelevel,
    1556         workdir ? workdir : exp->workdir,
    1557         reduction ? reduction : exp->reduction,
     1249        workdir ? workdir : newExp->workdir,
     1250        reduction ? reduction : newExp->reduction,
    15581251        filter,
    1559         comment,
     1252        comment,
    15601253        airmass,
    15611254        ra,
    … …  
    15701263        ccd_temp,
    15711264        posang,
    1572         m1_x,
    1573         m1_y,
    1574         m1_z,
    1575         m1_tip,
    1576         m1_tilt,
    1577         m2_x,
    1578         m2_y,
    1579         m2_z,
    1580         m2_tip,
    1581         m2_tilt,
    1582         env_temp,
    1583         env_humid,
    1584         env_wind,
    1585         env_dir,
    1586         teltemp_m1,
    1587         teltemp_m1cell,
    1588         teltemp_m2,
    1589         teltemp_spider,
    1590         teltemp_truss,
    1591         teltemp_extra,
    1592         pon_time,
     1265        m1_x,
     1266        m1_y,
     1267        m1_z,
     1268        m1_tip,
     1269        m1_tilt,
     1270        m2_x,
     1271        m2_y,
     1272        m2_z,
     1273        m2_tip,
     1274        m2_tilt,
     1275        env_temp,
     1276        env_humid,
     1277        env_wind,
     1278        env_dir,
     1279        teltemp_m1,
     1280        teltemp_m1cell,
     1281        teltemp_m2,
     1282        teltemp_spider,
     1283        teltemp_truss,
     1284        teltemp_extra,
     1285        pon_time,
    15931286        user_1,
    15941287        user_2,
    … …  
    15991292        0.0,
    16001293        code
    1601     );
    1602 
    1603     if (dateobs) {
    1604         psFree(dateobs);
    1605     }
    1606 
    1607     return raw;
     1294    )) {
     1295        // rollback
     1296        if (!psDBRollback(config->dbh)) {
     1297            psError(PS_ERR_UNKNOWN, false, "database error");
     1298        }
     1299        psError(PS_ERR_UNKNOWN, false, "database error");
     1300        psFree(newExp);
     1301        return false;
     1302    }
     1303
     1304    // if this is a detrend image don't put it in the chip queue (and we're
     1305    // done)
     1306    if (detrend) {
     1307        psFree(newExp);
     1308
     1309        // set the state for the newExp to stop
     1310        if (!pxnewExpSetState(config, exp_id, "stop")) {
     1311            // rollback
     1312            if (!psDBRollback(config->dbh)) {
     1313                psError(PS_ERR_UNKNOWN, false, "database error");
     1314            }
     1315            psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
     1316            return false;
     1317        }
     1318
     1319        return true;
     1320    }
     1321
     1322
     1323    // set the state for the newExp to stop
     1324    if (!pxnewExpSetState(config, exp_id, "stop")) {
     1325        // rollback
     1326        if (!psDBRollback(config->dbh)) {
     1327            psError(PS_ERR_UNKNOWN, false, "database error");
     1328        }
     1329        psError(PS_ERR_UNKNOWN, false, "failed to change newExp.state for exp_id: %s", exp_id);
     1330        psFree(newExp);
     1331        return false;
     1332    }
     1333
     1334    // insert an entry into the chipPendingExp table
     1335    // this can only be run as the newExp's state has been set to stop
     1336    if (!pxchipQueueByExpTag(config,
     1337                newExp->exp_id,
     1338                newExp->workdir,
     1339                NULL, // label
     1340                newExp->reduction,
     1341                NULL, // expgroup
     1342                dvodb,
     1343                tess_id,
     1344                end_stage
     1345    )) {
     1346        // rollback
     1347        if (!psDBRollback(config->dbh)) {
     1348            psError(PS_ERR_UNKNOWN, false, "database error");
     1349        }
     1350        psError(PS_ERR_UNKNOWN, false, "failed to queue chipPendingExp");
     1351        psFree(newExp);
     1352        return false;
     1353    }
     1354    psFree(newExp);
     1355
     1356    if (!psDBCommit(config->dbh)) {
     1357        psError(PS_ERR_UNKNOWN, false, "database error");
     1358        return false;
     1359    }
     1360
     1361    return true;
    16081362}
     1363
     1364
     1365static bool processedexpMode(pxConfig *config)
     1366{
     1367    PS_ASSERT_PTR_NON_NULL(config, false);
     1368
     1369    bool status = false;
     1370    psU64 limit = psMetadataLookupU64(&status, config->args, "-limit");
     1371    if (!status) {
     1372        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -limit");
     1373        return false;
     1374    }
     1375
     1376    bool faulted = psMetadataLookupU64(&status, config->args, "-faulted");
     1377    if (!status) {
     1378        psError(PXTOOLS_ERR_PROG, false, "failed to lookup value for -faulted");
     1379        return false;
     1380    }
     1381
     1382    psString query = pxDataGet("regtool_processedexp.sql");
     1383    if (!query) {
     1384        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1385        return false;
     1386    }
     1387
     1388    if (config->where) {
     1389        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     1390        psStringAppend(&query, " AND %s", whereClause);
     1391        psFree(whereClause);
     1392    }
     1393
     1394    if (faulted) {
     1395        // list only faulted rows
     1396        psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     1397    } else {
     1398        // don't list faulted rows
     1399        psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     1400    }
     1401
     1402    // treat limit == 0 as "no limit"
     1403    if (limit) {
     1404        psString limitString = psDBGenerateLimitSQL(limit);
     1405        psStringAppend(&query, " %s", limitString);
     1406        psFree(limitString);
     1407    }
     1408
     1409    if (!p_psDBRunQuery(config->dbh, query)) {
     1410        psError(PS_ERR_UNKNOWN, false, "database error");
     1411        return false;
     1412    }
     1413    psFree(query);
     1414
     1415    psArray *output = p_psDBFetchResult(config->dbh);
     1416    if (!output) {
     1417        psErrorCode err = psErrorCodeLast();
     1418        switch (err) {
     1419            case PS_ERR_DB_CLIENT:
     1420                psError(PXTOOLS_ERR_SYS, false, "database error");
     1421            case PS_ERR_DB_SERVER:
     1422                psError(PXTOOLS_ERR_PROG, false, "database error");
     1423            default:
     1424                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1425        }
     1426
     1427        return false;
     1428    }
     1429    if (!psArrayLength(output)) {
     1430        psTrace("regtool", PS_LOG_INFO, "no rows found");
     1431        psFree(output);
     1432        return true;
     1433    }
     1434
     1435    bool simple = false;
     1436    {
     1437        bool status = false;
     1438        simple = psMetadataLookupBool(&status, config->args, "-simple");
     1439        if (!status) {
     1440            psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -simple");
     1441            return false;
     1442        }
     1443    }
     1444
     1445    if (psArrayLength(output)) {
     1446        // negative simple so the default is true
     1447        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     1448            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1449            psFree(output);
     1450            return false;
     1451        }
     1452    }
     1453
     1454    psFree(output);
     1455
     1456    return true;
     1457}
     1458
     1459static bool revertprocessedexpMode(pxConfig *config)
     1460{
     1461    PS_ASSERT_PTR_NON_NULL(config, false);
     1462
     1463    psString query = pxDataGet("regtool_revertprocessedexp.sql");
     1464    if (!query) {
     1465        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1466        return false;
     1467    }
     1468
     1469    if (config->where) {
     1470        psString whereClause = psDBGenerateWhereConditionSQL(config->where, "rawExp");
     1471        psStringAppend(&query, " AND %s", whereClause);
     1472        psFree(whereClause);
     1473    }
     1474
     1475    if (!p_psDBRunQuery(config->dbh, query)) {
     1476        psError(PS_ERR_UNKNOWN, false, "database error");
     1477        psFree(query);
     1478        return false;
     1479    }
     1480    psFree(query);
     1481
     1482    if (psDBAffectedRows(config->dbh) < 1) {
     1483        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
     1484        return false;
     1485    }
     1486
     1487    return true;
     1488}
     1489
     1490
     1491static bool updateprocessedexpMode(pxConfig *config)
     1492{
     1493    bool status = false;
     1494    psS16 code = psMetadataLookupS16(&status, config->args, "-code");
     1495    if (!status) {
     1496        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for -code");
     1497        return false;
     1498    }
     1499    if (code == INT16_MAX) {
     1500        psError(PS_ERR_UNKNOWN, true, "-code is required");
     1501        return false;
     1502    }
     1503
     1504    if (!pxSetFaultCode(config->dbh, "rawExp", config->where, code)) {
     1505        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
     1506        return false;
     1507    }
     1508
     1509    return true;
     1510}
Note: See TracChangeset for help on using the changeset viewer.