IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 10, 2010, 6:28:51 PM (16 years ago)
Author:
watersc1
Message:

Skycell Summary and stack Association stuff should be finished. I'll merge and do final tests on monday.

Location:
branches/czw_branch/20100519
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/20100519

  • branches/czw_branch/20100519/ippTools/src

    • Property svn:ignore

      •  

        old new  
        3838stamp-h1
        3939warptool
        40 
         40staticskytool

  • branches/czw_branch/20100519/ippTools/src/addtool.c

    r27773 r28304  
    4040static bool maskedMode(pxConfig *config);
    4141static bool unblockMode(pxConfig *config);
     42static bool addminidvodbrunMode(pxConfig *config);
     43static bool updateminidvodbrunMode(pxConfig *config);
     44static bool listminidvodbrunMode(pxConfig *config);
     45static bool flipminidvodbrunMode(pxConfig *config);
     46static bool checkminidvodbrunaddrunMode(pxConfig *config);
     47static bool addminidvodbprocessedMode(pxConfig *config);
     48static bool listminidvodbprocessedMode(pxConfig *config);
     49static bool revertminidvodbprocessedMode(pxConfig *config);
     50static bool updateminidvodbprocessedMode(pxConfig *config);
     51
     52
    4253
    4354# define MODECASE(caseName, func) \
    … …  
    6980        MODECASE(ADDTOOL_MODE_MASKED,               maskedMode);
    7081        MODECASE(ADDTOOL_MODE_UNBLOCK,              unblockMode);
     82        MODECASE(ADDTOOL_MODE_ADDMINIDVODBRUN,      addminidvodbrunMode);
     83        MODECASE(ADDTOOL_MODE_UPDATEMINIDVODBRUN,   updateminidvodbrunMode);
     84        MODECASE(ADDTOOL_MODE_LISTMINIDVODBRUN,     listminidvodbrunMode);
     85        MODECASE(ADDTOOL_MODE_FLIPMINIDVODBRUN,     flipminidvodbrunMode);
     86        MODECASE(ADDTOOL_MODE_CHECKMINIDVODBRUNADDRUN, checkminidvodbrunaddrunMode);
     87        MODECASE(ADDTOOL_MODE_ADDMINIDVODBPROCESSED,addminidvodbprocessedMode);
     88        MODECASE(ADDTOOL_MODE_LISTMINIDVODBPROCESSED,listminidvodbprocessedMode);
     89        MODECASE(ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,revertminidvodbprocessedMode);
     90        MODECASE(ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED,updateminidvodbprocessedMode);
     91
    7192        default:
    7293            psAbort("invalid option (this should not happen)");
    … …  
    102123    PXOPT_COPY_STR(config->args, where,  "-reduction", "camRun.reduction", "==");
    103124
     125
    104126    if (!psListLength(where->list)) {
    105127        psFree(where);
    … …  
    114136    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
    115137    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
     138    PXOPT_LOOKUP_STR(minidvodb_name,  config->args, "-set_minidvodb_name", false, false);
     139    PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-set_minidvodb_group", false, false);
    116140    PXOPT_LOOKUP_BOOL(image_only, config->args, "-image_only", false);
     141    PXOPT_LOOKUP_BOOL(minidvodb,  config->args, "-set_minidvodb", false);
    117142    PXOPT_LOOKUP_BOOL(destreaked, config->args, "-destreaked", false);
    118143    PXOPT_LOOKUP_BOOL(pretend,    config->args, "-pretend", false);
    119144    PXOPT_LOOKUP_BOOL(simple,     config->args, "-simple", false);
     145
     146
    120147
    121148    // find the cam_id of all the exposures that we want to queue up.
    … …  
    245272                               dvodb       ? dvodb     : row->dvodb,
    246273                               note        ? note      : NULL,
    247                                image_only
     274                               image_only,
     275                               minidvodb,
     276                               minidvodb_group,
     277                               minidvodb_name
    248278        )) {
    249279            if (!psDBRollback(config->dbh)) {
    250                 psError(PS_ERR_UNKNOWN, false, "database error");
     280                psError(PS_ERR_UNKNOWN, false, "database error sfg");
    251281            }
    252282            psError(PS_ERR_UNKNOWN, false,
    … …  
    291321
    292322    // pxUpdateRun gets parameters from config->args and runs the update query
    293     bool result = pxUpdateRun(config, where, &query, "addRun", "add_id", 
     323    bool result = pxUpdateRun(config, where, &query, "addRun", "add_id",
    294324        "addProcessedExp", false);
    295325
    … …  
    374404    PXOPT_LOOKUP_STR(path_base,     config->args, "-path_base", false, false);
    375405    PXOPT_LOOKUP_F32(dtime_addstar, config->args, "-dtime_addstar", false, false);
     406    PXOPT_LOOKUP_STR(dvodb_path, config->args, "-dvodb_path", false, false);
     407    PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-minidvodb_name", false, false);
    376408    PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
    377409
    … …  
    399431        return false;
    400432    }
     433
    401434    psFree(query);
    402435
    … …  
    424457        dtime_addstar,
    425458        path_base,
     459        dvodb_path,
    426460        fault
    427461        );
    … …  
    437471        return false;
    438472    }
     473
     474    //if there is a minidvodb_name, set it in addRun (it's not known until it is processed)
     475    if (minidvodb_name) {
     476      psString setName = NULL;
     477      psStringAppend (&setName, "UPDATE addRun set minidvodb_name = '%s' where add_id = %" PRId64, minidvodb_name, row->add_id);
     478      if (!p_psDBRunQuery(config->dbh, setName)) {
     479        if (!psDBRollback(config->dbh)) {
     480          psError(PS_ERR_UNKNOWN, false, "database error");
     481        }
     482        psError(PS_ERR_UNKNOWN, false, "database error");
     483
     484        return false;
     485      }
     486    }
     487
     488
     489
     490
    439491
    440492    // since there is only one exp per 'new' set addRun.state = 'full'
    … …  
    522574
    523575    if (!p_psDBRunQuery(config->dbh, query)) {
    524         psError(PS_ERR_UNKNOWN, false, "database error");
     576      psError(PS_ERR_UNKNOWN, false, "database error");
    525577        psFree(query);
    526578        return false;
    … …  
    576628
    577629    {
    578         psString query = pxDataGet("addtool_reset_faulted_runs.sql");
     630        psString query = pxDataGet("addtool_revertprocessedexp.sql");
    579631        if (!query) {
     632            // rollback
     633            if (!psDBRollback(config->dbh)) {
     634                psError(PS_ERR_UNKNOWN, false, "database error");
     635            }
    580636            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    581637            psFree(where);
    … …  
    602658        psFree(query);
    603659    }
    604 
    605     {
    606         psString query = pxDataGet("addtool_revertprocessedexp.sql");
    607         if (!query) {
    608             // rollback
    609             if (!psDBRollback(config->dbh)) {
    610                 psError(PS_ERR_UNKNOWN, false, "database error");
    611             }
    612             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    613             psFree(where);
    614             return false;
    615         }
    616 
    617         // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
    618         if (where && psListLength(where->list)) {
    619             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    620             psStringAppend(&query, " AND %s", whereClause);
    621             psFree(whereClause);
    622         }
    623 
    624         if (!p_psDBRunQuery(config->dbh, query)) {
    625             // rollback
    626             if (!psDBRollback(config->dbh)) {
    627                 psError(PS_ERR_UNKNOWN, false, "database error");
    628             }
    629             psError(PS_ERR_UNKNOWN, false, "database error");
    630             psFree(query);
    631             psFree(where);
    632             return false;
    633         }
    634         psFree(query);
    635     }
    636660    psFree(where);
    637661
    … …  
    733757    return true;
    734758}
     759
     760static bool addminidvodbrunMode(pxConfig *config)
     761{
     762  PS_ASSERT_PTR_NON_NULL(config, NULL);
     763
     764  // required
     765
     766  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-set_minidvodb_group", true, false);
     767  PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-set_mergedvodb_path", true, false);
     768
     769  //optional
     770  PXOPT_LOOKUP_STR(minidvodb_name, config->args, "-set_minidvodb_name", false, false);
     771  PXOPT_LOOKUP_STR(minidvodb_path, config->args, "-set_minidvodb_path", false, false);
     772  PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     773
     774  if (!psDBTransaction(config->dbh)) {
     775    psError(PS_ERR_UNKNOWN, false, "database error");
     776    return false;
     777  }
     778
     779  psString minidvodbpath = "NULL";
     780
     781  // I don't know how to get around the complaints of minidvodb_path can't be null. this 'fixes' it, but someone smarter can fix it properly.
     782  if (minidvodb_path) {
     783    minidvodbpath = minidvodb_path;
     784  }
     785
     786  if (!minidvodbRunInsert(config->dbh,
     787            0, // job_id
     788            minidvodb_name,
     789            minidvodb_group,
     790            minidvodbpath,
     791            mergedvodb_path,
     792            "new",
     793            0
     794            )) {
     795    psError(PS_ERR_UNKNOWN, false, "database error");
     796    return false;
     797  }
     798
     799  psU64 affected = psDBAffectedRows(config->dbh);
     800  if (affected != 1) {
     801    psError(PS_ERR_UNKNOWN, false,
     802            "should have affected one row but %" PRIu64 " rows were modified",
     803            affected);
     804    return false;
     805  }
     806
     807  psS64 minidvodb_id = psDBLastInsertID(config->dbh);
     808  printf("%" PRId64 "\n", minidvodb_id);
     809
     810
     811  if (!minidvodb_name) {
     812    psStringAppend(&minidvodb_name, "%s.%" PRIu64,minidvodb_group,minidvodb_id);
     813  }
     814
     815  if (!minidvodb_path) {
     816    psStringAppend(&minidvodb_path,"%s/%s",mergedvodb_path,minidvodb_name);
     817  }
     818
     819  psString query = NULL;
     820
     821  psStringAppend(&query, "UPDATE minidvodbRun SET minidvodb_path = '%s', minidvodb_name = '%s' where minidvodb_id = %" PRIu64";", minidvodb_path, minidvodb_name, minidvodb_id);
     822
     823  if (!p_psDBRunQuery(config->dbh, query)) {
     824    psError(PS_ERR_UNKNOWN, false, "database error");
     825    psFree(query);
     826    return false;
     827  }
     828
     829  if (!psDBCommit(config->dbh)) {
     830    psError(PS_ERR_UNKNOWN, false, "database error");
     831    return false;
     832  }
     833
     834  return true;
     835}
     836
     837static bool updateminidvodbrunMode(pxConfig *config) {
     838  PS_ASSERT_PTR_NON_NULL(config, false);
     839
     840    psMetadata *where = psMetadataAlloc();
     841    PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodb_id", "==");
     842    PXOPT_COPY_STR(config->args, where, "-minidvodb_name",     "minidvodb_name", "==");
     843    PXOPT_COPY_STR(config->args, where, "-state",     "state", "==");
     844    PXOPT_COPY_STR(config->args, where, "-minidvodb_path", "minidvodb_path", "==");
     845    PXOPT_COPY_STR(config->args, where, "-mergedvodb_path", "mergedvodb_path", "==");
     846    PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
     847
     848    PXOPT_LOOKUP_STR(minidvodb_name,  config->args, "-set_minidvodb_name", false, false);
     849    PXOPT_LOOKUP_STR(minidvodb_path,  config->args, "-set_minidvodb_path", false, false);
     850    PXOPT_LOOKUP_STR(state,  config->args, "-set_state", false, false);
     851    PXOPT_LOOKUP_STR(mergedvodb_path,  config->args, "-set_mergedvodb_path", false, false);
     852    PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-set_minidvodb_group", false, false);
     853
     854
     855    if (!psListLength(where->list)) {
     856      psFree(where);
     857      psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     858      return false;
     859    }
     860
     861    psString query = psStringCopy("UPDATE minidvodbRun SET ");
     862    int cnt = 0;
     863    psString comma = ",";
     864    if (minidvodb_name) {
     865      psStringAppend(&query, " minidvodb_name = '%s'", minidvodb_name);
     866      cnt++;
     867    }
     868
     869    if (minidvodb_path) {
     870      if (cnt) {
     871          psStringAppend(&query, "%s", comma);
     872      }
     873
     874      psStringAppend(&query, " minidvodb_path = '%s'", minidvodb_path);
     875      cnt++;
     876    }
     877
     878    if (state) {
     879      if (cnt) {
     880        psStringAppend(&query, "%s", comma);
     881      }
     882      psStringAppend(&query, " state = '%s'", state);
     883      cnt++;
     884    }
     885
     886    if (mergedvodb_path) {
     887      if (cnt) {
     888        psStringAppend(&query, "%s", comma);
     889      }
     890      psStringAppend(&query, " mergedvodb_path = '%s'", mergedvodb_path);
     891      cnt++;
     892    }
     893
     894    if (minidvodb_group) {
     895      if (cnt) {
     896        psStringAppend(&query, "%s", comma);
     897      }
     898      psStringAppend(&query, " minidvodb_group = '%s'", minidvodb_group);
     899      cnt++;
     900    }
     901
     902    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     903    psStringAppend(&query, " WHERE %s", whereClause);
     904
     905    if (!p_psDBRunQuery(config->dbh, query)) {
     906      psError(PS_ERR_UNKNOWN, false, "database error");
     907      psFree(query);
     908      return false;
     909    }
     910
     911    psFree(query);
     912    psFree(where);
     913
     914    return true;
     915
     916}
     917
     918static bool flipminidvodbrunMode(pxConfig *config) {
     919  PS_ASSERT_PTR_NON_NULL(config, false);
     920
     921  psMetadata *where = psMetadataAlloc();
     922  PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-minidvodb_group",true, false);
     923  PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
     924
     925//this flips the new - > active
     926// and the active - > waiting in one action
     927
     928
     929// the first query looks to find things that are new and where all the fields are filled (ie, ready to be flipped to active)
     930
     931// start a transaction eraly so it will contain any row level locks
     932  if (!psDBTransaction(config->dbh)) {
     933    psError(PS_ERR_UNKNOWN, false, "database error");
     934    return false;
     935  }
     936
     937  psString firstquery = psStringCopy("SELECT * from  minidvodbRun where state = 'new' and minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL");
     938
     939  psString firstwhereClause = psDBGenerateWhereConditionSQL(where, NULL);
     940  psStringAppend(&firstquery, " AND %s", firstwhereClause);
     941
     942
     943
     944  if (!p_psDBRunQuery(config->dbh, firstquery)) {
     945    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     946    if (!psDBRollback(config->dbh)) {
     947      psError(PS_ERR_UNKNOWN, false, "database error");
     948    }
     949    return false;
     950  }
     951  psFree(firstquery);
     952
     953 //we don't care what the stuff is that is found, just that there is stuff. This is a check to see that there is something in the 'new' state, before flipping (so that if there is nothing in new, it won't flip the active to waiting.  the flipminidvo is just to make it easy to flip from new -> active.
     954
     955  psArray *output = p_psDBFetchResult(config->dbh);
     956  if (!output) {
     957    psError(PS_ERR_UNKNOWN, false, "database error");
     958    return false;
     959  }
     960  if (!psArrayLength(output)) {
     961    psTrace("addtool", PS_LOG_INFO, "no rows found");
     962    psFree(output);
     963    return true;
     964  }
     965
     966
     967  //ok, there's something, so flip active -> waiting
     968
     969  psString query = psStringCopy("UPDATE minidvodbRun SET state = 'waiting' WHERE state = 'active' ");
     970
     971  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     972  psStringAppend(&query, " AND %s", whereClause);
     973
     974
     975  if (!p_psDBRunQuery(config->dbh, query)) {
     976    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     977    if (!psDBRollback(config->dbh)) {
     978      psError(PS_ERR_UNKNOWN, false, "database error");
     979    }
     980    return false;
     981  }
     982
     983
     984  //now flip new -> active
     985  psString query2 = psStringCopy("UPDATE minidvodbRun SET state = 'active' WHERE state = 'new' AND minidvodb_name is NOT NULL and minidvodb_group IS NOT NULL and minidvodb_path IS NOT NULL and mergedvodb_path IS NOT NULL ");
     986  psStringAppend(&query2, " AND minidvodb_group = '%s' limit 1;", minidvodb_group);
     987  if (!p_psDBRunQuery(config->dbh, query2)) {
     988    psError(PS_ERR_UNKNOWN, false, "database error");
     989    if (!psDBRollback(config->dbh)) {
     990      psError(PS_ERR_UNKNOWN, false, "database error");
     991    }
     992    psFree(query);
     993    return false;
     994  }
     995
     996
     997  if (!psDBCommit(config->dbh)) {
     998    psError(PS_ERR_UNKNOWN, false, "database error");
     999    if (!psDBRollback(config->dbh)) {
     1000      psError(PS_ERR_UNKNOWN, false, "database error");
     1001    }
     1002    psFree(query);
     1003  return false;
     1004  }
     1005 psFree(query2);
     1006 psFree(where);
     1007
     1008 return true;
     1009
     1010}
     1011
     1012
     1013static bool checkminidvodbrunaddrunMode(pxConfig *config) {
     1014  PS_ASSERT_PTR_NON_NULL(config, false);
     1015  psMetadata *where = psMetadataAlloc();
     1016
     1017  //this checks to see if a minidvod_group/name is has completed addRun processing
     1018  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbRun.minidvodb_group", "==");
     1019  PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "==");
     1020  PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
     1021
     1022
     1023  PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
     1024  PXOPT_LOOKUP_BOOL(all_addrun_states, config->args, "-all_addrun_states", false);
     1025  //this doesn't care what state the addRun is in (useful for counting addRuns)
     1026  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1027
     1028  if (!psListLength(where->list)) {
     1029        psFree(where);
     1030        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1031        return false;
     1032  }
     1033
     1034  psString query = pxDataGet("addtool_checkminidvodbaddrun.sql");
     1035
     1036  if (!query) {
     1037        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1038        return false;
     1039  }
     1040
     1041
     1042  if (psListLength(where->list)) {
     1043    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1044        psStringAppend(&query, " WHERE %s", whereClause);
     1045        psFree(whereClause);
     1046  }
     1047
     1048  if (!all_addrun_states) {
     1049    psStringAppend(&query, " AND (cnt2 = cnt) ");
     1050  }
     1051
     1052  if (limit) {
     1053    psString limitString = psDBGenerateLimitSQL(limit);
     1054    psStringAppend(&query, " %s", limitString);
     1055    psFree(limitString);
     1056  }
     1057
     1058
     1059  if (!p_psDBRunQuery(config->dbh, query)) {
     1060    psError(PS_ERR_UNKNOWN, false, "database error");
     1061    psFree(query);
     1062    return false;
     1063  }
     1064  psFree(query);
     1065  psArray *output = p_psDBFetchResult(config->dbh);
     1066  if (!output) {
     1067    psError(PS_ERR_UNKNOWN, false, "database error");
     1068    return false;
     1069  }
     1070  if (!psArrayLength(output)) {
     1071    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1072    psFree(output);
     1073    return true;
     1074  }
     1075
     1076  if (!ippdbPrintMetadatas(stdout, output, "minidvodbRun", !simple)) {
     1077    psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1078    psFree(output);
     1079    return false;
     1080  }
     1081
     1082  psFree(output);
     1083
     1084  return true;
     1085}
     1086
     1087
     1088
     1089static bool listminidvodbrunMode(pxConfig *config) {
     1090    PS_ASSERT_PTR_NON_NULL(config, false);
     1091    psMetadata *where = psMetadataAlloc();
     1092
     1093    PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "LIKE");
     1094    PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbRun.minidvodb_group", "==");
     1095    PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbRun.minidvodb_id", "==");
     1096
     1097    PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
     1098    PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
     1099    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1100
     1101
     1102    if (!psListLength(where->list)) {
     1103      psFree(where);
     1104      psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1105      return false;
     1106    }
     1107
     1108    psString query = pxDataGet("addtool_find_minidvodbrun.sql");
     1109
     1110    if (!query) {
     1111      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1112      return false;
     1113    }
     1114
     1115    if (psListLength(where->list)) {
     1116      psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1117      psStringAppend(&query, " WHERE %s", whereClause);
     1118      psFree(whereClause);
     1119    }
     1120
     1121    if (limit) {
     1122      psString limitString = psDBGenerateLimitSQL(limit);
     1123      psStringAppend(&query, " %s", limitString);
     1124      psFree(limitString);
     1125    }
     1126
     1127    if (!p_psDBRunQuery(config->dbh, query)) {
     1128      psError(PS_ERR_UNKNOWN, false, "database error");
     1129      psFree(query);
     1130      return false;
     1131    }
     1132
     1133    psFree(query);
     1134    psArray *output = p_psDBFetchResult(config->dbh);
     1135    if (!output) {
     1136      psError(PS_ERR_UNKNOWN, false, "database error");
     1137      return false;
     1138    }
     1139    if (!psArrayLength(output)) {
     1140      psTrace("addtool", PS_LOG_INFO, "no rows found");
     1141      psFree(output);
     1142      return true;
     1143    }
     1144
     1145    if (!ippdbPrintMetadatas(stdout, output, "minidvodbRun",  !simple)) {
     1146      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1147      psFree(output);
     1148      return false;
     1149    }
     1150
     1151    psFree(output);
     1152
     1153return true;
     1154}
     1155
     1156static bool addminidvodbprocessedMode(pxConfig *config) {
     1157
     1158  PS_ASSERT_PTR_NON_NULL(config, false);
     1159
     1160    // required
     1161  PXOPT_LOOKUP_U64(minidvodb_id, config->args, "-minidvodb_id", true, false);
     1162  PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", true, false);
     1163  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-minidvodb_group", true, false);
     1164
     1165    // optional
     1166  PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
     1167  PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
     1168  PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
     1169  PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
     1170  PXOPT_LOOKUP_TIME(epoch, config->args, "-epoch", false, false);
     1171  PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
     1172    //generate restrictions
     1173  psMetadata *where = psMetadataAlloc();
     1174  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",   "minidvodbRun.minidvodb_id",   "==");
     1175
     1176
     1177  if (!psDBTransaction(config->dbh)) {
     1178    psError(PS_ERR_UNKNOWN, false, "database error");
     1179    return false;
     1180  }
     1181
     1182
     1183  psString query = pxDataGet("addtool_find_pendingmergeprocess.sql");
     1184  if (!query) {
     1185    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1186    return false;
     1187  }
     1188  // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     1189  if (psListLength(where->list)) {
     1190    psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
     1191    psStringAppend(&query, " AND %s", whereClaus);
     1192    psFree(whereClaus);
     1193  }
     1194  psFree(where);
     1195
     1196  if (!p_psDBRunQuery(config->dbh, query)) {
     1197    psError(PS_ERR_UNKNOWN, false, "database error");
     1198    psFree(query);
     1199    return false;
     1200  }
     1201  psFree(query);
     1202
     1203  psArray *output = p_psDBFetchResult(config->dbh);
     1204  if (!output) {
     1205    psError(PS_ERR_UNKNOWN, false, "database error");
     1206    return false;
     1207  }
     1208  if (!psArrayLength(output)) {
     1209    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1210    psFree(output);
     1211    return true;
     1212  }
     1213
     1214  minidvodbRunRow *pendingRow = minidvodbRunObjectFromMetadata(output->data[0]);
     1215  psFree(output);
     1216  minidvodbProcessedRow *row = minidvodbProcessedRowAlloc(
     1217               pendingRow->minidvodb_id,
     1218               merge_order,
     1219               dtime_resort,
     1220               dtime_relphot,
     1221               dtime_merge,
     1222               epoch,
     1223               mergedvodb_path,
     1224               fault
     1225               );
     1226
     1227  if (!minidvodbProcessedInsertObject(config->dbh, row)) {
     1228    // rollback
     1229    if (!psDBRollback(config->dbh)) {
     1230      psError(PS_ERR_UNKNOWN, false, "database error");
     1231    }
     1232    psError(PS_ERR_UNKNOWN, false, "database error");
     1233    psFree(row);
     1234    psFree(pendingRow);
     1235    return false;
     1236  }
     1237
     1238
     1239
     1240
     1241  //this finds the # of merged things (for the merge order)
     1242  psString query3 = NULL;
     1243  psStringAppend(&query3, "select count(*) from minidvodbRun join minidvodbProcessed using (minidvodb_id) where state = 'merged' and minidvodb_group = '%s';", minidvodb_group);
     1244
     1245  if (!p_psDBRunQuery(config->dbh, query3)) {
     1246    // rollback
     1247    if (!psDBRollback(config->dbh)) {
     1248      psError(PS_ERR_UNKNOWN, false, "database error");
     1249    }
     1250    psError(PS_ERR_UNKNOWN, false, "database error");
     1251    psFree(query3);
     1252    return false;
     1253  }
     1254  psArray *output2 = p_psDBFetchResult(config->dbh);
     1255  if (!output2) {
     1256    psError(PS_ERR_UNKNOWN, false, "database error");
     1257    return false;
     1258  }
     1259  if (!psArrayLength(output2)) {
     1260    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1261    psFree(output);
     1262    return true;
     1263  }
     1264  bool status;
     1265  psS64 m_order = psMetadataLookupS64(&status, output2->data[0], "count(*)");
     1266  if (!status) {
     1267
     1268    psAbort("failed to lookup value for count column");
     1269    return false;
     1270  }
     1271  psString final = NULL;
     1272  psStringAppend(&final, "%" PRIu64, m_order);
     1273    //return false;
     1274  psFree(query3);
     1275  psFree(output2);
     1276
     1277
     1278
     1279  //update the merge_order
     1280
     1281  psString query4 = NULL;
     1282  psStringAppend(&query4, "update minidvodbProcessed set merge_order = %"PRIu64,m_order);
     1283  psStringAppend(&query4," where minidvodb_id = %" PRIu64,  minidvodb_id);
     1284  printf("%s", query4);
     1285  if (!p_psDBRunQuery(config->dbh, query4)) {
     1286    // rollback
     1287    if (!psDBRollback(config->dbh)) {
     1288      psError(PS_ERR_UNKNOWN, false, "database error");
     1289    }
     1290    psError(PS_ERR_UNKNOWN, false, "database error");
     1291    psFree(query4);
     1292    return false;
     1293  }
     1294  //
     1295psFree(query4);
     1296
     1297
     1298
     1299// since there is only one exp per 'new' set mindvodbRun.state = 'merged'
     1300
     1301  psString query2 = NULL ;
     1302  psStringAppend(&query2, "UPDATE minidvodbRun SET state = 'merged' WHERE minidvodb_id = %'" PRIu64, row->minidvodb_id);
     1303
     1304  if (!p_psDBRunQuery(config->dbh, query2)) {
     1305    // rollback
     1306    if (!psDBRollback(config->dbh)) {
     1307      psError(PS_ERR_UNKNOWN, false, "database error");
     1308    }
     1309    psError(PS_ERR_UNKNOWN, false, "database error");
     1310    psFree(query2);
     1311    return false;
     1312  }
     1313
     1314
     1315
     1316
     1317
     1318
     1319
     1320
     1321  psFree(row);
     1322  psFree(pendingRow);
     1323
     1324
     1325
     1326
     1327
     1328  //commit the changes
     1329  if (!psDBCommit(config->dbh)) {
     1330    psError(PS_ERR_UNKNOWN, false, "database error");
     1331    return false;
     1332  }
     1333
     1334
     1335  //print the merge_order (why not!)
     1336  printf("%s", final);
     1337  psFree(final);
     1338
     1339  return true;
     1340}
     1341
     1342
     1343
     1344static bool listminidvodbprocessedMode(pxConfig *config) {
     1345  psMetadata *where = psMetadataAlloc();
     1346  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbProcessed.minidvodb_id", "==");
     1347  PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbProcessed.minidvodb_name", "==");
     1348  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbProcessed.minidvodb_group", "==");
     1349  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1350  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1351  PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     1352  if (!psListLength(where->list)) {
     1353        psFree(where);
     1354        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1355        return false;
     1356    }
     1357
     1358  psString query = pxDataGet("addtool_find_minidvodbprocessed.sql");
     1359    if (!query) {
     1360        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1361        return false;
     1362    }
     1363
     1364if (psListLength(where->list)) {
     1365        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1366        psStringAppend(&query, " WHERE %s", whereClause);
     1367        psFree(whereClause);
     1368    }
     1369
     1370// we either add AND (condition) or WHERE (condition):
     1371    if (where->list && faulted) {
     1372        // list only faulted rows
     1373        psStringAppend(&query, " %s", " AND minidvodbProcessed.fault != 0");
     1374    }
     1375    if (where->list && !faulted) {
     1376        // don't list faulted rows
     1377        psStringAppend(&query, " %s", " AND minidvodbProcessed.fault = 0");
     1378    }
     1379    if (!where->list && faulted) {
     1380        // list only faulted rows
     1381        psStringAppend(&query, " %s", " WHERE minidvodbProcessed.fault != 0");
     1382    }
     1383    if (!where->list && !faulted) {
     1384        // don't list faulted rows
     1385        psStringAppend(&query, " %s", " WHERE minidvodbProcessed.fault = 0");
     1386    }
     1387    psFree(where);
     1388
     1389    // order by epoch
     1390    psStringAppend(&query, " ORDER BY minidvodb_id");
     1391
     1392    // treat limit == 0 as "no limit"
     1393    if (limit) {
     1394        psString limitString = psDBGenerateLimitSQL(limit);
     1395        psStringAppend(&query, " %s", limitString);
     1396        psFree(limitString);
     1397    }
     1398
     1399    if (!p_psDBRunQuery(config->dbh, query)) {
     1400      psError(PS_ERR_UNKNOWN, false, "database error ");
     1401        psFree(query);
     1402        return false;
     1403    }
     1404    psFree(query);
     1405
     1406    psArray *output = p_psDBFetchResult(config->dbh);
     1407    if (!output) {
     1408        psError(PS_ERR_UNKNOWN, false, "database error");
     1409        return false;
     1410    }
     1411    if (!psArrayLength(output)) {
     1412        psTrace("addtool", PS_LOG_INFO, "no rows found");
     1413        psFree(output);
     1414        return true;
     1415    }
     1416
     1417    // negate simple so the default is true
     1418    if (!ippdbPrintMetadatas(stdout, output, "minidvodbProcessed", !simple)) {
     1419        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1420        psFree(output);
     1421        return false;
     1422    }
     1423
     1424    psFree(output);
     1425
     1426return true;
     1427}
     1428
     1429
     1430
     1431static bool revertminidvodbprocessedMode(pxConfig *config) {
     1432  psMetadata *where = psMetadataAlloc();
     1433  PS_ASSERT_PTR_NON_NULL(config, false);
     1434  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbProcessed.minidvodb_id", "==");
     1435  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "addRun.minidvodb_group", "==");
     1436
     1437  if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1438    psFree(where);
     1439    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1440    return false;
     1441  }
     1442
     1443  if (!psDBTransaction(config->dbh)) {
     1444      psError(PS_ERR_UNKNOWN, false, "database error");
     1445      psFree(where);
     1446      return false;
     1447  }
     1448
     1449  {
     1450    psString query = pxDataGet("addtool_revertminidvodbprocessed.sql");
     1451    if (!query) {
     1452      // rollback
     1453      if (!psDBRollback(config->dbh)) {
     1454        psError(PS_ERR_UNKNOWN, false, "database error");
     1455      }
     1456      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1457      psFree(where);
     1458      return false;
     1459    }
     1460
     1461    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     1462    if (where && psListLength(where->list)) {
     1463      psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1464      psStringAppend(&query, " AND %s", whereClause);
     1465      psFree(whereClause);
     1466    }
     1467
     1468    if (!p_psDBRunQuery(config->dbh, query)) {
     1469      // rollback
     1470      if (!psDBRollback(config->dbh)) {
     1471        psError(PS_ERR_UNKNOWN, false, "database error");
     1472      }
     1473      psError(PS_ERR_UNKNOWN, false, "database error");
     1474      psFree(query);
     1475      psFree(where);
     1476            return false;
     1477    }
     1478    psFree(query);
     1479  }
     1480  psFree(where);
     1481
     1482  if (!psDBCommit(config->dbh)) {
     1483    psError(PS_ERR_UNKNOWN, false, "database error");
     1484    return false;
     1485  }
     1486
     1487  return true;
     1488}
     1489
     1490
     1491
     1492static bool updateminidvodbprocessedMode(pxConfig *config) {
     1493  PS_ASSERT_PTR_NON_NULL(config, false);
     1494  psMetadata *where = psMetadataAlloc();
     1495
     1496  PXOPT_LOOKUP_U64(minidvodb_id,  config->args, "-minidvodb_id", true, false);
     1497  PXOPT_LOOKUP_U64(merge_order,  config->args, "-set_merge_order", false, false);
     1498  PXOPT_LOOKUP_S16(fault,  config->args, "-set_fault", false, false);
     1499  PXOPT_LOOKUP_F32(dtime_relphot,  config->args, "-set_dtime_relphot", false, false);
     1500  PXOPT_LOOKUP_F32(dtime_resort,  config->args, "-set_dtime_resort", false, false);
     1501  PXOPT_LOOKUP_F32(dtime_merge,  config->args, "-set_dtime_merge", false, false);
     1502
     1503  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodbProcessed.minidvodb_id", "==");
     1504  PXOPT_COPY_STR(config->args, where, "-minidvodb_name",     "minidvodbRun.minidvodb_name", "==");
     1505
     1506
     1507  if (!psListLength(where->list)) {
     1508    psFree(where);
     1509    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1510    return false;
     1511  }
     1512
     1513  psString query = psStringCopy("UPDATE minidvodbProcessed JOIN minidvodbRun USING (minidvodb_id) SET ");
     1514  int cnt = 0;
     1515  psString comma = ",";
     1516  if (fault) {
     1517    psStringAppend(&query, " fault = %d", fault);
     1518  cnt++;
     1519  }
     1520
     1521  if (merge_order) {
     1522    if (cnt) {
     1523      psStringAppend(&query, "%s", comma);
     1524    }
     1525
     1526    psStringAppend(&query, " merge_order = %" PRId64, merge_order);
     1527    cnt++;
     1528  }
     1529
     1530  if (dtime_relphot) {
     1531    if (cnt) {
     1532      psStringAppend(&query, "%s", comma);
     1533    }
     1534    psStringAppend(&query, " dtime_relphot = %f", dtime_relphot);
     1535    cnt++;
     1536  }
     1537
     1538  if (dtime_resort) {
     1539    if (cnt) {
     1540      psStringAppend(&query, "%s", comma);
     1541    }
     1542    psStringAppend(&query, " dtime_resort = %f", dtime_resort);
     1543    cnt++;
     1544  }
     1545
     1546  if (dtime_merge) {
     1547    if (cnt) {
     1548      psStringAppend(&query, "%s", comma);
     1549    }
     1550    psStringAppend(&query, " dtime_merge = %f", dtime_merge);
     1551    cnt++;
     1552 }
     1553
     1554  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1555  psStringAppend(&query, " WHERE %s", whereClause);
     1556
     1557  if (!p_psDBRunQuery(config->dbh, query)) {
     1558   psError(PS_ERR_UNKNOWN, false, "database error");
     1559   psFree(query);
     1560   return false;
     1561  }
     1562
     1563  psFree(query);
     1564  psFree(where);
     1565
     1566  return true;
     1567}
     1568
     1569

  • branches/czw_branch/20100519/ippTools/src/addtool.h

    r25299 r28304  
    3939    ADDTOOL_MODE_DONECLEANUP,
    4040    ADDTOOL_MODE_EXPORTRUN,
    41     ADDTOOL_MODE_IMPORTRUN
     41    ADDTOOL_MODE_IMPORTRUN,
     42    ADDTOOL_MODE_ADDMINIDVODBRUN,
     43    ADDTOOL_MODE_UPDATEMINIDVODBRUN,
     44    ADDTOOL_MODE_LISTMINIDVODBRUN,
     45    ADDTOOL_MODE_FLIPMINIDVODBRUN,
     46    ADDTOOL_MODE_CHECKMINIDVODBRUNADDRUN,
     47    ADDTOOL_MODE_ADDMINIDVODBPROCESSED,
     48    ADDTOOL_MODE_LISTMINIDVODBPROCESSED,
     49    ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,
     50    ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED
    4251} addtoolMode;
    4352

  • branches/czw_branch/20100519/ippTools/src/addtoolConfig.c

    r27773 r28304  
    6363    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",           0, "do not actually modify the database", false);
    6464    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
    65 
     65    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-set_minidvodb",            0, "use minidvodb", false);
     66    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_minidvodb_group", 0,   "define minidvodb_group", NULL);
     67    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_minidvodb_name", 0,   "define minidvodb_bname", NULL);
    6668    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    6769    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    … …  
    8486    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    8587    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
     88
    8689    // -pendingexp
    8790    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    98101    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-add_id", 0,            "define addtool ID (required)", 0);
    99102    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", NULL);
     103     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-dvodb_path", 0,            "define base output location", NULL);
     104      psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-minidvodb_name", 0,            "define minidvodb_name", NULL);
    100105    psMetadataAddF32(addprocessedexpArgs, PS_LIST_TAIL, "-dtime_addstar", 0, "define elapsed time for DVO insertion (seconds)", NAN);
    101106    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    … …  
    142147    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    143148
     149    // -addminidvodbruns
     150    psMetadata *addminidvodbrunArgs = psMetadataAlloc();
     151    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
     152    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define minidvodb_group (required)", NULL);
     153    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
     154    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for the merged dvodb (required)", NULL);
     155    psMetadataAddStr(addminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
     156
     157    // -updateminidvodbruns
     158    psMetadata *updateminidvodbrunArgs = psMetadataAlloc();
     159    psMetadataAddU64(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id ", 0);
     160    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_group",        0, "search by minidvodb_name (LIKE)", NULL);
     161    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name (LIKE)", NULL);
     162    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_path",        0, "search by path for minidvodb", NULL);
     163    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-mergedvodb_path",        0, "search by path for the merged dvodb", NULL);
     164    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
     165    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_name",        0, "define minidvodb_name", NULL);
     166    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_path",        0, "define path for minidvodb", NULL);
     167    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_mergedvodb_path",        0, "define path for minidvodb", NULL);
     168    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_minidvodb_group",        0, "define path for the merged dvodb", NULL);
     169    psMetadataAddStr(updateminidvodbrunArgs, PS_LIST_TAIL, "-set_state",        0, "define state", NULL);
     170   
     171    // -listminidvodbrunArgs
     172    psMetadata *listminidvodbrunArgs = psMetadataAlloc();
     173    psMetadataAddU64(listminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
     174    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name (LIKE)", NULL);
     175    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_group",     0,    "search by minidvodb.minidvodb_group", NULL);
     176    psMetadataAddStr(listminidvodbrunArgs, PS_LIST_TAIL, "-state",        0, "search by state", NULL);
     177    psMetadataAddU64(listminidvodbrunArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
     178    psMetadataAddBool(listminidvodbrunArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
     179   
     180    //psMetadataAddBool(listminidvodbrunArgs, PS_LIST_TAIL, "-finished_addrun",        0, "limit to minidvodbs with completed addRuns (none in new state)", false);
     181    psMetadata *flipminidvodbrunArgs = psMetadataAlloc();
     182    psMetadataAddStr(flipminidvodbrunArgs, PS_LIST_TAIL, "-minidvodb_group",     0,    "for the supplied minidvodb_group (required): flip the current 'new' to 'active', the current 'active' to 'waiting'", NULL);
     183   
     184    psMetadata *checkminidvodbrunaddrunArgs = psMetadataAlloc();
     185    psMetadataAddStr(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-minidvodb_group",     0,    "for the supplied minidvodb_group (required): check if the addRun stage is complete (all in addRun.state = full) ", NULL);
     186    psMetadataAddStr(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-minidvodb_name",     0,    "for the supplied minidvodb_name: check if the addRun stage is complete (all in addRun.state = full) ", NULL);
     187    psMetadataAddStr(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-state",     0,    "limit by minidvodbRun state ", NULL);
     188    psMetadataAddU64(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
     189    psMetadataAddBool(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
     190    psMetadataAddBool(checkminidvodbrunaddrunArgs, PS_LIST_TAIL, "-all_addrun_states",        0, "list all minidvodbRun.minidvodb_names, not just ones that have complete addRuns", false);
     191
     192    psMetadata *addminidvodbprocessedArgs = psMetadataAlloc();
     193    psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id", 0,    "define minidvodb_id (required)", 0);
     194    psMetadataAddU64(addminidvodbprocessedArgs, PS_LIST_TAIL, "-merge_order",    0,    "define merge order", 0);
     195    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_relphot",  0,    "define elapsed time for relphot (seconds)", NAN);
     196    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_resort", 0,    "define elapsed time for resort (seconds)", NAN);
     197    psMetadataAddF32(addminidvodbprocessedArgs, PS_LIST_TAIL, "-dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", NAN);
     198    psMetadataAddTime(addminidvodbprocessedArgs, PS_LIST_TAIL, "-epoch",         0,    "time merge is finished", NULL);
     199    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-mergedvodb_path",0,    "path of merged dvodb", NULL);
     200    psMetadataAddStr(addminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_group",0,    "minidvodb_group", NULL);
     201    psMetadataAddS16(addminidvodbprocessedArgs, PS_LIST_TAIL, "-fault",          0,    "set fault code", 0);
     202
     203    psMetadata *listminidvodbprocessedArgs = psMetadataAlloc();
     204    psMetadataAddU64(listminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
     205    psMetadataAddStr(listminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
     206    psMetadataAddStr(listminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_group",        0, "search by minidvodb.minidvodb_group", NULL);
     207    psMetadataAddU64(listminidvodbprocessedArgs, PS_LIST_TAIL, "-limit",        0, "limit to N items", 0);
     208    psMetadataAddBool(listminidvodbprocessedArgs, PS_LIST_TAIL, "-simple",        0, "simple output", false);
     209    psMetadataAddBool(listminidvodbprocessedArgs, PS_LIST_TAIL, "-faulted",        0, "limit to faulted state", false);
     210
     211    psMetadata *revertminidvodbprocessedArgs = psMetadataAlloc();
     212    psMetadataAddU64(revertminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
     213    psMetadataAddStr(revertminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_group",        0, "search by addRun.minidvodb_group", NULL);
     214
     215    psMetadata *updateminidvodbprocessedArgs = psMetadataAlloc();
     216    psMetadataAddU64(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_id",        0, "search by minidvodb_id", 0);
     217    psMetadataAddStr(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-minidvodb_name",        0, "search by minidvodb_name", NULL);
     218    psMetadataAddS16(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_fault",  0,            "set fault code", 0);
     219    psMetadataAddU64(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_merge_order",    0,    "define merge order", 0);
     220    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_relphot",  0,    "define elapsed time for relphot (seconds)", 0);
     221    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_resort", 0,    "define elapsed time for resort (seconds)", 0);
     222    psMetadataAddF32(updateminidvodbprocessedArgs, PS_LIST_TAIL, "-set_dtime_merge",    0,    "define elapsed time for DVO merge (seconds)", 0);
     223   
    144224    psMetadata *argSets = psMetadataAlloc();
    145225    psMetadata *modes = psMetadataAlloc();
    … …  
    154234    PXOPT_ADD_MODE("-block",                "set a label block",                    ADDTOOL_MODE_BLOCK,         blockArgs);
    155235    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  ADDTOOL_MODE_MASKED,        maskedArgs);
    156     PXOPT_ADD_MODE("-unblock",              "remove a label block",                 ADDTOOL_MODE_UNBLOCK,       unblockArgs);
     236    PXOPT_ADD_MODE("-addminidvodbrun",      "create minidvodbs ",                   ADDTOOL_MODE_ADDMINIDVODBRUN, addminidvodbrunArgs);
     237    PXOPT_ADD_MODE("-updateminidvodbrun",   "change minidvodb properties",          ADDTOOL_MODE_UPDATEMINIDVODBRUN,     updateminidvodbrunArgs);
     238    PXOPT_ADD_MODE("-listminidvodbrun",     "list minidvodbs",                      ADDTOOL_MODE_LISTMINIDVODBRUN,       listminidvodbrunArgs);
     239    PXOPT_ADD_MODE("-flipminidvodbrun",     "flip minidvodbs",                      ADDTOOL_MODE_FLIPMINIDVODBRUN,       flipminidvodbrunArgs);
     240    PXOPT_ADD_MODE("-checkminidvodbrunaddrun", "check minidvodbs to see if addRuns are completed", ADDTOOL_MODE_CHECKMINIDVODBRUNADDRUN,       checkminidvodbrunaddrunArgs);
     241    PXOPT_ADD_MODE("-addminidvodbprocessed","add a processed minidvodb",            ADDTOOL_MODE_ADDMINIDVODBPROCESSED,  addminidvodbprocessedArgs);
     242    PXOPT_ADD_MODE("-listminidvodbprocessed","list processed minidvodbs",           ADDTOOL_MODE_LISTMINIDVODBPROCESSED, listminidvodbprocessedArgs);
     243    PXOPT_ADD_MODE("-revertminidvodbprocessed","revert processed minidvobs",        ADDTOOL_MODE_REVERTMINIDVODBPROCESSED,     revertminidvodbprocessedArgs);
     244    PXOPT_ADD_MODE("-updateminidvodbprocessed","change processed minidvodb properties",ADDTOOL_MODE_UPDATEMINIDVODBPROCESSED,  updateminidvodbprocessedArgs);
     245 
     246 
     247
    157248
    158249    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/czw_branch/20100519/ippTools/src/camtool.c

    r28164 r28304  
    503503
    504504/*     psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s psastro %s ppstats %s ppImage %s streaks %s\n", */
    505 /*          ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks); */
     505/*          ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks); */
    506506    psString software_ver = NULL;
    507507    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    637637        path_base,
    638638        fault,
    639         software_ver,
    640         maskfrac_ref_npix,
    641         maskfrac_ref_static,
    642         maskfrac_ref_dynamic,
    643         maskfrac_ref_magic,
    644         maskfrac_ref_advisory,
    645         maskfrac_max_npix,
    646         maskfrac_max_static,
    647         maskfrac_max_dynamic,
    648         maskfrac_max_magic,
    649         maskfrac_max_advisory,
    650         quality
     639        software_ver,
     640        maskfrac_ref_npix,
     641        maskfrac_ref_static,
     642        maskfrac_ref_dynamic,
     643        maskfrac_ref_magic,
     644        maskfrac_ref_advisory,
     645        maskfrac_max_npix,
     646        maskfrac_max_static,
     647        maskfrac_max_dynamic,
     648        maskfrac_max_magic,
     649        maskfrac_max_advisory,
     650        quality
    651651        );
    652652
    … …  
    677677    if (!pxSetRunSoftware(config, "camRun", "cam_id", cam_id, software_ver)) {
    678678      if (!psDBRollback(config->dbh)) {
    679         psError(PS_ERR_UNKNOWN, false, "database error");
     679        psError(PS_ERR_UNKNOWN, false, "database error");
    680680      }
    681681      psError(PS_ERR_UNKNOWN, false, "failed to set camRun.software_ver for cam_id: %" PRId64,
    682               cam_id);
     682              cam_id);
    683683      psFree(output);
    684684      return(false);
    … …  
    687687    if (maskfrac_ref_npix) {
    688688      if (!pxCamSetRunMaskfrac(config, "camRun", "cam_id",cam_id,
    689                                (float) maskfrac_ref_npix, maskfrac_ref_static,
    690                                maskfrac_ref_dynamic, maskfrac_ref_magic, maskfrac_ref_advisory,
    691                                (float) maskfrac_max_npix, maskfrac_max_static,
    692                                maskfrac_max_dynamic, maskfrac_max_magic, maskfrac_max_advisory)) {
    693         if (!psDBRollback(config->dbh)) {
    694           psError(PS_ERR_UNKNOWN, false, "database error");
    695         }
    696         psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
    697                 cam_id);
    698         psFree(output);
    699         return(false);
     689                               (float) maskfrac_ref_npix, maskfrac_ref_static,
     690                               maskfrac_ref_dynamic, maskfrac_ref_magic, maskfrac_ref_advisory,
     691                               (float) maskfrac_max_npix, maskfrac_max_static,
     692                               maskfrac_max_dynamic, maskfrac_max_magic, maskfrac_max_advisory)) {
     693        if (!psDBRollback(config->dbh)) {
     694          psError(PS_ERR_UNKNOWN, false, "database error");
     695        }
     696        psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
     697                cam_id);
     698        psFree(output);
     699        return(false);
    700700      }
    701701    }
    … …  
    709709        return false;
    710710    }
    711    
     711
    712712    psFree(row);
    713713
    714714    // EAM:  NULL for end_stage means go as far as possible
    715715    // Also, we can run fake even if tess_id is not defined
    716     if (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam")) {
     716    // but stop if quality is non-zero.
     717    if ((quality > 0) || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
    717718        psFree(pendingRow);
    718719        if (!psDBCommit(config->dbh)) {
    … …  
    893894
    894895    {
    895         psString query = pxDataGet("camtool_reset_faulted_runs.sql");
     896        psString query = pxDataGet("camtool_revertprocessedexp.sql");
    896897        if (!query) {
     898            // rollback
     899            if (!psDBRollback(config->dbh)) {
     900                psError(PS_ERR_UNKNOWN, false, "database error");
     901            }
    897902            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    898903            psFree(where);
    … …  
    919924        psFree(query);
    920925    }
    921 
    922     {
    923         psString query = pxDataGet("camtool_revertprocessedexp.sql");
    924         if (!query) {
    925             // rollback
    926             if (!psDBRollback(config->dbh)) {
    927                 psError(PS_ERR_UNKNOWN, false, "database error");
    928             }
    929             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    930             psFree(where);
    931             return false;
    932         }
    933 
    934         // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
    935         if (where && psListLength(where->list)) {
    936             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    937             psStringAppend(&query, " AND %s", whereClause);
    938             psFree(whereClause);
    939         }
    940 
    941         if (!p_psDBRunQuery(config->dbh, query)) {
    942             // rollback
    943             if (!psDBRollback(config->dbh)) {
    944                 psError(PS_ERR_UNKNOWN, false, "database error");
    945             }
    946             psError(PS_ERR_UNKNOWN, false, "database error");
    947             psFree(query);
    948             psFree(where);
    949             return false;
    950         }
    951         psFree(query);
    952     }
    953926    psFree(where);
    954927

  • branches/czw_branch/20100519/ippTools/src/difftool.c

    r28245 r28304  
    22902290  if (psListLength(where->list)) {
    22912291    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    2292     psStringAppend(&query, " WHERE %s", whereClause);
     2292    psStringAppend(&query, " AND %s", whereClause);
    22932293    psFree(whereClause);
    22942294  } else if (!all && !where2) {
    … …  
    23012301      psStringAppend(&query, " %s", where2);
    23022302    } else {
    2303       psStringAppend(&query, " WHERE 1 %s", where2);
     2303      psStringAppend(&query, " AND 1 %s", where2);
    23042304    }
    23052305  }

  • branches/czw_branch/20100519/ippTools/src/disttool.c

    r27542 r28304  
    148148    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    149149
    150     if (use_alternate) { 
     150    if (use_alternate) {
    151151        if (strcmp(stage, "raw")) {
    152152            psError(PXTOOLS_ERR_SYS, true, "alternate inputs only supported for raw stage");
    … …  
    299299      query = pxDataGet("disttool_definebyquery_SSdiff.sql");
    300300      if (!query) {
    301         psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
    302         psFree(where);
    303         return(false);
     301        psError(PXTOOLS_ERR_SYS, false, "failed to retrieve SQL statement");
     302        psFree(where);
     303        return(false);
    304304      }
    305305
    306306      if (label) {
    307         psStringAppend(&query, " AND (diffRun.label = '%s') ", label);
     307        psStringAppend(&query, " AND (diffRun.label = '%s') ", label);
    308308      }
    309309      if (dist_group) {
    310         psStringAppend(&query, " AND (diffRun.dist_group = '%s') ", dist_group);
     310        psStringAppend(&query, " AND (diffRun.dist_group = '%s') ", dist_group);
    311311      }
    312312
    313       no_magic = true;   
     313      no_magic = true;
    314314    } else {
    315315        psError(PS_ERR_UNKNOWN, true, "unknown value for stage: %s", stage);
    … …  
    470470    PXOPT_COPY_STR(config->args, where, "-data_group", "distRun.data_group", "LIKE");
    471471    PXOPT_COPY_STR(config->args, where, "-dist_group", "distTarget.dist_group", "==");
    472     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     472    PXOPT_COPY_TIME(config->args, where, "-time_stamp_begin", "distRun.time_stamp", ">=");
     473    PXOPT_COPY_TIME(config->args, where, "-time_stamp_end", "distRun.time_stamp", "<=");
     474
     475    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     476    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     477    if (clean && full) {
     478        psFree(where);
     479        psError(PXTOOLS_ERR_CONFIG, true, "-clean and -full are contradictory parameters");
     480        return false;
     481    }
    473482
    474483    if (!psListLength(where->list)) {
    … …  
    491500    }
    492501
     502    psString extraWhere = NULL;
    493503    psString query = psStringCopy("UPDATE distRun join distTarget using(target_id, stage) SET distRun.time_stamp = UTC_TIMESTAMP()");
    494504
    … …  
    498508    if (state) {
    499509        psStringAppend(&query, " , distRun.state = '%s'", state);
     510        if (!strcmp(state, "goto_cleaned")) {
     511            // don't queue for clean up if run has already already cleaned
     512            psStringAppend(&extraWhere, " AND (distRun.state != 'cleaned' AND distRun.state != 'goto_cleaned')");
     513        }
    500514    }
    501515
    … …  
    521535    psFree(whereClause);
    522536    psFree(where);
     537
     538    if (extraWhere) {
     539        psStringAppend(&query, "%s", extraWhere);
     540    }
     541    if (clean) {
     542        psStringAppend(&query, " AND (distRun.clean)");
     543    } else if (full) {
     544        psStringAppend(&query, " AND (!distRun.clean)");
     545    }
    523546
    524547    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    16801703        return false;
    16811704    }
    1682        
     1705
    16831706
    16841707    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);

  • branches/czw_branch/20100519/ippTools/src/disttoolConfig.c

    r27542 r28304  
    7979    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group",     0, "limit updates to data_group", NULL);
    8080    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dist_group",     0, "limit updates to data_group", NULL);
     81    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-time_stamp_begin", 0, "limit updates by time_stamp (>=)", NULL);
     82    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-time_stamp_end", 0, "limit updates by time_stamp (<=)", NULL);
     83    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL,"-clean",     0, "limit updates to clean distRuns", false);
     84    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL,"-full",      0, "limit updates to not clean distRuns", false);
    8185    psMetadataAddS16(updaterunArgs, PS_LIST_TAIL, "-fault",      0, "define fault code", 0);
     86
    8287    // -revertrun
    8388    psMetadata *revertrunArgs = psMetadataAlloc();

  • branches/czw_branch/20100519/ippTools/src/flatcorr.c

    r26981 r28304  
    671671                row->dvodb,
    672672                NULL,       // note is not propagated
    673                 0)) {
     673                0,
     674                0,  //The minidvodb stuff is off
     675                NULL,
     676                NULL)) {
    674677            if (!psDBRollback(config->dbh)) {
    675678                psError(PS_ERR_UNKNOWN, false, "database error");

  • branches/czw_branch/20100519/ippTools/src/magictool.c

    r28041 r28304  
    13671367            (strncmp(state, "new", 4) == 0)
    13681368            || (strncmp(state, "full", 5) == 0)
     1369            || (strncmp(state, "drop", 5) == 0)
    13691370            || (strncmp(state, "reg", 4) == 0)
    13701371        )

  • branches/czw_branch/20100519/ippTools/src/pstamptool.c

    r27969 r28304  
    3030#include "pxdata.h"
    3131#include "pstamptool.h"
     32#include "pstamp.h"
    3233
    3334static bool adddatastoreMode(pxConfig *config);
    … …  
    5354static bool updatedependentMode(pxConfig *config);
    5455static bool revertdependentMode(pxConfig *config);
     56static bool getwebrequestnumMode(pxConfig *config);
    5557
    5658# define MODECASE(caseName, func) \
    … …  
    9597        MODECASE(PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentMode);
    9698        MODECASE(PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentMode);
     99        MODECASE(PSTAMPTOOL_MODE_GETWEBREQUESTNUM, getwebrequestnumMode);
    97100        default:
    98101            psAbort("invalid option (this should not happen)");
    … …  
    939942    PXOPT_LOOKUP_S16(fault, config->args, "-fault",  false, false);
    940943
    941     // By default only revert faults < 10 which are our "ipp exit codes"
     944    // By default only revert faults < PSTAMP_FIRST_ERROR_CODE which are our "ipp exit codes"
    942945    // codes larger than that are the pstamp request interface.
    943946    // Don't fault those unless -fault waa provided
    944     psString faultClause = "";
     947    psString faultClause = psStringCopy("");
    945948    if (!fault) {
    946         faultClause = " \nAND (pstampJob.fault < 10)";
     949        psStringAppend(&faultClause, " \nAND (pstampJob.fault < %d)", PSTAMP_FIRST_ERROR_CODE);
    947950    }
    948951
    … …  
    961964
    962965    if (!p_psDBRunQueryF(config->dbh, query, faultClause)) {
    963         psError(PS_ERR_UNKNOWN, false, "database error");
    964         return false;
    965     }
     966        psFree(faultClause);
     967        psFree(query);
     968        psError(PS_ERR_UNKNOWN, false, "database error");
     969        return false;
     970    }
     971
     972    psFree(faultClause);
    966973
    967974    return true;
    … …  
    11331140            psFree(output);
    11341141            return false;
     1142        }
     1143        psS32 fault = psMetadataLookupS64(NULL, dep, "fault");
     1144        if (fault > 0) {
     1145            fprintf(stderr, "existing dependent has fault %d\n", fault);
     1146            exit (fault);
    11351147        }
    11361148        printf("%" PRId64 "\n", dep_id);
    … …  
    13151327        return false;
    13161328    }
     1329
     1330    PXOPT_LOOKUP_S16(fault,      config->args, "-fault",          false, false);
     1331
    13171332    psString query = pxDataGet("pstamptool_revertdependent.sql");
    13181333    if (!query) {
    … …  
    13261341    psFree(where);
    13271342
    1328     if (!p_psDBRunQuery(config->dbh, query)) {
    1329         psError(PS_ERR_UNKNOWN, false, "database error");
    1330         psFree(query);
    1331         return false;
    1332     }
    1333 
    1334     return true;
    1335 }
     1343    if (!fault) {
     1344        // unless asked to clear a specific fault value, restrict reverts to fault codes
     1345        // that are less than the minimum fault in the API
     1346        psStringAppend(&query, " AND (pstampDependent.fault < %d)", PSTAMP_FIRST_ERROR_CODE);
     1347    }
     1348
     1349    if (!p_psDBRunQuery(config->dbh, query)) {
     1350        psError(PS_ERR_UNKNOWN, false, "database error");
     1351        psFree(query);
     1352        return false;
     1353    }
     1354
     1355    return true;
     1356}
     1357
     1358static bool getwebrequestnumMode(pxConfig *config)
     1359{
     1360    PS_ASSERT_PTR_NON_NULL(config, false);
     1361
     1362    if (!pstampWebRequestInsert(config->dbh, 0 )) {
     1363        psError(PS_ERR_UNKNOWN, false, "failed to insert pstampWebRequest");
     1364        return false;
     1365    }
     1366
     1367    psS64 req_id = psDBLastInsertID(config->dbh);
     1368
     1369    printf("%" PRId64 "\n", req_id);
     1370
     1371    return true;
     1372}

  • branches/czw_branch/20100519/ippTools/src/pstamptool.h

    r27874 r28304  
    4848    PSTAMPTOOL_MODE_UPDATEDEPENDENT,
    4949    PSTAMPTOOL_MODE_REVERTDEPENDENT,
     50    PSTAMPTOOL_MODE_GETWEBREQUESTNUM,
    5051} pstamptoolMode;
    5152

  • branches/czw_branch/20100519/ippTools/src/pstamptoolConfig.c

    r27874 r28304  
    235235    psMetadataAddBool(projectArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    236236
     237    // -getwebrequestnum
     238    psMetadata *getwebrequestnumArgs = psMetadataAlloc();
     239
    237240    psMetadata *argSets = psMetadataAlloc();
    238241    psMetadata *modes = psMetadataAlloc();
    … …  
    264267    PXOPT_ADD_MODE("-modproject",      "", PSTAMPTOOL_MODE_MODPROJECT, modprojectArgs);
    265268    PXOPT_ADD_MODE("-project",         "", PSTAMPTOOL_MODE_PROJECT,    projectArgs);
     269    PXOPT_ADD_MODE("-getwebrequestnum","", PSTAMPTOOL_MODE_GETWEBREQUESTNUM,   getwebrequestnumArgs);
    266270
    267271    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/czw_branch/20100519/ippTools/src/pxadd.c

    r26981 r28304  
    130130                       char *dvodb,
    131131                       char *note,
    132                        bool image_only)
     132                       bool image_only,
     133                       bool minidvodb,
     134                       char *minidvodb_group,
     135                       char *minidvodb_name)
    133136{
    134137    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    158161                         note     ? note     : "NULL",
    159162                         image_only,
     163                         minidvodb,
     164                         minidvodb_group,
     165                         minidvodb_name,
    160166                         (long long) cam_id
    161167    )) {
    162         psError(PS_ERR_UNKNOWN, false, "database error");
     168      psError(PS_ERR_UNKNOWN, false, "database error %s", query);
    163169        return false;
    164170    }

  • branches/czw_branch/20100519/ippTools/src/pxadd.h

    r25835 r28304  
    3838                       char *dvodb,
    3939                       char *note,
    40                        bool image_only);
     40                       bool image_only,
     41                       bool minidvodb,
     42                       char *minidvodb_group,
     43                       char *minidvodb_name);
    4144
    4245#endif // PXADD_H

  • branches/czw_branch/20100519/ippTools/src/pxcam.c

    r28043 r28304  
    152152                    char *tess_id,
    153153                    char *end_stage,
    154                     psS64 magicked,
     154                    psS64 magicked,
    155155                    char *note)
    156156{
    … …  
    172172    // different on 32/64
    173173    if (!p_psDBRunQueryF(config->dbh, query,
    174                 "new", // state
    175                 workdir  ? workdir  : "NULL",
    176                 "dirty", //workdir_state
    177                 label    ? label    : "NULL",
    178                 data_group ? data_group : "NULL",
    179                 dist_group ? dist_group : "NULL",
    180                 recipe   ? recipe   : "NULL",
    181                 expgroup ? expgroup : "NULL",
    182                 dvodb    ? dvodb    : "NULL",
    183                 tess_id  ? tess_id  : "NULL",
    184                 end_stage ? end_stage : "NULL",
    185                 (long long) magicked,
    186                          "NULL", // This shouldn't be propagated
    187                          "NULL",
    188                          "NULL",
    189                          "NULL",
    190                          "NULL",
    191                          "NULL",
     174                         "new", // state
     175                         workdir  ? workdir  : "NULL",
     176                         "dirty", //workdir_state
     177                         label    ? label    : "NULL",
     178                         data_group ? data_group : "NULL",
     179                         dist_group ? dist_group : "NULL",
     180                         recipe   ? recipe   : "NULL",
     181                         expgroup ? expgroup : "NULL",
     182                         dvodb    ? dvodb    : "NULL",
     183                         tess_id  ? tess_id  : "NULL",
     184                         end_stage ? end_stage : "NULL",
     185                         (long long) magicked,
     186                         // Here follows the software version and mask statistics which shouldn't be propagated
     187                         "NULL",
     188                         "NULL",
     189                         "NULL",
     190                         "NULL",
     191                         "NULL",
     192                         "NULL",
     193                         "NULL",
     194                         "NULL",
     195                         "NULL",
     196                         "NULL",
     197                         "NULL",
    192198                note     ? note     : "NULL",
    193199                (long long)chip_id

  • branches/czw_branch/20100519/ippTools/src/pxchip.c

    r28043 r28304  
    4040    psMetadataAddStr(md,  PS_LIST_TAIL, "-telescope",          0, "search for telescope", NULL);
    4141    psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_begin",      0, "search for exposures by time (>=)", NULL);
    42     psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<)", NULL);
     42    psMetadataAddTime(md, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<=)", NULL);
    4343    psMetadataAddStr(md,  PS_LIST_TAIL, "-exp_tag",            0, "search by exp_tag", NULL);
    4444    psMetadataAddStr(md,  PS_LIST_TAIL, "-exp_type",           0, "search by exp_type", NULL);

  • branches/czw_branch/20100519/ippTools/src/pxtools.c

    r28164 r28304  
    4848}
    4949
    50 psString pxMergeCodeVersions(psString version1, psString version2) {
     50psString pxMergeCodeVersions(psString version1, psString version2)
     51{
     52    if (!version1 && !version2) {
     53        return NULL;
     54    }
     55
     56    if (!version1) {
     57        return psStringCopy(version2);
     58    }
     59    if (!version2) {
     60        return psStringCopy(version1);
     61    }
     62
     63    bool mod1 = false, mod2 = false;    // Modified versions?
     64    if (strchr(version1, 'M')) {
     65        psStringSubstitute(&version1, "M", "");
     66        mod1 = true;
     67    }
     68    if (strchr(version2, 'M')) {
     69        psStringSubstitute(&version2, "M", "");
     70        mod2 = true;
     71    }
     72
     73    int num1 = strtol(version1, NULL, 10);
     74    int num2 = strtol(version2, NULL, 10);
     75    int numO = PS_MAX(num1, num2);
     76
    5177    psString out = NULL;
    52 
    53     bool mod1 = false;
    54     bool mod2 = false;
    55 
    56     psS32 num1;
    57     psS32 num2;
    58     psS32 numO;
    59 
    60     if (!version1) {
    61         psStringAppend(&out, "%s", version2);
    62         return(out);
    63     }
    64     if (!version2) {
    65         psStringAppend(&out, "%s", version1);
    66         return(out);
    67     }
    68  
    69     if (strchr(version1,'M')) {
    70         psStringSubstitute(&version1,"M","");
    71         mod1 = true;
    72     }
    73     if (strchr(version2,'M')) {
    74         psStringSubstitute(&version2,"M","");
    75         mod2 = true;
    76     }
    77 
    78     num1 = strtol(version1,NULL,10);
    79     num2 = strtol(version2,NULL,10);
    80 
    81     if (num1 >= num2) {
    82         numO = num1;
    83     }
    84     else {
    85         numO = num2;
    86     }
    87  
    88     psStringAppend(&out,"%" PRId32,numO);
     78    psStringAppend(&out, "%" PRId32, numO);
    8979    if (mod1 || mod2) {
    90         psStringAppend(&out,"M");
    91     }
    92     return(out);
     80        psStringAppend(&out, "M");
     81    }
     82    return out;
    9383}
    9484
    9585bool pxCoalesceRunStatus(pxConfig *config, const psString dbQFile, psS64 stage_id, psString *software_ver,
    96                          psS64 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
    97                          psF32 *maskfrac_magic, psF32 *maskfrac_advisory) {
     86                         psS64 *maskfrac_npix, psF32 *maskfrac_static, psF32 *maskfrac_dynamic,
     87                         psF32 *maskfrac_magic, psF32 *maskfrac_advisory)
     88{
    9889    psString query = pxDataGet(dbQFile);
    99 /*   psString text_id = NULL; */
    100 /*   psStringAppend(&text_id," %" PRId64,stage_id); */
    101 /*   psStringSubstitute(&query,text_id,"@STAGE_ID@"); */
    102 /*   psFree(text_id); */
     90    if (!query) {
     91        psError(psErrorCodeLast(), false, "Unable to read query");
     92        return false;
     93    }
    10394    if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
    104         psError(PS_ERR_UNKNOWN, false, "database error");
    105         psFree(query);
    106         return(false);
     95        psError(psErrorCodeLast(), false, "database error");
     96        psFree(query);
     97        return false;
    10798    }
    10899    psFree(query);
     100
    109101    psArray *output = p_psDBFetchResult(config->dbh);
    110102    if (!output) {
    111         psError(PS_ERR_UNKNOWN, false, "database error");
    112         return(false);
    113     }
    114  
     103        psError(psErrorCodeLast(), false, "database error");
     104        return false;
     105    }
     106
     107    *maskfrac_npix = 0;
     108    *maskfrac_static = 0.0;
     109    *maskfrac_dynamic = 0.0;
     110    *maskfrac_magic = 0.0;
     111    *maskfrac_advisory = 0.0;
     112
    115113    for (long i = 0; i < psArrayLength(output); i++) {
    116         psMetadata *row = output->data[i];
    117 
    118         psS32 this_npix = psMetadataLookupS32(NULL, row, "maskfrac_npix");
    119         psF32 this_static = psMetadataLookupF32(NULL, row, "maskfrac_static");
    120         psF32 this_dynamic = psMetadataLookupF32(NULL, row, "maskfrac_dynamic");
    121         psF32 this_magic = psMetadataLookupF32(NULL, row, "maskfrac_magic");
    122         psF32 this_advisory = psMetadataLookupF32(NULL, row, "maskfrac_advisory");
    123         psString this_version = psMetadataLookupStr(NULL, row, "software_ver");
    124 
    125         *software_ver = pxMergeCodeVersions(*software_ver,this_version);
    126 /*     printf("%ld : %d %f %f %f %f <-> %ld %f %f %f %f\n",i,this_npix,this_static,this_dynamic,this_magic,this_advisory, */
    127 /*         *maskfrac_npix,*maskfrac_static,*maskfrac_dynamic,*maskfrac_magic,*maskfrac_advisory); */
    128         if (this_npix > 0) {
    129             *maskfrac_static = ((*maskfrac_static * *maskfrac_npix) + (this_npix * this_static)) / (this_npix + *maskfrac_npix);
    130             *maskfrac_dynamic = ((*maskfrac_dynamic * *maskfrac_npix) + (this_npix * this_dynamic)) / (this_npix + *maskfrac_npix);
    131             *maskfrac_magic = ((*maskfrac_magic * *maskfrac_npix) + (this_npix * this_magic)) / (this_npix + *maskfrac_npix);
    132             *maskfrac_advisory = ((*maskfrac_advisory * *maskfrac_npix) + (this_npix * this_advisory)) / (this_npix + *maskfrac_npix);
    133             *maskfrac_npix += this_npix;
    134         }
     114        psMetadata *row = output->data[i];
     115
     116        psS32 this_npix = psMetadataLookupS32(NULL, row, "maskfrac_npix");
     117        psF32 this_static = psMetadataLookupF32(NULL, row, "maskfrac_static");
     118        psF32 this_dynamic = psMetadataLookupF32(NULL, row, "maskfrac_dynamic");
     119        psF32 this_magic = psMetadataLookupF32(NULL, row, "maskfrac_magic");
     120        psF32 this_advisory = psMetadataLookupF32(NULL, row, "maskfrac_advisory");
     121
     122        psTrace("pxtools", 3, "Mask stats: %d %f %f %f %f\n",
     123                this_npix, this_static, this_dynamic, this_magic, this_advisory);
     124
     125        if (this_npix == 0 || this_npix == PS_MAX_S32) {
     126            continue;
     127        }
     128        if (!isfinite(this_static) || !isfinite(this_dynamic) ||
     129            !isfinite(this_magic) || !isfinite(this_advisory)) {
     130            continue;
     131        }
     132
     133        psString this_version = psMetadataLookupStr(NULL, row, "software_ver");
     134        *software_ver = pxMergeCodeVersions(*software_ver,this_version);
     135
     136        *maskfrac_npix += this_npix;
     137        *maskfrac_static += this_npix * this_static;
     138        *maskfrac_dynamic += this_npix * this_dynamic;
     139        *maskfrac_magic += this_npix * this_magic;
     140        *maskfrac_advisory += this_npix * this_advisory;
    135141    }
    136142    psFree(output);
    137     return(true);
    138 }
    139 
    140 bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
    141                       psString software_ver) {
     143
     144    if (*maskfrac_npix > 0) {
     145        *maskfrac_static /= *maskfrac_npix;
     146        *maskfrac_dynamic /= *maskfrac_npix;
     147        *maskfrac_magic /= *maskfrac_npix;
     148        *maskfrac_advisory /= *maskfrac_npix;
     149    }
     150
     151    return true;
     152}
     153
     154bool pxSetRunSoftware(pxConfig *config, const psString tableName, const psString stage_id_name,
     155                      const psS64 stage_id, psString software_ver)
     156{
    142157    char *query = "UPDATE %s SET software_ver = '%s' WHERE %s = %" PRId64;
    143 /*   printf(query,tableName,software_ver,stage_id_name,stage_id); */
    144     if (!p_psDBRunQueryF(config->dbh,query,tableName,software_ver,stage_id_name,stage_id)) {
    145         psError(PS_ERR_UNKNOWN, false,
    146                 "failed to set software version for %s %" PRId64,stage_id_name,stage_id);
    147         return(false);
    148     }
    149  
    150     return(true);
    151 }
    152 
    153 bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
    154                       psS64 maskfrac_npix, psF32 maskfrac_static, psF32 maskfrac_dynamic,
    155                       psF32 maskfrac_magic, psF32 maskfrac_advisory) {
    156     char *query = "UPDATE %s SET maskfrac_npix = %f, maskfrac_static = %f, maskfrac_dynamic = %f, maskfrac_magic = %f, maskfrac_advisory = %f WHERE %s = %" PRId64;
    157     if (!p_psDBRunQueryF(config->dbh,query,tableName,(float) maskfrac_npix,maskfrac_static,
    158                          maskfrac_dynamic, maskfrac_magic,maskfrac_advisory,stage_id_name,stage_id)) {
    159         psError(PS_ERR_UNKNOWN, false,
    160                 "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
    161         return(false);
    162     }
    163  
    164 
    165 
    166     return(true);
    167 }
    168 
    169 bool pxCamSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name, const psS64 stage_id,
    170                          psS64 maskfrac_ref_npix, psF32 maskfrac_ref_static, psF32 maskfrac_ref_dynamic,
    171                          psF32 maskfrac_ref_magic, psF32 maskfrac_ref_advisory,
    172                          psS64 maskfrac_max_npix, psF32 maskfrac_max_static, psF32 maskfrac_max_dynamic,
    173                          psF32 maskfrac_max_magic, psF32 maskfrac_max_advisory) {
    174   char *query = "UPDATE %s SET maskfrac_ref_npix = %f, maskfrac_ref_static = %f, maskfrac_ref_dynamic = %f, maskfrac_ref_magic = %f, maskfrac_ref_advisory = %f, maskfrac_max_npix = %f, maskfrac_max_static = %f, maskfrac_max_dynamic = %f, maskfrac_max_magic = %f, maskfrac_max_advisory = %f WHERE %s = %" PRId64;
    175   if (!p_psDBRunQueryF(config->dbh,query,tableName,(float) maskfrac_ref_npix,maskfrac_ref_static,
    176                        maskfrac_ref_dynamic, maskfrac_ref_magic,maskfrac_ref_advisory,
    177                        (float) maskfrac_max_npix,maskfrac_max_static,
    178                        maskfrac_max_dynamic, maskfrac_max_magic,maskfrac_max_advisory,
    179                        stage_id_name,stage_id)) {
    180     psError(PS_ERR_UNKNOWN, false,
    181             "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
    182     return(false);
     158    if (!p_psDBRunQueryF(config->dbh, query, tableName, software_ver, stage_id_name, stage_id)) {
     159        psError(psErrorCodeLast(), false,
     160                "failed to set software version for %s %" PRId64, stage_id_name, stage_id);
     161        return false;
     162    }
     163
     164    return true;
     165}
     166
     167bool pxSetRunMaskfrac(pxConfig *config, const psString tableName, const psString stage_id_name,
     168                      const psS64 stage_id, psS64 maskfrac_npix, psF32 maskfrac_static,
     169                      psF32 maskfrac_dynamic, psF32 maskfrac_magic, psF32 maskfrac_advisory)
     170{
     171    char *query = "UPDATE %s SET maskfrac_npix = %f, maskfrac_static = %f, maskfrac_dynamic = %f, "
     172        "maskfrac_magic = %f, maskfrac_advisory = %f WHERE %s = %" PRId64;
     173    if (!p_psDBRunQueryF(config->dbh, query, tableName, (float)maskfrac_npix, maskfrac_static,
     174                         maskfrac_dynamic, maskfrac_magic, maskfrac_advisory, stage_id_name, stage_id)) {
     175        psError(psErrorCodeLast(), false,
     176                "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
     177        return false;
     178    }
     179
     180
     181
     182    return true;
     183}
     184
     185bool pxCamSetRunMaskfrac(pxConfig *config, const psString tableName,
     186                         const psString stage_id_name, const psS64 stage_id,
     187                         psS64 maskfrac_ref_npix, psF32 maskfrac_ref_static, psF32 maskfrac_ref_dynamic,
     188                         psF32 maskfrac_ref_magic, psF32 maskfrac_ref_advisory,
     189                         psS64 maskfrac_max_npix, psF32 maskfrac_max_static, psF32 maskfrac_max_dynamic,
     190                         psF32 maskfrac_max_magic, psF32 maskfrac_max_advisory) {
     191  char *query = "UPDATE %s SET maskfrac_ref_npix = %f, maskfrac_ref_static = %f, maskfrac_ref_dynamic = %f, "
     192      "maskfrac_ref_magic = %f, maskfrac_ref_advisory = %f, maskfrac_max_npix = %f, maskfrac_max_static = %f, "
     193      "maskfrac_max_dynamic = %f, maskfrac_max_magic = %f, maskfrac_max_advisory = %f WHERE %s = %" PRId64;
     194  if (!p_psDBRunQueryF(config->dbh, query, tableName, (float)maskfrac_ref_npix, maskfrac_ref_static,
     195                       maskfrac_ref_dynamic,  maskfrac_ref_magic, maskfrac_ref_advisory,
     196                       (float)maskfrac_max_npix, maskfrac_max_static,
     197                       maskfrac_max_dynamic,  maskfrac_max_magic, maskfrac_max_advisory,
     198                       stage_id_name, stage_id)) {
     199      psError(psErrorCodeLast(), false,
     200              "failed to set maskfrac stats for %s %" PRId64,stage_id_name,stage_id);
     201      return false;
    183202  }
    184  
    185 
    186 
    187   return(true);
     203
     204  return true;
    188205}
    189206
    … …  
    222239    psMetadataItem *item = psMetadataLookup(config->args, name);
    223240    if (!item) {
    224         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for %s", name);
     241        psError(psErrorCodeLast(), false, "failed to lookup value for %s", name);
    225242        return false;
    226243    }
    … …  
    239256            item->comment = psStringCopy (op);
    240257            if (!psMetadataAddItem(where, item, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
    241                 psError(PS_ERR_UNKNOWN, false, "failed to add item %s", field);
     258                psError(psErrorCodeLast(), false, "failed to add item %s", field);
    242259                psFree(where);
    243260                return false;
    … …  
    272289    PXOPT_LOOKUP_STR(note, config->args,        "-set_note", false, false);
    273290
     291    if ((state)&&(!strcmp(state, "update"))) {
     292        fprintf(stderr, "'-updaterun -set_state update' is not supported.");
     293        if (!strcmp(runTable, "chipRun")) {
     294            fprintf(stderr, " Use -setimfiletoupdate.\n");
     295        } else {
     296            fprintf(stderr, " Use -setskyfiletoupdate.\n");
     297        }
     298        exit(1);
     299    }
     300
    274301    psString dist_group = NULL;
    275302    if (has_dist_group) {
    … …  
    293320    char *comma = ",";
    294321
    295 #   define addColumn(_tab, _val)                                        \
    296     do {                                                                \
    297         if (_val) {                                                     \
    298             psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
    299             separator = comma;                                          \
    300         }                                                               \
     322#   define addColumn(_tab, _val)                                        \
     323    do {                                                                \
     324        if (_val) {                                                     \
     325            psStringAppend(pQuery, "%s %s.%s = '%s'", separator, _tab, #_val, _val); \
     326            separator = comma;                                          \
     327        }                                                               \
    301328    } while (0)
    302329
    … …  
    331358
    332359    if (!p_psDBRunQueryF(config->dbh, *pQuery, joinHook)) {
    333         psError(PS_ERR_UNKNOWN, false, "database error");
     360        psError(psErrorCodeLast(), false, "database error");
    334361        return false;
    335362    }
    … …  
    343370
    344371    if (!p_psDBRunQuery(config->dbh, query)) {
    345         psError(PS_ERR_UNKNOWN, false, "database error");
     372        psError(psErrorCodeLast(), false, "database error");
    346373        return false;
    347374    }
    … …  
    349376    psArray *output = p_psDBFetchResult(config->dbh);
    350377    if (!output) {
    351         psError(PS_ERR_UNKNOWN, false, "database error");
     378        psError(psErrorCodeLast(), false, "database error");
    352379        return false;
    353380    }
    354381    if (!psArrayLength(output)) {
    355382        psFree(output);
    356         psError(PS_ERR_UNKNOWN, true, "no rows in dbversion");
     383        psError(PXTOOLS_ERR_PROG, true, "no rows in dbversion");
    357384        return false;
    358385    }
    359386    if (psArrayLength(output) > 1) {
    360         psError(PS_ERR_UNKNOWN, true, "unexpected number of rows found in dbversion: %ld",
     387        psError(PXTOOLS_ERR_PROG, true, "unexpected number of rows found in dbversion: %ld",
    361388                psArrayLength(output));
    362389        return false;
    … …  
    373400    psArray *array = NULL;
    374401    if (!pxLookupVersion(config, &array)) {
    375         psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     402        psError(psErrorCodeLast(), false, "pxLookupVersion failed");
    376403        return NULL;
    377404    }
    378405    psMetadata *md = array->data[0];
    379406    if (!md) {
    380         psError(PS_ERR_UNKNOWN, true, "output of pxLookupVersion is null");
     407        psError(PXTOOLS_ERR_PROG, true, "output of pxLookupVersion is null");
    381408        return NULL;
    382409    }
    … …  
    394421    psArray *array = NULL;
    395422    if (!pxLookupVersion(config, &array) || !array) {
    396         psError(PS_ERR_UNKNOWN, false, "pxLookupVersion failed");
     423        psError(psErrorCodeLast(), false, "pxLookupVersion failed");
    397424        return false;
    398425    }
    399426    if (!ippdbPrintMetadatas(file, array, "dbversion", true)) {
    400         psError(PS_ERR_UNKNOWN, false, "failed to print array");
     427        psError(psErrorCodeLast(), false, "failed to print array");
    401428        psFree(array);
    402429        return false;
    … …  
    414441    psMetadataItem *multi_item =  psMetadataLookup(input, "dbversion");
    415442    if (!multi_item || (multi_item->type != PS_DATA_METADATA_MULTI)) {
    416         psError(PS_ERR_UNKNOWN, true, "dbversion multi not found in input");
     443        psError(PXTOOLS_ERR_PROG, true, "dbversion multi not found in input");
    417444        return false;
    418445    }
    … …  
    420447    psMetadataItem *dbversion = psListGet(multi_item->data.list, 0);
    421448    if (!dbversion) {
    422         psError(PS_ERR_UNKNOWN, true, "dbversion not found in input");
     449        psError(PXTOOLS_ERR_PROG, true, "dbversion not found in input");
    423450        return false;
    424451    }
    … …  
    429456        psString schema_version = pxGetDBVersion(config);
    430457        if (!schema_version) {
    431             psError(PS_ERR_UNKNOWN, false, "pxGetDBVersion failed");
     458            psError(psErrorCodeLast(), false, "pxGetDBVersion failed");
    432459            return false;
    433460        }
    … …  
    435462        psString import_version = psMetadataLookupStr(NULL, md, "schema_version");
    436463        if (import_version && strcmp(import_version, schema_version)) {
    437             psError(PS_ERR_UNKNOWN, true, "input file schema_version: %s does not match data base: %s",
    438                     import_version, schema_version);
     464            psError(PXTOOLS_ERR_PROG, true, "input file schema_version: %s does not match data base: %s",
     465                    import_version, schema_version);
    439466            return false;
    440467        } else if (!import_version) {
    441             psError(PS_ERR_UNKNOWN, true, "input file schema_version is NULL");
     468            psError(PXTOOLS_ERR_PROG, true, "input file schema_version is NULL");
    442469            return false;
    443470        } else {
    … …  
    445472        }
    446473    } else {
    447         psError(PS_ERR_UNKNOWN, true, "Unexpected config dump format");
    448         return false;
    449     }
    450 
    451     return true;
    452 }
     474        psError(PXTOOLS_ERR_PROG, true, "Unexpected config dump format");
     475        return false;
     476    }
     477
     478    return true;
     479}

  • branches/czw_branch/20100519/ippTools/src/stacktool.c

    r28245 r28304  
    3939static bool addsumskyfileMode(pxConfig *config);
    4040static bool sumskyfileMode(pxConfig *config);
     41static bool sassskyfileMode(pxConfig *config);
    4142static bool revertsumskyfileMode(pxConfig *config);
    4243static bool tosummaryMode(pxConfig *config);
    … …  
    7778        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,         addsumskyfileMode);
    7879        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
     80        MODECASE(STACKTOOL_MODE_SASSSKYFILE,            sassskyfileMode);
    7981        MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileMode);
    8082        MODECASE(STACKTOOL_MODE_TOSUMMARY,             tosummaryMode);
    … …  
    116118  psString idString = NULL;
    117119  psStringAppend(&idString, "%" PRId64, stack_id);
    118   psStringSubstitute(&select,idString, "@STACK_ID@");
     120  // Copy string to get around the issue with psStringSubstitute not believing
     121  // that select is a psString.
     122  psString rep = psStringCopy(select);
     123  psFree(select);
     124  select = rep;
     125  psStringSubstitute(&select, idString, "@STACK_ID@");
    119126  psFree(idString);
    120127
    … …  
    143150    return(NULL);
    144151  }
    145   psMetadata *outrow = NULL;
     152  psMetadata *outrow = psMetadataAlloc();
    146153  for (long i = 0; i < output->n; i++) {
    147154    psMetadata *row = output->data[i];
    148     if (!psMetadataCopy(row,outrow)) {
    149       psError(PS_ERR_UNKNOWN, false, "Failed to copy row to return");
    150       return(NULL);
    151     }
    152   }
     155
     156    printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,row,"sass_id"),
     157           psMetadataLookupStr(NULL,row,"data_group"),
     158           psMetadataLookupStr(NULL,row,"tess_id"),
     159           psMetadataLookupStr(NULL,row,"filter"),
     160           psMetadataLookupStr(NULL,row,"projection_cell"));
     161
     162    if (psMetadataLookupS64(NULL,row,"sass_id") == PS_MAX_S64) {
     163      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",0);
     164    }
     165    else {
     166      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",psMetadataLookupS64(NULL,row,"sass_id"));
     167    }
     168    psMetadataAddStr(outrow,PS_LIST_TAIL,"data_group",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"data_group"));
     169    psMetadataAddStr(outrow,PS_LIST_TAIL,"tess_id",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"tess_id"));
     170    psMetadataAddStr(outrow,PS_LIST_TAIL,"filter",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"filter"));
     171    psMetadataAddStr(outrow,PS_LIST_TAIL,"projection_cell",PS_META_REPLACE,"",
     172                     psMetadataLookupStr(NULL,row,"projection_cell"));
     173  }
     174  printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,outrow,"sass_id"),
     175         psMetadataLookupStr(NULL,outrow,"data_group"),
     176         psMetadataLookupStr(NULL,outrow,"tess_id"),
     177         psMetadataLookupStr(NULL,outrow,"filter"),
     178         psMetadataLookupStr(NULL,outrow,"projection_cell"));
     179 
     180
    153181  psFree(output);
    154182  stackAssociationRow *sassRow = stackAssociationObjectFromMetadata(outrow);
    … …  
    10631091    psMetadata *where = psMetadataAlloc();
    10641092    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    1065     PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociationMap.sass_id", "==");
    10661093    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
    10671094    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    … …  
    10821109
    10831110    psString query = pxDataGet("stacktool_sumskyfile.sql");
     1111    if (!query) {
     1112        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1113        return false;
     1114    }
     1115
     1116    if (psListLength(where->list)) {
     1117        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1118        psStringAppend(&query, " WHERE %s", whereClause);
     1119        psFree(whereClause);
     1120    } else if (!all) {
     1121        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1122        return false;
     1123    }
     1124
     1125    psFree(where);
     1126
     1127    // treat limit == 0 as "no limit"
     1128    if (limit) {
     1129        psString limitString = psDBGenerateLimitSQL(limit);
     1130        psStringAppend(&query, " %s", limitString);
     1131        psFree(limitString);
     1132    }
     1133
     1134    if (!p_psDBRunQuery(config->dbh, query)) {
     1135        psError(PS_ERR_UNKNOWN, false, "database error");
     1136        psFree(query);
     1137        return false;
     1138    }
     1139    psFree(query);
     1140
     1141    psArray *output = p_psDBFetchResult(config->dbh);
     1142    if (!output) {
     1143        psErrorCode err = psErrorCodeLast();
     1144        switch (err) {
     1145            case PS_ERR_DB_CLIENT:
     1146                psError(PXTOOLS_ERR_SYS, false, "database error");
     1147            case PS_ERR_DB_SERVER:
     1148                psError(PXTOOLS_ERR_PROG, false, "database error");
     1149            default:
     1150                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1151        }
     1152
     1153        return false;
     1154    }
     1155    if (!psArrayLength(output)) {
     1156        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1157        psFree(output);
     1158        return true;
     1159    }
     1160
     1161    if (psArrayLength(output)) {
     1162        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     1163            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1164            psFree(output);
     1165            return false;
     1166        }
     1167    }
     1168
     1169    psFree(output);
     1170
     1171    return true;
     1172}
     1173
     1174static bool sassskyfileMode(pxConfig *config)
     1175{
     1176    PS_ASSERT_PTR_NON_NULL(config, false);
     1177
     1178    psMetadata *where = psMetadataAlloc();
     1179    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociation.sass_id", "==");
     1180    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackAssociation.tess_id", "==");
     1181    PXOPT_COPY_STR(config->args, where, "-projection_cell", "stackAssociation.projection_cell", "==");
     1182    PXOPT_COPY_STR(config->args, where, "-filter", "stackAssociation.filter", "LIKE");
     1183    PXOPT_COPY_STR(config->args, where, "-data_group", "stackAssociation.data_group", "LIKE");
     1184
     1185//  The following three selectors are incompatible with the sql so omit them
     1186//    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     1187//     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
     1188//    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     1189
     1190    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1191
     1192    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1193    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1194
     1195    psString query = pxDataGet("stacktool_sassskyfile.sql");
    10841196    if (!query) {
    10851197        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    13181430  PS_ASSERT_PTR_NON_NULL(config, NULL);
    13191431
    1320   PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", true, false);
     1432  PXOPT_LOOKUP_S64(sass_id, config->args, "-sass_id", true, false);
    13211433  PXOPT_LOOKUP_STR(projection_cell, config->args, "-projection_cell", true, false);
    13221434  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    … …  
    13271439    return(false);
    13281440  }
    1329   if (!p_psDBRunQueryF(config->dbh, query, stack_id, projection_cell, path_base)) {
     1441  if (!p_psDBRunQueryF(config->dbh, query, sass_id, projection_cell, path_base)) {
    13301442    psError(PS_ERR_UNKNOWN, false, "database error");
    13311443    psFree(query);

  • branches/czw_branch/20100519/ippTools/src/stacktool.h

    r28164 r28304  
    3333    STACKTOOL_MODE_ADDSUMSKYFILE,
    3434    STACKTOOL_MODE_SUMSKYFILE,
     35    STACKTOOL_MODE_SASSSKYFILE,
    3536    STACKTOOL_MODE_REVERTSUMSKYFILE,
    3637    STACKTOOL_MODE_TOSUMMARY,

  • branches/czw_branch/20100519/ippTools/src/stacktoolConfig.c

    r28245 r28304  
    197197    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
    198198
     199    // -sassskyfile
     200    psMetadata *sassskyfileArgs = psMetadataAlloc();
     201    psMetadataAddS64(sassskyfileArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
     202    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     203    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-projection_cell", 0,         "search by projection cell", 0);
     204
     205    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackAssociation.data_group (LIKE comparison)", NULL);
     206    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     207    psMetadataAddU64(sassskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     208    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     209    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
     210
    199211    // -revertsumskyfile
    200212    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    … …  
    221233    // -addsummary
    222234    psMetadata *addsummaryArgs = psMetadataAlloc();
    223     psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-stack_id", 0,      "set stack ID", 0);
     235    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-sass_id", 0,      "set stack Association ID", 0);
    224236    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-projection_cell", 0, "set projection cell", NULL);
    225237    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,     "set summary path base", NULL);             
    … …  
    273285    PXOPT_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    274286    PXOPT_ADD_MODE("-sumskyfile",      "list results of stackRun", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     287    PXOPT_ADD_MODE("-sassskyfile",      "list results of stackAssociation", STACKTOOL_MODE_SASSSKYFILE,      sassskyfileArgs);
    275288    PXOPT_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
    276289    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", STACKTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);

  • branches/czw_branch/20100519/ippTools/src/staticskytool.c

    r28164 r28304  
    4242static bool importrunMode(pxConfig *config);
    4343
     44static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state);
     45
    4446# define MODECASE(caseName, func) \
    4547    case caseName: \
    … …  
    129131    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    130132    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     133    PXOPT_LOOKUP_BOOL(check_inputs, config->args, "-check_inputs", false);
    131134
    132135    psString select = pxDataGet("staticskytool_definebyquery_select.sql");
    … …  
    255258            psWarning("staticskytool ERROR: no rows found for known tess_id, skycell_id?");
    256259            continue;
     260        }
     261
     262        if (check_inputs) {
     263          // negative simple so the default is true
     264          if (!ippdbPrintMetadatas(stdout, inputs, "staticskyInput", !simple)) {
     265            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     266            psFree(output);
     267            psFree(where);
     268            return false;
     269          }
     270          psFree(inputs);
     271          continue;
    257272        }
    258273
    … …  
    550565    }
    551566
     567    if (!fault) {
     568        if (!setstaticskyRunState(config, sky_id, "full")) {
     569            if (!psDBRollback(config->dbh)) {
     570                psError(PS_ERR_UNKNOWN, false, "database error");
     571            }
     572            psError(PS_ERR_UNKNOWN, false, "failed to change staticskyRun state");
     573            return false;
     574        }
     575    }
     576
    552577    // point of no return
    553578    if (!psDBCommit(config->dbh)) {
    … …  
    643668    PS_ASSERT_PTR_NON_NULL(config, false);
    644669
    645 # if (0)
    646670    psMetadata *where = psMetadataAlloc();
    647     PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    648     pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    649     PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     671    PXOPT_COPY_S64(config->args, where, "-sky_id", "staticskyResult.sky_id", "==");
     672    pxAddLabelSearchArgs(config, where, "-label", "staticskyRun.label", "==");
     673    PXOPT_COPY_S16(config->args, where, "-fault", "staticskyResult.fault", "==");
    650674
    651675    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    … …  
    656680
    657681    // Delete product
    658     psString delete = pxDataGet("staticskytool_revertsumskyfile_delete.sql");
     682    psString delete = pxDataGet("staticskytool_revert.sql");
    659683    if (!delete) {
    660684        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    680704
    681705    psFree(where);
    682 # endif
    683 
    684706    return true;
    685707}
    686708
    687 # if (0)
    688 static bool updateresultState(pxConfig *config)
    689 {
    690     // check that state is a valid string value
    691     if (!pxIsValidState(state)) {
    692         psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    693         return false;
    694     }
    695 
    696     char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
    697     if (!p_psDBRunQueryF(config->dbh, query, state, stack_id)) {
    698         psError(PS_ERR_UNKNOWN, false,
    699                 "failed to change state for stack_id %"PRId64, stack_id);
    700         return false;
    701     }
    702     return true;
    703 }
    704 # endif
    705 
    706709static bool updateresult(pxConfig *config)
    707710{
    708711    PS_ASSERT_PTR_NON_NULL(config, false);
    709712
    710 # if (0)
    711713    PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    712714
    713715    psMetadata *where = psMetadataAlloc();
    714     PXOPT_COPY_S64(config->args, where, "-stack_id",   "stack_id",   "==");
    715 
    716     if (!pxSetFaultCode(config->dbh, "stackSumSkyfile", where, fault)) {
     716    PXOPT_COPY_S64(config->args, where, "-sky_id",   "sky_id",   "==");
     717
     718    if (!pxSetFaultCode(config->dbh, "staticskyResult", where, fault)) {
    717719        psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    718720        psFree (where);
    … …  
    720722    }
    721723    psFree (where);
    722 
    723 # endif
    724724    return true;
    725725}
    … …  
    898898# endif
    899899  return true;
     900}
     901
     902static bool setstaticskyRunState(pxConfig *config, psS64 sky_id, const char *state)
     903{
     904    PS_ASSERT_PTR_NON_NULL(state, false);
     905
     906    // check that state is a valid string value
     907    if (!pxIsValidState(state)) {
     908        psError(PS_ERR_UNKNOWN, false, "invalid staticskyRun state: %s", state);
     909        return false;
     910    }
     911
     912    char *query = "UPDATE staticskyRun SET state = '%s' WHERE sky_id = %"PRId64;
     913    if (!p_psDBRunQueryF(config->dbh, query, state, sky_id)) {
     914        psError(PS_ERR_UNKNOWN, false, "failed to change state for sky_id %"PRId64, sky_id);
     915        return false;
     916    }
     917    return true;
     918
    900919}
    901920

  • branches/czw_branch/20100519/ippTools/src/staticskytoolConfig.c

    r28164 r28304  
    6161    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    6262    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     63    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-check_inputs",  0, "list inputs, do not modify database", false);
    6364    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    6465

  • branches/czw_branch/20100519/ippTools/src/warptool.c

    r28245 r28304  
    430430    }
    431431
    432     psString query = psStringCopy("UPDATE warpRun JOIN warpSkyfile USING(warp_id) JOIN fakeRun USING(fake_id) JOIN camRun USING(cam_id) JOIN chipRun USING(chip_id) JOIN rawExp USING(exp_id)");
     432    psString query = psStringCopy("UPDATE warpRun");
    433433
    434434    // pxUpdateRun gets parameters from config->args and updates
Note: See TracChangeset for help on using the changeset viewer.