IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 24, 2010, 2:59:09 PM (16 years ago)
Author:
Paul Price
Message:

Merging trunk in advance of reintegrating into trunk.

Location:
branches/pap
Files:
30 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/pap

  • branches/pap/ippTools/src

    • Property svn:ignore

      •  

        old new  
        3939warptool
        4040staticskytool
        41 
        4241bgtool
         42diffphottool

  • branches/pap/ippTools/src/Makefile.am

    r28199 r28484  
    2626        warptool \
    2727        receivetool \
    28         pubtool
     28        pubtool \
     29        diffphottool
    2930
    3031pkginclude_HEADERS = \
    … …  
    7172        staticskytool.h \
    7273        warptool.h \
    73         pubtool.h
     74        pubtool.h \
     75        diffphottool.h
    7476
    7577lib_LTLIBRARIES = libpxtools.la
    … …  
    272274    pubtoolConfig.c
    273275
     276diffphottool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     277diffphottool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     278diffphottool_SOURCES = \
     279    diffphottool.c \
     280    diffphottoolConfig.c
     281
    274282clean-local:
    275283        -rm -f TAGS

  • branches/pap/ippTools/src/addtool.c

    r27773 r28484  
    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  if (minidvodb_path) {
     820    psStringAppend(&minidvodb_path,"/%s",minidvodb_name);
     821  }
     822
     823
     824  psString query = NULL;
     825
     826  psStringAppend(&query, "UPDATE minidvodbRun SET minidvodb_path = '%s', minidvodb_name = '%s' where minidvodb_id = %" PRIu64";", minidvodb_path, minidvodb_name, minidvodb_id);
     827
     828  if (!p_psDBRunQuery(config->dbh, query)) {
     829    psError(PS_ERR_UNKNOWN, false, "database error");
     830    psFree(query);
     831    return false;
     832  }
     833
     834  if (!psDBCommit(config->dbh)) {
     835    psError(PS_ERR_UNKNOWN, false, "database error");
     836    return false;
     837  }
     838
     839  return true;
     840}
     841
     842static bool updateminidvodbrunMode(pxConfig *config) {
     843  PS_ASSERT_PTR_NON_NULL(config, false);
     844
     845    psMetadata *where = psMetadataAlloc();
     846    PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodb_id", "==");
     847    PXOPT_COPY_STR(config->args, where, "-minidvodb_name",     "minidvodb_name", "==");
     848    PXOPT_COPY_STR(config->args, where, "-state",     "state", "==");
     849    PXOPT_COPY_STR(config->args, where, "-minidvodb_path", "minidvodb_path", "==");
     850    PXOPT_COPY_STR(config->args, where, "-mergedvodb_path", "mergedvodb_path", "==");
     851    PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
     852
     853    PXOPT_LOOKUP_STR(minidvodb_name,  config->args, "-set_minidvodb_name", false, false);
     854    PXOPT_LOOKUP_STR(minidvodb_path,  config->args, "-set_minidvodb_path", false, false);
     855    PXOPT_LOOKUP_STR(state,  config->args, "-set_state", false, false);
     856    PXOPT_LOOKUP_STR(mergedvodb_path,  config->args, "-set_mergedvodb_path", false, false);
     857    PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-set_minidvodb_group", false, false);
     858
     859
     860    if (!psListLength(where->list)) {
     861      psFree(where);
     862      psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     863      return false;
     864    }
     865
     866    psString query = psStringCopy("UPDATE minidvodbRun SET ");
     867    int cnt = 0;
     868    psString comma = ",";
     869    if (minidvodb_name) {
     870      psStringAppend(&query, " minidvodb_name = '%s'", minidvodb_name);
     871      cnt++;
     872    }
     873
     874    if (minidvodb_path) {
     875      if (cnt) {
     876          psStringAppend(&query, "%s", comma);
     877      }
     878
     879      psStringAppend(&query, " minidvodb_path = '%s'", minidvodb_path);
     880      cnt++;
     881    }
     882
     883    if (state) {
     884      if (cnt) {
     885        psStringAppend(&query, "%s", comma);
     886      }
     887      psStringAppend(&query, " state = '%s'", state);
     888      cnt++;
     889    }
     890
     891    if (mergedvodb_path) {
     892      if (cnt) {
     893        psStringAppend(&query, "%s", comma);
     894      }
     895      psStringAppend(&query, " mergedvodb_path = '%s'", mergedvodb_path);
     896      cnt++;
     897    }
     898
     899    if (minidvodb_group) {
     900      if (cnt) {
     901        psStringAppend(&query, "%s", comma);
     902      }
     903      psStringAppend(&query, " minidvodb_group = '%s'", minidvodb_group);
     904      cnt++;
     905    }
     906
     907    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     908    psStringAppend(&query, " WHERE %s", whereClause);
     909
     910    if (!p_psDBRunQuery(config->dbh, query)) {
     911      psError(PS_ERR_UNKNOWN, false, "database error");
     912      psFree(query);
     913      return false;
     914    }
     915
     916    psFree(query);
     917    psFree(where);
     918
     919    return true;
     920
     921}
     922
     923static bool flipminidvodbrunMode(pxConfig *config) {
     924  PS_ASSERT_PTR_NON_NULL(config, false);
     925
     926  psMetadata *where = psMetadataAlloc();
     927  PXOPT_LOOKUP_STR(minidvodb_group,  config->args, "-minidvodb_group",true, false);
     928  PXOPT_COPY_STR(config->args, where, "-minidvodb_group",     "minidvodb_group", "==");
     929
     930//this flips the new - > active
     931// and the active - > waiting in one action
     932
     933
     934// the first query looks to find things that are new and where all the fields are filled (ie, ready to be flipped to active)
     935
     936// start a transaction eraly so it will contain any row level locks
     937  if (!psDBTransaction(config->dbh)) {
     938    psError(PS_ERR_UNKNOWN, false, "database error");
     939    return false;
     940  }
     941
     942  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");
     943
     944  psString firstwhereClause = psDBGenerateWhereConditionSQL(where, NULL);
     945  psStringAppend(&firstquery, " AND %s", firstwhereClause);
     946
     947
     948
     949  if (!p_psDBRunQuery(config->dbh, firstquery)) {
     950    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     951    if (!psDBRollback(config->dbh)) {
     952      psError(PS_ERR_UNKNOWN, false, "database error");
     953    }
     954    return false;
     955  }
     956  psFree(firstquery);
     957
     958 //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.
     959
     960  psArray *output = p_psDBFetchResult(config->dbh);
     961  if (!output) {
     962    psError(PS_ERR_UNKNOWN, false, "database error");
     963    return false;
     964  }
     965  if (!psArrayLength(output)) {
     966    psTrace("addtool", PS_LOG_INFO, "no rows found");
     967    psFree(output);
     968    return true;
     969  }
     970
     971
     972  //ok, there's something, so flip active -> waiting
     973
     974  psString query = psStringCopy("UPDATE minidvodbRun SET state = 'waiting' WHERE state = 'active' ");
     975
     976  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     977  psStringAppend(&query, " AND %s", whereClause);
     978
     979
     980  if (!p_psDBRunQuery(config->dbh, query)) {
     981    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     982    if (!psDBRollback(config->dbh)) {
     983      psError(PS_ERR_UNKNOWN, false, "database error");
     984    }
     985    return false;
     986  }
     987
     988
     989  //now flip new -> active
     990  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 ");
     991  psStringAppend(&query2, " AND minidvodb_group = '%s' limit 1;", minidvodb_group);
     992  if (!p_psDBRunQuery(config->dbh, query2)) {
     993    psError(PS_ERR_UNKNOWN, false, "database error");
     994    if (!psDBRollback(config->dbh)) {
     995      psError(PS_ERR_UNKNOWN, false, "database error");
     996    }
     997    psFree(query);
     998    return false;
     999  }
     1000
     1001
     1002  if (!psDBCommit(config->dbh)) {
     1003    psError(PS_ERR_UNKNOWN, false, "database error");
     1004    if (!psDBRollback(config->dbh)) {
     1005      psError(PS_ERR_UNKNOWN, false, "database error");
     1006    }
     1007    psFree(query);
     1008  return false;
     1009  }
     1010 psFree(query2);
     1011 psFree(where);
     1012
     1013 return true;
     1014
     1015}
     1016
     1017
     1018static bool checkminidvodbrunaddrunMode(pxConfig *config) {
     1019  PS_ASSERT_PTR_NON_NULL(config, false);
     1020  psMetadata *where = psMetadataAlloc();
     1021
     1022  //this checks to see if a minidvod_group/name is has completed addRun processing
     1023  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbRun.minidvodb_group", "==");
     1024  PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "==");
     1025  PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
     1026
     1027
     1028  PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
     1029  PXOPT_LOOKUP_BOOL(all_addrun_states, config->args, "-all_addrun_states", false);
     1030  //this doesn't care what state the addRun is in (useful for counting addRuns)
     1031  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1032
     1033  if (!psListLength(where->list)) {
     1034        psFree(where);
     1035        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1036        return false;
     1037  }
     1038
     1039  psString query = pxDataGet("addtool_checkminidvodbaddrun.sql");
     1040
     1041  if (!query) {
     1042        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1043        return false;
     1044  }
     1045
     1046
     1047  if (psListLength(where->list)) {
     1048    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1049        psStringAppend(&query, " WHERE %s", whereClause);
     1050        psFree(whereClause);
     1051  }
     1052
     1053  if (!all_addrun_states) {
     1054    psStringAppend(&query, " AND (cnt2 = cnt) ");
     1055  }
     1056
     1057  if (limit) {
     1058    psString limitString = psDBGenerateLimitSQL(limit);
     1059    psStringAppend(&query, " %s", limitString);
     1060    psFree(limitString);
     1061  }
     1062
     1063
     1064  if (!p_psDBRunQuery(config->dbh, query)) {
     1065    psError(PS_ERR_UNKNOWN, false, "database error");
     1066    psFree(query);
     1067    return false;
     1068  }
     1069  psFree(query);
     1070  psArray *output = p_psDBFetchResult(config->dbh);
     1071  if (!output) {
     1072    psError(PS_ERR_UNKNOWN, false, "database error");
     1073    return false;
     1074  }
     1075  if (!psArrayLength(output)) {
     1076    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1077    psFree(output);
     1078    return true;
     1079  }
     1080
     1081  if (!ippdbPrintMetadatas(stdout, output, "minidvodbRun", !simple)) {
     1082    psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1083    psFree(output);
     1084    return false;
     1085  }
     1086
     1087  psFree(output);
     1088
     1089  return true;
     1090}
     1091
     1092
     1093
     1094static bool listminidvodbrunMode(pxConfig *config) {
     1095    PS_ASSERT_PTR_NON_NULL(config, false);
     1096    psMetadata *where = psMetadataAlloc();
     1097
     1098    PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbRun.minidvodb_name", "LIKE");
     1099    PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbRun.minidvodb_group", "==");
     1100    PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbRun.minidvodb_id", "==");
     1101
     1102    PXOPT_COPY_STR(config->args, where, "-state", "minidvodbRun.state", "==");
     1103    PXOPT_LOOKUP_U64(limit,      config->args, "-limit", false, false);
     1104    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1105
     1106
     1107    if (!psListLength(where->list)) {
     1108      psFree(where);
     1109      psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1110      return false;
     1111    }
     1112
     1113    psString query = pxDataGet("addtool_find_minidvodbrun.sql");
     1114
     1115    if (!query) {
     1116      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1117      return false;
     1118    }
     1119
     1120    if (psListLength(where->list)) {
     1121      psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1122      psStringAppend(&query, " WHERE %s", whereClause);
     1123      psFree(whereClause);
     1124    }
     1125
     1126    if (limit) {
     1127      psString limitString = psDBGenerateLimitSQL(limit);
     1128      psStringAppend(&query, " %s", limitString);
     1129      psFree(limitString);
     1130    }
     1131
     1132    if (!p_psDBRunQuery(config->dbh, query)) {
     1133      psError(PS_ERR_UNKNOWN, false, "database error");
     1134      psFree(query);
     1135      return false;
     1136    }
     1137
     1138    psFree(query);
     1139    psArray *output = p_psDBFetchResult(config->dbh);
     1140    if (!output) {
     1141      psError(PS_ERR_UNKNOWN, false, "database error");
     1142      return false;
     1143    }
     1144    if (!psArrayLength(output)) {
     1145      psTrace("addtool", PS_LOG_INFO, "no rows found");
     1146      psFree(output);
     1147      return true;
     1148    }
     1149
     1150    if (!ippdbPrintMetadatas(stdout, output, "minidvodbRun",  !simple)) {
     1151      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1152      psFree(output);
     1153      return false;
     1154    }
     1155
     1156    psFree(output);
     1157
     1158return true;
     1159}
     1160
     1161static bool addminidvodbprocessedMode(pxConfig *config) {
     1162
     1163  PS_ASSERT_PTR_NON_NULL(config, false);
     1164
     1165    // required
     1166  PXOPT_LOOKUP_U64(minidvodb_id, config->args, "-minidvodb_id", true, false);
     1167  PXOPT_LOOKUP_STR(mergedvodb_path, config->args, "-mergedvodb_path", true, false);
     1168  PXOPT_LOOKUP_STR(minidvodb_group, config->args, "-minidvodb_group", true, false);
     1169
     1170    // optional
     1171  PXOPT_LOOKUP_U64(merge_order,     config->args, "-merge_order", false, false);
     1172  PXOPT_LOOKUP_F32(dtime_relphot, config->args, "-dtime_relphot", false, false);
     1173  PXOPT_LOOKUP_F32(dtime_resort, config->args, "-dtime_resort", false, false);
     1174  PXOPT_LOOKUP_F32(dtime_merge, config->args, "-dtime_merge", false, false);
     1175  PXOPT_LOOKUP_TIME(epoch, config->args, "-epoch", false, false);
     1176  PXOPT_LOOKUP_S16(fault,         config->args, "-fault", false, false);
     1177    //generate restrictions
     1178  psMetadata *where = psMetadataAlloc();
     1179  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",   "minidvodbRun.minidvodb_id",   "==");
     1180
     1181
     1182  if (!psDBTransaction(config->dbh)) {
     1183    psError(PS_ERR_UNKNOWN, false, "database error");
     1184    return false;
     1185  }
     1186
     1187
     1188  psString query = pxDataGet("addtool_find_pendingmergeprocess.sql");
     1189  if (!query) {
     1190    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1191    return false;
     1192  }
     1193  // use psDBGenerateWhereSQL because the SQL yields an intermediate table
     1194  if (psListLength(where->list)) {
     1195    psString whereClaus = psDBGenerateWhereConditionSQL(where, NULL);
     1196    psStringAppend(&query, " AND %s", whereClaus);
     1197    psFree(whereClaus);
     1198  }
     1199  psFree(where);
     1200
     1201  if (!p_psDBRunQuery(config->dbh, query)) {
     1202    psError(PS_ERR_UNKNOWN, false, "database error");
     1203    psFree(query);
     1204    return false;
     1205  }
     1206  psFree(query);
     1207
     1208  psArray *output = p_psDBFetchResult(config->dbh);
     1209  if (!output) {
     1210    psError(PS_ERR_UNKNOWN, false, "database error");
     1211    return false;
     1212  }
     1213  if (!psArrayLength(output)) {
     1214    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1215    psFree(output);
     1216    return true;
     1217  }
     1218
     1219  minidvodbRunRow *pendingRow = minidvodbRunObjectFromMetadata(output->data[0]);
     1220  psFree(output);
     1221  minidvodbProcessedRow *row = minidvodbProcessedRowAlloc(
     1222               pendingRow->minidvodb_id,
     1223               merge_order,
     1224               dtime_resort,
     1225               dtime_relphot,
     1226               dtime_merge,
     1227               epoch,
     1228               mergedvodb_path,
     1229               fault
     1230               );
     1231
     1232  if (!minidvodbProcessedInsertObject(config->dbh, row)) {
     1233    // rollback
     1234    if (!psDBRollback(config->dbh)) {
     1235      psError(PS_ERR_UNKNOWN, false, "database error");
     1236    }
     1237    psError(PS_ERR_UNKNOWN, false, "database error");
     1238    psFree(row);
     1239    psFree(pendingRow);
     1240    return false;
     1241  }
     1242
     1243
     1244
     1245
     1246  //this finds the # of merged things (for the merge order)
     1247  psString query3 = NULL;
     1248  psStringAppend(&query3, "select count(*) from minidvodbRun join minidvodbProcessed using (minidvodb_id) where state = 'merged' and minidvodb_group = '%s';", minidvodb_group);
     1249
     1250  if (!p_psDBRunQuery(config->dbh, query3)) {
     1251    // rollback
     1252    if (!psDBRollback(config->dbh)) {
     1253      psError(PS_ERR_UNKNOWN, false, "database error");
     1254    }
     1255    psError(PS_ERR_UNKNOWN, false, "database error");
     1256    psFree(query3);
     1257    return false;
     1258  }
     1259  psArray *output2 = p_psDBFetchResult(config->dbh);
     1260  if (!output2) {
     1261    psError(PS_ERR_UNKNOWN, false, "database error");
     1262    return false;
     1263  }
     1264  if (!psArrayLength(output2)) {
     1265    psTrace("addtool", PS_LOG_INFO, "no rows found");
     1266    psFree(output);
     1267    return true;
     1268  }
     1269  bool status;
     1270  psS64 m_order = psMetadataLookupS64(&status, output2->data[0], "count(*)");
     1271  if (!status) {
     1272
     1273    psAbort("failed to lookup value for count column");
     1274    return false;
     1275  }
     1276  psString final = NULL;
     1277  psStringAppend(&final, "%" PRIu64, m_order);
     1278    //return false;
     1279  psFree(query3);
     1280  psFree(output2);
     1281
     1282
     1283
     1284  //update the merge_order
     1285
     1286  psString query4 = NULL;
     1287  psStringAppend(&query4, "update minidvodbProcessed set merge_order = %"PRIu64,m_order);
     1288  psStringAppend(&query4," where minidvodb_id = %" PRIu64,  minidvodb_id);
     1289  printf("%s", query4);
     1290  if (!p_psDBRunQuery(config->dbh, query4)) {
     1291    // rollback
     1292    if (!psDBRollback(config->dbh)) {
     1293      psError(PS_ERR_UNKNOWN, false, "database error");
     1294    }
     1295    psError(PS_ERR_UNKNOWN, false, "database error");
     1296    psFree(query4);
     1297    return false;
     1298  }
     1299  //
     1300psFree(query4);
     1301
     1302
     1303
     1304// since there is only one exp per 'new' set mindvodbRun.state = 'merged'
     1305
     1306  psString query2 = NULL ;
     1307  psStringAppend(&query2, "UPDATE minidvodbRun SET state = 'merged' WHERE minidvodb_id = %'" PRIu64, row->minidvodb_id);
     1308
     1309  if (!p_psDBRunQuery(config->dbh, query2)) {
     1310    // rollback
     1311    if (!psDBRollback(config->dbh)) {
     1312      psError(PS_ERR_UNKNOWN, false, "database error");
     1313    }
     1314    psError(PS_ERR_UNKNOWN, false, "database error");
     1315    psFree(query2);
     1316    return false;
     1317  }
     1318
     1319
     1320
     1321
     1322
     1323
     1324
     1325
     1326  psFree(row);
     1327  psFree(pendingRow);
     1328
     1329
     1330
     1331
     1332
     1333  //commit the changes
     1334  if (!psDBCommit(config->dbh)) {
     1335    psError(PS_ERR_UNKNOWN, false, "database error");
     1336    return false;
     1337  }
     1338
     1339
     1340  //print the merge_order (why not!)
     1341  printf("%s", final);
     1342  psFree(final);
     1343
     1344  return true;
     1345}
     1346
     1347
     1348
     1349static bool listminidvodbprocessedMode(pxConfig *config) {
     1350  psMetadata *where = psMetadataAlloc();
     1351  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbProcessed.minidvodb_id", "==");
     1352  PXOPT_COPY_STR(config->args, where, "-minidvodb_name", "minidvodbProcessed.minidvodb_name", "==");
     1353  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "minidvodbProcessed.minidvodb_group", "==");
     1354  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1355  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1356  PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     1357  if (!psListLength(where->list)) {
     1358        psFree(where);
     1359        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1360        return false;
     1361    }
     1362
     1363  psString query = pxDataGet("addtool_find_minidvodbprocessed.sql");
     1364    if (!query) {
     1365        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1366        return false;
     1367    }
     1368
     1369if (psListLength(where->list)) {
     1370        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1371        psStringAppend(&query, " WHERE %s", whereClause);
     1372        psFree(whereClause);
     1373    }
     1374
     1375// we either add AND (condition) or WHERE (condition):
     1376    if (where->list && faulted) {
     1377        // list only faulted rows
     1378        psStringAppend(&query, " %s", " AND minidvodbProcessed.fault != 0");
     1379    }
     1380    if (where->list && !faulted) {
     1381        // don't list faulted rows
     1382        psStringAppend(&query, " %s", " AND minidvodbProcessed.fault = 0");
     1383    }
     1384    if (!where->list && faulted) {
     1385        // list only faulted rows
     1386        psStringAppend(&query, " %s", " WHERE minidvodbProcessed.fault != 0");
     1387    }
     1388    if (!where->list && !faulted) {
     1389        // don't list faulted rows
     1390        psStringAppend(&query, " %s", " WHERE minidvodbProcessed.fault = 0");
     1391    }
     1392    psFree(where);
     1393
     1394    // order by epoch
     1395    psStringAppend(&query, " ORDER BY minidvodb_id");
     1396
     1397    // treat limit == 0 as "no limit"
     1398    if (limit) {
     1399        psString limitString = psDBGenerateLimitSQL(limit);
     1400        psStringAppend(&query, " %s", limitString);
     1401        psFree(limitString);
     1402    }
     1403
     1404    if (!p_psDBRunQuery(config->dbh, query)) {
     1405      psError(PS_ERR_UNKNOWN, false, "database error ");
     1406        psFree(query);
     1407        return false;
     1408    }
     1409    psFree(query);
     1410
     1411    psArray *output = p_psDBFetchResult(config->dbh);
     1412    if (!output) {
     1413        psError(PS_ERR_UNKNOWN, false, "database error");
     1414        return false;
     1415    }
     1416    if (!psArrayLength(output)) {
     1417        psTrace("addtool", PS_LOG_INFO, "no rows found");
     1418        psFree(output);
     1419        return true;
     1420    }
     1421
     1422    // negate simple so the default is true
     1423    if (!ippdbPrintMetadatas(stdout, output, "minidvodbProcessed", !simple)) {
     1424        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1425        psFree(output);
     1426        return false;
     1427    }
     1428
     1429    psFree(output);
     1430
     1431return true;
     1432}
     1433
     1434
     1435
     1436static bool revertminidvodbprocessedMode(pxConfig *config) {
     1437  psMetadata *where = psMetadataAlloc();
     1438  PS_ASSERT_PTR_NON_NULL(config, false);
     1439  PXOPT_COPY_S64(config->args, where, "-minidvodb_id", "minidvodbProcessed.minidvodb_id", "==");
     1440  PXOPT_COPY_STR(config->args, where, "-minidvodb_group", "addRun.minidvodb_group", "==");
     1441
     1442  if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1443    psFree(where);
     1444    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1445    return false;
     1446  }
     1447
     1448  if (!psDBTransaction(config->dbh)) {
     1449      psError(PS_ERR_UNKNOWN, false, "database error");
     1450      psFree(where);
     1451      return false;
     1452  }
     1453
     1454  {
     1455    psString query = pxDataGet("addtool_revertminidvodbprocessed.sql");
     1456    if (!query) {
     1457      // rollback
     1458      if (!psDBRollback(config->dbh)) {
     1459        psError(PS_ERR_UNKNOWN, false, "database error");
     1460      }
     1461      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1462      psFree(where);
     1463      return false;
     1464    }
     1465
     1466    // use psDBGenerateWhereConditionalSQL with AND ... because the SQL ends in a WHERE
     1467    if (where && psListLength(where->list)) {
     1468      psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1469      psStringAppend(&query, " AND %s", whereClause);
     1470      psFree(whereClause);
     1471    }
     1472
     1473    if (!p_psDBRunQuery(config->dbh, query)) {
     1474      // rollback
     1475      if (!psDBRollback(config->dbh)) {
     1476        psError(PS_ERR_UNKNOWN, false, "database error");
     1477      }
     1478      psError(PS_ERR_UNKNOWN, false, "database error");
     1479      psFree(query);
     1480      psFree(where);
     1481            return false;
     1482    }
     1483    psFree(query);
     1484  }
     1485  psFree(where);
     1486
     1487  if (!psDBCommit(config->dbh)) {
     1488    psError(PS_ERR_UNKNOWN, false, "database error");
     1489    return false;
     1490  }
     1491
     1492  return true;
     1493}
     1494
     1495
     1496
     1497static bool updateminidvodbprocessedMode(pxConfig *config) {
     1498  PS_ASSERT_PTR_NON_NULL(config, false);
     1499  psMetadata *where = psMetadataAlloc();
     1500
     1501  PXOPT_LOOKUP_U64(minidvodb_id,  config->args, "-minidvodb_id", true, false);
     1502  PXOPT_LOOKUP_U64(merge_order,  config->args, "-set_merge_order", false, false);
     1503  PXOPT_LOOKUP_S16(fault,  config->args, "-set_fault", false, false);
     1504  PXOPT_LOOKUP_F32(dtime_relphot,  config->args, "-set_dtime_relphot", false, false);
     1505  PXOPT_LOOKUP_F32(dtime_resort,  config->args, "-set_dtime_resort", false, false);
     1506  PXOPT_LOOKUP_F32(dtime_merge,  config->args, "-set_dtime_merge", false, false);
     1507
     1508  PXOPT_COPY_S64(config->args, where, "-minidvodb_id",     "minidvodbProcessed.minidvodb_id", "==");
     1509  PXOPT_COPY_STR(config->args, where, "-minidvodb_name",     "minidvodbRun.minidvodb_name", "==");
     1510
     1511
     1512  if (!psListLength(where->list)) {
     1513    psFree(where);
     1514    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1515    return false;
     1516  }
     1517
     1518  psString query = psStringCopy("UPDATE minidvodbProcessed JOIN minidvodbRun USING (minidvodb_id) SET ");
     1519  int cnt = 0;
     1520  psString comma = ",";
     1521  if (fault) {
     1522    psStringAppend(&query, " fault = %d", fault);
     1523  cnt++;
     1524  }
     1525
     1526  if (merge_order) {
     1527    if (cnt) {
     1528      psStringAppend(&query, "%s", comma);
     1529    }
     1530
     1531    psStringAppend(&query, " merge_order = %" PRId64, merge_order);
     1532    cnt++;
     1533  }
     1534
     1535  if (dtime_relphot) {
     1536    if (cnt) {
     1537      psStringAppend(&query, "%s", comma);
     1538    }
     1539    psStringAppend(&query, " dtime_relphot = %f", dtime_relphot);
     1540    cnt++;
     1541  }
     1542
     1543  if (dtime_resort) {
     1544    if (cnt) {
     1545      psStringAppend(&query, "%s", comma);
     1546    }
     1547    psStringAppend(&query, " dtime_resort = %f", dtime_resort);
     1548    cnt++;
     1549  }
     1550
     1551  if (dtime_merge) {
     1552    if (cnt) {
     1553      psStringAppend(&query, "%s", comma);
     1554    }
     1555    psStringAppend(&query, " dtime_merge = %f", dtime_merge);
     1556    cnt++;
     1557 }
     1558
     1559  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1560  psStringAppend(&query, " WHERE %s", whereClause);
     1561
     1562  if (!p_psDBRunQuery(config->dbh, query)) {
     1563   psError(PS_ERR_UNKNOWN, false, "database error");
     1564   psFree(query);
     1565   return false;
     1566  }
     1567
     1568  psFree(query);
     1569  psFree(where);
     1570
     1571  return true;
     1572}
     1573
     1574

  • branches/pap/ippTools/src/addtool.h

    r25299 r28484  
    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/pap/ippTools/src/addtoolConfig.c

    r27773 r28484  
    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/pap/ippTools/src/camtool.c

    r28089 r28484  
    130130    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    131131
     132    // default
     133    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     134    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     135
    132136    // find the exp_id of all the exposures that we want to queue up.
    133137    psString query = pxDataGet("camtool_find_chip_id.sql");
    … …  
    161165    if (!psArrayLength(output)) {
    162166        psTrace("camtool", PS_LOG_INFO, "no rows found");
     167        psFree(output);
     168        return true;
     169    }
     170
     171    if (pretend) {
     172        // negative simple so the default is true
     173        if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) {
     174            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     175            psFree(output);
     176            return false;
     177        }
    163178        psFree(output);
    164179        return true;
    … …  
    292307    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    293308
    294     psString query = pxDataGet("camtool_find_pendingexp.sql");
     309    psString query = pxDataGet("camtool_pendingexp.sql");
    295310    if (!query) {
    296311        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    305320    }
    306321    psFree(where);
     322
     323    psStringAppend(&query, "\nORDER BY priority DESC, cam_id");
    307324
    308325    // treat limit == 0 as "no limit"
    … …  
    503520
    504521/*     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); */
     522/*          ver_pslib,ver_psmodules,ver_psphot,ver_psastro,ver_ppstats,ver_ppimage,ver_streaks); */
    506523    psString software_ver = NULL;
    507524    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    531548    PXOPT_COPY_S64(config->args, where, "-cam_id",   "camRun.cam_id",   "==");
    532549
    533     psString query = pxDataGet("camtool_find_pendingexp.sql");
     550    psString query = pxDataGet("camtool_addprocessedexp.sql");
    534551    if (!query) {
    535552        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    637654        path_base,
    638655        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
     656        software_ver,
     657        maskfrac_ref_npix,
     658        maskfrac_ref_static,
     659        maskfrac_ref_dynamic,
     660        maskfrac_ref_magic,
     661        maskfrac_ref_advisory,
     662        maskfrac_max_npix,
     663        maskfrac_max_static,
     664        maskfrac_max_dynamic,
     665        maskfrac_max_magic,
     666        maskfrac_max_advisory,
     667        quality
    651668        );
    652669
    … …  
    677694    if (!pxSetRunSoftware(config, "camRun", "cam_id", cam_id, software_ver)) {
    678695      if (!psDBRollback(config->dbh)) {
    679         psError(PS_ERR_UNKNOWN, false, "database error");
     696        psError(PS_ERR_UNKNOWN, false, "database error");
    680697      }
    681698      psError(PS_ERR_UNKNOWN, false, "failed to set camRun.software_ver for cam_id: %" PRId64,
    682               cam_id);
     699              cam_id);
    683700      psFree(output);
    684701      return(false);
    … …  
    687704    if (maskfrac_ref_npix) {
    688705      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);
     706                               (float) maskfrac_ref_npix, maskfrac_ref_static,
     707                               maskfrac_ref_dynamic, maskfrac_ref_magic, maskfrac_ref_advisory,
     708                               (float) maskfrac_max_npix, maskfrac_max_static,
     709                               maskfrac_max_dynamic, maskfrac_max_magic, maskfrac_max_advisory)) {
     710        if (!psDBRollback(config->dbh)) {
     711          psError(PS_ERR_UNKNOWN, false, "database error");
     712        }
     713        psError(PS_ERR_UNKNOWN, false, "failed to set camRun.maskstats for cam_id: %" PRId64,
     714                cam_id);
     715        psFree(output);
     716        return(false);
    700717      }
    701718    }
    … …  
    709726        return false;
    710727    }
    711    
     728
    712729    psFree(row);
    713730
    714731    // EAM:  NULL for end_stage means go as far as possible
    715732    // Also, we can run fake even if tess_id is not defined
    716     if (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam")) {
     733    // but stop if quality is non-zero.
     734    if ((quality > 0) || (pendingRow->end_stage && psStrcasestr(pendingRow->end_stage, "cam"))) {
    717735        psFree(pendingRow);
    718736        if (!psDBCommit(config->dbh)) {
    … …  
    893911
    894912    {
    895         psString query = pxDataGet("camtool_reset_faulted_runs.sql");
     913        psString query = pxDataGet("camtool_revertprocessedexp.sql");
    896914        if (!query) {
     915            // rollback
     916            if (!psDBRollback(config->dbh)) {
     917                psError(PS_ERR_UNKNOWN, false, "database error");
     918            }
    897919            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    898920            psFree(where);
    … …  
    919941        psFree(query);
    920942    }
    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     }
    953943    psFree(where);
    954944

  • branches/pap/ippTools/src/camtoolConfig.c

    r28089 r28484  
    6565    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group",     0, "define dist group", NULL);
    6666    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note",           0, "define note", NULL);
     67    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",           0, "do not actual modify the database", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",            0, "use the simple output format", false);
    6769
    6870    // -updaterun
    … …  
    8385    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);
    8486    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_note", 0,         "define new note", NULL);
     87
    8588    // -pendingexp
    8689    psMetadata *pendingexpArgs = psMetadataAlloc();

  • branches/pap/ippTools/src/difftool.c

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

  • branches/pap/ippTools/src/difftool.h

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

  • branches/pap/ippTools/src/difftoolConfig.c

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

  • branches/pap/ippTools/src/disttool.c

    r27542 r28484  
    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/pap/ippTools/src/disttoolConfig.c

    r27542 r28484  
    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/pap/ippTools/src/dqstatstool.c

    r27304 r28484  
    8585
    8686  if (label) {
    87     PXOPT_COPY_STR(config->args, where, "-label", "camRun.label", "==");
     87    pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "LIKE"); // define using cam label
    8888  }
    8989  // use psDBGenerateWhereConditionSQL because the SQL ends in a WHERE
    … …  
    654654        psError(PS_EXIT_CONFIG_ERROR, false, "Unable to find max value for %s",colname);
    655655        return(false);
    656       }     
     656      }
     657      psString filter = psMetadataLookupStr(&status,rule,"FILTER");
     658      if (!status) {
     659        status = true;
     660      }
     661      if (filter) {
     662        psString imfilter = psMetadataLookupStr(&status,tableRow,"FILTER");
     663        if (strcmp(filter,imfilter) != 0) {
     664          continue;
     665        }
     666      }
    657667      // Not happy with this being set to a F32. Can this ever be something else?
    658668      psF32 value      = psMetadataLookupF32(&status,tableRow,colname);

  • branches/pap/ippTools/src/flatcorr.c

    r26981 r28484  
    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/pap/ippTools/src/magictool.c

    r28041 r28484  
    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/pap/ippTools/src/pstamptool.c

    r28146 r28484  
    271271        uri,
    272272        NULL,   // outdir
     273        NULL,   // timestamp
    273274        0       // fault
    274275        )) {
    … …  
    547548    PXOPT_LOOKUP_BOOL(clearfault,config->args, "-clearfault",    false);
    548549
     550    if (!state && !label && !outProduct && !fault && !uri && !outdir && !name && !reqType && !clearfault) {
     551        psError(PS_ERR_UNKNOWN, true, "at least one set option is required");
     552        return false;
     553    }
     554
    549555    psMetadata *where = psMetadataAlloc();
    550556    PXOPT_COPY_S64(config->args, where, "-req_id",     "req_id", "==");
    … …  
    552558    PXOPT_COPY_S32(config->args, where, "-fault",      "fault", "==");
    553559    PXOPT_COPY_STR(config->args, where, "-state",      "state", "==");
     560    PXOPT_COPY_TIME(config->args, where, "-timestamp_begin", "timestamp", ">=");
     561    PXOPT_COPY_TIME(config->args, where, "-timestamp_end", "timestamp", "<=");
    554562    pxAddLabelSearchArgs(config, where, "-label",      "pstampRequest.label", "LIKE");
    555563    if (!psListLength(where->list)) {
    … …  
    559567    }
    560568
    561     psString query = psStringCopy("UPDATE pstampRequest SET");
     569    psString query = psStringCopy("UPDATE pstampRequest SET timestamp = UTC_TIMESTAMP()");
    562570
    563571    psString stateCheck = NULL;
    564     char c = ' ';
    565572    if (state) {
    566         psStringAppend(&query, "%c state = '%s'", c, state);
    567         c = ',';
     573        psStringAppend(&query, ", state = '%s'", state);
    568574        if (!strcmp(state, "goto_cleaned")) {
    569575            psStringAppend(&stateCheck, " AND state != 'cleaned'");
    … …  
    571577    }
    572578    if (label) {
    573         psStringAppend(&query, "%c label = '%s'", c, label);
    574         c = ',';
     579        psStringAppend(&query, ", label = '%s'", label);
    575580    }
    576581    if (outProduct) {
    577         psStringAppend(&query, "%c outProduct = '%s'", c, outProduct);
    578         c = ',';
     582        psStringAppend(&query, ", outProduct = '%s'", outProduct);
    579583    }
    580584    if (outdir) {
    581         psStringAppend(&query, "%c outdir = '%s'", c, outdir);
    582         c = ',';
     585        psStringAppend(&query, ", outdir = '%s'", outdir);
    583586    }
    584587    if (clearfault) {
    … …  
    587590            return false;
    588591        }
    589         psStringAppend(&query, "%c fault = 0", c);
    590         c = ',';
     592        psStringAppend(&query, ", fault = 0");
    591593    } else if (fault) {
    592         psStringAppend(&query, "%c fault = %d", c, fault);
    593         c = ',';
     594        psStringAppend(&query, ", fault = %d", fault);
    594595    }
    595596    if (uri) {
    596         psStringAppend(&query, "%c uri = '%s'", c, uri);
    597         c = ',';
     597        psStringAppend(&query, ", uri = '%s'", uri);
    598598    }
    599599    if (name) {
    600         psStringAppend(&query, "%c name = '%s'", c, name);
    601         c = ',';
     600        psStringAppend(&query, ", name = '%s'", name);
    602601    }
    603602    if (reqType) {
    604         psStringAppend(&query, "%c reqType = '%s'", c, reqType);
    605         c = ',';
    606     }
    607     if (c != ',') {
    608         psError(PS_ERR_UNKNOWN, true, "at least one set option is required");
    609         return false;
     603        psStringAppend(&query, ", reqType = '%s'", reqType);
    610604    }
    611605
    … …  
    876870
    877871    PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", false, false);
     872    PXOPT_LOOKUP_S64(req_id,    config->args, "-req_id", false, false);
    878873    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
    879874
    880     if (!job_id && !dep_id) {
    881         psError(PS_ERR_UNKNOWN, true, "at least -job_id or -dep_id is required");
     875    if (!job_id && !req_id && !dep_id) {
     876        psError(PS_ERR_UNKNOWN, true, "at least one of -job_id -req_id or -dep_id is required");
    882877        return false;
    883878    }
    … …  
    894889
    895890    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     891    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    896892    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     893    PXOPT_COPY_STR(config->args, where, "-state",  "pstampJob.state", "==");
    897894
    898895    psString query = pxDataGet("pstamptool_updatejob.sql");

  • branches/pap/ippTools/src/pstamptoolConfig.c

    r28106 r28484  
    103103    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,        "search by state", NULL);
    104104    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     105    psMetadataAddTime(updatereqArgs, PS_LIST_TAIL, "-timestamp_begin", 0, "search by timestamp (>=)", NULL);
     106    psMetadataAddTime(updatereqArgs, PS_LIST_TAIL, "-timestamp_end", 0, "search by timestamp (<=)", NULL);
    105107    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_state", 0,        "new state", NULL);
    106108    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_label", 0,        "new label", NULL);
    … …  
    158160    // -updatejob
    159161    psMetadata *updatejobArgs = psMetadataAlloc();
    160     psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    161     psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-dep_id", 0,            "dep_id for which to change state", 0);
     162    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id of jobs to update", 0);
     163    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "job_id of jobs to update", 0);
     164    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-dep_id", 0,            "dep_id of jobs to update", 0);
     165    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "current state of jobs to update", 0);
    162166    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-set_state", 0,            "new state", NULL);
    163167    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-set_fault", 0,            "new result", 0);

  • branches/pap/ippTools/src/pubtool.c

    r27071 r28484  
    151151    PS_ASSERT_PTR_NON_NULL(config, false);
    152152
    153     psMetadata *where = psMetadataAlloc(); // WHERE conditions
     153    psMetadata *diffWhere = psMetadataAlloc(); // WHERE conditions for diffs
     154    psMetadata *camWhere = psMetadataAlloc(); // WHERE conditions for cams
     155    psMetadata *diffphotWhere = psMetadataAlloc(); // WHERE conditions for diffphots
    154156
    155157    // required
    156158
    157159    // optional
    158     PXOPT_COPY_S64(config->args, where, "-client_id", "client_id", "==");
    159     pxAddLabelSearchArgs(config, where, "-label", "label", "=="); // define using newExp label
     160    PXOPT_COPY_S64(config->args, diffWhere, "-client_id", "client_id", "==");
     161    pxAddLabelSearchArgs(config, diffWhere, "-label", "diffRun.label", "==");
     162    pxAddLabelSearchArgs(config, diffWhere, "-data_group", "diffRun.data_group", "LIKE");
     163    PXOPT_COPY_TIME(config->args, diffWhere, "-dateobs_begin", "rawExp.dateobs", ">=");
     164    PXOPT_COPY_TIME(config->args, diffWhere, "-dateobs_end", "rawExp.dateobs", "<=");
     165    PXOPT_COPY_STR(config->args, diffWhere, "-filter", "rawExp.filter", "LIKE");
     166    PXOPT_COPY_STR(config->args, diffWhere, "-obs_mode", "rawExp.obs_mode", "LIKE");
     167
     168    PXOPT_COPY_S64(config->args, camWhere, "-client_id", "client_id", "==");
     169    pxAddLabelSearchArgs(config, camWhere, "-label", "camRun.label", "==");
     170    pxAddLabelSearchArgs(config, camWhere, "-data_group", "camRun.data_group", "LIKE");
     171    PXOPT_COPY_TIME(config->args, camWhere, "-dateobs_begin", "rawExp.dateobs", ">=");
     172    PXOPT_COPY_TIME(config->args, camWhere, "-dateobs_end", "rawExp.dateobs", "<=");
     173    PXOPT_COPY_STR(config->args, camWhere, "-filter", "rawExp.filter", "LIKE");
     174    PXOPT_COPY_STR(config->args, camWhere, "-obs_mode", "rawExp.obs_mode", "LIKE");
     175
     176    PXOPT_COPY_S64(config->args, diffphotWhere, "-client_id", "client_id", "==");
     177    pxAddLabelSearchArgs(config, diffphotWhere, "-label", "diffphotRun.label", "==");
     178    pxAddLabelSearchArgs(config, diffphotWhere, "-data_group", "diffphotRun.data_group", "LIKE");
     179    PXOPT_COPY_TIME(config->args, diffphotWhere, "-dateobs_begin", "rawExp.dateobs", ">=");
     180    PXOPT_COPY_TIME(config->args, diffphotWhere, "-dateobs_end", "rawExp.dateobs", "<=");
     181    PXOPT_COPY_STR(config->args, diffphotWhere, "-filter", "rawExp.filter", "LIKE");
     182    PXOPT_COPY_STR(config->args, diffphotWhere, "-obs_mode", "rawExp.obs_mode", "LIKE");
     183
     184    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     185    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     186    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     187    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     188    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    160189
    161190    psString query = pxDataGet("pubtool_definerun.sql"); // Query to run
    162191    if (!query) {
    163192        psError(PXTOOLS_ERR_SYS, false, "Failed to retreive SQL statement");
    164         psFree(where);
    165         return false;
     193        psFree(diffWhere);
     194        psFree(camWhere);
     195        return false;
     196    }
     197
     198    if (!rerun) {
     199        psStringAppend(&query, "\nWHERE publishRun.client_id IS NULL");
     200    }
     201
     202    if (limit) {
     203        psString limitString = psDBGenerateLimitSQL(limit);
     204        psStringAppend(&query, "\n%s", limitString);
     205        psFree(limitString);
    166206    }
    167207
    168208    if (!psDBTransaction(config->dbh)) {
    169209        psError(PS_ERR_UNKNOWN, false, "Database error");
    170         psFree(where);
    171         return false;
    172     }
    173 
    174     psString whereClause = psStringCopy(""); // Additional constraints to add to query
    175     if (psListLength(where->list)) {
    176         psString clause = psDBGenerateWhereConditionSQL(where, NULL);
    177         psStringAppend(&whereClause, "\n AND %s", clause);
     210        psFree(diffWhere);
     211        psFree(camWhere);
     212        psFree(diffphotWhere);
     213        return false;
     214    }
     215
     216    psString whereDiff = psStringCopy(""); // Additional constraints to add to query
     217    if (psListLength(diffWhere->list)) {
     218        psString clause = psDBGenerateWhereConditionSQL(diffWhere, NULL);
     219        psStringAppend(&whereDiff, "\n AND %s", clause);
    178220        psFree(clause);
    179221    }
    180     psFree(where);
    181 
    182     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
     222    psFree(diffWhere);
     223
     224    psString whereCam = psStringCopy(""); // Additional constraints to add to query
     225    if (psListLength(camWhere->list)) {
     226        psString clause = psDBGenerateWhereConditionSQL(camWhere, NULL);
     227        psStringAppend(&whereCam, "\n AND %s", clause);
     228        psFree(clause);
     229    }
     230    psFree(camWhere);
     231
     232    psString whereDiffphot = psStringCopy(""); // Additional constraints to add to query
     233    if (psListLength(diffphotWhere->list)) {
     234        psString clause = psDBGenerateWhereConditionSQL(diffphotWhere, NULL);
     235        psStringAppend(&whereDiffphot, "\n AND %s", clause);
     236        psFree(clause);
     237    }
     238    psFree(diffphotWhere);
     239
     240    if (!p_psDBRunQueryF(config->dbh, query, whereDiff, whereCam, whereDiffphot)) {
    183241        psError(PS_ERR_UNKNOWN, false, "Database error");
    184242        psFree(query);
    185         psFree(whereClause);
     243        psFree(whereDiff);
     244        psFree(whereCam);
     245        psFree(whereDiffphot);
    186246        if (!psDBRollback(config->dbh)) {
    187247            psError(PS_ERR_UNKNOWN, false, "Database error");
    … …  
    190250    }
    191251    psFree(query);
    192     psFree(whereClause);
     252    psFree(whereDiff);
     253    psFree(whereCam);
     254    psFree(whereDiffphot);
    193255
    194256    psArray *output = p_psDBFetchResult(config->dbh); // Output of SELECT statement
    … …  
    206268    }
    207269
     270    if (pretend) {
     271        if (!ippdbPrintMetadatas(stdout, output, "publishRun", !simple)) {
     272            psError(psErrorCodeLast(), false, "Failed to print array");
     273            psFree(output);
     274            return false;
     275        }
     276        psFree(output);
     277        return true;
     278    }
     279
    208280    for (int i = 0; i < output->n; i++) {
    209281        psMetadata *row = output->data[i]; // Row of interest
    210282        psS64 client = psMetadataLookupS64(NULL, row, "client_id"); // Client identifier
    211283        psS64 stage = psMetadataLookupS64(NULL, row, "stage_id");   // Stage identifier
    212         char *label = psMetadataLookupStr(NULL, row, "src_label");   // label from correct source
    213 
    214         if (!publishRunInsert(config->dbh, 0, client, stage, label, "new")) {
     284        const char *label = psMetadataLookupStr(NULL, row, "src_label");   // label from correct source
     285
     286        if (!publishRunInsert(config->dbh, 0, client, stage, set_label ? set_label : label, "new")) {
    215287            psError(PS_ERR_UNKNOWN, false, "Unable to add fileset");
    216288            psFree(output);
    … …  
    241313    PXOPT_COPY_STR(config->args, where, "-stage", "publishClient.stage", "==");
    242314    PXOPT_COPY_STR(config->args, where, "-comment", "publishClient.comment", "LIKE");
    243     PXOPT_COPY_STR(config->args, where, "-label", "publishRun.label", "==");
     315    pxAddLabelSearchArgs(config, where, "-label", "publishRun.label", "==");
    244316
    245317    // optional

  • branches/pap/ippTools/src/pubtoolConfig.c

    r27311 r28484  
    6262    // -definerun
    6363    psMetadata *definerunArgs = psMetadataAlloc();
     64    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-set_label", 0, "set label", NULL);
    6465    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-client_id", 0, "search by client_id", 0);
    6566    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "set and search by label", NULL);
     67    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by data_group", NULL);
     68    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-dateobs_begin", 0, "search for exposures by time (>=)", NULL);
     69    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-dateobs_end", 0, "search for exposures by time (<=)", NULL);
     70    psMetadataAddStr(definerunArgs,  PS_LIST_TAIL, "-filter", 0, "search for filter", NULL);
     71    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-obs_mode", 0, "search by observation mode", NULL);
     72    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-rerun", 0, "Re-run publish?", false);
     73    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-pretend", 0, "Pretend to define?", false);
     74    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
     75    psMetadataAddU64(definerunArgs, PS_LIST_TAIL, "-limit",  0, "limit result set", 0);
    6676
    6777    // -pending
    … …  
    7080    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-stage", 0, "search on source", NULL);
    7181    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
    72     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-label", 0, "search on label", NULL);
     82    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on label", NULL);
    7383    psMetadataAddBool(pendingArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
    7484    psMetadataAddU64(pendingArgs, PS_LIST_TAIL, "-limit",  0, "limit result set", 0);

  • branches/pap/ippTools/src/pxadd.c

    r26981 r28484  
    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/pap/ippTools/src/pxadd.h

    r25835 r28484  
    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/pap/ippTools/src/pxchip.c

    r28043 r28484  
    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/pap/ippTools/src/pxtools.c

    r28199 r28484  
    260260        psMetadataItem *item = NULL;
    261261        while ((item = psListGetAndIncrement(iter))) {
     262            psMetadataItem *new = psMetadataItemCopy(item);
    262263            // need to change the name and comment
    263             psFree (item->name);
    264             item->name = psStringCopy (field);
    265             psFree (item->comment);
    266             item->comment = psStringCopy (op);
    267             if (!psMetadataAddItem(where, item, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
     264            psFree (new->name);
     265            new->name = psStringCopy (field);
     266            psFree (new->comment);
     267            new->comment = psStringCopy (op);
     268            if (!psMetadataAddItem(where, new, PS_LIST_TAIL, PS_META_DUPLICATE_OK)) {
    268269                psError(psErrorCodeLast(), false, "failed to add item %s", field);
    269270                psFree(where);
    … …  
    271272            }
    272273        }
    273         psFree (iter);
     274        psFree(iter);
    274275    }
    275276    return true;
    … …  
    298299    PXOPT_LOOKUP_STR(data_group, config->args,  "-set_data_group", false, false);
    299300    PXOPT_LOOKUP_STR(note, config->args,        "-set_note", false, false);
     301
     302    if ((state)&&(!strcmp(state, "update"))) {
     303        fprintf(stderr, "'-updaterun -set_state update' is not supported.");
     304        if (!strcmp(runTable, "chipRun")) {
     305            fprintf(stderr, " Use -setimfiletoupdate.\n");
     306        } else {
     307            fprintf(stderr, " Use -setskyfiletoupdate.\n");
     308        }
     309        exit(1);
     310    }
    300311
    301312    psString dist_group = NULL;

  • branches/pap/ippTools/src/stacktool.c

    r28043 r28484  
    3939static bool addsumskyfileMode(pxConfig *config);
    4040static bool sumskyfileMode(pxConfig *config);
     41static bool sassskyfileMode(pxConfig *config);
    4142static bool revertsumskyfileMode(pxConfig *config);
     43static bool tosummaryMode(pxConfig *config);
     44static bool addsummaryMode(pxConfig *config);
    4245static bool pendingcleanuprunMode(pxConfig *config);
    4346static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    7578        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,         addsumskyfileMode);
    7679        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
     80        MODECASE(STACKTOOL_MODE_SASSSKYFILE,            sassskyfileMode);
    7781        MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileMode);
     82        MODECASE(STACKTOOL_MODE_TOSUMMARY,             tosummaryMode);
     83        MODECASE(STACKTOOL_MODE_ADDSUMMARY,            addsummaryMode);
    7884        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    7985        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    102108    exit(exit_status);
    103109}
     110//stackAssociationRow *association = pxStackAssociationDefine(data_group,tess_id,filter,skycell_id);
     111stackAssociationRow *pxStackAssociationDefine(pxConfig *config, psS64 stack_id) {
     112  psString select = pxDataGet("stacktool_associationdefine_select.sql");
     113  if (!select) {
     114    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     115    return false;
     116  }
     117
     118  psString idString = NULL;
     119  psStringAppend(&idString, "%" PRId64, stack_id);
     120  // Copy string to get around the issue with psStringSubstitute not believing
     121  // that select is a psString.
     122  psString rep = psStringCopy(select);
     123  psFree(select);
     124  select = rep;
     125  psStringSubstitute(&select, idString, "@STACK_ID@");
     126  psFree(idString);
     127
     128  if (!p_psDBRunQuery(config->dbh, select)) {
     129    psError(PS_ERR_UNKNOWN,false, "database error");
     130    psFree(select);
     131    return(NULL);
     132  }
     133  psFree(select);
     134  psArray *output = p_psDBFetchResult(config->dbh);
     135  if (!output) {
     136    psErrorCode err = psErrorCodeLast();
     137    switch (err) {
     138    case PS_ERR_DB_CLIENT:
     139      psError(PXTOOLS_ERR_SYS, false, "database error");
     140    case PS_ERR_DB_SERVER:
     141      psError(PXTOOLS_ERR_PROG, false, "database error");
     142    default:
     143      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     144    }
     145    return(NULL);
     146  }
     147  if (psArrayLength(output) != 1) {
     148    psWarning("stacktool: incorrect number of rows found");
     149    psFree(output);
     150    return(NULL);
     151  }
     152  psMetadata *outrow = psMetadataAlloc();
     153  for (long i = 0; i < output->n; i++) {
     154    psMetadata *row = output->data[i];
     155
     156    printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,row,"sass_id"),
     157           psMetadataLookupStr(NULL,row,"data_group"),
     158           psMetadataLookupStr(NULL,row,"tess_id"),
     159           psMetadataLookupStr(NULL,row,"filter"),
     160           psMetadataLookupStr(NULL,row,"projection_cell"));
     161
     162    if (psMetadataLookupS64(NULL,row,"sass_id") == PS_MAX_S64) {
     163      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",0);
     164    }
     165    else {
     166      psMetadataAddS64(outrow,PS_LIST_TAIL,"sass_id",PS_META_REPLACE,"",psMetadataLookupS64(NULL,row,"sass_id"));
     167    }
     168    psMetadataAddStr(outrow,PS_LIST_TAIL,"data_group",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"data_group"));
     169    psMetadataAddStr(outrow,PS_LIST_TAIL,"tess_id",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"tess_id"));
     170    psMetadataAddStr(outrow,PS_LIST_TAIL,"filter",PS_META_REPLACE,"",psMetadataLookupStr(NULL,row,"filter"));
     171    psMetadataAddStr(outrow,PS_LIST_TAIL,"projection_cell",PS_META_REPLACE,"",
     172                     psMetadataLookupStr(NULL,row,"projection_cell"));
     173  }
     174  printf("%" PRId64 " %s %s %s %s\n",psMetadataLookupS64(NULL,outrow,"sass_id"),
     175         psMetadataLookupStr(NULL,outrow,"data_group"),
     176         psMetadataLookupStr(NULL,outrow,"tess_id"),
     177         psMetadataLookupStr(NULL,outrow,"filter"),
     178         psMetadataLookupStr(NULL,outrow,"projection_cell"));
     179 
     180
     181  psFree(output);
     182  stackAssociationRow *sassRow = stackAssociationObjectFromMetadata(outrow);
     183  psFree(outrow);
     184  return(sassRow);
     185}
     186     
     187     
     188 
     189                                             
    104190
    105191
    … …  
    151237    PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_min",          "camProcessedExp.iq_m4", ">=");
    152238    PXOPT_COPY_F32(config->args,  where, "-select_iq_m4_max",          "camProcessedExp.iq_m4", "<=");
     239    PXOPT_COPY_F32(config->args,  where, "-select_zpt_obs_min",        "camProcessedExp.zpt_obs", ">=");
     240    PXOPT_COPY_F32(config->args,  where, "-select_zpt_obs_max",        "camProcessedExp.zpt_obs", "<=");
    153241
    154242    PXOPT_COPY_STR(config->args,  where, "-select_exp_type",           "rawExp.exp_type", "==");
    … …  
    370458            tess_id,
    371459            filter,
    372             NULL, // software_ver
     460            NULL, // software_ver
    373461            note);
    374462
    … …  
    395483        psFree(run);
    396484
     485        //CZW Add an association entry here.
     486        // Define the requested association, and insert it if it doesn't already exist
     487        stackAssociationRow *association = pxStackAssociationDefine(config,stack_id);
     488        psS64 sass_id;
     489        if (!association->sass_id) {
     490          psTrace("stacktool.association",2,"No required Association found. Adding.");
     491
     492          if (!stackAssociationInsertObject(config->dbh,association)) {
     493            if (!psDBRollback(config->dbh)) {
     494              psError(PS_ERR_UNKNOWN, false, "database error");
     495            }
     496            psError(PS_ERR_UNKNOWN, false, "database error");
     497            psFree(output);
     498            psFree(run);
     499            psFree(insert);
     500            psFree(list);
     501            psFree(association);
     502            if (!psDBRollback(config->dbh)) {
     503              psError(PS_ERR_UNKNOWN, false, "database error");
     504            }
     505            return(false);
     506          }
     507          sass_id = psDBLastInsertID(config->dbh);
     508          association->sass_id = sass_id;
     509        }
     510        // Insert the map entry for this row.
     511        stackAssociationMapRow *maprow = stackAssociationMapRowAlloc(sass_id,stack_id);
     512        if (!stackAssociationMapInsertObject(config->dbh,maprow)) {
     513          if (!psDBRollback(config->dbh)) {
     514            psError(PS_ERR_UNKNOWN, false, "database error");
     515          }
     516          psError(PS_ERR_UNKNOWN, false, "database error");
     517          psFree(output);
     518          psFree(run);
     519          psFree(insert);
     520          psFree(list);
     521          psFree(association);
     522          if (!psDBRollback(config->dbh)) {
     523            psError(PS_ERR_UNKNOWN, false, "database error");
     524          }
     525          return(false);
     526        }
     527       
     528       
    397529        // Create a suitable insertion query for this run
    398530        psString thisInsert = psStringCopy(insert);
    … …  
    527659        tess_id,
    528660        filter,
    529         NULL, // software_ver
     661        NULL, // software_ver
    530662        note);
    531663
    … …  
    552684    run->stack_id = psDBLastInsertID(config->dbh);
    553685
     686    //CZW Add an association entry here.
     687   
    554688    // insert the stackInputSkyfile rows
    555689    psListIterator *iter = psListIteratorAlloc(warp_ids->data.list, 0, false);
    … …  
    603737#endif
    604738    psMetadata *where = psMetadataAlloc();
    605     PXOPT_COPY_S64(config->args, where, "-stack_id",  "stack_id",   "==");
    606     PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
    607     PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     739    PXOPT_COPY_S64(config->args, where, "-stack_id",  "stackRun.stack_id",   "==");
     740    PXOPT_COPY_STR(config->args, where, "-label",     "stackRun.label",     "==");
     741    PXOPT_COPY_STR(config->args, where, "-state",     "stackRun.state",     "==");
     742    PXOPT_COPY_STR(config->args, where, "-sass_id",   "stackAssociationMap.sass_id",  "==");
    608743    if (!psListLength(where->list)) {
    609744        psFree(where);
    … …  
    612747    }
    613748
     749    //CZW join against stackAssociationMap
    614750    psString query = psStringCopy("UPDATE stackRun");
    615751
    … …  
    854990
    855991    psTrace("czw.test",1,"Received versions: pslib %s psmodules %s psphot %s ppstats %s ppstack %s streaks %s\n",
    856             ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppstack,ver_streaks);
     992            ver_pslib,ver_psmodules,ver_psphot,ver_ppstats,ver_ppstack,ver_streaks);
    857993    psString software_ver = NULL;
    858994    if ((ver_pslib)&&(ver_psmodules)) {
    … …  
    8711007      software_ver = pxMergeCodeVersions(software_ver,ver_streaks);
    8721008    }
    873    
     1009
    8741010    // default values
    8751011    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    9111047                               good_frac,
    9121048                               fault,
    913                                software_ver,
     1049                               software_ver,
    9141050                               quality
    9151051          )) {
    … …  
    9221058
    9231059    if (fault == 0) {
    924         // Set stackRun software if we are finished.
    925         if (!pxSetRunSoftware(config, "stackRun", "stack_id", stack_id, software_ver)) {
    926           if (!psDBRollback(config->dbh)) {
    927             psError(PS_ERR_UNKNOWN, false, "database error");
    928           }
    929           psError(PS_ERR_UNKNOWN, false, "failed to set stackRun.software_ver for stack_id: %" PRId64,
    930                   stack_id);
    931           return(false);
    932         }
     1060        // Set stackRun software if we are finished.
     1061        if (!pxSetRunSoftware(config, "stackRun", "stack_id", stack_id, software_ver)) {
     1062          if (!psDBRollback(config->dbh)) {
     1063            psError(PS_ERR_UNKNOWN, false, "database error");
     1064          }
     1065          psError(PS_ERR_UNKNOWN, false, "failed to set stackRun.software_ver for stack_id: %" PRId64,
     1066                  stack_id);
     1067          return(false);
     1068        }
    9331069
    9341070        if (!setstackRunState(config, stack_id, "full")) {
    … …  
    10381174}
    10391175
    1040 
    1041 static bool revertsumskyfileMode(pxConfig *config)
     1176static bool sassskyfileMode(pxConfig *config)
    10421177{
    10431178    PS_ASSERT_PTR_NON_NULL(config, false);
    10441179
    10451180    psMetadata *where = psMetadataAlloc();
    1046     PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
    1047     pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
    1048     PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    1049 
    1050     if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    1051         psFree(where);
    1052         psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    1053         return false;
    1054     }
    1055 
    1056     // Delete product
    1057     psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    1058     if (!delete) {
     1181    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociation.sass_id", "==");
     1182    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackAssociation.tess_id", "==");
     1183    PXOPT_COPY_STR(config->args, where, "-projection_cell", "stackAssociation.projection_cell", "==");
     1184    PXOPT_COPY_STR(config->args, where, "-filter", "stackAssociation.filter", "LIKE");
     1185    PXOPT_COPY_STR(config->args, where, "-data_group", "stackAssociation.data_group", "LIKE");
     1186
     1187//  The following three selectors are incompatible with the sql so omit them
     1188//    PXOPT_COPY_S64(config->args, where, "-warp_id", "warpRun.warp_id", "==");
     1189//     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
     1190//    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     1191
     1192    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1193
     1194    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1195    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1196
     1197    psString query = pxDataGet("stacktool_sassskyfile.sql");
     1198    if (!query) {
    10591199        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10601200        return false;
    … …  
    10631203    if (psListLength(where->list)) {
    10641204        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1065         psStringAppend(&delete, " AND %s", whereClause);
     1205        psStringAppend(&query, " WHERE %s", whereClause);
    10661206        psFree(whereClause);
    1067     }
    1068 
    1069     if (!p_psDBRunQuery(config->dbh, delete)) {
    1070         psError(PS_ERR_UNKNOWN, false, "database error");
    1071         psFree(delete);
    1072         psFree(where);
    1073         return false;
    1074     }
    1075     psFree(delete);
    1076 
    1077     int numRows = psDBAffectedRows(config->dbh); // Number of row affected
    1078     psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
    1079 
    1080     psFree(where);
    1081 
    1082     return true;
    1083 }
    1084 
    1085 
    1086 static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
    1087 {
    1088     PS_ASSERT_PTR_NON_NULL(state, false);
    1089 
    1090     // check that state is a valid string value
    1091     if (!pxIsValidState(state)) {
    1092         psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    1093         return false;
    1094     }
    1095 
    1096     char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
    1097     if (!p_psDBRunQueryF(config->dbh, query, state, stack_id)) {
    1098         psError(PS_ERR_UNKNOWN, false,
    1099                 "failed to change state for stack_id %"PRId64, stack_id);
    1100         return false;
    1101     }
    1102 
    1103     return true;
    1104 }
    1105 
    1106 #ifdef notdef
    1107 static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
    1108 {
    1109     PS_ASSERT_PTR_NON_NULL(state, false);
    1110 
    1111     // check that state is a valid string value
    1112     if (!pxIsValidState(state)) {
    1113         psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    1114         return false;
    1115     }
    1116 
    1117     char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
    1118     if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
    1119         psError(PS_ERR_UNKNOWN, false,
    1120                 "failed to change state for label %s", label);
    1121         return false;
    1122     }
    1123 
    1124     return true;
    1125 }
    1126 #endif
    1127 
    1128 static bool pendingcleanuprunMode(pxConfig *config)
    1129 {
    1130     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1131 
    1132     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1133     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1134 
    1135     psMetadata *where = psMetadataAlloc();
    1136     pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    1137 
    1138     psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    1139     if (!query) {
    1140         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1141         return false;
    1142     }
    1143 
    1144     if (where && psListLength(where->list)) {
    1145         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1146         psStringAppend(&query, " AND %s", whereClause);
    1147         psFree(whereClause);
    1148     }
     1207    } else if (!all) {
     1208        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1209        return false;
     1210    }
     1211
    11491212    psFree(where);
    11501213
    … …  
    11651228    psArray *output = p_psDBFetchResult(config->dbh);
    11661229    if (!output) {
    1167         psError(PS_ERR_UNKNOWN, false, "database error");
     1230        psErrorCode err = psErrorCodeLast();
     1231        switch (err) {
     1232            case PS_ERR_DB_CLIENT:
     1233                psError(PXTOOLS_ERR_SYS, false, "database error");
     1234            case PS_ERR_DB_SERVER:
     1235                psError(PXTOOLS_ERR_PROG, false, "database error");
     1236            default:
     1237                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1238        }
     1239
    11681240        return false;
    11691241    }
    … …  
    11741246    }
    11751247
     1248    if (psArrayLength(output)) {
     1249        if (!ippdbPrintMetadatas(stdout, output, "stackSumSkyfile", !simple)) {
     1250            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1251            psFree(output);
     1252            return false;
     1253        }
     1254    }
     1255
     1256    psFree(output);
     1257
     1258    return true;
     1259}
     1260
     1261
     1262static bool revertsumskyfileMode(pxConfig *config)
     1263{
     1264    PS_ASSERT_PTR_NON_NULL(config, false);
     1265
     1266    psMetadata *where = psMetadataAlloc();
     1267    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackSumSkyfile.stack_id", "==");
     1268    pxAddLabelSearchArgs(config, where, "-label", "stackRun.label", "==");
     1269    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
     1270
     1271    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     1272        psFree(where);
     1273        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1274        return false;
     1275    }
     1276
     1277    // Delete product
     1278    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     1279    if (!delete) {
     1280        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1281        return false;
     1282    }
     1283
     1284    if (psListLength(where->list)) {
     1285        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1286        psStringAppend(&delete, " AND %s", whereClause);
     1287        psFree(whereClause);
     1288    }
     1289
     1290    if (!p_psDBRunQuery(config->dbh, delete)) {
     1291        psError(PS_ERR_UNKNOWN, false, "database error");
     1292        psFree(delete);
     1293        psFree(where);
     1294        return false;
     1295    }
     1296    psFree(delete);
     1297
     1298    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     1299    psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
     1300
     1301    psFree(where);
     1302
     1303    return true;
     1304}
     1305
     1306
     1307static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state)
     1308{
     1309    PS_ASSERT_PTR_NON_NULL(state, false);
     1310
     1311    // check that state is a valid string value
     1312    if (!pxIsValidState(state)) {
     1313        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1314        return false;
     1315    }
     1316
     1317    char *query = "UPDATE stackRun SET state = '%s' WHERE stack_id = %"PRId64;
     1318    if (!p_psDBRunQueryF(config->dbh, query, state, stack_id)) {
     1319        psError(PS_ERR_UNKNOWN, false,
     1320                "failed to change state for stack_id %"PRId64, stack_id);
     1321        return false;
     1322    }
     1323
     1324    return true;
     1325}
     1326
     1327#ifdef notdef
     1328static bool setstackRunStateByLabel(pxConfig *config, const char *label, const char *state)
     1329{
     1330    PS_ASSERT_PTR_NON_NULL(state, false);
     1331
     1332    // check that state is a valid string value
     1333    if (!pxIsValidState(state)) {
     1334        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
     1335        return false;
     1336    }
     1337
     1338    char *query = "UPDATE stackRun SET state = '%s' WHERE label = '%s'";
     1339    if (!p_psDBRunQueryF(config->dbh, query, state, label)) {
     1340        psError(PS_ERR_UNKNOWN, false,
     1341                "failed to change state for label %s", label);
     1342        return false;
     1343    }
     1344
     1345    return true;
     1346}
     1347#endif
     1348static bool tosummaryMode(pxConfig *config) {
     1349  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1350 
     1351  psMetadata *where = psMetadataAlloc();
     1352  PXOPT_COPY_S64(config->args, where, "-stack_id",    "stackSumSkyfile.warp_id", "==");
     1353  PXOPT_COPY_S64(config->args, where, "-sass_id",     "stackAssociationMap.sass_id", "==");
     1354  PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackSumSkyfile.tess_id", "==");
     1355  PXOPT_COPY_STR(config->args, where, "-state",      "stackRun.state", "==");
     1356  PXOPT_COPY_STR(config->args, where, "-filter",    "stackRun.filter", "LIKE");
     1357  pxAddLabelSearchArgs (config, where, "-label",   "stackRun.label", "LIKE");
     1358  pxAddLabelSearchArgs (config, where, "-data_group",   "stackRun.data_group", "LIKE");
     1359 
     1360  PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     1361
     1362  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1363  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1364 
     1365  // find all rawImfiles matching the default query
     1366  psString query = pxDataGet("stacktool_tosummary.sql");
     1367  if (!query) {
     1368    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1369    return false;
     1370  }
     1371
     1372  // generate where strings for arguments that require extra processing
     1373  // beyond PXOPT_COPY*
     1374  if (psListLength(where->list)) {
     1375    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1376    psStringAppend(&query, " AND %s", whereClause);
     1377    psFree(whereClause);
     1378  } else if (!all) {
     1379    psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     1380    return false;
     1381  }
     1382 
     1383  psFree(where);
     1384
     1385  // treat limit == 0 as "no limit"
     1386  if (limit) {
     1387    psString limitString = psDBGenerateLimitSQL(limit);
     1388    psStringAppend(&query, " %s", limitString);
     1389    psFree(limitString);
     1390  }
     1391
     1392  if (!p_psDBRunQuery(config->dbh, query)) {
     1393    psError(PS_ERR_UNKNOWN, false, "database error");
     1394    psFree(query);
     1395    return false;
     1396  }
     1397  psFree(query);
     1398
     1399  psArray *output = p_psDBFetchResult(config->dbh);
     1400  if (!output) {
     1401    psErrorCode err = psErrorCodeLast();
     1402    switch (err) {
     1403    case PS_ERR_DB_CLIENT:
     1404      psError(PXTOOLS_ERR_SYS, false, "database error");
     1405    case PS_ERR_DB_SERVER:
     1406      psError(PXTOOLS_ERR_PROG, false, "database error");
     1407    default:
     1408      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1409    }
     1410   
     1411    return false;
     1412  }
     1413  if (!psArrayLength(output)) {
     1414    psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1415    psFree(output);
     1416    return true;
     1417  }
     1418 
     1419  if (psArrayLength(output)) {
    11761420    // negative simple so the default is true
    1177     if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) {
    1178         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1179         psFree(output);
    1180         return false;
    1181     }
    1182 
    1183     psFree(output);
    1184 
    1185     return true;
    1186 }
    1187 
    1188 static bool pendingcleanupskyfileMode(pxConfig *config)
     1421    if (!ippdbPrintMetadatas(stdout, output, "stackRun", !simple)) {
     1422      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1423      psFree(output);
     1424      return false;
     1425    }
     1426  }
     1427 
     1428  psFree(output);
     1429  return(true);
     1430}
     1431static bool addsummaryMode(pxConfig *config) {
     1432  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1433
     1434  PXOPT_LOOKUP_S64(sass_id, config->args, "-sass_id", true, false);
     1435  PXOPT_LOOKUP_STR(projection_cell, config->args, "-projection_cell", true, false);
     1436  PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
     1437
     1438  psString query = pxDataGet("stacktool_addsummary.sql");
     1439  if (!query) {
     1440    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1441    return(false);
     1442  }
     1443  if (!p_psDBRunQueryF(config->dbh, query, sass_id, projection_cell, path_base)) {
     1444    psError(PS_ERR_UNKNOWN, false, "database error");
     1445    psFree(query);
     1446    return(false);
     1447  }
     1448  psS64 numUpdated = psDBAffectedRows(config->dbh);
     1449 
     1450  if (numUpdated != 1) {
     1451    psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1452    psFree(query);
     1453    return false;
     1454  }
     1455 
     1456  psFree(query);
     1457
     1458  // Print anything here?
     1459 
     1460  return(true);
     1461}
     1462
     1463static bool pendingcleanuprunMode(pxConfig *config)
    11891464{
    11901465    PS_ASSERT_PTR_NON_NULL(config, NULL);
    11911466
    1192     PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    11931467    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    11941468    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    11951469
    11961470    psMetadata *where = psMetadataAlloc();
    1197     if (stack_id) {
    1198         PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    1199     }
     1471    PXOPT_COPY_S64(config->args, where, "-stack_id", "stackRun.stack_id", "==");
     1472    PXOPT_COPY_S64(config->args, where, "-sass_id", "stackAssociationMap.sass_id", "==");
     1473   
    12001474    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    12011475
    1202     psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
     1476    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    12031477    if (!query) {
    12041478        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    12391513
    12401514    // negative simple so the default is true
    1241     if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) {
     1515    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) {
    12421516        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    12431517        psFree(output);
    … …  
    12501524}
    12511525
    1252 
    1253 static bool donecleanupMode(pxConfig *config)
     1526static bool pendingcleanupskyfileMode(pxConfig *config)
    12541527{
    12551528    PS_ASSERT_PTR_NON_NULL(config, NULL);
    12561529
     1530    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
    12571531    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    12581532    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    12591533
    12601534    psMetadata *where = psMetadataAlloc();
    1261     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    1262 
    1263     psString query = pxDataGet("stacktool_donecleanup.sql");
     1535    if (stack_id) {
     1536        PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     1537    }
     1538    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
     1539
     1540    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
    12641541    if (!query) {
    12651542        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    … …  
    13001577
    13011578    // negative simple so the default is true
     1579    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) {
     1580        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1581        psFree(output);
     1582        return false;
     1583    }
     1584
     1585    psFree(output);
     1586
     1587    return true;
     1588}
     1589
     1590
     1591static bool donecleanupMode(pxConfig *config)
     1592{
     1593    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1594
     1595    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1596    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1597
     1598    psMetadata *where = psMetadataAlloc();
     1599    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1600    PXOPT_COPY_STR(config->args, where, "-sass_id", "sass_id", "==");
     1601
     1602    psString query = pxDataGet("stacktool_donecleanup.sql");
     1603    if (!query) {
     1604        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1605        return false;
     1606    }
     1607
     1608    if (where && psListLength(where->list)) {
     1609        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1610        psStringAppend(&query, " AND %s", whereClause);
     1611        psFree(whereClause);
     1612    }
     1613    psFree(where);
     1614
     1615    // treat limit == 0 as "no limit"
     1616    if (limit) {
     1617        psString limitString = psDBGenerateLimitSQL(limit);
     1618        psStringAppend(&query, " %s", limitString);
     1619        psFree(limitString);
     1620    }
     1621
     1622    if (!p_psDBRunQuery(config->dbh, query)) {
     1623        psError(PS_ERR_UNKNOWN, false, "database error");
     1624        psFree(query);
     1625        return false;
     1626    }
     1627    psFree(query);
     1628
     1629    psArray *output = p_psDBFetchResult(config->dbh);
     1630    if (!output) {
     1631        psError(PS_ERR_UNKNOWN, false, "database error");
     1632        return false;
     1633    }
     1634    if (!psArrayLength(output)) {
     1635        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1636        psFree(output);
     1637        return true;
     1638    }
     1639
     1640    // negative simple so the default is true
    13021641    if (!ippdbPrintMetadatas(stdout, output, "stackDoneCleanup", !simple)) {
    13031642        psError(PS_ERR_UNKNOWN, false, "failed to print array");
    … …  
    13291668}
    13301669
     1670//CZW I have not added sass information to the export/import run modes yet.
    13311671bool exportrunMode(pxConfig *config)
    13321672{

  • branches/pap/ippTools/src/stacktool.h

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

  • branches/pap/ippTools/src/stacktoolConfig.c

    r28043 r28484  
    8888    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_min", 0, "define min iq_m4", NAN);
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_iq_m4_max", 0, "define max iq_m4", NAN);
     90    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_zpt_obs_min", 0, "define min zero point", NAN);
     91    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_zpt_obs_max", 0, "define max zero point", NAN);
    9092    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random", 0, "use this number of random elements", 0);
    9193    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_num", 0, "minimum number of inputs", 0);
    … …  
    197199    psMetadataAddBool(sumskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
    198200
     201    // -sassskyfile
     202    psMetadata *sassskyfileArgs = psMetadataAlloc();
     203    psMetadataAddS64(sassskyfileArgs, PS_LIST_TAIL, "-sass_id", 0,           "search by stack association ID", 0);
     204    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     205    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-projection_cell", 0,         "search by projection cell", 0);
     206
     207    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-data_group", 0,        "search by stackAssociation.data_group (LIKE comparison)", NULL);
     208    psMetadataAddStr(sassskyfileArgs, PS_LIST_TAIL, "-filter", 0,            "search by filter (LIKE comparison)", NULL);
     209    psMetadataAddU64(sassskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     210    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     211    psMetadataAddBool(sassskyfileArgs, PS_LIST_TAIL, "-all",  0,            "enable search without arguments", false);
     212
    199213    // -revertsumskyfile
    200214    psMetadata *revertsumskyfileArgs= psMetadataAlloc();
    … …  
    204218    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    205219
     220    // -tosummary
     221    psMetadata *tosummaryArgs = psMetadataAlloc();
     222    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-stack_id", 0,  "search by stack ID", 0);
     223    psMetadataAddS64(tosummaryArgs, PS_LIST_TAIL, "-sass_id", 0,  "search by stack association ID", 0);
     224    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-tess_id", 0,   "search by tessellation ID", NULL);
     225    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-state", 0,     "search by state", NULL);
     226    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-filter", 0,    "search by filter", NULL);
     227    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison)", NULL);
     228    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-data_group", PS_META_DUPLICATE_OK, "search by stackRun data_group (LIKE comparison)", NULL);
     229    psMetadataAddStr(tosummaryArgs, PS_LIST_TAIL, "-dist_group", PS_META_DUPLICATE_OK, "search by stackRun dist_group (LIKE comparison)", NULL);
     230
     231    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     232    psMetadataAddU64(tosummaryArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     233    psMetadataAddBool(tosummaryArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     234
     235    // -addsummary
     236    psMetadata *addsummaryArgs = psMetadataAlloc();
     237    psMetadataAddS64(addsummaryArgs, PS_LIST_TAIL, "-sass_id", 0,      "set stack Association ID", 0);
     238    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-projection_cell", 0, "set projection cell", NULL);
     239    psMetadataAddStr(addsummaryArgs, PS_LIST_TAIL, "-path_base", 0,     "set summary path base", NULL);             
     240   
    206241    // -pendingcleanuprun
    207242    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
    … …  
    252287    PXOPT_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    253288    PXOPT_ADD_MODE("-sumskyfile",      "list results of stackRun", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     289    PXOPT_ADD_MODE("-sassskyfile",      "list results of stackAssociation", STACKTOOL_MODE_SASSSKYFILE,      sassskyfileArgs);
    254290    PXOPT_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
    255291    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", STACKTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
    … …  
    257293    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     STACKTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    258294    PXOPT_ADD_MODE("-updatesumskyfile",      "update fault code for sumskyfile",     STACKTOOL_MODE_UPDATESUMSKYFILE,          updatesumskyfileArgs);
     295    PXOPT_ADD_MODE("-tosummary",            "show runs that can be summarized", STACKTOOL_MODE_TOSUMMARY, tosummaryArgs);
     296    PXOPT_ADD_MODE("-addsummary",           "add entry to the summary table", STACKTOOL_MODE_ADDSUMMARY, addsummaryArgs);
    259297    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", STACKTOOL_MODE_EXPORTRUN, exportrunArgs);
    260298    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           STACKTOOL_MODE_IMPORTRUN, importrunArgs);

  • branches/pap/ippTools/src/warptool.c

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

  • branches/pap/ippTools/src/warptool.h

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

  • branches/pap/ippTools/src/warptoolConfig.c

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