IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 7, 2009, 4:08:25 PM (17 years ago)
Author:
Paul Price
Message:

Merging trunk (r25026) to get up-to-date on old branch.

Location:
branches/pap
Files:
44 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/pap

  • branches/pap/ippTools/src

    • Property svn:ignore

      •  

        old new  
        3434disttool
        3535receivetool
         36
         37pubtool

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

    r23921 r25027  
    1919        regtool \
    2020        stacktool \
    21         warptool
    22 
    23 #       receivetool
     21        warptool \
     22        receivetool \
     23        pubtool
    2424
    2525
    … …  
    6060        regtool.h \
    6161        stacktool.h \
    62         warptool.h
     62        warptool.h \
     63        pubtool.h
    6364
    6465lib_LTLIBRARIES = libpxtools.la
    … …  
    221222    receivetoolConfig.c
    222223
     224pubtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     225pubtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     226pubtool_SOURCES = \
     227    pubtool.c \
     228    pubtoolConfig.c
     229
    223230clean-local:
    224231        -rm -f TAGS

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

    r23920 r25027  
    491491    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    492492    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
     493   
     494    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    493495
    494496    // generate restrictions
    … …  
    614616
    615617    // since there is only one exp per 'new' set camRun.state = 'full'
    616     if (!pxcamRunSetState(config, row->cam_id, "full")) {
     618    if (!pxcamRunSetState(config, row->cam_id, "full", magicked)) {
    617619        psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
    618620        psFree(row);
    … …  
    766768    pxcamGetSearchArgs (config, where);
    767769    PXOPT_COPY_S64(config->args, where, "-cam_id",    "camRun.cam_id",         "==");
    768     PXOPT_COPY_STR(config->args, where, "-label",     "camRun.label",          "==");
     770    pxAddLabelSearchArgs (config, where, "-label",    "camRun.label",     "==");
    769771    PXOPT_COPY_STR(config->args, where, "-reduction", "camRun.reduction",      "==");
    770772    PXOPT_COPY_S16(config->args, where, "-fault", "camProcessedExp.fault", "==");
    … …  
    953955
    954956    psMetadata *where = psMetadataAlloc();
    955     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     957    pxAddLabelSearchArgs (config, where, "-label", "camRun.label", "==");
    956958
    957959    psString query = pxDataGet("camtool_pendingcleanuprun.sql");

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

    r23920 r25027  
    167167    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    168168    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     169    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-magicked",   0,         "set magicked", 0);
    169170
    170171    // -processedexp
    … …  
    187188    pxcamSetSearchArgs(revertprocessedexpArgs);
    188189    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-cam_id",   0,            "search by cam_id", 0);
    189     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-label",    0,            "search by camRun label", NULL);
     190    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "search by camRun label", NULL);
    190191    psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-reduction",0,            "search by camRun reduction class", NULL);
    191192    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",     0,            "search by fault code", 0);

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

    r23919 r25027  
    473473    PXOPT_LOOKUP_F32(n_cr, config->args,           "-n_cr", false, false);
    474474    PXOPT_LOOKUP_STR(path_base, config->args,      "-path_base", false, false);
    475     PXOPT_LOOKUP_BOOL(magicked, config->args,      "-magicked", false);
     475    PXOPT_LOOKUP_S64(magicked, config->args,       "-magicked", false, false);
    476476
    477477    // default values
    … …  
    601601    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    602602    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
    603     PXOPT_COPY_S32(config->args, where, "-magicked", "chipRun.magicked", "==");
     603    PXOPT_COPY_S64(config->args, where, "-magicked", "chipRun.magicked", "==");
    604604
    605605    if (!psListLength(where->list) &&
    … …  
    676676    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
    677677    PXOPT_COPY_STR(config->args, where, "-class_id", "chipProcessedImfile.class_id", "==");
    678     // require a single label
    679     PXOPT_COPY_STR(config->args, where, "-label", "chipRun.label", "==");
     678    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "==");
    680679    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
    681680    PXOPT_COPY_S16(config->args, where, "-fault", "chipProcessedImfile.fault", "==");

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

    r23919 r25027  
    169169    psMetadataAddStr(revertprocessedimfileArgs,  PS_LIST_TAIL, "-class_id",           0, "search by class ID", NULL);
    170170    psMetadataAddStr(revertprocessedimfileArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
    171     psMetadataAddStr(revertprocessedimfileArgs,  PS_LIST_TAIL, "-label",              0, "search by chipRun label (LIKE comparison)", NULL);
     171    psMetadataAddStr(revertprocessedimfileArgs,  PS_LIST_TAIL, "-label",              PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
    172172    pxchipSetSearchArgs(revertprocessedimfileArgs);
    173173    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);

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

    r18561 r25027  
    7171}
    7272
     73# define PXOPT_COPY_NULLTEST_F32(from, to, oldname, newname, comment) \
     74{ \
     75    bool status = false; \
     76    psF32 var = psMetadataLookupF32(&status, from, oldname); \
     77    if (!status) { \
     78        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     79        return false; \
     80    } \
     81    if (!isnan(var)) { \
     82        if (!psMetadataAddF32(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, var)) { \
     83            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     84            psFree(to); \
     85            return false; \
     86        } \
     87        if (!psMetadataAddTime(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, "==", NULL)) { \
     88            psError(PS_ERR_UNKNOWN, false, "failed to add NULL test " newname); \
     89            psFree(to); \
     90            return false; \
     91        } \
     92    } \
     93}
     94
    7395static bool searchMode(pxConfig *config)
    7496{
    … …  
    89111
    90112    // airmass_min  < airmass  < airmass_max
    91     PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_min", "<=");
    92     PXOPT_COPY_F32(config->args, where, "-airmass", "airmass_max", ">=");
     113    PXOPT_COPY_NULLTEST_F32(config->args, where, "-airmass", "airmass_min", "<=");
     114    PXOPT_COPY_NULLTEST_F32(config->args, where, "-airmass", "airmass_max", ">=");
    93115
    94116    // exp_time_min < exp_time < exp_time_max
    95     PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
    96     PXOPT_COPY_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
     117    PXOPT_COPY_NULLTEST_F32(config->args, where, "-exp_time", "exp_time_min", "<=");
     118    PXOPT_COPY_NULLTEST_F32(config->args, where, "-exp_time", "exp_time_max", ">=");
    97119
    98120    // ccd_temp_min < ccd_temp < ccd_temp_max
    99     PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
    100     PXOPT_COPY_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
     121    PXOPT_COPY_NULLTEST_F32(config->args, where, "-ccd_temp", "ccd_temp_min", "<=");
     122    PXOPT_COPY_NULLTEST_F32(config->args, where, "-ccd_temp", "ccd_temp_max", ">=");
    101123
    102124    PXOPT_COPY_F64(config->args, where, "-posang", "posang_min", "<=");

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

    r23829 r25027  
    276276    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    277277    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    278     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    279     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     278    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     279    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    280280    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);
    281281    PXOPT_LOOKUP_TIME(time_end, config->args, "-time_end", false, false);
    … …  
    521521    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    522522    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    523     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    524     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     523    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     524    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    525525
    526526    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    557557    PXOPT_COPY_F64(config->args, where, "-select_posang_min", "posang", ">=");
    558558    PXOPT_COPY_F64(config->args, where, "-select_posang_max", "posang", "<=");
    559     PXOPT_COPY_F64(config->args, where, "-select_solang_min", "solang", ">=");
    560     PXOPT_COPY_F64(config->args, where, "-select_solang_max", "solang", "<=");
     559    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_min", "sun_angle", ">=");
     560    PXOPT_COPY_F64(config->args, where, "-select_sun_angle_max", "sun_angle", "<=");
     561    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_min", "sun_alt", ">=");
     562    PXOPT_COPY_F64(config->args, where, "-select_sun_alt_max", "sun_alt", "<=");
     563
     564    PXOPT_COPY_F64(config->args, where, "-select_moon_angle_min", "moon_angle", ">=");
     565    PXOPT_COPY_F64(config->args, where, "-select_moon_angle_max", "moon_angle", "<=");
     566    PXOPT_COPY_F64(config->args, where, "-select_moon_alt_min", "moon_alt", ">=");
     567    PXOPT_COPY_F64(config->args, where, "-select_moon_alt_max", "moon_alt", "<=");
     568    PXOPT_COPY_F64(config->args, where, "-select_moon_phase_min", "moon_phase", ">=");
     569    PXOPT_COPY_F64(config->args, where, "-select_moon_phase_max", "moon_phase", "<=");
     570    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
    561571
    562572    if (!psListLength(where->list)) {
    … …  
    767777    PXOPT_LOOKUP_F64(posang_min, config->args, "-set_posang_min", false, false);
    768778    PXOPT_LOOKUP_F64(posang_max, config->args, "-set_posang_max", false, false);
    769     PXOPT_LOOKUP_F64(solang_min, config->args, "-set_solang_min", false, false);
    770     PXOPT_LOOKUP_F64(solang_max, config->args, "-set_solang_max", false, false);
     779    PXOPT_LOOKUP_F64(solang_min, config->args, "-set_sun_angle_min", false, false);
     780    PXOPT_LOOKUP_F64(solang_max, config->args, "-set_sun_angle_max", false, false);
    771781    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    772782    PXOPT_LOOKUP_TIME(time_begin, config->args, "-set_time_begin", false, false);
    … …  
    16051615    PXOPT_LOOKUP_F64(posang_min, config->args, "-posang_min", false, false);
    16061616    PXOPT_LOOKUP_F64(posang_max, config->args, "-posang_max", false, false);
    1607     PXOPT_LOOKUP_F64(solang_min, config->args, "-solang_min", false, false);
    1608     PXOPT_LOOKUP_F64(solang_max, config->args, "-solang_max", false, false);
     1617    PXOPT_LOOKUP_F64(solang_min, config->args, "-sun_angle_min", false, false);
     1618    PXOPT_LOOKUP_F64(solang_max, config->args, "-sun_angle_max", false, false);
    16091619    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    16101620    PXOPT_LOOKUP_TIME(time_begin, config->args, "-time_begin", false, false);

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

    r23688 r25027  
    6868    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    6969    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    70     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    71     psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     70    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     71    psMetadataAddF64(definebytagArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
     72
    7273    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    7374    psMetadataAddTime(definebytagArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
    … …  
    99100    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    100101    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    101     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    102     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     102    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     103    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    103104    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    104105    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);
    … …  
    124125    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min",  0,            "define min rotator position angle", NAN);
    125126    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max",  0,            "define max rotator position angle", NAN);
    126     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min",  0,            "define min solar angle", NAN);
    127     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max",  0,            "define max solar angle", NAN);
     127    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min",  0,            "define min solar angle", NAN);
     128    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max",  0,            "define max solar angle", NAN);
     129    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_min",  0,            "define min solar altitude", NAN);
     130    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_alt_max",  0,            "define max solar altitude", NAN);
     131
     132    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_angle_min",  0,          "define min moon angle", NAN);
     133    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_angle_max",  0,          "define max moon angle", NAN);
     134    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_alt_min",  0,            "define min moon alt", NAN);
     135    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_alt_max",  0,            "define max moon alt", NAN);
     136    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_phase_min",  0,          "define min moon phase", NAN);
     137    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_moon_phase_max",  0,          "define max moon phase", NAN);
     138    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",                0,          "search by comment field (LIKE comparison)", NULL);
     139
    128140    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "print the exposures that would be included in the detrend run and exit", false);
    129141    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class for processing", NULL);
    … …  
    154166    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_min",  0,            "define rotator position angle", NAN);
    155167    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_posang_max",  0,            "define rotator position angle", NAN);
    156     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_min",  0,            "define solar angle", NAN);
    157     psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_solang_max",  0,            "define solar angle", NAN);
     168    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_min",  0,            "define solar angle", NAN);
     169    psMetadataAddF64(definebydetrunArgs, PS_LIST_TAIL, "-set_sun_angle_max",  0,            "define solar angle", NAN);
    158170    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_registered",  0,            "time detrend run was registered", now);
    159171    psMetadataAddTime(definebydetrunArgs, PS_LIST_TAIL, "-set_time_begin",  0,            "start of period to apply detrend too", NULL);
    … …  
    830842    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
    831843    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    832     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    833     psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     844    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     845    psMetadataAddF64(register_detrendArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    834846    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    835847    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-time_begin",  0,            "detrend applies to exposures taken during this period", NULL);

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

    r23940 r25027  
    4040static bool revertdiffskyfileMode(pxConfig *config);
    4141static bool definepoprunMode(pxConfig *config);
    42 static bool definebyqueryMode(pxConfig *config);
     42static bool definewarpstackMode(pxConfig *config);
    4343static bool definewarpwarpMode(pxConfig *config);
    4444static bool pendingcleanuprunMode(pxConfig *config);
    … …  
    4949static bool importrunMode(pxConfig *config);
    5050
    51 static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, bool magicked);
     51static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
    5252static bool diffRunComplete(pxConfig *config);
    5353
    … …  
    7979        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE,     revertdiffskyfileMode);
    8080        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,          definepoprunMode);
    81         MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY,         definebyqueryMode);
     81        MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,         definewarpstackMode);
    8282        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
    8383        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    … …  
    116116    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
    117117    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
     118    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
     119    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    118120    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    119121    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    120     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    121122
    122123    // default
    … …  
    133134            registered,
    134135            tess_id,
    135             exp_id,
     136            bothways,
     137            exposure,
    136138            false
    137139    );
    138140    if (!run) {
    139141        psError(PS_ERR_UNKNOWN, false, "failed to alloc diffRun object");
    140         return true;
     142        return false;
    141143    }
    142144    if (!diffRunInsertObject(config->dbh, run)) {
    143145        psError(PS_ERR_UNKNOWN, false, "database error");
    144146        psFree(run);
    145         return true;
     147        return false;
    146148    }
    147149
    … …  
    150152
    151153    if (!diffRunPrintObject(stdout, run, !simple)) {
    152             psError(PS_ERR_UNKNOWN, false, "failed to print object");
    153             psFree(run);
    154             return false;
     154        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     155        psFree(run);
     156        return false;
    155157    }
    156158
    … …  
    487489    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    488490    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    489     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false);
    490491    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (fault == 0), false);
    491492
    … …  
    511512    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    512513    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    513     PXOPT_LOOKUP_BOOL(magicked, config->args, "-magicked", false);
     514    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    514515
    515516    if (!psDBTransaction(config->dbh)) {
    … …  
    521522                           diff_id,
    522523                           skycell_id,
    523                            uri,
    524524                           path_base,
    525525                           "full",
    … …  
    582582    PXOPT_COPY_STR(config->args, where, "-skycell_id", "diffInputSkyfile.skycell_id", "==");
    583583    PXOPT_COPY_S64(config->args, where,  "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
    584     PXOPT_COPY_STR(config->args, where, "-tess_id", "diffSkyfile.tess_id", "==");
     584    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    585585    PXOPT_COPY_S16(config->args, where, "-fault", "diffSkyfile.fault", "==");
    586586    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    … …  
    662662    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
    663663
     664    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
     665        psFree(where);
     666        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     667        return false;
     668    }
     669
    664670    if (!psDBTransaction(config->dbh)) {
    665671        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    695701        psFree(query);
    696702
    697         psLogMsg("diftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     703        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    698704    }
    699705
    … …  
    739745
    740746
    741 static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, bool magicked)
     747static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked)
    742748{
    743749    PS_ASSERT_PTR_NON_NULL(state, false);
    … …  
    749755    }
    750756
    751     char *query = "UPDATE diffRun SET state = '%s', magicked = %d WHERE diff_id = %"PRId64;
     757    char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    752758
    753759    if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    … …  
    771777                         psS64 template_warp_id, // Warp identifier for template image, PS_MAX_S64 for none
    772778                         psS64 template_stack_id, // Stack identifier for template image, PS_MAX_S64 for none
    773                          psS64 exp_id, // exposure id for input_warp_id (if defined)
    774779                         pxConfig *config // Configuration
    775780                         )
    … …  
    802807            registered,
    803808            tess_id,
    804             exp_id,
    805             false       // magicked
     809            false,
     810            false,
     811            0       // magicked
    806812    );
    807813
    … …  
    882888    PXOPT_LOOKUP_S64(input_warp_id, config->args, "-input_warp_id", false, false);
    883889    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    884     PXOPT_LOOKUP_S64(exp_id, config->args, "-exp_id", false, false);
    885890    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    886891
    … …  
    902907        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    903908                "No input has been defined (-input_stack_id or -input_warp_id)");
    904         return false;
    905     }
    906     if (input_warp_id && !exp_id) {
    907         psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    908                 "-exp_id is required with -input_warp_id.");
    909909        return false;
    910910    }
    … …  
    917917                      template_warp_id ? template_warp_id : PS_MAX_S64,
    918918                      template_stack_id ? template_stack_id : PS_MAX_S64,
    919                       exp_id ? exp_id : PS_MAX_S64,
    920919                      config)) {
    921920        psError(PS_ERR_UNKNOWN, false, "failed to create populated diffRun");
    … …  
    935934
    936935
    937 static bool definebyqueryMode(pxConfig *config)
     936static bool definewarpstackMode(pxConfig *config)
    938937{
    939938    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    944943
    945944    PXOPT_COPY_S64(config->args, expWhere, "-exp_id", "exp_id", "==");
     945    PXOPT_COPY_STR(config->args, expWhere, "-filter", "filter", "==");
    946946    PXOPT_COPY_S64(config->args, warpWhere, "-warp_id", "warpRun.warp_id", "==");
    947947    PXOPT_COPY_STR(config->args, warpWhere, "-skycell_id", "warpSkyfile.skycell_id", "==");
    948948    PXOPT_COPY_STR(config->args, warpWhere, "-tess_id", "warpRun.tess_id", "==");
    949     PXOPT_COPY_STR(config->args, warpWhere, "-filter", "rawExp.filter", "==");
    950949    PXOPT_COPY_STR(config->args, warpWhere, "-warp_label", "warpRun.label", "==");
    951950    PXOPT_COPY_F32(config->args, warpWhere,  "-good_frac", "warpSkyfile.good_frac", ">=");
    … …  
    960959    PXOPT_LOOKUP_BOOL(reRun, config->args, "-rerun", false);
    961960    PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
     961    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    962962
    963963    // find all things to queue
    964     psString query = pxDataGet("difftool_definebyquery_part1.sql");
     964    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    965965    if (!query) {
    966966        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    10571057    }
    10581058
     1059    if (pretend) {
     1060        // negative simple so the default is true
     1061        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     1062            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1063            psFree(output);
     1064            return false;
     1065        }
     1066        psFree(output);
     1067        return true;
     1068    }
     1069
    10591070    // create temporary table
    1060     query = pxDataGet("difftool_definebyquery_temp_create.sql");
     1071    query = pxDataGet("difftool_definewarpstack_temp_create.sql");
    10611072    if (!p_psDBRunQuery(config->dbh, query)) {
    10621073        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    10701081    query = NULL;
    10711082
    1072     psString skycell_query = pxDataGet("difftool_definebyquery_part2.sql");
     1083    psString skycell_query = pxDataGet("difftool_definewarpstack_part2.sql");
    10731084
    10741085    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    … …  
    11831194                registered,
    11841195                tess_id,
    1185                 exp_id,
    1186                 false       // magicked
     1196                false,                  // bothways
     1197                true,                   // exposure
     1198                0       // magicked
    11871199        );
    11881200
    … …  
    12821294                   "ABS(TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs)))", "<=");
    12831295
     1296    // other where restrictions:
     1297    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_begin",      "inputRawExp.dateobs",        ">=");
     1298    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_end",        "inputRawExp.dateobs",        "<=");
     1299    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_min",             "inputRawExp.ra",             ">=");
     1300    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_max",             "inputRawExp.ra",             "<");
     1301    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_min",           "inputRawExp.decl",           ">=");
     1302    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_max",           "inputRawExp.decl",           "<");
     1303    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_min", "inputRawExp.sat_pixel_frac", ">=");
     1304    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_max", "inputRawExp.sat_pixel_frac", "<");
     1305    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_min",        "inputRawExp.airmass",        ">=");
     1306    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_max",        "inputRawExp.airmass",        "<");
     1307    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_min",       "inputRawExp.exp_time",       ">=");
     1308    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_max",       "inputRawExp.exp_time",       "<");
     1309    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_min",             "inputRawExp.bg",             ">=");
     1310    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_max",             "inputRawExp.bg",             "<");
     1311    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_min",       "inputRawExp.bg_stdev",       ">=");
     1312    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_max",       "inputRawExp.bg_stdev",       "<");
     1313    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_min",  "inputRawExp.bg_mean_stdev",  ">=");
     1314    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_max",  "inputRawExp.bg_mean_stdev",  "<");
     1315    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_min",            "inputRawExp.alt",            ">=");
     1316    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_max",            "inputRawExp.alt",            "<");
     1317    PXOPT_COPY_F64(config->args,   selectWhere, "-az_min",             "inputRawExp.az",             ">=");
     1318    PXOPT_COPY_F64(config->args,   selectWhere, "-az_max",             "inputRawExp.az",             "<");
     1319    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_min",       "inputRawExp.ccd_temp",       ">=");
     1320    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_max",       "inputRawExp.ccd_temp",       "<");
     1321    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_min",         "inputRawExp.posang",         ">=");
     1322    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_max",         "inputRawExp.posang",         "<");
     1323    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
     1324    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
     1325    PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1326
    12841327    // Haversine formula for great circle distance
    12851328    PXOPT_COPY_F32(config->args, selectWhere, "-distance",
    1286                    "DEGREES(2*ASIN(SQRT(POW(SIN(inputRawExp.decl - templateRawExp.decl),2) + COS(inputRawExp.decl)*COS(templateRawExp.decl)*POW(SIN(inputRawExp.ra - templateRawExp.ra),2))))", "<=");
     1329                   "DEGREES(2*ASIN(SQRT(POW(SIN(inputRawExp.decl - templateRawExp.decl),2) + "
     1330                   "COS(inputRawExp.decl)*COS(templateRawExp.decl)*"
     1331                   "POW(SIN(inputRawExp.ra - templateRawExp.ra),2))))", "<=");
    12871332
    12881333    PXOPT_LOOKUP_BOOL(backwards, config->args, "-backwards", false);
    … …  
    13081353    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    13091354
     1355    if (!psDBTransaction(config->dbh)) {
     1356        psError(PS_ERR_UNKNOWN, false, "database error");
     1357        psFree(selectWhere);
     1358        psFree(insertWhere);
     1359        return false;
     1360    }
     1361
     1362    if (!rerun) {
     1363        // Need to build table of exposures with diffs
     1364        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
     1365        if (!tempCreate) {
     1366            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1367            psFree(selectWhere);
     1368            psFree(insertWhere);
     1369            if (!psDBRollback(config->dbh)) {
     1370                psError(PS_ERR_UNKNOWN, false, "database error");
     1371            }
     1372            return false;
     1373        }
     1374
     1375        if (!p_psDBRunQuery(config->dbh, tempCreate)) {
     1376            psError(PS_ERR_UNKNOWN, false, "Unable to create temp table: %s", tempCreate);
     1377            psFree(tempCreate);
     1378            psFree(selectWhere);
     1379            psFree(insertWhere);
     1380            if (!psDBRollback(config->dbh)) {
     1381                psError(PS_ERR_UNKNOWN, false, "database error");
     1382            }
     1383            return false;
     1384        }
     1385        psFree(tempCreate);
     1386
     1387        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
     1388        if (!tempInsert) {
     1389            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1390            psFree(selectWhere);
     1391            psFree(insertWhere);
     1392            if (!psDBRollback(config->dbh)) {
     1393                psError(PS_ERR_UNKNOWN, false, "database error");
     1394            }
     1395            return false;
     1396        }
     1397
     1398        psString where = psStringCopy(""); // WHERE for insertion
     1399        if (label) {
     1400            psStringAppend(&where, "\nAND diffRun.label = '%s'", label);
     1401        }
     1402
     1403        if (!p_psDBRunQueryF(config->dbh, tempInsert, where, where)) {
     1404            psError(PS_ERR_UNKNOWN, false, "Unable to insert into temp table: %s", tempInsert);
     1405            psFree(tempInsert);
     1406            psFree(where);
     1407            psFree(selectWhere);
     1408            psFree(insertWhere);
     1409            if (!psDBRollback(config->dbh)) {
     1410                psError(PS_ERR_UNKNOWN, false, "database error");
     1411            }
     1412            return false;
     1413        }
     1414        psFree(where);
     1415        psFree(tempInsert);
     1416    }
     1417
     1418    // Get list of warps to diff
    13101419    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    13111420    if (!select) {
    13121421        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1422        psFree(selectWhere);
     1423        psFree(insertWhere);
     1424        if (!psDBRollback(config->dbh)) {
     1425            psError(PS_ERR_UNKNOWN, false, "database error");
     1426        }
    13131427        return false;
    13141428    }
    … …  
    13231437    psFree(selectWhere);
    13241438
     1439    if (!available) {
     1440        psStringAppend(&whereClause,
     1441                       "\n%s inputWarpRun.state = 'full'"
     1442                       "AND templateWarpRun.state = 'full'",
     1443                       whereClause ? "AND" : "WHERE");
     1444    }
     1445
    13251446    if (!rerun) {
    1326         psStringAppend(&whereClause, "\n%s (diffRun.diff_id IS NULL", whereClause ? "AND" : "WHERE");
    1327         if (label) {
    1328             psStringAppend(&whereClause, " OR diffRun.label != %s", label);
    1329         }
    1330         psStringAppend(&whereClause, ")");
    1331     }
    1332 
    1333     if (!available) {
    1334         psStringAppend(&whereClause, "\n%s inputWarpRun.state = 'full'", whereClause ? "AND" : "WHERE");
    1335     }
    1336 
    1337     if (!psDBTransaction(config->dbh)) {
    1338         psError(PS_ERR_UNKNOWN, false, "database error");
    1339         psFree(select);
    1340         psFree(whereClause);
    1341         psFree(insertWhere);
    1342         return false;
     1447        psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
    13431448    }
    13441449
    13451450    if (!p_psDBRunQueryF(config->dbh, select,
    1346                          !rerun ? "\n" : "", // Activate LEFT JOIN against diffRun?
     1451                         !rerun ? "\n" : "", // Activate LEFT JOIN against diffs?
    13471452                         whereClause)) {
    13481453        psError(PS_ERR_UNKNOWN, false, "Unable to run query: %s [WITH] %s", select, whereClause);
    … …  
    14141519        psMetadata *row = results->data[i]; // Result row from query
    14151520
    1416         psS64 exp_id = psMetadataLookupS64(NULL, row, "input_exp_id");
    14171521        psS64 input_id = psMetadataLookupS64(NULL, row, "input_warp_id");
    14181522        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    14191523        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
    1420         if (!exp_id || !input_id || !template || !tess_id) {
     1524        if (!input_id || !template || !tess_id) {
    14211525            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    14221526            psFree(list);
    … …  
    14301534
    14311535        diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1432                                           tess_id, exp_id, false); // Run to insert
     1536                                          tess_id, true, true, false); // Run to insert
    14331537        if (!diffRunInsertObject(config->dbh, run)) {
    14341538            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    15111615
    15121616    psMetadata *where = psMetadataAlloc();
    1513     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1617    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    15141618
    15151619    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    … …  
    15761680        PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    15771681    }
    1578     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1682    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
    15791683
    15801684    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    … …  
    17381842
    17391843        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
    1740         bool magicked = psMetadataLookupBool(NULL, row, "magicked");
     1844        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    17411845
    17421846        // set diffRun.state to 'stop'

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

    r23502 r25027  
    3434    DIFFTOOL_MODE_REVERTDIFFSKYFILE,
    3535    DIFFTOOL_MODE_DEFINEPOPRUN,
    36     DIFFTOOL_MODE_DEFINEBYQUERY,
     36    DIFFTOOL_MODE_DEFINEWARPSTACK,
    3737    DIFFTOOL_MODE_DEFINEWARPWARP,
    3838    DIFFTOOL_MODE_PENDINGCLEANUPRUN,

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

    r23940 r25027  
    4949    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,            "define workdir (required)", NULL);
    5050    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID (required)", NULL);
     51    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-bothways",  0,            "do the subtraction both ways?", false);
     52    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-exposure",  0,            "subtraction for entire exposure?", false);
    5153    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label",  0,            "define label", NULL);
    5254    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    … …  
    9092    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    9193    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    92     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
    9394    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
    9495    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    132133    psMetadataAddStr(revertdiffskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    133134    psMetadataAddS16(revertdiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     135    psMetadataAddBool(revertdiffskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    134136
    135137    // -definepoprun
    … …  
    142144    psMetadataAddStr(definepoprunArgs, PS_LIST_TAIL, "-reduction",  0,            "define reduction class", NULL);
    143145    psMetadataAddBool(definepoprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    144     psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-exp_id", 0,              "define exposure ID for template", 0);
    145146    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_warp_id", 0,            "define warp ID for template", 0);
    146147    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-template_stack_id", 0,            "define stack ID for template", 0);
    … …  
    148149    psMetadataAddS64(definepoprunArgs, PS_LIST_TAIL, "-input_stack_id", 0,            "define stack ID for input", 0);
    149150
    150     // -definebyquery
    151     psMetadata *definebyqueryArgs = psMetadataAlloc();
    152     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-warp_id", 0, "search by warp ID", 0);
    153     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
    154     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
    155     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
    156     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
    157     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
    158     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
    159     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
    160     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
    161     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
    162     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
    163     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    164     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
    165     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
    166     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
    167     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     151    // -definewarpstack
     152    psMetadata *definewarpstackArgs = psMetadataAlloc();
     153    psMetadataAddS64(definewarpstackArgs, PS_LIST_TAIL, "-warp_id", 0, "search by warp ID", 0);
     154    psMetadataAddS64(definewarpstackArgs, PS_LIST_TAIL, "-exp_id", 0, "search by exposure ID", 0);
     155    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", NULL);
     156    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", NULL);
     157    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-filter", 0, "search by filter", NULL);
     158    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-stack_label", 0, "search by stack label", NULL);
     159    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-warp_label", 0, "search by warp label", NULL);
     160    psMetadataAddF32(definewarpstackArgs, PS_LIST_TAIL, "-good_frac", 0, "minimum good fraction of skycell", NAN);
     161    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-workdir", 0, "define workdir (required)", NULL);
     162    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-label",  0, "define label", NULL);
     163    psMetadataAddStr(definewarpstackArgs, PS_LIST_TAIL, "-reduction",  0, "define reduction class", NULL);
     164    psMetadataAddTime(definewarpstackArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     165    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-new-templates", 0, "also search for diffs with new template", false);
     166    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-rerun", 0, "define new run even if one exists", false);
     167    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-available", 0, "define new run even if warpRun has some faults", false);
     168    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     169    psMetadataAddBool(definewarpstackArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
    168170
    169171    // -definewarpwarp
    … …  
    188190    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    189191    psMetadataAddBool(definewarpwarpArgs, PS_LIST_TAIL, "-pretend", 0, "list results but to not queue", false);
     192    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_begin",      0, "search for exposures by time (>=)", NULL);
     193    psMetadataAddTime(definewarpwarpArgs, PS_LIST_TAIL, "-dateobs_end",        0, "search for exposures by time (<)", NULL);
     194    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_min",             0, "search by min RA (degrees) ", NAN);
     195    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ra_max",             0, "search by max RA (degrees) ", NAN);
     196    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_min",           0, "search by min DEC (degrees)", NAN);
     197    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-decl_max",           0, "search by max DEC (degrees)", NAN);
     198    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
     199    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
     200    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_min",       0, "search by min exposure time", NAN);
     201    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-exp_time_max",       0, "search by max exposure time", NAN);
     202    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by min fraction of saturated pixels", NAN);
     203    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by max fraction of saturated pixels", NAN);
     204    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_min",             0, "search by min background", NAN);
     205    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_max",             0, "search by max background", NAN);
     206    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_min",       0, "search by min background standard deviation", NAN);
     207    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max background standard deviation", NAN);
     208    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by min background mean standard deviation (across imfiles)", NAN);
     209    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max background mean standard deviation (across imfiles)", NAN);
     210    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_min",            0, "search by min altitude", NAN);
     211    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-alt_max",            0, "search by max altitude", NAN);
     212    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_min",             0, "search by min azimuth ", NAN);
     213    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-az_max",             0, "search by max azimuth ", NAN);
     214    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
     215    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
     216    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
     217    psMetadataAddF64(definewarpwarpArgs,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
     218    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     219    psMetadataAddF32(definewarpwarpArgs,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     220    psMetadataAddStr(definewarpwarpArgs,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    190221
    191222    // -pendingcleanuprun
    … …  
    239270    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    240271    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    241     PXOPT_ADD_MODE("-definebyquery",    "", DIFFTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
     272    PXOPT_ADD_MODE("-definewarpstack",  "", DIFFTOOL_MODE_DEFINEWARPSTACK,   definewarpstackArgs);
    242273    PXOPT_ADD_MODE("-definewarpwarp",   "", DIFFTOOL_MODE_DEFINEWARPWARP,    definewarpwarpArgs);
    243274    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);

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

    r23912 r25027  
    4747static bool pendingdestMode(pxConfig *config);
    4848
     49static bool definetargetMode(pxConfig *config);
     50static bool updatetargetMode(pxConfig *config);
     51static bool listtargetMode(pxConfig *config);
     52
     53static bool definedsproductMode(pxConfig *config);
     54static bool updatedsproductMode(pxConfig *config);
     55
     56static bool definedestinationMode(pxConfig *config);
     57static bool updatedestinationMode(pxConfig *config);
     58
     59static bool defineinterestMode(pxConfig *config);
     60static bool updateinterestMode(pxConfig *config);
     61
    4962# define MODECASE(caseName, func) \
    5063    case caseName: \
    … …  
    8194        MODECASE(DISTTOOL_MODE_REVERTRCRUN, revertrcrunMode);
    8295        MODECASE(DISTTOOL_MODE_PENDINGDEST, pendingdestMode);
     96        MODECASE(DISTTOOL_MODE_DEFINETARGET, definetargetMode);
     97        MODECASE(DISTTOOL_MODE_UPDATETARGET, updatetargetMode);
     98        MODECASE(DISTTOOL_MODE_LISTTARGET, listtargetMode);
     99        MODECASE(DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductMode);
     100        MODECASE(DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductMode);
     101        MODECASE(DISTTOOL_MODE_DEFINEDESTINATION, definedestinationMode);
     102        MODECASE(DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationMode);
     103        MODECASE(DISTTOOL_MODE_DEFINEINTEREST, defineinterestMode);
     104        MODECASE(DISTTOOL_MODE_UPDATEINTEREST, updateinterestMode);
    83105        default:
    84106            psAbort("invalid option (this should not happen)");
    … …  
    151173    PXOPT_LOOKUP_STR(stage, config->args,     "-stage", true, false);
    152174    PXOPT_LOOKUP_STR(workdir, config->args,   "-workdir", true, false);
     175
     176    // optional
    153177    PXOPT_LOOKUP_S64(magic_ds_id, config->args, "-magic_ds_id",  false, false);
    154 
    155     // optional
    156178    PXOPT_LOOKUP_BOOL(no_magic, config->args, "-no_magic", false);
    157179    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
    158180    PXOPT_LOOKUP_S64(limit, config->args, "-limit", false, false);
     181    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    159182   
    160183    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    … …  
    166189    PXOPT_COPY_S64(config->args, where, "-exp_id",    "rawExp.exp_id",           "==");
    167190    PXOPT_COPY_S64(config->args, where, "-chip_id",   "chipRun.chip_id",         "==");
    168     PXOPT_COPY_STR(config->args, where, "-obs_mode",  "rawExp.obs_mode",         "==");
    169191
    170192    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    … …  
    181203            psFree(where);
    182204            return false;
     205        }
     206
     207        // for raw stage we select by chipRun.label because raw labels typically aren't set
     208        if (label) {
     209            psStringAppend(&query, " AND (chipRun.label = '%s')", label);
    183210        }
    184211    } else if (!strcmp(stage, "chip")) {
    … …  
    323350    }
    324351    if (!psArrayLength(output)) {
    325         psTrace("warptool", PS_LOG_INFO, "no rows found");
     352        psTrace("disttool", PS_LOG_INFO, "no rows found");
    326353        psFree(output);
    327354        return true;
    328355    }
    329356
    330     // XXX Remove this debugging output at some point
    331     if (!ippdbPrintMetadatas(stdout, output, "newdistRuns", true)) {
    332         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    333         psFree(output);
    334         return false;
    335     }
     357
    336358    if (dry_run) {
     359        if (!ippdbPrintMetadatas(stdout, output, "newdistRuns", true)) {
     360            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     361            psFree(output);
     362            return false;
     363        }
    337364        psFree(output);
    338365        return true;
    339366    }
    340367
     368    if (!psDBTransaction(config->dbh)) {
     369        psError(PS_ERR_UNKNOWN, false, "database error");
     370        return false;
     371    }
     372
     373    psArray *list = psArrayAllocEmpty(limit);
    341374    for (long i=0; i < psArrayLength(output); i++) {
    342375        psMetadata *md = output->data[i];
    … …  
    345378        psS64 stage_id = psMetadataLookupS64(NULL, md, "stage_id");
    346379        psS64 target_id = psMetadataLookupS64(NULL, md, "target_id");
     380        psString target_label = psMetadataLookupStr(NULL, md, "label");
    347381        bool clean = psMetadataLookupBool(NULL, md, "clean");
    348382
    … …  
    350384        psStringAppend(&outroot, "%s/%s/%s", workdir, run_tag, stage);
    351385
    352         if (!distRunInsert(config->dbh,
     386        if (set_label == NULL) {
     387            set_label = target_label;
     388        }
     389        distRunRow *row = distRunRowAlloc(
    353390                0,      // dist_id
    354391                target_id,
    … …  
    362399                NULL,   // time_stamp
    363400                0       // fault
    364         )) {
     401                );
     402
     403        if (!row) {
     404            psError(PS_ERR_UNKNOWN, false, "failed to allocate distRunRow");
     405            psFree(outroot);
     406            psFree(output);
     407            return false;
     408        }
     409        if (!distRunInsertObject(config->dbh, row)) {
    365410            psError(PS_ERR_UNKNOWN, false, "database error");
    366411            psFree(outroot);
    … …  
    369414        }
    370415        psFree(outroot);
    371     }
    372 
     416        psS64 dist_id = psDBLastInsertID(config->dbh);
     417        row->dist_id = dist_id;
     418        psArrayAdd(list, list->n, row);
     419        psFree(row);
     420    }
     421
     422    if (!psDBCommit(config->dbh)) {
     423        psError(PS_ERR_UNKNOWN, false, "database error");
     424        return false;
     425    }
     426    if (!distRunPrintObjects(stdout, list, !simple)) {
     427        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     428        psFree(list);
     429        return false;
     430    }
     431
     432    psFree(list);
    373433    psFree(output);
    374434
    … …  
    436496    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
    437497    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    438     PXOPT_COPY_S16(config->args, where, "-fault", "distComponent.fault", "==");
     498
     499    // we need to disambiguate fault so make a copy of the where list before adding fault
     500    psMetadata *whereComponent = psMetadataCopy(NULL, where);
     501    PXOPT_COPY_S16(config->args, where,  "-fault", "distRun.fault", "==");
     502    PXOPT_COPY_S16(config->args, whereComponent, "-fault", "distComponent.fault", "==");
    439503
    440504    // It might be useful to be able to query by the parameters of the underlying runs
    … …  
    481545
    482546        numUpdated = psDBAffectedRows(config->dbh);
    483 
    484 #ifdef notdef
    485         // don't need this. distRun.state may still be in 'new' state
    486         if (numUpdated < 1) {
    487             psError(PS_ERR_UNKNOWN, false, "should have affected at least 1 row");
    488             if (!psDBRollback(config->dbh)) {
    489                 psError(PS_ERR_UNKNOWN, false, "database error");
    490             }
    491             return false;
    492         }
    493 #endif
    494547    }
    495548
    … …  
    508561        }
    509562
    510         if (psListLength(where->list)) {
    511             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     563        if (psListLength(whereComponent->list)) {
     564            psString whereClause = psDBGenerateWhereConditionSQL(whereComponent, NULL);
    512565            psStringAppend(&query, " AND %s", whereClause);
    513566            psFree(whereClause);
    … …  
    530583
    531584    psFree(where);
     585    psFree(whereComponent);
    532586
    533587    if (!psDBCommit(config->dbh)) {
    … …  
    546600    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    547601    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    548     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     602    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    549603
    550604    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    667721    psMetadata *where = psMetadataAlloc();
    668722    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    669     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     723    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
    670724
    671725    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    811865    psMetadata *where = psMetadataAlloc();
    812866    PXOPT_COPY_S64(config->args, where, "-dist_id", "dist_id", "==");
    813     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     867    pxAddLabelSearchArgs (config, where, "-label", "distRun.label", "==");
    814868
    815869    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    11091163
    11101164
    1111     PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
     1165    PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
    11121166    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
    11131167    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    … …  
    12131267    return true;
    12141268}
     1269
     1270static bool definetargetMode(pxConfig *config)
     1271{
     1272    PS_ASSERT_PTR_NON_NULL(config, false);
     1273
     1274    // required
     1275    PXOPT_LOOKUP_STR(label, config->args, "-label", true, false);
     1276    PXOPT_LOOKUP_STR(filter, config->args, "-filter", true, false);
     1277    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     1278
     1279    // optional
     1280    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1281    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1282    PXOPT_LOOKUP_STR(comment, config->args, "-comment", false, false);
     1283
     1284    distTargetRow *row = distTargetRowAlloc(
     1285            0,          // target_id
     1286            label,
     1287            filter,
     1288            stage,
     1289            clean,
     1290            state ? state : "enabled",
     1291            comment
     1292            );
     1293           
     1294    if (!row) {
     1295        psError(PS_ERR_UNKNOWN, false, "failed to allocate distTarget object");
     1296        return false;
     1297    }
     1298   if (!distTargetInsertObject(config->dbh, row)) {
     1299        psError(PS_ERR_UNKNOWN, false, "database error");
     1300        psFree(row);
     1301        return false;
     1302    }
     1303
     1304    // get the assigned target_id
     1305    row->target_id = psDBLastInsertID(config->dbh);
     1306
     1307    if (!distTargetPrintObject(stdout, row, true)) {
     1308            psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1309            psFree(row);
     1310            return false;
     1311    }
     1312
     1313    psFree(row);
     1314
     1315    return true;
     1316}
     1317static bool updatetargetMode(pxConfig *config)
     1318{
     1319    PS_ASSERT_PTR_NON_NULL(config, false);
     1320
     1321    psMetadata *where = psMetadataAlloc();
     1322    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1323    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1324    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     1325    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1326
     1327    PXOPT_LOOKUP_STR(state, config->args, "-set_state", true, false);
     1328
     1329    psString query = psStringCopy("UPDATE distTarget SET state = '%s'");
     1330
     1331    if (psListLength(where->list)) {
     1332        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1333        psStringAppend(&query, " WHERE %s", whereClause);
     1334        psFree(whereClause);
     1335    } else {
     1336        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1337        psFree(where);
     1338        psFree(query);
     1339        return false;
     1340    }
     1341    psFree(where);
     1342
     1343    if (!p_psDBRunQueryF(config->dbh, query, state)) {
     1344        psError(PS_ERR_UNKNOWN, false, "database error");
     1345        psFree(query);
     1346        return false;
     1347    }
     1348    psFree(query);
     1349
     1350    return true;
     1351}
     1352
     1353static bool listtargetMode(pxConfig *config)
     1354{
     1355    PS_ASSERT_PTR_NON_NULL(config, false);
     1356
     1357    psMetadata *where = psMetadataAlloc();
     1358    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1359    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1360    PXOPT_COPY_STR(config->args, where, "-filter", "filter", "==");
     1361    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1362    PXOPT_COPY_STR(config->args, where, "-state", "state", "==");
     1363
     1364    PXOPT_LOOKUP_BOOL(clean, config->args, "-clean", false);
     1365    PXOPT_LOOKUP_BOOL(full, config->args, "-full", false);
     1366
     1367    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1368    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1369
     1370    if (clean && full) {
     1371        psError(PS_ERR_UNKNOWN, false, "can't select both -clean and -full");
     1372        return false;
     1373    }
     1374
     1375    psString query = psStringCopy("SELECT * FROM distTarget");
     1376
     1377    if (psListLength(where->list)) {
     1378        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1379        psStringAppend(&query, " WHERE %s", whereClause);
     1380        psFree(whereClause);
     1381        if (clean) {
     1382            psStringAppend(&query, " AND (clean)");
     1383        } else if (full) {
     1384            psStringAppend(&query, " AND (!clean)");
     1385        }
     1386    } else if (clean) {
     1387        psStringAppend(&query, " WHERE clean");
     1388    } else if (full) {
     1389        psStringAppend(&query, " WHERE !clean");
     1390    }
     1391    psFree(where);
     1392
     1393    // treat limit == 0 as "no limit"
     1394    if (limit) {
     1395        psString limitString = psDBGenerateLimitSQL(limit);
     1396        psStringAppend(&query, " %s", limitString);
     1397        psFree(limitString);
     1398    }
     1399
     1400    if (!p_psDBRunQuery(config->dbh, query)) {
     1401        psError(PS_ERR_UNKNOWN, false, "database error");
     1402        psFree(query);
     1403        if (!psDBRollback(config->dbh)) {
     1404            psError(PS_ERR_UNKNOWN, false, "database error");
     1405        }
     1406        return false;
     1407    }
     1408    psFree(query);
     1409
     1410    psArray *output = p_psDBFetchResult(config->dbh);
     1411    if (!output) {
     1412        psError(PS_ERR_UNKNOWN, false, "database error");
     1413        return false;
     1414    }
     1415    if (!psArrayLength(output)) {
     1416        psTrace("disttool", PS_LOG_INFO, "no rows found");
     1417        psFree(output);
     1418        return true;
     1419    }
     1420
     1421    if (!ippdbPrintMetadatas(stdout, output, "distTarget", !simple)) {
     1422        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1423        psFree(output);
     1424        return false;
     1425    }
     1426
     1427    psFree(output);
     1428
     1429    return true;
     1430}
     1431
     1432static bool definedsproductMode(pxConfig *config)
     1433{
     1434    PS_ASSERT_PTR_NON_NULL(config, false);
     1435
     1436    // required
     1437    PXOPT_LOOKUP_STR(name, config->args,   "-name", true, false);
     1438    PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", true, false);
     1439    PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", true, false);
     1440
     1441    // XXX: should we insure that these names do not contatin any whitespace?
     1442
     1443    rcDSProductRow *row = rcDSProductRowAlloc(
     1444            0,          // prod_id
     1445            name,
     1446            dbname,
     1447            dbhost
     1448            );
     1449           
     1450    if (!row) {
     1451        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDSProduct object");
     1452        return false;
     1453    }
     1454   if (!rcDSProductInsertObject(config->dbh, row)) {
     1455        psError(PS_ERR_UNKNOWN, false, "database error");
     1456        psFree(row);
     1457        return false;
     1458    }
     1459
     1460    // get the assigned target_id
     1461    row->prod_id = psDBLastInsertID(config->dbh);
     1462
     1463    if (!rcDSProductPrintObject(stdout, row, true)) {
     1464        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1465        psFree(row);
     1466        return false;
     1467    }
     1468
     1469    psFree(row);
     1470
     1471    return true;
     1472}
     1473static bool updatedsproductMode(pxConfig *config)
     1474{
     1475    PS_ASSERT_PTR_NON_NULL(config, false);
     1476
     1477    psMetadata *where = psMetadataAlloc();
     1478    PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     1479
     1480    PXOPT_LOOKUP_STR(dbname, config->args, "-ds_dbname", false, false);
     1481    PXOPT_LOOKUP_STR(dbhost, config->args, "-ds_dbhost", false, false);
     1482
     1483    if (!(dbname || dbhost)) {
     1484        psError(PS_ERR_UNKNOWN, true, "one or more of dbname or dbhost is required");
     1485        psFree(where);
     1486        return false;
     1487    }
     1488    psString query = psStringCopy("UPDATE rcDSProduct SET");
     1489    psString sep = "";
     1490    if (dbname) {
     1491        psStringAppend(&query, " dbname = '%s'", dbname);
     1492        sep = ",";
     1493    }
     1494    if (dbhost) {
     1495        psStringAppend(&query, " %s dbhost = '%s'", sep, dbhost);
     1496    }
     1497
     1498    if (psListLength(where->list)) {
     1499        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1500        psStringAppend(&query, " WHERE %s", whereClause);
     1501        psFree(whereClause);
     1502    } else {
     1503        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1504        psFree(where);
     1505        psFree(query);
     1506        return false;
     1507    }
     1508    psFree(where);
     1509
     1510    if (!p_psDBRunQuery(config->dbh, query)) {
     1511        psError(PS_ERR_UNKNOWN, false, "database error");
     1512        psFree(query);
     1513        return false;
     1514    }
     1515    psFree(query);
     1516
     1517    return true;
     1518}
     1519
     1520static bool definedestinationMode(pxConfig *config)
     1521{
     1522    PS_ASSERT_PTR_NON_NULL(config, false);
     1523
     1524    // required
     1525    PXOPT_LOOKUP_S64(prod_id, config->args,      "-prod_id", true, false);
     1526    PXOPT_LOOKUP_STR(name, config->args,         "-name", true, false);
     1527
     1528    // optional
     1529    PXOPT_LOOKUP_STR(status_uri, config->args,   "-status_uri", false, false);
     1530    PXOPT_LOOKUP_STR(comment, config->args,      "-comment", false, false);
     1531    PXOPT_LOOKUP_STR(last_fileset, config->args, "-last_fileset", false, false);
     1532    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1533
     1534    // XXX: should we insure that these names do not contatin any whitespace?
     1535
     1536    rcDestinationRow *row = rcDestinationRowAlloc(
     1537            0,          // dest_id
     1538            prod_id,
     1539            name,
     1540            status_uri,
     1541            comment,
     1542            last_fileset,
     1543            state ? state : "enabled"
     1544            );
     1545           
     1546    if (!row) {
     1547        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcDestination object");
     1548        return false;
     1549    }
     1550   if (!rcDestinationInsertObject(config->dbh, row)) {
     1551        psError(PS_ERR_UNKNOWN, false, "database error");
     1552        psFree(row);
     1553        return false;
     1554    }
     1555
     1556    // get the assigned target_id
     1557    row->dest_id = psDBLastInsertID(config->dbh);
     1558
     1559    if (!rcDestinationPrintObject(stdout, row, true)) {
     1560        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1561        psFree(row);
     1562        return false;
     1563    }
     1564
     1565    psFree(row);
     1566
     1567    return true;
     1568}
     1569
     1570static bool updatedestinationMode(pxConfig *config)
     1571{
     1572    PS_ASSERT_PTR_NON_NULL(config, false);
     1573
     1574    psMetadata *where = psMetadataAlloc();
     1575    PXOPT_COPY_S64(config->args, where, "-dest_id", "dest_id", "==");
     1576    PXOPT_COPY_S64(config->args, where, "-prod_id", "prod_id", "==");
     1577
     1578    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1579#ifdef ALLOW_UPDATE_LAST_FILESET
     1580    PXOPT_LOOKUP_STR(last_fileset, config->args, "-set_last_fileset", false, false);
     1581    if (!(state || last_fileset)) {
     1582        psError(PS_ERR_UNKNOWN, true, "one or more of -set_state or -set_last_fileset is required");
     1583# else
     1584    if (!state) {
     1585#endif
     1586        psFree(where);
     1587        return false;
     1588    }
     1589    psString query = psStringCopy("UPDATE rcDestination SET");
     1590    psString sep = "";
     1591    if (state) {
     1592        psStringAppend(&query, " state = '%s'", state);
     1593        sep = ",";
     1594    }
     1595#ifdef ALLOW_UPDATE_LAST_FILESET
     1596    // last_fileset normally gets set by updatercrunMode
     1597    // Allowing it to be set here might cause problems
     1598    // especially since we are allowing selection by prod_id
     1599    if (last_fileset) {
     1600        psStringAppend(&query, " %s last_fileset = '%s'", sep, last_fileset);
     1601    }
     1602#endif
     1603
     1604    if (psListLength(where->list)) {
     1605        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1606        psStringAppend(&query, " WHERE %s", whereClause);
     1607        psFree(whereClause);
     1608    } else {
     1609        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1610        psFree(where);
     1611        psFree(query);
     1612        return false;
     1613    }
     1614    psFree(where);
     1615
     1616    if (!p_psDBRunQuery(config->dbh, query)) {
     1617        psError(PS_ERR_UNKNOWN, false, "database error");
     1618        psFree(query);
     1619        return false;
     1620    }
     1621    psFree(query);
     1622
     1623    return true;
     1624}
     1625
     1626static bool defineinterestMode(pxConfig *config)
     1627{
     1628    PS_ASSERT_PTR_NON_NULL(config, false);
     1629
     1630    // required
     1631    PXOPT_LOOKUP_S64(dest_id, config->args,      "-dest_id", true, false);
     1632    PXOPT_LOOKUP_S64(target_id, config->args,    "-target_id", true, false);
     1633
     1634    // optional
     1635    PXOPT_LOOKUP_STR(state, config->args,        "-set_state", false, false);
     1636
     1637    // XXX: should we insure that these names do not contatin any whitespace?
     1638
     1639    rcInterestRow *row = rcInterestRowAlloc(
     1640            0,          // int_id
     1641            dest_id,
     1642            target_id,
     1643            state ? state : "enabled"
     1644            );
     1645           
     1646    if (!row) {
     1647        psError(PS_ERR_UNKNOWN, false, "failed to allocate rcInterest object");
     1648        return false;
     1649    }
     1650   if (!rcInterestInsertObject(config->dbh, row)) {
     1651        psError(PS_ERR_UNKNOWN, false, "database error");
     1652        psFree(row);
     1653        return false;
     1654    }
     1655
     1656    // get the assigned target_id
     1657    row->int_id = psDBLastInsertID(config->dbh);
     1658
     1659    if (!rcInterestPrintObject(stdout, row, true)) {
     1660        psError(PS_ERR_UNKNOWN, false, "failed to print object");
     1661        psFree(row);
     1662        return false;
     1663    }
     1664
     1665    psFree(row);
     1666
     1667    return true;
     1668}
     1669
     1670static bool updateinterestMode(pxConfig *config)
     1671{
     1672    PS_ASSERT_PTR_NON_NULL(config, false);
     1673
     1674    psMetadata *where = psMetadataAlloc();
     1675    PXOPT_COPY_S64(config->args, where, "-int_id",    "int_id", "==");
     1676    PXOPT_COPY_S64(config->args, where, "-dest_id",   "dest_id", "==");
     1677    PXOPT_COPY_S64(config->args, where, "-target_id", "target_id", "==");
     1678
     1679    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     1680    if (!state) {
     1681        psError(PS_ERR_UNKNOWN, true, "-set_state is required");
     1682        psFree(where);
     1683        return false;
     1684    }
     1685    psString query = NULL;
     1686    psStringAppend(&query, "UPDATE rcInterest SET state = '%s'", state);
     1687
     1688    if (psListLength(where->list)) {
     1689        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1690        psStringAppend(&query, " WHERE %s", whereClause);
     1691        psFree(whereClause);
     1692    } else {
     1693        psError(PS_ERR_UNKNOWN, true, "search parameters are required");
     1694        psFree(where);
     1695        psFree(query);
     1696        return false;
     1697    }
     1698    psFree(where);
     1699
     1700    if (!p_psDBRunQuery(config->dbh, query)) {
     1701        psError(PS_ERR_UNKNOWN, false, "database error");
     1702        psFree(query);
     1703        return false;
     1704    }
     1705    psFree(query);
     1706
     1707    return true;
     1708}
     1709

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

    r23912 r25027  
    4040    DISTTOOL_MODE_REVERTRCRUN,
    4141    DISTTOOL_MODE_PENDINGDEST,
     42    DISTTOOL_MODE_DEFINEDESTINATION,
     43    DISTTOOL_MODE_UPDATEDESTINATION,
     44    DISTTOOL_MODE_DEFINEDSPRODUCT,
     45    DISTTOOL_MODE_UPDATEDSPRODUCT,
     46    DISTTOOL_MODE_DEFINETARGET,
     47    DISTTOOL_MODE_UPDATETARGET,
     48    DISTTOOL_MODE_LISTTARGET,
     49    DISTTOOL_MODE_DEFINEINTEREST,
     50    DISTTOOL_MODE_UPDATEINTEREST,
    4251} disttoolMode;
    4352

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

    r23912 r25027  
    5959    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_ds_id",   0, "define chip_id", 0);
    6060    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",         0, "select by label", NULL);
    61     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",      0, "select by obs_mode", NULL);
    6261
    6362    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
     63    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    6464
    6565    // -definerun
    … …  
    9797    psMetadataAddS64(pendingcomponentArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    9898    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-stage",    0, "limit results to runs for stage", NULL);
    99     psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    0, "limit results to label", NULL);
     99    psMetadataAddStr(pendingcomponentArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "limit results to label", NULL);
    100100    psMetadataAddU64(pendingcomponentArgs, PS_LIST_TAIL, "-limit",  0,  "limit result set to N items", 0);
    101101    psMetadataAddBool(pendingcomponentArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    120120    psMetadata *toadvanceArgs = psMetadataAlloc();
    121121    psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    122     psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",   0, "limit updates to label", NULL);
     122    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit updates to label", NULL);
    123123    psMetadataAddU64(toadvanceArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    124124    psMetadataAddBool(toadvanceArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    127127    psMetadata *pendingfilesetArgs = psMetadataAlloc();
    128128    psMetadataAddS64(pendingfilesetArgs, PS_LIST_TAIL, "-dist_id", 0, "define dist_id", 0);
    129     psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     129    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
    130130    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-stage",   0, "limit results to runs for stage", NULL);
    131131    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    … …  
    144144    psMetadataAddU64(pendingdestArgs, PS_LIST_TAIL, "-limit",   0,  "limit result set to N items", 0);
    145145    psMetadataAddBool(pendingdestArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    146     psMetadataAddStr(pendingdestArgs, PS_LIST_TAIL, "-label",   0, "limit results to label", NULL);
     146    psMetadataAddStr(pendingdestArgs, PS_LIST_TAIL, "-label",   PS_META_DUPLICATE_OK, "limit results to label", NULL);
    147147
    148148    // -revertfileset
    … …  
    178178    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-status_fs_name",  0, "define status fileset name", NULL);
    179179    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-set_state",0, "new value for state", NULL);
    180     psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-last_fileset",0, "new value for last_fileset", NULL);
     180    psMetadataAddStr(updatercrunArgs, PS_LIST_TAIL, "-set_last_fileset",0, "new value for last_fileset", NULL);
    181181    psMetadataAddS16(updatercrunArgs, PS_LIST_TAIL, "-fault",    0, "define fault code", -1);
    182182
    … …  
    188188    psMetadataAddS16(revertrcrunArgs, PS_LIST_TAIL,  "-fault",   0, "define fault code", 0);
    189189    psMetadataAddBool(revertrcrunArgs, PS_LIST_TAIL, "-all",     0, "revert all faulted runs", NULL);
     190
     191    // -definedsproduct
     192    psMetadata *definedsproductArgs = psMetadataAlloc();
     193    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-name",  0, "define product name", NULL);
     194    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
     195    psMetadataAddStr(definedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
     196
     197    // -updatedsproduct
     198    // does this mode make sense?
     199    psMetadata *updatedsproductArgs = psMetadataAlloc();
     200    psMetadataAddS64(updatedsproductArgs, PS_LIST_TAIL, "-prod_id",   0, "select by prod_id", 0);
     201    // can't select by name because it isn't necssarily unique
     202    psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbname",0, "define data store database name", NULL);
     203    psMetadataAddStr(updatedsproductArgs, PS_LIST_TAIL, "-ds_dbhost",0, "define data store database host", NULL);
     204
     205    // -definedestination
     206    psMetadata *definedestinationArgs = psMetadataAlloc();
     207    psMetadataAddS64(definedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id (required)", 0);
     208    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name (required)", NULL);
     209    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
     210    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
     211    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-last_fileset",0, "define last_fileset", NULL);
     212    psMetadataAddStr(definedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
     213
     214    // -updatedestination
     215    psMetadata *updatedestinationArgs = psMetadataAlloc();
     216    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-dest_id",     0, "define dest_id", 0);
     217    psMetadataAddS64(updatedestinationArgs, PS_LIST_TAIL, "-prod_id",     0, "define prod_id", 0);
     218    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-name",        0, "define destination name", NULL);
     219    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-status_uri",  0, "define status_uri", NULL);
     220    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-comment",     0, "define comment", NULL);
     221//  last_fileset gets updated by -updatercrun
     222//  psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_last_fileset",0, "define last_fileset", NULL);
     223    psMetadataAddStr(updatedestinationArgs, PS_LIST_TAIL, "-set_state",   0, "define state", NULL);
     224
     225    // -definetarget
     226    psMetadata *definetargetArgs = psMetadataAlloc();
     227    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-label",     0, "define label (required)", NULL);
     228    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-filter",     0, "define filter (required)", NULL);
     229    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage (required)", NULL);
     230    psMetadataAddBool(definetargetArgs, PS_LIST_TAIL,"-clean",     0, "define clean", false);
     231    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     232    psMetadataAddStr(definetargetArgs, PS_LIST_TAIL, "-comment",   0, "define comment", NULL);
     233
     234    // -updatetarget
     235    psMetadata *updatetargetArgs = psMetadataAlloc();
     236    psMetadataAddS64(updatetargetArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     237    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-stage",     0, "define stage", NULL);
     238    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     239    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-label",     0, "define label", NULL);
     240    psMetadataAddStr(updatetargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
     241
     242    // -listtarget
     243    psMetadata *listtargetArgs = psMetadataAlloc();
     244    psMetadataAddS64(listtargetArgs, PS_LIST_TAIL, "-target_id", 0, "list target with target_id", 0);
     245    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-label",  0, "list targets for label", NULL);
     246    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-filter",    0, "define filter", NULL);
     247    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-stage",     0, "list targets for stage", NULL);
     248    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-clean",     0, "list clean targets", false);
     249    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL,"-full",      0, "list full targets", false);
     250    psMetadataAddStr(listtargetArgs, PS_LIST_TAIL, "-state",     0, "list targets in state", NULL);
     251    psMetadataAddU64(listtargetArgs, PS_LIST_TAIL, "-limit",     0, "limit number of targets listed to N", 0);
     252    psMetadataAddBool(listtargetArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     253
     254    // -defineinterest
     255    psMetadata *defineinterestArgs = psMetadataAlloc();
     256    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id (required)", 0);
     257    psMetadataAddS64(defineinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id (required)", 0);
     258    psMetadataAddStr(defineinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     259
     260    // -updateinterest
     261    psMetadata *updateinterestArgs = psMetadataAlloc();
     262    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-int_id",    0, "define int_id", 0);
     263    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-dest_id",   0, "define dest_id", 0);
     264    psMetadataAddS64(updateinterestArgs, PS_LIST_TAIL, "-target_id", 0, "define target_id", 0);
     265    psMetadataAddStr(updateinterestArgs, PS_LIST_TAIL, "-set_state", 0, "define state (required)", NULL);
    190266
    191267    psMetadata *argSets = psMetadataAlloc();
    … …  
    208284    PXOPT_ADD_MODE("-pendingdest",        "", DISTTOOL_MODE_PENDINGDEST, pendingdestArgs);
    209285
     286    PXOPT_ADD_MODE("-definedsproduct",    "", DISTTOOL_MODE_DEFINEDSPRODUCT, definedsproductArgs);
     287    PXOPT_ADD_MODE("-updatedsproduct",    "", DISTTOOL_MODE_UPDATEDSPRODUCT, updatedsproductArgs);
     288//  PXOPT_ADD_MODE("-listdsproduct",      "", DISTTOOL_MODE_LISTDSPRODUCT, updatedsproductArgs);
     289
     290    PXOPT_ADD_MODE("-definedestination",  "", DISTTOOL_MODE_DEFINEDESTINATION, definedestinationArgs);
     291    PXOPT_ADD_MODE("-updatedestination",  "", DISTTOOL_MODE_UPDATEDESTINATION, updatedestinationArgs);
     292//  PXOPT_ADD_MODE("-listdestination",    "", DISTTOOL_MODE_LISTDESTINATION, listdestinationArgs);
     293
     294    PXOPT_ADD_MODE("-definetarget",       "", DISTTOOL_MODE_DEFINETARGET, definetargetArgs);
     295    PXOPT_ADD_MODE("-updatetarget",       "", DISTTOOL_MODE_UPDATETARGET, updatetargetArgs);
     296    PXOPT_ADD_MODE("-listtarget",         "", DISTTOOL_MODE_LISTTARGET, listtargetArgs);
     297
     298    PXOPT_ADD_MODE("-defineinterest",     "", DISTTOOL_MODE_DEFINEINTEREST, defineinterestArgs);
     299    PXOPT_ADD_MODE("-updateinterest",     "", DISTTOOL_MODE_UPDATEINTEREST, updateinterestArgs);
     300//  PXOPT_ADD_MODE("-listinterest",       "", DISTTOOL_MODE_LISTINTEREST, listinterestArgs);
     301
    210302    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    211303        psError(PS_ERR_UNKNOWN, true, "option parsing failed");

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

    r23921 r25027  
    134134    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    135135    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    136     PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    137     PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    138     PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
    139     PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     136    PXOPT_COPY_RADEC(config->args, where, "-ra_min", "ra", ">=");
     137    PXOPT_COPY_RADEC(config->args, where, "-ra_max", "ra", "<");
     138    PXOPT_COPY_RADEC(config->args, where, "-decl_min", "decl", ">=");
     139    PXOPT_COPY_RADEC(config->args, where, "-decl_max", "decl", "<");
    140140    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
    141141    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
    … …  
    157157    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    158158    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    159     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    160     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     159    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     160    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    161161    PXOPT_COPY_STR(config->args, where, "-comment", "comment", "LIKE");
    162162
    … …  
    235235        bool status;
    236236        char *end_stage = psMetadataLookupStr(&status, md, "end_stage");
    237         if (end_stage && strcasecmp(end_stage, "warp")) continue;
     237        if (end_stage && strcasecmp(end_stage, "warp")) continue;
    238238
    239239        char *raw_tess_id   = psMetadataLookupStr(&status, md, "tess_id");
    240         if (raw_tess_id || tess_id) continue;
     240        if (raw_tess_id || tess_id) continue;
    241241
    242242        char *label  = psMetadataLookupStr(&status, md, "label");
    … …  
    244244
    245245        if (!status) {
    246             psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
     246            psError(PS_ERR_UNKNOWN, false, "cannot queue analysis to WARP without a defined tess id: label: %s, exp_id %" PRId64, label, exp_id);
    247247            psFree(output);
    248248            return false;
    … …  
    302302    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    303303    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    304     PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    305     PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    306     PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
    307     PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     304    PXOPT_COPY_RADEC(config->args, where, "-ra_min", "ra", ">=");
     305    PXOPT_COPY_RADEC(config->args, where, "-ra_max", "ra", "<");
     306    PXOPT_COPY_RADEC(config->args, where, "-decl_min", "decl", ">=");
     307    PXOPT_COPY_RADEC(config->args, where, "-decl_max", "decl", "<");
    308308    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
    309309    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
    … …  
    325325    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    326326    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    327     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    328     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     327    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     328    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    329329    PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    330330
    … …  
    455455
    456456    if (where && psListLength(where->list)) {
    457         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    458         psStringAppend(&query, " WHERE %s", whereClause);
     457        psString whereClause = psDBGenerateWhereConditionSQL(where, "fakeRun");
     458        psStringAppend(&query, " AND %s", whereClause);
    459459        psFree(whereClause);
    460460    }
    … …  
    563563
    564564    psMetadata *where = psMetadataAlloc();
    565     PXOPT_COPY_S64(config->args, where, "-fake_id", "fakeRun.fake_id", "==");
     565    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    566566    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    567567    PXOPT_COPY_STR(config->args, where, "-class_id", "rawImfile.class_id", "==");
    … …  
    632632
    633633    psMetadata *where = psMetadataAlloc();
     634    pxAddLabelSearchArgs (config, where, "-label", "fakeRun.label", "==");
    634635    PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
    635     PXOPT_COPY_STR(config->args, where, "-label", "fakeRun.label", "==");
    636636    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    637637    PXOPT_COPY_STR(config->args, where, "-exp_name", "exp_name", "==");
    … …  
    646646    PXOPT_COPY_F64(config->args, where, "-airmass_min", "airmass", ">=");
    647647    PXOPT_COPY_F64(config->args, where, "-airmass_max", "airmass", "<");
    648     PXOPT_COPY_F64(config->args, where, "-ra_min", "ra", ">=");
    649     PXOPT_COPY_F64(config->args, where, "-ra_max", "ra", "<");
    650     PXOPT_COPY_F64(config->args, where, "-decl_min", "decl", ">=");
    651     PXOPT_COPY_F64(config->args, where, "-decl_max", "decl", "<");
     648    PXOPT_COPY_RADEC(config->args, where, "-ra_min", "ra", ">=");
     649    PXOPT_COPY_RADEC(config->args, where, "-ra_max", "ra", "<");
     650    PXOPT_COPY_RADEC(config->args, where, "-decl_min", "decl", ">=");
     651    PXOPT_COPY_RADEC(config->args, where, "-decl_max", "decl", "<");
    652652    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "exp_time", ">=");
    653653    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "exp_time", "<");
    … …  
    669669    PXOPT_COPY_F64(config->args, where, "-posang_max", "posang", "<");
    670670    PXOPT_COPY_STR(config->args, where, "-object", "object", "==");
    671     PXOPT_COPY_F32(config->args, where, "-solang_min", "solang", ">=");
    672     PXOPT_COPY_F32(config->args, where, "-solang_max", "solang", "<");
     671    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "sun_angle", ">=");
     672    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "sun_angle", "<");
    673673
    674674    if (!psListLength(where->list)
    … …  
    895895
    896896    psMetadata *where = psMetadataAlloc();
    897     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     897    pxAddLabelSearchArgs (config, where, "-label", "fakeRun.label", "==");
    898898
    899899    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
    … …  
    11571157        // pxwarpQueueByFakeID() can only be run after fakeRun.state has been set to stop
    11581158        if (!pxwarpQueueByFakeID(config,
    1159                     fakeRun->fake_id,
    1160                     fakeRun->workdir,
    1161                     fakeRun->label,
    1162                     fakeRun->dvodb,
    1163                     fakeRun->tess_id,
    1164                     fakeRun->end_stage
     1159                                 fakeRun->fake_id,
     1160                                 fakeRun->workdir,
     1161                                 fakeRun->label,
     1162                                 fakeRun->dvodb,
     1163                                 fakeRun->tess_id,
     1164                                 fakeRun->reduction,
     1165                                 fakeRun->end_stage
    11651166        )) {
    11661167            psError(PS_ERR_UNKNOWN, false, "failed to queue warpRun");

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

    r23921 r25027  
    6161    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
    6262    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
    63     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
    64     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
    65     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
    66     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     63    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min RA (degrees)", NAN);
     64    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max RA (degrees)", NAN);
     65    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min DEC (degrees)", NAN);
     66    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max DEC (degrees)", NAN);
    6767    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
    6868    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
    … …  
    8484    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    8585    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    86     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    87     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     86    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     87    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    8888    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
    8989    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
    … …  
    114114    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
    115115    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
    116     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
    117     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
    118     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
    119     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     116    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min RA (degrees)", NAN);
     117    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max RA (degrees)", NAN);
     118    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min DEC (degrees)", NAN);
     119    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max DEC (degrees)", NAN);
    120120    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
    121121    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
    … …  
    137137    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    138138    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    139     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    140     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     139    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     140    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    141141    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    142142
    … …  
    198198    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    199199    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by fake ID", 0);
    200     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
     200    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    201201    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
    202202    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
    … …  
    212212    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
    213213    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
    214     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
    215     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
    216     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
    217     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     214    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min RA (degrees)", NAN);
     215    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max RA (degrees)", NAN);
     216    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min DEC (degrees)", NAN);
     217    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max DEC (degrees)", NAN);
    218218    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
    219219    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
    … …  
    235235    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
    236236    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
    237     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
    238     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     237    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_min",  0,            "define min solar angle", NAN);
     238    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sun_angle_max",  0,            "define max solar angle", NAN);
    239239
    240240    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);

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

    r23828 r25027  
    535535    PXOPT_LOOKUP_BOOL(limit,   config->args, "-limit",   false);
    536536
     537    psMetadata *where = psMetadataAlloc();
     538    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     539
    537540    psString query = pxDataGet("flatcorr_pendingprocess.sql");
    538541    if (!query) {
    … …  
    540543        return false;
    541544    }
     545
     546    if (where && psListLength(where->list)) {
     547        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     548        psStringAppend(&query, " AND %s", whereClause);
     549        psFree(whereClause);
     550    }
     551    psFree(where);
    542552
    543553    // treat limit == 0 as "no limit"

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

    r23688 r25027  
    101101    psMetadataAddU64 (pendingprocessArgs, PS_LIST_TAIL, "-limit",  0, "limit result set to N items", 0);
    102102    psMetadataAddBool(pendingprocessArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     103    psMetadataAddStr(pendingprocessArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by label", NULL);
    103104
    104105    // -addprocess (XXX need to add fault and stats)
    … …  
    106107    psMetadataAddS64 (addprocessArgs, PS_LIST_TAIL, "-corr_id",  0, "add complete run for specified corr_id (required)", 0);
    107108    psMetadataAddStr (addprocessArgs, PS_LIST_TAIL, "-hostname", 0, "set hostname", NULL);
    108     psMetadataAddS16 (addprocessArgs, PS_LIST_TAIL, "-fault",     0, "set fault code", 0);
     109    psMetadataAddS16 (addprocessArgs, PS_LIST_TAIL, "-code",     0, "set fault code", 0);
    109110
    110111    // -updaterun

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

    r23688 r25027  
    22 * magicdstool.c
    33 *
    4  * Copyright (C) 2006-2007  IfA
     4 * Copyright (C) 2006-2009  IfA
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    2727#include <math.h>
    2828#include <ippdb.h>
     29#include <ippStages.h>
    2930
    3031#include "pxtools.h"
    … …  
    3839static bool revertdestreakedfileMode(pxConfig *config);
    3940static bool getskycellsMode(pxConfig *config);
     41static bool toremoveMode(pxConfig *config);
     42static bool torestoreMode(pxConfig *config);
     43static bool torevertMode(pxConfig *config);
    4044
    4145static bool setmagicDSRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    6872        MODECASE(MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,revertdestreakedfileMode);
    6973        MODECASE(MAGICDSTOOL_MODE_GETSKYCELLS,         getskycellsMode);
     74        MODECASE(MAGICDSTOOL_MODE_TOREMOVE,            toremoveMode);
     75        MODECASE(MAGICDSTOOL_MODE_TORESTORE,           torestoreMode);
     76        MODECASE(MAGICDSTOOL_MODE_TOREVERT,            torevertMode);
    7077        default:
    7178            psAbort("invalid option (this should not happen)");
    … …  
    9198static bool definebyqueryMode(pxConfig *config)
    9299{
    93     PS_ASSERT_PTR_NON_NULL(config, false);
    94     psError(PS_ERR_UNKNOWN, true, "definebyquery not implelmented yet");
    95 
    96     return false;
    97 #ifdef notyet
    98100
    99101    // Required
     102    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     103
     104    // Optional
    100105    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
    101 
    102     // Optional
    103     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    104     PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    105     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     106    PXOPT_LOOKUP_STR(recoveryroot, config->args, "-recoveryroot", false, false);
     107    PXOPT_LOOKUP_BOOL(re_place, config->args, "-replace", false);
     108    PXOPT_LOOKUP_STR(set_label, config->args, "-set_label", false, false);
     109    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
     110    PXOPT_LOOKUP_BOOL(dry_run, config->args, "-dry_run", false);
    106111    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    107 
    108     // Create temporary table of the best diffs
    109     {
    110         psString query = pxDataGet("magictool_definebyquery_temp_create.sql");
    111         if (!query) {
    112             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    113             return false;
    114         }
    115 
    116         if (!p_psDBRunQuery(config->dbh, query)) {
     112    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     113
     114    // search args
     115    psMetadata *where = psMetadataAlloc();
     116    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "==");
     117    PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     118    PXOPT_COPY_S64(config->args, where, "-cam_id",  "cam_id", "==");
     119    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     120    PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
     121    PXOPT_COPY_S64(config->args, where, "-magic_id","magic_id", "==");
     122    PXOPT_COPY_S32(config->args, where, "-streaks_max","streaks", "<=");
     123
     124    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
     125
     126    ippStage stageNum = ippStringToStage(stage);
     127   
     128    psString query = NULL;
     129    switch (stageNum) {
     130    case IPP_STAGE_RAW:
     131        query = pxDataGet("magicdstool_definebyquery_raw.sql");
     132        break;
     133    case IPP_STAGE_CHIP:
     134        query = pxDataGet("magicdstool_definebyquery_chip.sql");
     135        break;
     136    case IPP_STAGE_CAMERA:
     137        query = pxDataGet("magicdstool_definebyquery_camera.sql");
     138        break;
     139    case IPP_STAGE_WARP:
     140        query = pxDataGet("magicdstool_definebyquery_warp.sql");
     141        break;
     142    case IPP_STAGE_DIFF:
     143        query = pxDataGet("magicdstool_definebyquery_diff.sql");
     144        break;
     145    case IPP_STAGE_FAKE:
     146    case IPP_STAGE_STACK:
     147        psError(PXTOOLS_ERR_DATA, true, "%sRuns do not need to be destreaked", stage);
     148        return false;
     149    case IPP_STAGE_NONE:
     150        psError(PXTOOLS_ERR_DATA, true, "%s is not a valid stage", stage);
     151        return false;
     152    default:
     153        psError(PXTOOLS_ERR_PROG, true, "ippStageToString returned %d for invalid stage %s",
     154            stageNum, stage);
     155        return false;
     156    }
     157
     158    if (!query) {
     159        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     160        return false;
     161    }
     162    char *rerun_flag =  rerun ? "\n1 " : "\n0" ;
     163
     164    if (stageNum != IPP_STAGE_DIFF) {
     165        if (psListLength(where->list)) {
     166            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     167            psStringAppend(&query, "\nAND %s", whereClause);
     168            psFree(whereClause);
     169        }
     170        psFree(where);
     171
     172        // treat limit == 0 as "no limit"
     173        if (limit) {
     174            psString limitString = psDBGenerateLimitSQL(limit);
     175            psStringAppend(&query, " %s", limitString);
     176            psFree(limitString);
     177        }
     178        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag)) {
    117179            psError(PS_ERR_UNKNOWN, false, "database error");
    118             return false;
    119         }
    120         psFree(query);
    121     }
    122 
    123     // Insert list of best diffs into temporary table
    124     {
    125         psString query = pxDataGet("magictool_definebyquery_temp_insert.sql");
    126         if (!query) {
    127             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    128             return false;
    129         }
    130 
    131         psMetadata *where = psMetadataAlloc();
    132         PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    133         PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    134         PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    135 
    136         psString whereClause = NULL;    // WHERE conditions
    137         if (psListLength(where->list)) {
    138             whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    139             psStringPrepend(&whereClause, "\n AND ");
    140         }
    141         psFree(where);
    142 
    143         if (!p_psDBRunQueryF(config->dbh, query, whereClause)) {
    144             psError(PS_ERR_UNKNOWN, false, "database error");
    145             psFree(whereClause);
    146180            psFree(query);
    147181            return false;
    148182        }
    149         psFree(whereClause);
    150         psFree(query);
    151     }
    152 
    153     // Get list of exposures ready to magic
    154     {
    155         psString query = pxDataGet("magictool_definebyquery_select.sql");
    156         if (!query) {
    157             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    158             return false;
    159         }
    160 
    161         psString magicSkyCellNumsWhere = NULL;    // WHERE conditions for magicSkyCellNums
    162         {
    163             psMetadata *where = psMetadataAlloc();
    164             PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    165             PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    166             PXOPT_COPY_F32(config->args, where, "-good_frac", "warpSkyfile.good_frac", ">=");
    167 
    168             if (psListLength(where->list)) {
    169                 magicSkyCellNumsWhere = psDBGenerateWhereConditionSQL(where, NULL);
    170                 psStringPrepend(&magicSkyCellNumsWhere, "\n AND ");
    171             }
    172             psFree(where);
    173         }
    174 
    175         // "available" means only concern ourselves with exposures that have all diffs completed, unless we're
    176         // told to only take what's available.
    177         // "new" means we want a new run even if there's already a magic run defined
    178         PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    179         PXOPT_LOOKUP_BOOL(new, config->args, "-new", false);
    180 
    181         psString queryWhere = NULL;     // WHERE conditions for entire query
    182         if (available) {
    183             psStringAppend(&queryWhere, " WHERE num_done = num_todo");
    184         }
    185         if (new) {
    186             const char *newWhere = " magic_id IS NULL"; // String to add
    187             if (queryWhere) {
    188                 psStringAppend(&queryWhere, " AND %s", newWhere);
    189             } else {
    190                 psStringAppend(&queryWhere, " WHERE %s", newWhere);
    191             }
    192         }
    193         if (queryWhere) {
    194             psStringAppend(&query, " %s", queryWhere);
    195             psFree(queryWhere);
    196         }
    197 
    198 
    199         if (!p_psDBRunQueryF(config->dbh, query, magicSkyCellNumsWhere ? magicSkyCellNumsWhere : "")) {
     183    } else {
     184        // diff stage query has two types bothways and !bothways
     185        // so we need to send the rerun flag and the where data twice
     186        psString whereString = psStringCopy("");
     187        if (psListLength(where->list)) {
     188            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     189            psStringAppend(&whereString, "\nAND %s", whereClause);
     190            psFree(whereClause);
     191        }
     192        psFree(where);
     193
     194        // treat limit == 0 as "no limit"
     195        if (limit) {
     196            psString limitString = psDBGenerateLimitSQL(limit);
     197            psStringAppend(&query, " %s", limitString);
     198            psFree(limitString);
     199        }
     200
     201        if (!p_psDBRunQueryF(config->dbh, query, rerun_flag, whereString, rerun_flag, whereString)) {
    200202            psError(PS_ERR_UNKNOWN, false, "database error");
    201             psFree(magicSkyCellNumsWhere);
     203            psFree(whereString);
    202204            psFree(query);
    203205            return false;
    204206        }
    205         psFree(magicSkyCellNumsWhere);
    206         psFree(query);
    207     }
     207        psFree(whereString);
     208    }
     209    psFree(query);
    208210
    209211    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    227229    }
    228230
    229     // Parse the list of exposures ready to magic
    230 
    231     if (!psDBTransaction(config->dbh)) {
    232         psError(PS_ERR_UNKNOWN, false, "database error");
    233         return false;
    234     }
    235 
    236     psString insert = pxDataGet("magictool_definebyquery_insert.sql"); // Insert query
     231    // Parse the list of runs ready to be destreaked
     232
     233    if (!dry_run && !psDBTransaction(config->dbh)) {
     234        psError(PS_ERR_UNKNOWN, false, "database error");
     235        return false;
     236    }
    237237
    238238    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    239239    for (long i = 0; i < psArrayLength(output); i++) {
    240240        psMetadata *row = output->data[i]; // Row of interest
    241         psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id"); // Exposure identifier
     241        psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
     242        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id");
     243        psS64 magic_id = psMetadataLookupS64(NULL, row, "magic_id");
     244        psS64 inv_magic_id = psMetadataLookupS64(NULL, row, "inv_magic_id");
     245        psS64 cam_id = psMetadataLookupS64(NULL, row, "cam_id");
     246        psString magicRunLabel = psMetadataLookupStr(NULL, row, "label");
     247        psString magicRunWorkdir = psMetadataLookupStr(NULL, row, "workdir");
     248       
     249        // if workdir is not supplied use the magicRun's
     250        if (!workdir) {
     251            workdir = magicRunWorkdir;
     252        }
     253
     254        psString outroot = NULL;
     255        // set outroot to workdir/exp_id/stage for example /somewhere/424242/chip
     256        psStringAppend(&outroot, "%s/%" PRId64 "/%s", workdir, exp_id, stage);
    242257
    243258        // create a new magicRun for this group
    244         magicRunRow *run = magicRunRowAlloc(0, exp_id, "new", workdir, "dirty", label, dvodb, registered, 0);
     259        magicDSRunRow *run = magicDSRunRowAlloc(
     260                0, // magic_ds_id
     261                magic_id,
     262                inv_magic_id,
     263                "new",
     264                stage,
     265                stage_id,
     266                cam_id,
     267                set_label ? set_label : magicRunLabel,
     268                outroot,
     269                recoveryroot,
     270                re_place,
     271                0); // remove
     272
     273        psFree(outroot);
    245274        if (!run) {
    246             psAbort("failed to alloc magicRun object");
    247         }
    248 
    249         if (!magicRunInsertObject(config->dbh, run)) {
    250             psError(PS_ERR_UNKNOWN, false, "database error");
    251             psFree(run);
    252             psFree(insert);
    253             psFree(output);
    254             psFree(list);
    255             if (!psDBRollback(config->dbh)) {
     275            psAbort("failed to alloc magicDSRun object");
     276        }
     277
     278        if (!dry_run) {
     279            if (!magicDSRunInsertObject(config->dbh, run)) {
    256280                psError(PS_ERR_UNKNOWN, false, "database error");
     281                psFree(run);
     282                psFree(output);
     283                psFree(list);
     284                if (!psDBRollback(config->dbh)) {
     285                    psError(PS_ERR_UNKNOWN, false, "database error");
     286                }
     287                return false;
    257288            }
    258             return false;
    259         }
    260 
    261         psS64 magic_id = psDBLastInsertID(config->dbh); // Assigned identifier
    262         run->magic_id = magic_id;
     289            psS64 magic_ds_id = psDBLastInsertID(config->dbh); // Assigned identifier
     290            run->magic_ds_id = magic_ds_id;
     291        }
    263292
    264293        psArrayAdd(list, list->n, run);
    265294        psFree(run);
    266 
    267         // Create a suitable insertion query for this run
    268         psString thisInsert = psStringCopy(insert);
    269         {
    270             psString idString = NULL;
    271             psStringAppend(&idString, "%" PRId64, magic_id);
    272             psStringSubstitute(&thisInsert, idString, "@MAGIC_ID@");
    273             psFree(idString);
    274         }
    275         {
    276             psString idString = NULL;
    277             psStringAppend(&idString, "%" PRId64, exp_id);
    278             psStringSubstitute(&thisInsert, idString, "@EXP_ID@");
    279             psFree(idString);
    280         }
    281 
    282         if (!p_psDBRunQueryF(config->dbh, thisInsert, magic_id, exp_id)) {
    283             psError(PS_ERR_UNKNOWN, false, "database error");
    284             psFree(thisInsert);
    285             psFree(insert);
    286             psFree(output);
    287             psFree(list);
    288             if (!psDBRollback(config->dbh)) {
    289                 psError(PS_ERR_UNKNOWN, false, "database error");
    290             }
    291             return false;
    292         }
    293         psFree(thisInsert);
    294     }
    295 
    296     if (!psDBCommit(config->dbh)) {
     295    }
     296
     297    if (!dry_run && !psDBCommit(config->dbh)) {
    297298        psError(PS_ERR_UNKNOWN, false, "database error");
    298299        return false;
    … …  
    300301    psFree(output);
    301302
    302     if (!magicRunPrintObjects(stdout, list, !simple)) {
     303    if (!magicDSRunPrintObjects(stdout, list, !simple)) {
    303304        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    304305        psFree(list);
    … …  
    309310
    310311    return true;
    311 #endif // notyet
    312312}
    313313
    … …  
    338338            0,          // ID
    339339            magic_id,
     340            0,          // inv_magic_id
    340341            "new",      // state
    341342            stage,
    … …  
    398399    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
    399400    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    400     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     401    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     402    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
    401403
    402404    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    495497    psMetadata *row = output->data[0];
    496498
    497     psString stage = psMetadataLookupStr(NULL, row, "stage");
     499    psString stage= psMetadataLookupStr(NULL, row, "stage");
    498500    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    499501
     502    ippStage stageNum = ippStringToStage(stage);
    500503
    501504    // chose the appropriate query based on the stage
    502     if (!strcmp(stage, "raw")) {
    503         query = "UPDATE rawImfile SET magicked = 1 where exp_id = %" PRId64 " AND class_id = '%s'";
    504     } else if (!strcmp(stage, "chip")) {
    505         query = "UPDATE chipProcessedImfile SET magicked = 1 where chip_id = %" PRId64 " AND class_id = '%s'";
    506     } else if (!strcmp(stage, "warp")) {
    507         query = "UPDATE warpSkyfile SET magicked = 1 where warp_id = %" PRId64 " AND skycell_id = '%s'";
    508     } else if (!strcmp(stage, "diff")) {
    509         query = "UPDATE diffSkyfile SET magicked = 1 where diff_id = %" PRId64 " AND skycell_id = '%s'";
    510     } else {
     505    switch (stageNum) {
     506    case IPP_STAGE_RAW:
     507        query = "UPDATE rawImfile SET magicked = %" PRId64 " where exp_id = %" PRId64 " AND class_id = '%s'";
     508        break;
     509    case IPP_STAGE_CHIP:
     510        query = "UPDATE chipProcessedImfile SET magicked = %" PRId64 " where chip_id = %" PRId64 " AND class_id = '%s'";
     511        break;
     512    case IPP_STAGE_CAMERA:
     513        // no there is no magicked column in camProcessedExp so we have nothing to do
     514        psFree(output);
     515        return true;
     516    case IPP_STAGE_WARP:
     517        query = "UPDATE warpSkyfile SET magicked = %" PRId64 " where warp_id = %" PRId64 " AND skycell_id = '%s'";
     518        break;
     519    case IPP_STAGE_DIFF:
     520        query = "UPDATE diffSkyfile SET magicked = %" PRId64 " where diff_id = %" PRId64 " AND skycell_id = '%s'";
     521        break;
     522    default:
    511523        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    512524        psFree(output);
    513525        return false;
    514526    }
    515     if (!p_psDBRunQueryF(config->dbh, query, stage_id, component)) {
     527
     528    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id, component)) {
    516529        psError(PS_ERR_UNKNOWN, false, "database error");
    517530        return false;
    … …  
    560573    psS64 stage_id = psMetadataLookupS64(NULL, row, "stage_id");
    561574
     575    ippStage stageNum = ippStringToStage(stage);
    562576
    563577    // chose the appropriate query based on the stage
    564     if (!strcmp(stage, "raw")) {
    565         query = "UPDATE rawExp SET magicked = 1 where exp_id = %" PRId64;
    566     } else if (!strcmp(stage, "chip")) {
    567         query = "UPDATE chipRun SET magicked = 1 where chip_id = %" PRId64;
    568     } else if (!strcmp(stage, "warp")) {
    569         query = "UPDATE warpRun SET magicked = 1 where warp_id = %" PRId64;
    570     } else if (!strcmp(stage, "diff")) {
    571         query = "UPDATE diffRun SET magicked = 1 where diff_id = %" PRId64;
    572     } else {
     578    switch (stageNum) {
     579    case IPP_STAGE_RAW:
     580        query = "UPDATE rawExp SET magicked = %" PRId64 " where exp_id = %" PRId64;
     581        break;
     582    case IPP_STAGE_CHIP:
     583        query = "UPDATE chipRun SET magicked = %" PRId64 " where chip_id = %" PRId64;
     584        break;
     585    case IPP_STAGE_CAMERA:
     586        query = "UPDATE camRun SET magicked = %" PRId64 " where cam_id = %" PRId64;
     587        break;
     588    case IPP_STAGE_WARP:
     589        query = "UPDATE warpRun SET magicked = %" PRId64 " where warp_id = %" PRId64;
     590        break;
     591    case IPP_STAGE_DIFF:
     592        query = "UPDATE diffRun SET magicked = %" PRId64 " where diff_id = %" PRId64;
     593        break;
     594    default:
    573595        psError(PS_ERR_UNKNOWN, true, "unexpected value for stage: %s found", stage);
    574596        psFree(output);
    575597        return false;
    576598    }
    577     if (!p_psDBRunQueryF(config->dbh, query, stage_id)) {
     599    if (!p_psDBRunQueryF(config->dbh, query, magic_ds_id, stage_id)) {
    578600        psError(PS_ERR_UNKNOWN, false, "database error");
    579601        return false;
    … …  
    625647    }
    626648
    627     if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault)) {
     649    if (!magicDSFileInsert(config->dbh, magic_ds_id, component, backup_path_base, recovery_path_base, fault, "full")) {
    628650            // rollback
    629651        if (!psDBRollback(config->dbh)) {
    … …  
    658680    PS_ASSERT_PTR_NON_NULL(cam_id, false);
    659681
    660     if (!strcmp(stage, "diff")) {
    661         // don't need these ids for diff stage because diff_id is in the magicRun
    662         *stage_id = 0;
    663         *cam_id = 0;
    664         return true;
    665     }
    666 
    667     int stageNum;
    668     if (!strcmp(stage, "raw")) {
    669         stageNum = 0;
    670     } else if (!strcmp(stage, "chip")) {
    671         stageNum = 1;
    672     } else if (!strcmp(stage, "warp")) {
    673         stageNum = 2;
    674     } else {
    675         psError(PXTOOLS_ERR_DATA, true, "%s is not a valid value for stage", stage);
    676         return false;
    677     }
    678 
     682    int stageNum = ippStringToStage(stage);;
     683    if (stageNum == IPP_STAGE_NONE) {
     684        psError(PXTOOLS_ERR_DATA, false, "%s is not a valid value for stage", stage);
     685        return false;
     686    }
    679687
    680688    psString query = pxDataGet("magicdstool_getrunids.sql");
    … …  
    709717
    710718    *cam_id = psMetadataLookupS64(NULL, row, "cam_id");
    711     if (stageNum == 0) {
     719    switch (stageNum) {
     720    case IPP_STAGE_RAW:
    712721        *stage_id = psMetadataLookupS64(NULL, row, "exp_id");
    713     } else if (stageNum == 1) {
     722        break;
     723    case IPP_STAGE_CHIP:
    714724        *stage_id = psMetadataLookupS64(NULL, row, "chip_id");
    715     } else if (stageNum == 2) {
     725        break;
     726    case IPP_STAGE_CAMERA:
     727        *stage_id = *cam_id;
     728        return true;
     729    case IPP_STAGE_WARP:
    716730        *stage_id = psMetadataLookupS64(NULL, row, "warp_id");
     731        break;
     732    case IPP_STAGE_DIFF:
     733        *stage_id = psMetadataLookupS64(NULL, row, "diff_id");
     734        break;
    717735    }
    718736
    … …  
    779797
    780798    psMetadata *where = psMetadataAlloc();
    781     PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     799    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magicDSRun.magic_ds_id", "==");
    782800    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");
    783801    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    784 
    785     psString query = psStringCopy("DELETE FROM magicDSFile WHERE fault != 0");
     802    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     803
     804    psString query = psStringCopy("DELETE FROM magicDSFile USING magicDSFile, magicDSRun  WHERE (magicDSRun.magic_ds_id = magicDSFile.magic_ds_id) AND magicDSFile.fault != 0");
    786805
    787806    if (psListLength(where->list)) {
    … …  
    889908}
    890909
     910static bool toremoveMode(pxConfig *config)
     911{
     912    PS_ASSERT_PTR_NON_NULL(config, false);
     913
     914    psMetadata *where = psMetadataAlloc();
     915    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     916    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     917    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     918
     919    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     920    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     921
     922    // look for "inputs" that need to processed
     923    psString query = pxDataGet("magicdstool_toremove.sql");
     924    if (!query) {
     925        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     926        return false;
     927    }
     928
     929    if (psListLength(where->list)) {
     930        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     931        psStringAppend(&query, " WHERE %s", whereClause);
     932        psFree(whereClause);
     933    }
     934    psFree(where);
     935
     936    // treat limit == 0 as "no limit"
     937    if (limit) {
     938        psString limitString = psDBGenerateLimitSQL(limit);
     939        psStringAppend(&query, " %s", limitString);
     940        psFree(limitString);
     941    }
     942
     943    if (!p_psDBRunQuery(config->dbh, query)) {
     944        psError(PS_ERR_UNKNOWN, false, "database error");
     945        psFree(query);
     946        return false;
     947    }
     948    psFree(query);
     949
     950    psArray *output = p_psDBFetchResult(config->dbh);
     951    if (!output) {
     952        psErrorCode err = psErrorCodeLast();
     953        switch (err) {
     954            case PS_ERR_DB_CLIENT:
     955                psError(PXTOOLS_ERR_SYS, false, "database error");
     956            case PS_ERR_DB_SERVER:
     957                psError(PXTOOLS_ERR_PROG, false, "database error");
     958            default:
     959                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     960        }
     961
     962        return false;
     963    }
     964    if (!psArrayLength(output)) {
     965        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     966        psFree(output);
     967        return true;
     968    }
     969
     970    if (psArrayLength(output)) {
     971        // negative simple so the default is true
     972        if (!ippdbPrintMetadatas(stdout, output, "toremove", !simple)) {
     973            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     974            psFree(output);
     975            return false;
     976        }
     977    }
     978
     979    psFree(output);
     980
     981    return true;
     982}
     983static bool torestoreMode(pxConfig *config)
     984{
     985    PS_ASSERT_PTR_NON_NULL(config, false);
     986
     987    psMetadata *where = psMetadataAlloc();
     988    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     989    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     990    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     991
     992    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     993    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     994
     995    // look for "inputs" that need to processed
     996    psString query = pxDataGet("magicdstool_torestore.sql");
     997    if (!query) {
     998        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     999        return false;
     1000    }
     1001
     1002    if (psListLength(where->list)) {
     1003        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1004        psStringAppend(&query, " WHERE %s", whereClause);
     1005        psFree(whereClause);
     1006    }
     1007    psFree(where);
     1008
     1009    // treat limit == 0 as "no limit"
     1010    if (limit) {
     1011        psString limitString = psDBGenerateLimitSQL(limit);
     1012        psStringAppend(&query, " %s", limitString);
     1013        psFree(limitString);
     1014    }
     1015
     1016    if (!p_psDBRunQuery(config->dbh, query)) {
     1017        psError(PS_ERR_UNKNOWN, false, "database error");
     1018        psFree(query);
     1019        return false;
     1020    }
     1021    psFree(query);
     1022
     1023    psArray *output = p_psDBFetchResult(config->dbh);
     1024    if (!output) {
     1025        psErrorCode err = psErrorCodeLast();
     1026        switch (err) {
     1027            case PS_ERR_DB_CLIENT:
     1028                psError(PXTOOLS_ERR_SYS, false, "database error");
     1029            case PS_ERR_DB_SERVER:
     1030                psError(PXTOOLS_ERR_PROG, false, "database error");
     1031            default:
     1032                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1033        }
     1034
     1035        return false;
     1036    }
     1037    if (!psArrayLength(output)) {
     1038        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     1039        psFree(output);
     1040        return true;
     1041    }
     1042
     1043    if (psArrayLength(output)) {
     1044        // negative simple so the default is true
     1045        if (!ippdbPrintMetadatas(stdout, output, "torestore", !simple)) {
     1046            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1047            psFree(output);
     1048            return false;
     1049        }
     1050    }
     1051
     1052    psFree(output);
     1053
     1054    return true;
     1055}
     1056
     1057
     1058static bool torevertMode(pxConfig *config)
     1059{
     1060    PS_ASSERT_PTR_NON_NULL(config, false);
     1061
     1062    psMetadata *where = psMetadataAlloc();
     1063    PXOPT_LOOKUP_STR(stage, config->args, "-stage", true, false);
     1064
     1065    PXOPT_COPY_S64(config->args, where, "-magic_ds_id", "magic_ds_id", "==");
     1066    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1067    pxAddLabelSearchArgs (config, where, "-label", "magicDSRun.label", "==");
     1068
     1069    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1070    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1071
     1072    psString sql_file = NULL;
     1073    psStringAppend(&sql_file, "magicdstool_torevert_%s.sql", stage);
     1074
     1075    psString query = pxDataGet(sql_file);
     1076    if (!query) {
     1077        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", sql_file);
     1078        psFree(sql_file);
     1079        return false;
     1080    }
     1081    psFree(sql_file);
     1082
     1083    if (psListLength(where->list)) {
     1084        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1085        psStringAppend(&query, " AND %s", whereClause);
     1086        psFree(whereClause);
     1087    }
     1088    psFree(where);
     1089
     1090    // treat limit == 0 as "no limit"
     1091    if (limit) {
     1092        psString limitString = psDBGenerateLimitSQL(limit);
     1093        psStringAppend(&query, " %s", limitString);
     1094        psFree(limitString);
     1095    }
     1096
     1097    if (!p_psDBRunQuery(config->dbh, query)) {
     1098        psError(PS_ERR_UNKNOWN, false, "database error");
     1099        psFree(query);
     1100        return false;
     1101    }
     1102    psFree(query);
     1103
     1104    psArray *output = p_psDBFetchResult(config->dbh);
     1105    if (!output) {
     1106        psErrorCode err = psErrorCodeLast();
     1107        switch (err) {
     1108            case PS_ERR_DB_CLIENT:
     1109                psError(PXTOOLS_ERR_SYS, false, "database error");
     1110            case PS_ERR_DB_SERVER:
     1111                psError(PXTOOLS_ERR_PROG, false, "database error");
     1112            default:
     1113                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1114        }
     1115
     1116        return false;
     1117    }
     1118    if (!psArrayLength(output)) {
     1119        psTrace("magicdstool", PS_LOG_INFO, "no rows found");
     1120        psFree(output);
     1121        return true;
     1122    }
     1123
     1124    if (psArrayLength(output)) {
     1125        // negative simple so the default is true
     1126        if (!ippdbPrintMetadatas(stdout, output, "torevert", !simple)) {
     1127            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1128            psFree(output);
     1129            return false;
     1130        }
     1131    }
     1132
     1133    psFree(output);
     1134
     1135    return true;
     1136}
     1137
     1138

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

    r20764 r25027  
    3232    MAGICDSTOOL_MODE_REVERTDESTREAKEDFILE,
    3333    MAGICDSTOOL_MODE_GETSKYCELLS,
     34    MAGICDSTOOL_MODE_TOREMOVE,
     35    MAGICDSTOOL_MODE_TORESTORE,
     36    MAGICDSTOOL_MODE_TOREVERT,
    3437} MAGICDStoolMode;
    3538

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

    r23688 r25027  
    4949    // -definebyquery
    5050    psMetadata *definebyqueryArgs = psMetadataAlloc();
    51 #ifdef notyet
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir (required)", NULL);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    55     psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
    56     psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    58     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-good_frac", 0, "limit good_frac", NAN);
    59     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-available", 0, "process what's immediately available?", false);
    60     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-new", 0, "generate new run even if existing?", false);
    61     psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    62 #endif
     51    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-stage",       0, "define stage (required)", NULL);
     52    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-workdir",     0, "define workdir", NULL);
     53    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
     54    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-replace", 0, "replace input files with the destreaked versions", false);
     55    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label",    0, "define label", NULL);
     56
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by magicRun.label", NULL);
     58    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id",   0, "search by exp_id", 0);
     59    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-chip_id",  0, "search by chip_id", 0);
     60    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-cam_id",  0, "search by cam_id", 0);
     61    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-warp_id",  0, "search by warp_id", 0);
     62    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id",  0, "search by diff_id", 0);
     63    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic_id", 0);
     64    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-streaks_max", 0, "maximum number of streaks", 0);
     65
     66    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun",   0, "queue a new run even if one arleady exists", false);
     67    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-dry_run", 0, "don't queue runs just display what would be queued", false);
     68    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     69    psMetadataAddU64(definebyqueryArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    6370
    6471    // -definerun
    6572    psMetadata *definerunArgs = psMetadataAlloc();
    6673    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magic_id (required)", 0);
    67     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define output directory (required)", NULL);
     74    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-stage", 0, "define stage for run (required)", NULL);
    6875    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-outroot", 0, "define output directory (required)", NULL);
    6976    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-recoveryroot", 0, "define recovery directory", NULL);
    … …  
    8895    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
    8996    psMetadataAddS64(todestreakArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    90     psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
     97    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     98    psMetadataAddStr(todestreakArgs, PS_LIST_TAIL, "-stage", 0, "limit query to stage", NULL);
    9199    psMetadataAddU64(todestreakArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    92100    psMetadataAddBool(todestreakArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    106114    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-component", 0, "search by component", NULL);
    107115    psMetadataAddS16(revertdestreakedfileArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     116    psMetadataAddStr(revertdestreakedfileArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
    108117
    109118    // -getskycells
    … …  
    113122    psMetadataAddStr(getskycellsArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    114123    psMetadataAddBool(getskycellsArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     124
     125    // -toremove
     126    psMetadata *toremoveArgs = psMetadataAlloc();
     127    psMetadataAddS64(toremoveArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     128    psMetadataAddS64(toremoveArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     129    psMetadataAddStr(toremoveArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     130    psMetadataAddU64(toremoveArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     131    psMetadataAddBool(toremoveArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     132
     133    // -torestore
     134    psMetadata *torestoreArgs = psMetadataAlloc();
     135    psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     136    psMetadataAddS64(torestoreArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     137    psMetadataAddStr(torestoreArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     138    psMetadataAddU64(torestoreArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     139    psMetadataAddBool(torestoreArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     140
     141    // -torevert
     142    psMetadata *torevertArgs = psMetadataAlloc();
     143    psMetadataAddS64(torevertArgs, PS_LIST_TAIL, "-magic_ds_id", 0, "search by magic Destreak ID", 0);
     144    psMetadataAddS64(torevertArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
     145    psMetadataAddStr(torevertArgs, PS_LIST_TAIL, "-stage", 0, "define output directory (required)", NULL);
     146    psMetadataAddStr(torevertArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "define label", NULL);
     147    psMetadataAddU64(torevertArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     148    psMetadataAddBool(torevertArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    115149
    116150    psFree(now);
    … …  
    133167    PXOPT_ADD_MODE("-getskycells", "get skycell files ",
    134168                    MAGICDSTOOL_MODE_GETSKYCELLS, getskycellsArgs);
     169    PXOPT_ADD_MODE("-toremove", "backup images pending removal",
     170                    MAGICDSTOOL_MODE_TOREMOVE, toremoveArgs);
     171    PXOPT_ADD_MODE("-torestore", "images pending restore of exicsed streak pixels",
     172                    MAGICDSTOOL_MODE_TORESTORE, torestoreArgs);
     173    PXOPT_ADD_MODE("-torevert", "faulted images to revert",
     174                    MAGICDSTOOL_MODE_TOREVERT, torevertArgs);
    135175
    136176    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r23688 r25027  
    4747static bool revertmaskMode(pxConfig *config);
    4848static bool maskMode(pxConfig *config);
    49 static bool diffskyfileMode(pxConfig *config);
    50 static bool warpskyfileMode(pxConfig *config);
    51 static bool chipprocessedimfileMode(pxConfig *config);
    52 static bool rawimfileMode(pxConfig *config);
    53 
     49static bool censorrunMode(pxConfig *config);
    5450
    5551static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    9086        MODECASE(MAGICTOOL_MODE_REVERTMASK,          revertmaskMode);
    9187        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
    92         MODECASE(MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileMode);
    93         MODECASE(MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileMode);
    94         MODECASE(MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileMode);
    95         MODECASE(MAGICTOOL_MODE_RAWIMFILE,           rawimfileMode);
     88        MODECASE(MAGICTOOL_MODE_CENSORRUN,           censorrunMode);
    9689        default:
    9790            psAbort("invalid option (this should not happen)");
    … …  
    127120    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    128121    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    129 
    130     psMetadata *where = psMetadataAlloc();
    131     PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    132     PXOPT_COPY_STR(config->args, where, "-diff_label", "diffRun.label", "==");
    133 
     122    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     123
     124    psMetadata *diffWhere = psMetadataAlloc(); // WHERE conditions for diffRuns
     125    PXOPT_COPY_STR(config->args, diffWhere, "-diff_label", "diffRun.label", "==");
     126    PXOPT_COPY_S64(config->args, diffWhere, "-diff_id", "diff_id", "==");
     127
     128    psMetadata *queryWhere = psMetadataAlloc(); // WHERE conditions for everything else
     129    PXOPT_COPY_S64(config->args, queryWhere, "-exp_id", "exp_id", "==");
    134130
    135131    // Get list of exposures ready to magic
    … …  
    146142        PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    147143
    148         psString queryWhere = NULL;     // WHERE conditions for entire query
     144        psString diffWhereStr = NULL;   // WHERE conditions for diffRuns
     145        psString queryWhereStr = NULL;  // WHERE conditions for entire query
    149146        if (!available) {
    150             psStringAppend(&queryWhere, " \nWHERE diffRun.state = 'full'");
    151         } else {
    152             // what if no skycells for the diff run completed?
    153         }
     147            psStringAppend(&diffWhereStr, "\nAND diffRun.state = 'full'");
     148        }
     149        // what if no skycells for the diff run completed?
     150
    154151        if (!rerun) {
    155             const char *newWhere = " magic_id IS NULL"; // String to add
    156             if (queryWhere) {
    157                 psStringAppend(&queryWhere, " AND %s", newWhere);
    158             } else {
    159                 psStringAppend(&queryWhere, "\nWHERE %s", newWhere);
    160             }
    161         }
     152            psStringAppend(&queryWhereStr, "\n%s magic_id IS NULL", queryWhereStr ? "AND" : "WHERE");
     153        }
     154
    162155        // now add the user specified qualifiers
    163         if (psListLength(where->list)) {
    164             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    165             psStringAppend(&queryWhere, "\n%s %s", queryWhere == NULL ? "WHERE" : "AND", whereClause);
     156        if (psListLength(diffWhere->list)) {
     157            psString whereClause = psDBGenerateWhereConditionSQL(diffWhere, NULL);
     158            psStringAppend(&diffWhereStr, "\nAND %s", whereClause);
    166159            psFree(whereClause);
    167160        }
    168         psFree(where);
    169         if (!queryWhere) {
    170             psStringAppend(&queryWhere, " ");
    171         }
    172 
    173         if (!p_psDBRunQueryF(config->dbh, query, queryWhere)) {
     161        if (psListLength(queryWhere->list)) {
     162            psString whereClause = psDBGenerateWhereConditionSQL(queryWhere, NULL);
     163            psStringAppend(&queryWhereStr, "\n%s %s", queryWhereStr ? "AND" : "WHERE", whereClause);
     164            psFree(whereClause);
     165        }
     166        psFree(diffWhere);
     167        psFree(queryWhere);
     168
     169        // Ensure the WHERE strings have something
     170        if (!diffWhereStr) {
     171            diffWhereStr = psStringCopy("");
     172        }
     173        if (!queryWhereStr) {
     174            queryWhereStr = psStringCopy("");
     175        }
     176
     177        if (!p_psDBRunQueryF(config->dbh, query, diffWhereStr, diffWhereStr, queryWhereStr)) {
    174178            psError(PS_ERR_UNKNOWN, false, "database error");
    175             psFree(queryWhere);
     179            psFree(diffWhereStr);
     180            psFree(queryWhereStr);
    176181            psFree(query);
    177182            return false;
    178183        }
    179         psFree(queryWhere);
     184        psFree(diffWhereStr);
     185        psFree(queryWhereStr);
    180186        psFree(query);
    181187    }
    … …  
    201207    }
    202208
     209
     210    if (pretend) {
     211        // negative simple so the default is true
     212        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     213            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     214            psFree(output);
     215            return false;
     216        }
     217        psFree(output);
     218        return true;
     219    }
     220
     221
    203222    // Parse the list of exposures ready to magic
    204 
    205223    if (!psDBTransaction(config->dbh)) {
    206224        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    215233        psS64 exp_id = psMetadataLookupS64(NULL, row, "exp_id"); // Exposure identifier
    216234        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id"); // difference identifier
     235        bool inverse = psMetadataLookupU64(NULL, row, "inverse"); // Inverse subtraction? Note types!
    217236
    218237        // create a new magicRun for this group
    219         magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, "new", workdir, "dirty", label, dvodb, registered, 0);
     238        magicRunRow *run = magicRunRowAlloc(0, exp_id, diff_id, inverse, "new", workdir, "dirty", label,
     239                                            dvodb, registered, 0);
    220240        if (!run) {
    221241            psAbort("failed to alloc magicRun object");
    … …  
    296316
    297317    // optional
     318    PXOPT_LOOKUP_BOOL(inverse, config->args, "-inverse", false);
    298319    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    299320    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    … …  
    305326            exp_id,
    306327            diff_id ? diff_id : PS_MAX_S64,
     328            inverse,
    307329            "reg",      // state
    308330            workdir,
    … …  
    363385    // required
    364386    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    365     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    366387    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
    367388
    … …  
    369390            config->dbh,
    370391            magic_id,
    371             diff_id,
    372392            node
    373393    );
    … …  
    457477    psMetadata *where = psMetadataAlloc();
    458478    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    459     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     479    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    460480
    461481    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    562582    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    563583    PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
    564 
    565     psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'run' WHERE fault != 0");
     584    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     585
     586    psString query = psStringCopy("UPDATE magicRun SET fault = 0, state = 'new' WHERE fault != 0");
    566587
    567588    if (psListLength(where->list)) {
    … …  
    584605    PS_ASSERT_PTR_NON_NULL(config, false);
    585606
    586     psMetadata *where = psMetadataAlloc();
    587     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    588     PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
     607    // Regrettably, there are multiple WHERE hooks which call the same things different names
     608    psMetadata *templatesWhere = psMetadataAlloc(); // WHERE for selecting template
     609    psMetadata *magicWhere = psMetadataAlloc();     // WHERE for selecting magic runs
     610
     611    PXOPT_COPY_S64(config->args, templatesWhere, "-magic_id", "magicRun.magic_id", "==");
     612    PXOPT_COPY_STR(config->args, templatesWhere, "-node", "diffInputSkyfile.skycell_id", "==");
     613
     614    PXOPT_COPY_S64(config->args, magicWhere, "-magic_id", "magicRun.magic_id", "==");
     615    PXOPT_COPY_STR(config->args, magicWhere, "-node", "magicTree.node", "==");
    589616
    590617    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    597624    }
    598625
    599     if (psListLength(where->list)) {
    600         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    601         psStringAppend(&query, " AND %s", whereClause);
     626    psString templatesWhereStr = psStringCopy(""); // WHERE for selecting template
     627    psString magicWhereStr = psStringCopy("");     // WHERE for selecting magic runs
     628
     629    if (psListLength(templatesWhere->list)) {
     630        psString whereClause = psDBGenerateWhereConditionSQL(templatesWhere, NULL);
     631        psStringAppend(&templatesWhereStr, "\nAND %s", whereClause);
    602632        psFree(whereClause);
    603633    }
    604     psFree(where);
     634    psFree(templatesWhere);
     635
     636    if (psListLength(magicWhere->list)) {
     637        psString whereClause = psDBGenerateWhereConditionSQL(magicWhere, NULL);
     638        psStringAppend(&magicWhereStr, "\nWHERE %s", whereClause);
     639        psFree(whereClause);
     640    }
     641    psFree(magicWhere);
    605642
    606643    // treat limit == 0 as "no limit"
    … …  
    611648    }
    612649
    613     if (!p_psDBRunQuery(config->dbh, query)) {
    614         psError(PS_ERR_UNKNOWN, false, "database error");
     650    if (!p_psDBRunQueryF(config->dbh, query,
     651                         templatesWhereStr, templatesWhereStr,
     652                         magicWhereStr, magicWhereStr)) {
     653        psError(PS_ERR_UNKNOWN, false, "database error");
     654        psFree(templatesWhereStr);
     655        psFree(magicWhereStr);
    615656        psFree(query);
    616657        return false;
    617658    }
     659    psFree(templatesWhereStr);
     660    psFree(magicWhereStr);
    618661    psFree(query);
    619662
    … …  
    704747
    705748            bool status = false;
    706             psS32 done = psMetadataLookupS32(&status, data, "done");
     749            psS64 done = psMetadataLookupS64(&status, data, "done");
    707750            if (!status) {
    708751                psAbort("failed to lookup value for done column");
    709752            }
    710             psS16 bad = psMetadataLookupS16(&status, data, "bad");
     753            psS64 bad = psMetadataLookupS64(&status, data, "bad");
    711754            if (!status) {
    712755                psAbort("failed to lookup value for bad column");
    … …  
    738781
    739782    psMetadata *where = psMetadataAlloc();
    740     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    741     PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     783    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     784    pxAddLabelSearchArgs (config, where, "-label", "magicRun.label", "==");
    742785
    743786    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     787    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    744788
    745789    // look for "inputs" that need to processed
    … …  
    750794    }
    751795
    752     psString whereClause = NULL;
     796    psString whereString = NULL;
    753797    if (psListLength(where->list)) {
    754         whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    755         psStringAppend(&query, " AND %s", whereClause);
     798        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     799        psStringAppend(&whereString, "\nAND %s", whereClause);
     800        psFree(whereClause);
    756801    }
    757802    psFree(where);
    758803
    759     if (!p_psDBRunQuery(config->dbh, query)) {
    760         psError(PS_ERR_UNKNOWN, false, "database error");
     804    // treat limit == 0 as "no limit"
     805    if (limit) {
     806        // cut limit in half
     807        // hack to prevent pending leaf nodes from blocking branch nodes
     808        psString limitString = psDBGenerateLimitSQL((limit + 1) / 2);
     809        psStringAppend(&query, " %s", limitString);
     810        psFree(limitString);
     811    }
     812
     813    if (!p_psDBRunQueryF(config->dbh, query, whereString, whereString)) {
     814        psError(PS_ERR_UNKNOWN, false, "database error");
     815        psFree(whereString);
    761816        psFree(query);
    762817        return false;
    … …  
    782837    }
    783838
     839    if (limit) {
     840        if (psArrayLength(output) >= limit) {
     841            // we've found enough (note that limit was applied to the query so '> limit' won't happen)
     842            // negative simple so the default is true
     843            if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
     844                psError(PS_ERR_UNKNOWN, false, "failed to print array");
     845                psFree(output);
     846                return false;
     847            }
     848            psFree(output);
     849            return true;
     850        }
     851    }
     852
    784853    // look for tree nodes that need to be processed
    785     query = pxDataGet("magictool_toprocess_tree.sql");
     854    query = pxDataGet("magictool_toprocess_runs.sql");
    786855    if (!query) {
    787856        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    789858    }
    790859
    791     if (whereClause) {
    792         psString new  = NULL;
    793         psStringAppend(&new, "\n AND %s", whereClause);
    794         psFree(whereClause);
    795         whereClause = new;
    796     }
    797     if (!p_psDBRunQueryF(config->dbh, query, whereClause ? whereClause :  "")) {
    798         psError(PS_ERR_UNKNOWN, false, "database error");
    799         psFree(whereClause);
     860    {
     861        psString limitString = psDBGenerateLimitSQL( 100 );
     862        psStringAppend(&query, " %s", limitString);
     863        psFree(limitString);
     864    }
     865
     866    if (!p_psDBRunQueryF(config->dbh, query, whereString ? whereString :  "")) {
     867        psError(PS_ERR_UNKNOWN, false, "database error");
     868        psFree(whereString);
    800869        psFree(query);
    801870        return false;
    802871    }
    803     psFree(whereClause);
     872    psFree(whereString);
    804873    psFree(query);
    805874
    806     psArray *magicTree = p_psDBFetchResult(config->dbh);
    807     if (!magicTree) {
     875    psArray *magicRuns = p_psDBFetchResult(config->dbh);
     876    if (!magicRuns) {
    808877        psErrorCode err = psErrorCodeLast();
    809878        switch (err) {
    … …  
    818887        return false;
    819888    }
    820     if (!psArrayLength(magicTree)) {
     889    if (!psArrayLength(magicRuns)) {
    821890        psTrace("magictool", PS_LOG_INFO, "no rows found");
    822         psFree(magicTree);
     891        psFree(magicRuns);
    823892        return true;
    824893    }
    825894
    826     // entries are ordered by magic_id
    827     long index = 0;
    828     while (index <  psArrayLength(magicTree)) {
     895    query = pxDataGet("magictool_toprocess_tree.sql");
     896    if (!query) {
     897        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     898        return false;
     899    }
     900
     901    for (psS64 index = 0; index < psArrayLength(magicRuns); index++) {
     902        if (limit && (psArrayLength(output) >= limit)) {
     903            break;
     904        }
    829905        bool status;
    830         psS64 current_magic_id = psMetadataLookupS64(&status, magicTree->data[index], "magic_id");
     906        psS64 magic_id = psMetadataLookupS64(&status, magicRuns->data[index], "magic_id");
    831907        if (!status) {
    832908            psAbort("failed to lookup value for magic_id column");
    833909        }
    834 
    835         // find the end of this block
    836         long first = index;
    837         long last = index;
    838         for (long i = index + 1; i < psArrayLength(magicTree); i++) {
    839             psS64 magic_id = psMetadataLookupS64(&status, magicTree->data[i], "magic_id");
    840             if (!status) {
    841                 psAbort("failed to lookup value for magic_id column");
     910       
     911        whereString = NULL;
     912        psStringAppend(&whereString, "\nAND (magic_id = %" PRId64 ")", magic_id);
     913        if (!p_psDBRunQueryF(config->dbh, query, whereString )) {
     914            psError(PS_ERR_UNKNOWN, false, "database error");
     915            psFree(whereString);
     916            psFree(query);
     917            return false;
     918        }
     919        psFree(whereString);
     920        psArray *magicTree = p_psDBFetchResult(config->dbh);
     921        if (!magicTree) {
     922            psErrorCode err = psErrorCodeLast();
     923            switch (err) {
     924                case PS_ERR_DB_CLIENT:
     925                    psError(PXTOOLS_ERR_SYS, false, "database error");
     926                case PS_ERR_DB_SERVER:
     927                    psError(PXTOOLS_ERR_PROG, false, "database error");
     928                default:
     929                    psError(PXTOOLS_ERR_PROG, false, "unknown error");
    842930            }
    843             if (magic_id != current_magic_id) {
    844                 break;
    845             }
    846             last = i;
    847         }
    848 
    849         index = last + 1;
    850 
    851         psHash *forest = psHashAlloc(last - first + 1);
     931
     932            return false;
     933        }
     934        psS64 length = psArrayLength(magicTree);
     935        if (!length) {
     936            psTrace("magictool", PS_LOG_INFO, "no rows found for magic_id %" PRId64, magic_id);
     937            psFree(magicTree);
     938            continue;
     939        }
     940
     941        psHash *forest = psHashAlloc(length);
    852942
    853943        // convert the array of metadata into a pxTree structure
    854         for (long i = first; i <= last; i++) {
     944        for (long i = 0; i < length; i++) {
    855945            bool status;
    856946            psString node = psMetadataLookupStr(&status, magicTree->data[i], "node");
    … …  
    877967        pxTreeCrawl(root, findReadyNodes, output);
    878968        psFree(root);
    879 
     969        psFree(magicTree);
    880970    }
    881971
    882972    if (psArrayLength(output)) {
     973        if (limit && (limit < psArrayLength(output))) {
     974            // truncate the array
     975            long arrayLength = psArrayLength(output);
     976            for (long i = arrayLength - 1; i >= limit; i--) {
     977                psArrayRemoveIndex(output, i);
     978            }
     979        }
    883980        // negative simple so the default is true
    884981        if (!ippdbPrintMetadatas(stdout, output, "magicMe", !simple)) {
    … …  
    889986    }
    890987
    891     psFree(magicTree);
    892988    psFree(output);
    893989
    … …  
    9051001
    9061002    // optional
    907     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     1003    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    9081004
    9091005    // default values
    … …  
    9131009                               magic_id,
    9141010                               node,
    915                                uri,
     1011                               path_base,
    9161012                               fault
    9171013        )) {
    … …  
    9311027    PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
    9321028    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    933     PXOPT_COPY_S16(config->args, where, "-fault", "fault", "==");
     1029    PXOPT_COPY_S16(config->args, where, "-fault", "magicNodeResult.fault", "==");
    9341030
    9351031    psString query = pxDataGet("magictool_revertnode.sql");
    … …  
    12261322}
    12271323
    1228 
    1229 static bool diffskyfileMode(pxConfig *config)
    1230 {
    1231     PS_ASSERT_PTR_NON_NULL(config, false);
    1232 
    1233     psMetadata *where = psMetadataAlloc();
    1234     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1235     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1236     PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
    1237 
    1238     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1239 
    1240     psString query = pxDataGet("magictool_diffskyfile.sql");
    1241     if (!query) {
    1242         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1243         return false;
    1244     }
    1245 
    1246     if (psListLength(where->list)) {
    1247         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1248         psStringAppend(&query, " AND %s", whereClause);
    1249         psFree(whereClause);
    1250     }
    1251     psFree(where);
    1252 
    1253     if (!p_psDBRunQuery(config->dbh, query)) {
    1254         psError(PS_ERR_UNKNOWN, false, "database error");
    1255         psFree(query);
    1256         return false;
    1257     }
    1258     psFree(query);
    1259 
    1260     psArray *output = p_psDBFetchResult(config->dbh);
    1261     if (!output) {
    1262         psErrorCode err = psErrorCodeLast();
    1263         switch (err) {
    1264             case PS_ERR_DB_CLIENT:
    1265                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1266             case PS_ERR_DB_SERVER:
    1267                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1268             default:
    1269                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1270         }
    1271 
    1272         return false;
    1273     }
    1274     if (!psArrayLength(output)) {
    1275         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1276         psFree(output);
    1277         return true;
    1278     }
    1279 
    1280     if (psArrayLength(output)) {
    1281         // negative simple so the default is true
    1282         if (!ippdbPrintMetadatas(stdout, output, "magicDiffSkyfile", !simple)) {
    1283             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1284             psFree(output);
    1285             return false;
    1286         }
    1287     }
    1288 
    1289     psFree(output);
    1290 
    1291     return true;
    1292 }
    1293 
    1294 
    1295 static bool warpskyfileMode(pxConfig *config)
    1296 {
    1297     PS_ASSERT_PTR_NON_NULL(config, false);
    1298 
    1299     psMetadata *where = psMetadataAlloc();
    1300     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1301     PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    1302 
    1303     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1304 
    1305     psString query = pxDataGet("magictool_warpskyfile.sql");
    1306     if (!query) {
    1307         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1308         return false;
    1309     }
    1310 
    1311     if (psListLength(where->list)) {
    1312         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1313         psStringAppend(&query, " AND %s", whereClause);
    1314         psFree(whereClause);
    1315     }
    1316     psFree(where);
    1317 
    1318     if (!p_psDBRunQuery(config->dbh, query)) {
    1319         psError(PS_ERR_UNKNOWN, false, "database error");
    1320         psFree(query);
    1321         return false;
    1322     }
    1323     psFree(query);
    1324 
    1325     psArray *output = p_psDBFetchResult(config->dbh);
    1326     if (!output) {
    1327         psErrorCode err = psErrorCodeLast();
    1328         switch (err) {
    1329             case PS_ERR_DB_CLIENT:
    1330                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1331             case PS_ERR_DB_SERVER:
    1332                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1333             default:
    1334                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1335         }
    1336 
    1337         return false;
    1338     }
    1339     if (!psArrayLength(output)) {
    1340         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1341         psFree(output);
    1342         return true;
    1343     }
    1344 
    1345     if (psArrayLength(output)) {
    1346         // negative simple so the default is true
    1347         if (!ippdbPrintMetadatas(stdout, output, "magicWarpSkyfile", !simple)) {
    1348             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1349             psFree(output);
    1350             return false;
    1351         }
    1352     }
    1353 
    1354     psFree(output);
    1355 
    1356     return true;
    1357 }
    1358 
    1359 
    1360 static bool chipprocessedimfileMode(pxConfig *config)
    1361 {
    1362     PS_ASSERT_PTR_NON_NULL(config, false);
    1363 
    1364     psMetadata *where = psMetadataAlloc();
    1365     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1366     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1367 
    1368     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1369 
    1370     psString query = pxDataGet("magictool_chipprocessedimfile.sql");
    1371     if (!query) {
    1372         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1373         return false;
    1374     }
    1375 
    1376     if (psListLength(where->list)) {
    1377         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1378         psStringAppend(&query, " AND %s", whereClause);
    1379         psFree(whereClause);
    1380     }
    1381     psFree(where);
    1382 
    1383     if (!p_psDBRunQuery(config->dbh, query)) {
    1384         psError(PS_ERR_UNKNOWN, false, "database error");
    1385         psFree(query);
    1386         return false;
    1387     }
    1388     psFree(query);
    1389 
    1390     psArray *output = p_psDBFetchResult(config->dbh);
    1391     if (!output) {
    1392         psErrorCode err = psErrorCodeLast();
    1393         switch (err) {
    1394             case PS_ERR_DB_CLIENT:
    1395                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1396             case PS_ERR_DB_SERVER:
    1397                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1398             default:
    1399                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1400         }
    1401 
    1402         return false;
    1403     }
    1404     if (!psArrayLength(output)) {
    1405         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1406         psFree(output);
    1407         return true;
    1408     }
    1409 
    1410     if (psArrayLength(output)) {
    1411         // negative simple so the default is true
    1412         if (!ippdbPrintMetadatas(stdout, output, "magicChipProcessedImfile", !simple)) {
    1413             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1414             psFree(output);
    1415             return false;
    1416         }
    1417     }
    1418 
    1419     psFree(output);
    1420 
    1421     return true;
    1422 }
    1423 
    1424 
    1425 static bool rawimfileMode(pxConfig *config)
    1426 {
    1427     PS_ASSERT_PTR_NON_NULL(config, false);
    1428 
    1429     psMetadata *where = psMetadataAlloc();
    1430     PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
    1431     PXOPT_COPY_STR(config->args, where, "-class_id", "warpSkyCellMap.class_id", "==");
    1432 
    1433     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1434 
    1435     psString query = pxDataGet("magictool_rawimfile.sql");
    1436     if (!query) {
    1437         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1438         return false;
    1439     }
    1440 
    1441     if (psListLength(where->list)) {
    1442         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1443         psStringAppend(&query, " AND %s", whereClause);
    1444         psFree(whereClause);
    1445     }
    1446     psFree(where);
    1447 
    1448     if (!p_psDBRunQuery(config->dbh, query)) {
    1449         psError(PS_ERR_UNKNOWN, false, "database error");
    1450         psFree(query);
    1451         return false;
    1452     }
    1453     psFree(query);
    1454 
    1455     psArray *output = p_psDBFetchResult(config->dbh);
    1456     if (!output) {
    1457         psErrorCode err = psErrorCodeLast();
    1458         switch (err) {
    1459             case PS_ERR_DB_CLIENT:
    1460                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1461             case PS_ERR_DB_SERVER:
    1462                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1463             default:
    1464                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1465         }
    1466 
    1467         return false;
    1468     }
    1469     if (!psArrayLength(output)) {
    1470         psTrace("magictool", PS_LOG_INFO, "no rows found");
    1471         psFree(output);
    1472         return true;
    1473     }
    1474 
    1475     if (psArrayLength(output)) {
    1476         // negative simple so the default is true
    1477         if (!ippdbPrintMetadatas(stdout, output, "magicRawImfile", !simple)) {
    1478             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1479             psFree(output);
    1480             return false;
    1481         }
    1482     }
    1483 
    1484     psFree(output);
    1485 
    1486     return true;
    1487 }
    1488 
    1489 
    14901324static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state)
    14911325{
    … …  
    15581392    return true;
    15591393}
     1394
     1395static bool censorStage(pxConfig *config, psString stage, psString whereClause)
     1396{
     1397    psString queryFile = NULL;
     1398    psStringAppend(&queryFile, "magictool_censor_%s.sql", stage);
     1399    psString query = pxDataGet(queryFile);
     1400    if (!query) {
     1401        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement from %s", queryFile);
     1402        psFree(queryFile);
     1403        if (!psDBRollback(config->dbh)) {
     1404            psError(PS_ERR_UNKNOWN, false, "database error");
     1405        }
     1406        return false;
     1407    }
     1408    psFree(queryFile);
     1409
     1410    psStringAppend(&query, " WHERE %s",  whereClause);
     1411
     1412    if (!p_psDBRunQuery(config->dbh, query)) {
     1413        psError(PS_ERR_UNKNOWN, false, "database error");
     1414        psFree(query);
     1415        if (!psDBRollback(config->dbh)) {
     1416            psError(PS_ERR_UNKNOWN, false, "database error");
     1417        }
     1418        return false;
     1419    }
     1420    psFree(query);
     1421
     1422    return true;
     1423}
     1424
     1425static bool censorrunMode(pxConfig *config)
     1426{
     1427    PS_ASSERT_PTR_NON_NULL(config, false);
     1428
     1429    psError(PS_ERR_PROGRAMMING, true, "-censorrun mode not ready yet");
     1430    return false;
     1431
     1432    psMetadata *where = psMetadataAlloc();
     1433
     1434    // at least one of these required
     1435    PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
     1436    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1437
     1438    if (!psListLength(where->list)) {
     1439        psError(PS_ERR_UNKNOWN, true, "either -exp_id or -magic_id is required");
     1440        psFree(where);
     1441        return false;
     1442    }
     1443
     1444    psString query = psStringCopy("UPDATE magicRun SET state = 'censored'");
     1445
     1446    psString whereClause = psDBGenerateWhereConditionSQL(where, "magicRun");
     1447    psFree(where);
     1448    psStringAppend(&query, " WHERE %s", whereClause);
     1449
     1450    if (!psDBTransaction(config->dbh)) {
     1451        psError(PS_ERR_UNKNOWN, false, "database error");
     1452        return false;
     1453    }
     1454
     1455    if (!p_psDBRunQuery(config->dbh, query)) {
     1456        psError(PS_ERR_UNKNOWN, false, "database error");
     1457        psFree(whereClause);
     1458        psFree(query);
     1459        return false;
     1460    }
     1461    psFree(query);
     1462
     1463    psS32 numUpdated = psDBAffectedRows(config->dbh);
     1464    if (numUpdated == 0) {
     1465        psError(PS_ERR_UNKNOWN, false, "failed to censor magicRun");
     1466        psFree(whereClause);
     1467        return false;
     1468    }
     1469
     1470    // Now queue any destreaked files to be re-verted
     1471
     1472    // note: on failure censorStage issues the rollback
     1473    if (!censorStage(config, "raw", whereClause)) {
     1474        psFree(whereClause);
     1475        return false;
     1476    }
     1477    if (!censorStage(config, "chip", whereClause)) {
     1478        psFree(whereClause);
     1479        return false;
     1480    }
     1481    if (!censorStage(config, "camera", whereClause)) {
     1482        psFree(whereClause);
     1483        return false;
     1484    }
     1485    if (!censorStage(config, "warp", whereClause)) {
     1486        psFree(whereClause);
     1487        return false;
     1488    }
     1489    if (!censorStage(config, "diff", whereClause)) {
     1490        psFree(whereClause);
     1491        return false;
     1492    }
     1493
     1494    psFree(whereClause);
     1495
     1496    if (!psDBCommit(config->dbh)) {
     1497        psError(PS_ERR_UNKNOWN, false, "database error");
     1498        return false;
     1499    }
     1500
     1501    return true;
     1502}

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

    r20700 r25027  
    4141    MAGICTOOL_MODE_REVERTMASK,
    4242    MAGICTOOL_MODE_MASK,
    43     MAGICTOOL_MODE_DIFFSKYFILE,
    44     MAGICTOOL_MODE_WARPSKYFILE,
    45     MAGICTOOL_MODE_CHIPPROCESSEDIMFILE,
    46     MAGICTOOL_MODE_RAWIMFILE,
     43    MAGICTOOL_MODE_CENSORRUN,
    4744} MAGICtoolMode;
    4845

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

    r23688 r25027  
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    5454    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     55    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id", 0, "search diff_id", 0);
    5556    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    5657    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    … …  
    5859    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-rerun", 0, "generate new run even if existing?", false);
    5960    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     61    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend", 0, "list results but do not queue", false);
    6062
    6163    // -definerun
    … …  
    6567    // following argument is for compatability
    6668    psMetadataAddS64(definerunArgs, PS_LIST_TAIL, "-diff_id", 0, "define diff_id", 0);
     69    psMetadataAddBool(definerunArgs, PS_LIST_TAIL, "-inverse", 0, "use the inverse subtraction?", false);
    6770    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0, "define label", NULL);
    6871    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0, "define dvodb", NULL);
    … …  
    7881    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    7982    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    80     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "define difftool ID (required)", 0);
    8183    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    8284
    … …  
    9395    psMetadataAddS64(totreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    9496    psMetadataAddU64(totreeArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    95     psMetadataAddStr(totreeArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     97    psMetadataAddStr(totreeArgs, PS_LIST_TAIL, "-label",    PS_META_DUPLICATE_OK, "define label", NULL);
    9698    psMetadataAddBool(totreeArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    9799
    … …  
    106108    psMetadataAddS64(reverttreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magictool ID", 0);
    107109    psMetadataAddS16(reverttreeArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
     110    psMetadataAddStr(reverttreeArgs, PS_LIST_TAIL, "-label", 0, "search by label", NULL);
    108111
    109112    // -inputs
    … …  
    118121    psMetadataAddS64(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", 0);
    119122    psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    120     psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     123    psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-label",       PS_META_DUPLICATE_OK, "define label", NULL);
    121124    psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    122125
    … …  
    125128    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    126129    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    127     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
     130    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base", NULL);
    128131    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    129132
    … …  
    158161    psMetadataAddBool(maskArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    159162
    160     // -diffskyfile
    161     psMetadata *diffskyfileArgs = psMetadataAlloc();
    162     psMetadataAddS64(diffskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    163     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    164     psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    165     psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    166 
    167     // -warpskyfile
    168     psMetadata *warpskyfileArgs = psMetadataAlloc();
    169     psMetadataAddS64(warpskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    170     psMetadataAddBool(warpskyfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    171     psMetadataAddStr(warpskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "define skycell identifier", NULL);
    172 
    173     // -chipprocessedimfile
    174     psMetadata *chipprocessedimfileArgs = psMetadataAlloc();
    175     psMetadataAddS64(chipprocessedimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    176     psMetadataAddStr(chipprocessedimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    177     psMetadataAddBool(chipprocessedimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    178 
    179     // -rawimfile
    180     psMetadata *rawimfileArgs = psMetadataAlloc();
    181     psMetadataAddS64(rawimfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    182     psMetadataAddStr(rawimfileArgs, PS_LIST_TAIL, "-class_id", 0, "define class identifier", NULL);
    183     psMetadataAddBool(rawimfileArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     163    // -censorun
     164    psMetadata *censorrunArgs = psMetadataAlloc();
     165    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
     166    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
    184167
    185168    psFree(now);
    … …  
    204187    PXOPT_ADD_MODE("-revertmask",          "", MAGICTOOL_MODE_REVERTMASK,          revertmaskArgs);
    205188    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
    206     PXOPT_ADD_MODE("-diffskyfile",         "", MAGICTOOL_MODE_DIFFSKYFILE,         diffskyfileArgs);
    207     PXOPT_ADD_MODE("-warpskyfile",         "", MAGICTOOL_MODE_WARPSKYFILE,         warpskyfileArgs);
    208     PXOPT_ADD_MODE("-chipprocessedimfile", "", MAGICTOOL_MODE_CHIPPROCESSEDIMFILE, chipprocessedimfileArgs);
    209     PXOPT_ADD_MODE("-rawimfile",           "", MAGICTOOL_MODE_RAWIMFILE,           rawimfileArgs);
     189    PXOPT_ADD_MODE("-censorrun",           "", MAGICTOOL_MODE_CENSORRUN,           censorrunArgs);
    210190
    211191    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

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

    r21412 r25027  
    3434static bool datastoreMode(pxConfig *config);
    3535static bool moddatastoreMode(pxConfig *config);
    36 static bool addReqMode(pxConfig *config);
    37 static bool completedReqMode(pxConfig *config);
    38 static bool listReqMode(pxConfig *config);
    39 static bool pendingReqMode(pxConfig *config);
    40 static bool updateReqMode(pxConfig *config);
    41 static bool revertReqMode(pxConfig *config);
    42 static bool addJobMode(pxConfig *config);
    43 static bool listJobMode(pxConfig *config);
    44 static bool pendingJobMode(pxConfig *config);
    45 static bool updateJobMode(pxConfig *config);
    46 static bool addProjectMode(pxConfig *config);
     36static bool addreqMode(pxConfig *config);
     37static bool completedreqMode(pxConfig *config);
     38static bool listreqMode(pxConfig *config);
     39static bool pendingreqMode(pxConfig *config);
     40static bool updatereqMode(pxConfig *config);
     41static bool revertreqMode(pxConfig *config);
     42static bool addjobMode(pxConfig *config);
     43static bool listjobMode(pxConfig *config);
     44static bool pendingjobMode(pxConfig *config);
     45static bool updatejobMode(pxConfig *config);
     46static bool addprojectMode(pxConfig *config);
    4747static bool projectMode(pxConfig *config);
    48 static bool modProjectMode(pxConfig *config);
     48static bool modprojectMode(pxConfig *config);
    4949
    5050# define MODECASE(caseName, func) \
    … …  
    7070        MODECASE(PSTAMPTOOL_MODE_DATASTORE, datastoreMode);
    7171        MODECASE(PSTAMPTOOL_MODE_MODDATASTORE, moddatastoreMode);
    72         MODECASE(PSTAMPTOOL_MODE_ADDREQ, addReqMode);
    73         MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedReqMode);
    74         MODECASE(PSTAMPTOOL_MODE_LISTREQ, listReqMode);
    75         MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingReqMode);
    76         MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updateReqMode);
    77         MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertReqMode);
    78         MODECASE(PSTAMPTOOL_MODE_ADDJOB, addJobMode);
    79         MODECASE(PSTAMPTOOL_MODE_LISTJOB, listJobMode);
    80         MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingJobMode);
    81         MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updateJobMode);
    82         MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addProjectMode);
    83         MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modProjectMode);
     72        MODECASE(PSTAMPTOOL_MODE_ADDREQ, addreqMode);
     73        MODECASE(PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqMode);
     74        MODECASE(PSTAMPTOOL_MODE_LISTREQ, listreqMode);
     75        MODECASE(PSTAMPTOOL_MODE_PENDINGREQ, pendingreqMode);
     76        MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updatereqMode);
     77        MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertreqMode);
     78        MODECASE(PSTAMPTOOL_MODE_ADDJOB, addjobMode);
     79        MODECASE(PSTAMPTOOL_MODE_LISTJOB, listjobMode);
     80        MODECASE(PSTAMPTOOL_MODE_PENDINGJOB, pendingjobMode);
     81        MODECASE(PSTAMPTOOL_MODE_UPDATEJOB, updatejobMode);
     82        MODECASE(PSTAMPTOOL_MODE_ADDPROJECT, addprojectMode);
     83        MODECASE(PSTAMPTOOL_MODE_MODPROJECT, modprojectMode);
    8484        MODECASE(PSTAMPTOOL_MODE_PROJECT, projectMode);
    8585        default:
    … …  
    220220}
    221221
    222 static bool addReqMode(pxConfig *config)
     222static bool addreqMode(pxConfig *config)
    223223{
    224224    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    251251}
    252252
    253 static bool pendingReqMode(pxConfig *config)
     253static bool pendingreqMode(pxConfig *config)
    254254{
    255255    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    311311}
    312312
    313 static bool listReqMode(pxConfig *config)
     313static bool listreqMode(pxConfig *config)
    314314{
    315315    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    359359}
    360360
    361 static bool completedReqMode(pxConfig *config)
     361static bool completedreqMode(pxConfig *config)
    362362{
    363363    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    408408}
    409409
    410 static bool updateReqMode(pxConfig *config)
     410static bool updatereqMode(pxConfig *config)
    411411{
    412412    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    472472}
    473473
    474 static bool revertReqMode(pxConfig *config)
     474static bool revertreqMode(pxConfig *config)
    475475{
    476476    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    493493}
    494494
    495 static bool addJobMode(pxConfig *config)
     495static bool addjobMode(pxConfig *config)
    496496{
    497497    bool    stampJob = false;
    … …  
    500500    PS_ASSERT_PTR_NON_NULL(config, false);
    501501
    502     PXOPT_LOOKUP_S64(uri,         config->args, "-uri",        true, false);
    503502    PXOPT_LOOKUP_S64(req_id,      config->args, "-req_id",     true, false);
    504503    PXOPT_LOOKUP_STR(rownum,      config->args, "-rownum",     true, false);
    505504    PXOPT_LOOKUP_STR(job_type,    config->args, "-job_type",   false, false);
    506505    PXOPT_LOOKUP_STR(outputBase,  config->args, "-outputBase", true,  false);
    507     PXOPT_LOOKUP_STR(argString,   config->args, "-args",       false, false);
    508506    PXOPT_LOOKUP_STR(stateString, config->args, "-state",      false, false);
    509507    PXOPT_LOOKUP_STR(fault,       config->args, "-fault",      false, false);
    … …  
    519517        return false;
    520518    }
    521 
    522     if (stampJob && !argString) {
    523         psError(PS_ERR_UNKNOWN, true, "-args is required for stamp job");
    524         return false;
    525     }
    526 
    527519    if (stampJob) {
    528520        query = pxDataGet("pstamptool_addjob_stampjob.sql");
    … …  
    535527    }
    536528
    537     if (!p_psDBRunQueryF(config->dbh, query, req_id, rownum, stateString, job_type, uri, exp_id, outputBase, fault, argString)) {
     529    if (!p_psDBRunQueryF(config->dbh, query, req_id, rownum, stateString, job_type, exp_id, outputBase, fault)) {
    538530        psError(PS_ERR_UNKNOWN, false, "database error");
    539531        return false;
    … …  
    554546}
    555547
    556 static bool listJobMode(pxConfig *config)
     548static bool listjobMode(pxConfig *config)
    557549{
    558550    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    626618}
    627619
    628 static bool pendingJobMode(pxConfig *config)
     620static bool pendingjobMode(pxConfig *config)
    629621{
    630622    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    688680}
    689681
    690 static bool updateJobMode(pxConfig *config)
     682static bool updatejobMode(pxConfig *config)
    691683{
    692684    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    723715    return true;
    724716}
    725 static bool addProjectMode(pxConfig *config)
     717static bool addprojectMode(pxConfig *config)
    726718{
    727719    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    801793    return true;
    802794}
    803 static bool modProjectMode(pxConfig *config)
     795static bool modprojectMode(pxConfig *config)
    804796{
    805797    PS_ASSERT_PTR_NON_NULL(config, false);

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

    r20151 r25027  
    100100    // -addjob
    101101    psMetadata *addjobArgs = psMetadataAlloc();
    102     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-uri", 0,            "define job file uri", NULL);
    103102    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-req_id", 0,            "define job req_id", 0);
    104103    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-rownum", 0,            "define job rownum", NULL);
    105104    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-job_type", 0,            "define job job_type", "stamp");
    106105    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-outputBase", 0,            "define job outputBase", NULL);
    107     psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-args", 0,            "define job args", NULL);
    108106    psMetadataAddStr(addjobArgs, PS_LIST_TAIL, "-state", 0,            "new state", "run");
    109107    psMetadataAddS64(addjobArgs, PS_LIST_TAIL, "-exp_id", 0,           "exposure id", 0);
    … …  
    128126    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    129127    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    130     // psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-result", 0,            "new result", NULL);
    131128    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
    132129

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

    r23590 r25027  
    4545    psMetadataAddF64(md,  PS_LIST_TAIL, "-airmass_min",        0, "define min airmass", NAN);
    4646    psMetadataAddF64(md,  PS_LIST_TAIL, "-airmass_max",        0, "define max airmass", NAN);
    47     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_min",             0, "define min", NAN);
    48     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_max",             0, "define max", NAN);
    49     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_min",           0, "define min", NAN);
    50     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_max",           0, "define max", NAN);
    51     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_min",       0, "define min", NAN);
    52     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_max",       0, "define max", NAN);
     47    psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_min",             0, "define min RA (degrees) ", NAN);
     48    psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_max",             0, "define max RA (degrees) ", NAN);
     49    psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_min",           0, "define min DEC (degrees)", NAN);
     50    psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_max",           0, "define max DEC (degrees)", NAN);
     51    psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_min",       0, "define min exposure time", NAN);
     52    psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_max",       0, "define max exposure time", NAN);
    5353    psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "define max fraction of saturated pixels", NAN);
    54     psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define min fraction of saturated pixels", NAN);
    55     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_min",             0, "define max", NAN);
    56     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_max",             0, "define max", NAN);
    57     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_min",       0, "define max", NAN);
    58     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_max",       0, "define max", NAN);
    59     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define max", NAN);
    60     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max", NAN);
    61     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_min",            0, "define min", NAN);
    62     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_max",            0, "define max", NAN);
    63     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_min",             0, "define min", NAN);
    64     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_max",             0, "define max", NAN);
     54    psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "define max fraction of saturated pixels", NAN);
     55    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_min",             0, "define min background", NAN);
     56    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_max",             0, "define max background", NAN);
     57    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_min",       0, "define min background standard deviation", NAN);
     58    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_max",       0, "define max background standard deviation", NAN);
     59    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "define min background mean standard deviation (across imfiles)", NAN);
     60    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "define max background mean standard deviation (across imfiles)", NAN);
     61    psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_min",            0, "define min altitude", NAN);
     62    psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_max",            0, "define max altitude", NAN);
     63    psMetadataAddF64(md,  PS_LIST_TAIL, "-az_min",             0, "define min azimuth ", NAN);
     64    psMetadataAddF64(md,  PS_LIST_TAIL, "-az_max",             0, "define max azimuth ", NAN);
    6565    psMetadataAddF32(md,  PS_LIST_TAIL, "-ccd_temp_min",       0, "define min ccd tempature", NAN);
    6666    psMetadataAddF32(md,  PS_LIST_TAIL, "-ccd_temp_max",       0, "define max ccd tempature", NAN);
    … …  
    6868    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "define max rotator position angle", NAN);
    6969    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    70     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "define min solar angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "define max solar angle", NAN);
     70    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "define min solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "define max solar angle", NAN);
    7272
    7373    return true;
    … …  
    7676bool pxcamGetSearchArgs (pxConfig *config, psMetadata *where) {
    7777
    78     PXOPT_COPY_S64(config->args,  where, "-chip_id",            "chipRun.chip_id",       "==");
    79     PXOPT_COPY_S64(config->args,  where, "-exp_id",             "rawExp.exp_id",         "==");
    80     PXOPT_COPY_STR(config->args,  where, "-exp_name",           "rawExp.exp_name",       "==");
    81     PXOPT_COPY_STR(config->args,  where, "-inst",               "rawExp.camera",         "==");
    82     PXOPT_COPY_STR(config->args,  where, "-telescope",          "rawExp.telescope",      "==");
    83     PXOPT_COPY_TIME(config->args, where, "-dateobs_begin",      "rawExp.dateobs",        ">=");
    84     PXOPT_COPY_TIME(config->args, where, "-dateobs_end",        "rawExp.dateobs",        "<=");
    85     PXOPT_COPY_STR(config->args,  where, "-exp_tag",            "rawExp.exp_tag",        "==");
    86     PXOPT_COPY_STR(config->args,  where, "-exp_type",           "rawExp.exp_type",       "==");
    87     PXOPT_COPY_STR(config->args,  where, "-comment",            "rawExp.comment",        "LIKE");
    88     PXOPT_COPY_STR(config->args,  where, "-filelevel",          "rawExp.filelevel",      "==");
    89     PXOPT_COPY_STR(config->args,  where, "-filter",             "rawExp.filter",         "==");
    90     PXOPT_COPY_F64(config->args,  where, "-airmass_min",        "rawExp.airmass",        ">=");
    91     PXOPT_COPY_F64(config->args,  where, "-airmass_max",        "rawExp.airmass",        "<");
    92     PXOPT_COPY_F64(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
    93     PXOPT_COPY_F64(config->args, where, "-ra_max",             "rawExp.ra",             "<");
    94     PXOPT_COPY_F64(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
    95     PXOPT_COPY_F64(config->args, where, "-decl_max",           "rawExp.decl",           "<");
    96     PXOPT_COPY_F32(config->args,  where, "-exp_time_min",       "rawExp.exp_time",       ">=");
    97     PXOPT_COPY_F32(config->args,  where, "-exp_time_max",       "rawExp.exp_time",       "<");
    98     PXOPT_COPY_F32(config->args,  where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
    99     PXOPT_COPY_F32(config->args,  where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
    100     PXOPT_COPY_F64(config->args,  where, "-bg_min",             "rawExp.bg",             ">=");
    101     PXOPT_COPY_F64(config->args,  where, "-bg_max",             "rawExp.bg",             "<");
    102     PXOPT_COPY_F64(config->args,  where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
    103     PXOPT_COPY_F64(config->args,  where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
    104     PXOPT_COPY_F64(config->args,  where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
    105     PXOPT_COPY_F64(config->args,  where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
    106     PXOPT_COPY_F64(config->args,  where, "-alt_min",            "rawExp.alt",            ">=");
    107     PXOPT_COPY_F64(config->args,  where, "-alt_max",            "rawExp.alt",            "<");
    108     PXOPT_COPY_F64(config->args,  where, "-az_min",             "rawExp.az",             ">=");
    109     PXOPT_COPY_F64(config->args,  where, "-az_max",             "rawExp.az",             "<");
    110     PXOPT_COPY_F32(config->args,  where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
    111     PXOPT_COPY_F32(config->args,  where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
    112     PXOPT_COPY_F64(config->args,  where, "-posang_min",         "rawExp.posang",         ">=");
    113     PXOPT_COPY_F64(config->args,  where, "-posang_max",         "rawExp.posang",         "<");
    114     PXOPT_COPY_STR(config->args,  where, "-object",             "rawExp.object",         "==");
    115     PXOPT_COPY_F32(config->args,  where, "-solang_min",         "rawExp.solang",         ">=");
    116     PXOPT_COPY_F32(config->args,  where, "-solang_max",         "rawExp.solang",         "<");
    117 
    118     return true;
    119 }
    120 
    121 bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state)
     78    PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",      "==");
     79    PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",        "==");
     80    PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",      "==");
     81    PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",        "==");
     82    PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",     "==");
     83    PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",      "rawExp.dateobs",       ">=");
     84    PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",        "rawExp.dateobs",       "<=");
     85    PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",       "==");
     86    PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",      "==");
     87    PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",       "LIKE");
     88    PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",     "==");
     89    PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "==");
     90    PXOPT_COPY_F64(config->args,   where, "-airmass_min",        "rawExp.airmass",        ">=");
     91    PXOPT_COPY_F64(config->args,   where, "-airmass_max",        "rawExp.airmass",        "<");
     92    PXOPT_COPY_RADEC(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
     93    PXOPT_COPY_RADEC(config->args, where, "-ra_max",             "rawExp.ra",             "<");
     94    PXOPT_COPY_RADEC(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
     95    PXOPT_COPY_RADEC(config->args, where, "-decl_max",           "rawExp.decl",           "<");
     96    PXOPT_COPY_F32(config->args,   where, "-exp_time_min",       "rawExp.exp_time",       ">=");
     97    PXOPT_COPY_F32(config->args,   where, "-exp_time_max",       "rawExp.exp_time",       "<");
     98    PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
     99    PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
     100    PXOPT_COPY_F64(config->args,   where, "-bg_min",             "rawExp.bg",             ">=");
     101    PXOPT_COPY_F64(config->args,   where, "-bg_max",             "rawExp.bg",             "<");
     102    PXOPT_COPY_F64(config->args,   where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
     103    PXOPT_COPY_F64(config->args,   where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
     104    PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
     105    PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
     106    PXOPT_COPY_F64(config->args,   where, "-alt_min",            "rawExp.alt",            ">=");
     107    PXOPT_COPY_F64(config->args,   where, "-alt_max",            "rawExp.alt",            "<");
     108    PXOPT_COPY_F64(config->args,   where, "-az_min",             "rawExp.az",             ">=");
     109    PXOPT_COPY_F64(config->args,   where, "-az_max",             "rawExp.az",             "<");
     110    PXOPT_COPY_F32(config->args,   where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
     111    PXOPT_COPY_F32(config->args,   where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
     112    PXOPT_COPY_F64(config->args,   where, "-posang_min",         "rawExp.posang",         ">=");
     113    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
     114    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
     115    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",         "rawExp.sun_angle",         ">=");
     116    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",         "rawExp.sun_angle",         "<");
     117
     118    return true;
     119}
     120
     121bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state, psS64 magicked)
    122122{
    123123    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    131131    }
    132132
    133     char *query = "UPDATE camRun SET state = '%s' WHERE cam_id = %" PRId64;
    134     if (!p_psDBRunQueryF(config->dbh, query, state, cam_id)) {
     133    char *query = "UPDATE camRun SET state = '%s', magicked = %" PRId64 " WHERE cam_id = %" PRId64;
     134    if (!p_psDBRunQueryF(config->dbh, query, state, magicked, cam_id)) {
    135135        psError(PS_ERR_UNKNOWN, false,
    136136                "failed to change state for cam_id %" PRId64, cam_id);

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

    r19182 r25027  
    2525#include "pxtools.h"
    2626
    27 bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state);
     27bool pxcamRunSetState(pxConfig *config, psS64 cam_id, const char *state, psS64 magicked);
    2828bool pxcamRunSetStateByQuery(pxConfig *config, psMetadata *where, const char *state);
    2929bool pxcamRunSetLabel(pxConfig *config, psS64 cam_id, const char *label);

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

    r23418 r25027  
    4747    psMetadataAddF32(md,  PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
    4848    psMetadataAddF32(md,  PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
    49     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_min",             0, "search by min", NAN);
    50     psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_max",             0, "search by max", NAN);
    51     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_min",           0, "search by min", NAN);
    52     psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_max",           0, "search by max", NAN);
    53     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_min",       0, "search by min", NAN);
    54     psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_max",       0, "search by max", NAN);
    55     psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by max fraction of saturated pixels", NAN);
    56     psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by min fraction of saturated pixels", NAN);
    57     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_min",             0, "search by max", NAN);
    58     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_max",             0, "search by max", NAN);
    59     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_min",       0, "search by max", NAN);
    60     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max", NAN);
    61     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by max", NAN);
    62     psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max", NAN);
    63     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_min",            0, "search by min", NAN);
    64     psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_max",            0, "search by max", NAN);
    65     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_min",             0, "search by min", NAN);
    66     psMetadataAddF64(md,  PS_LIST_TAIL, "-az_max",             0, "search by max", NAN);
     49    psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_min",             0, "search by min RA (degrees) ", NAN);
     50    psMetadataAddF64(md,  PS_LIST_TAIL, "-ra_max",             0, "search by max RA (degrees) ", NAN);
     51    psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_min",           0, "search by min DEC (degrees)", NAN);
     52    psMetadataAddF64(md,  PS_LIST_TAIL, "-decl_max",           0, "search by max DEC (degrees)", NAN);
     53    psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_min",       0, "search by min exposure time", NAN);
     54    psMetadataAddF32(md,  PS_LIST_TAIL, "-exp_time_max",       0, "search by max exposure time", NAN);
     55    psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by min fraction of saturated pixels", NAN);
     56    psMetadataAddF32(md,  PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by max fraction of saturated pixels", NAN);
     57    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_min",             0, "search by min background", NAN);
     58    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_max",             0, "search by max background", NAN);
     59    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_min",       0, "search by min background standard deviation", NAN);
     60    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max background standard deviation", NAN);
     61    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by min background mean standard deviation (across imfiles)", NAN);
     62    psMetadataAddF64(md,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max background mean standard deviation (across imfiles)", NAN);
     63    psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_min",            0, "search by min altitude", NAN);
     64    psMetadataAddF64(md,  PS_LIST_TAIL, "-alt_max",            0, "search by max altitude", NAN);
     65    psMetadataAddF64(md,  PS_LIST_TAIL, "-az_min",             0, "search by min azimuth ", NAN);
     66    psMetadataAddF64(md,  PS_LIST_TAIL, "-az_max",             0, "search by max azimuth ", NAN);
    6767    psMetadataAddF64(md,  PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
    6868    psMetadataAddF64(md,  PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     72    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    7173    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    72     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    73     psMetadataAddF32(md,  PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    7575    psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode", 0, "search by observation mode", NULL);
    … …  
    9999    PXOPT_COPY_F64(config->args, where, "-airmass_min", "rawExp.airmass", ">=");
    100100    PXOPT_COPY_F64(config->args, where, "-airmass_max", "rawExp.airmass", "<");
    101     PXOPT_COPY_F64(config->args, where, "-ra_min", "rawExp.ra", ">=");
    102     PXOPT_COPY_F64(config->args, where, "-ra_max", "rawExp.ra", "<");
    103     PXOPT_COPY_F64(config->args, where, "-decl_min", "rawExp.decl", ">=");
    104     PXOPT_COPY_F64(config->args, where, "-decl_max", "rawExp.decl", "<");
     101    PXOPT_COPY_RADEC(config->args, where, "-ra_min", "rawExp.ra", ">=");
     102    PXOPT_COPY_RADEC(config->args, where, "-ra_max", "rawExp.ra", "<");
     103    PXOPT_COPY_RADEC(config->args, where, "-decl_min", "rawExp.decl", ">=");
     104    PXOPT_COPY_RADEC(config->args, where, "-decl_max", "rawExp.decl", "<");
    105105    PXOPT_COPY_F32(config->args, where, "-exp_time_min", "rawExp.exp_time", ">=");
    106106    PXOPT_COPY_F32(config->args, where, "-exp_time_max", "rawExp.exp_time", "<");
    … …  
    122122    PXOPT_COPY_F64(config->args, where, "-posang_max", "rawExp.posang", "<");
    123123    PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "==");
    124     PXOPT_COPY_F32(config->args, where, "-solang_min", "rawExp.solang", ">=");
    125     PXOPT_COPY_F32(config->args, where, "-solang_max", "rawExp.solang", "<");
     124    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "rawExp.sun_angle", ">=");
     125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");
    126126    PXOPT_COPY_STR(config->args, where, "-comment", "rawExp.comment", "LIKE");
    127127    PXOPT_COPY_STR(config->args, where, "-obs_mode", "rawExp.obs_mode", "==");
    … …  
    175175    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET state = '%s'");
    176176
    177     if (where) {
     177    if (where && psListLength(where->list) > 0) {
    178178        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    179179        psStringAppend(&query, " %s", whereClause);
    … …  
    216216    psString query = psStringCopy("UPDATE chipRun JOIN rawExp USING(exp_id) SET label = '%s'");
    217217
    218     if (where) {
     218    if (where && psListLength(where->list) > 0) {
    219219        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    220220        psStringAppend(&query, " %s", whereClause);
    … …  
    264264            dvodb,
    265265            tess_id,
    266             end_stage, 
     266            end_stage,
    267267            0           // magicked
    268268            )
    … …  
    277277    psS64 chip_id =  psDBLastInsertID(config->dbh);
    278278
    279     // Create rows in chipImfile table for each input exposure. 
     279    // Create rows in chipImfile table for each input exposure.
    280280    // This creates the chip_image_id values
    281281    psString query = "INSERT INTO chipImfile "
    … …  
    295295        return 0;
    296296    }
    297    
     297
    298298    return chip_id;
    299299}

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

    r23918 r25027  
    231231}
    232232
     233// convert the supplied value from degrees (external) to radians (internal)
     234#define PXOPT_COPY_RADEC(from, to, oldname, newname, comment) \
     235{ \
     236    bool status = false; \
     237    psF64 var = psMetadataLookupF64(&status, from, oldname); \
     238    if (!status) { \
     239        psError(PS_ERR_UNKNOWN, false, "failed to lookup value for " oldname); \
     240        return false; \
     241    } \
     242    if (!isnan(var)) { \
     243        if (!psMetadataAddF64(to, PS_LIST_TAIL, newname, PS_META_DUPLICATE_OK, comment, PS_RAD_DEG*var)) { \
     244            psError(PS_ERR_UNKNOWN, false, "failed to add item " newname); \
     245            psFree(to); \
     246            return false; \
     247        } \
     248    } \
     249}
     250
    233251#define PXOPT_COPY_F32(from, to, oldname, newname, comment) \
    234252  PXOPT_COPY_F(from, to, F32, oldname, newname, comment)

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

    r23613 r25027  
    126126
    127127bool pxwarpQueueByFakeID(pxConfig *config,
    128                     psS64 fake_id,
    129                     char *workdir,
    130                     char *label,
    131                     char *dvodb,
    132                     char *tess_id,
    133                     char *end_stage)
     128                         psS64 fake_id,
     129                         const char *workdir,
     130                         const char *label,
     131                         const char *dvodb,
     132                         const char *tess_id,
     133                         const char *reduction,
     134                         const char *end_stage)
    134135{
    135136    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    146147        dvodb,
    147148        tess_id,
     149                       reduction,
    148150        end_stage,
    149151        NULL,      // registered

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

    r23613 r25027  
    3131
    3232bool pxwarpQueueByFakeID(pxConfig *config,
    33                     psS64 fake_id,
    34                     char *workdir,
    35                     char *label,
    36                     char *dvodb,
    37                     char *tess_id,
    38                     char *end_stage);
     33                         psS64 fake_id,
     34                         const char *workdir,
     35                         const char *label,
     36                         const char *dvodb,
     37                         const char *tess_id,
     38                         const char *reduction,
     39                         const char *end_stage);
    3940
    4041#endif // PXWARP_H

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

    r23898 r25027  
    11/*
    2  * disttool.c
     2 * receivetool.c
    33 *
    44 * Copyright (C) 2008
    … …  
    3636static bool updatelastMode(pxConfig *config);
    3737static bool pendingfilesetMode(pxConfig *config);
     38static bool updatefilesetMode(pxConfig *config);
    3839static bool addfileMode(pxConfig *config);
    3940static bool pendingfileMode(pxConfig *config);
    4041static bool addresultMode(pxConfig *config);
     42static bool toadvanceMode(pxConfig *config);
    4143static bool revertMode(pxConfig *config);
    4244
    … …  
    6567        MODECASE(RECEIVETOOL_MODE_UPDATELAST, updatelastMode);
    6668        MODECASE(RECEIVETOOL_MODE_PENDINGFILESET, pendingfilesetMode);
     69        MODECASE(RECEIVETOOL_MODE_UPDATEFILESET, updatefilesetMode);
     70        MODECASE(RECEIVETOOL_MODE_TOADVANCE, toadvanceMode);
    6771        MODECASE(RECEIVETOOL_MODE_ADDFILE, addfileMode);
    6872        MODECASE(RECEIVETOOL_MODE_PENDINGFILE, pendingfileMode);
    … …  
    102106    PXOPT_LOOKUP_STR(comment, config->args, "-comment",  false, false);
    103107    PXOPT_LOOKUP_STR(last, config->args, "-last",  false, false);
    104 
    105     if (!receiveSourceInsert(config->dbh, 0, source, product, workdir, comment, last)) {
     108    PXOPT_LOOKUP_STR(status_product, config->args, "-status_product",  false, false);
     109    PXOPT_LOOKUP_STR(ds_dbname, config->args, "-ds_dbname",  false, false);
     110    PXOPT_LOOKUP_STR(ds_dbhost, config->args, "-ds_dbhost",  false, false);
     111
     112    if (!receiveSourceInsert(config->dbh, 0, source, product, workdir, comment, last, status_product, ds_dbname, ds_dbhost)) {
    106113        psError(PS_ERR_UNKNOWN, false, "Database error");
    107114        return false;
    … …  
    146153    }
    147154
    148     if (!p_psDBRunQueryF(config->dbh, query)) {
     155    if (!p_psDBRunQuery(config->dbh, query)) {
    149156        psError(PS_ERR_UNKNOWN, false, "Database error");
    150157        psFree(query);
    … …  
    231238        psFree(output);
    232239
    233         if (!receiveFilesetInsert(config->dbh, 0, source_id, fileset)) {
     240        if (!receiveFilesetInsert(config->dbh, 0, source_id, fileset, "reg", NULL, NULL, 0)) {
    234241            psError(PS_ERR_UNKNOWN, false, "Unable to add fileset");
    235242            psFree(source_id_str);
    … …  
    266273                   fileset, source_id);
    267274
    268     if (!p_psDBRunQueryF(config->dbh, query)) {
     275    if (!p_psDBRunQuery(config->dbh, query)) {
    269276        psError(PS_ERR_UNKNOWN, false, "Database error");
    270277        psFree(query);
    … …  
    306313    psFree(where);
    307314
     315    // make sure that the data is processed in the order that the filesets
     316    // were posted
     317    psStringAppend(&query, "\nORDER BY fileset_id");
     318
    308319    if (limit) {
    309320        psString limitString = psDBGenerateLimitSQL(limit);
    … …  
    312323    }
    313324
    314     if (!p_psDBRunQueryF(config->dbh, query)) {
     325    if (!p_psDBRunQuery(config->dbh, query)) {
    315326        psError(PS_ERR_UNKNOWN, false, "Database error");
    316327        psFree(query);
    … …  
    345356    // required
    346357    PXOPT_LOOKUP_S64(fileset_id, config->args, "-fileset_id", true, false);
    347     psMetadataItem *files = psMetadataLookup(config->args, "-file");
     358    PXOPT_LOOKUP_STR(file_list, config->args, "-file_list", true, false);
     359
     360    unsigned int numBad;
     361    psMetadata *files = psMetadataConfigRead(NULL, &numBad, file_list, false);
    348362    if (!files) {
    349         psError(PS_ERR_UNKNOWN, true, "-file is required");
    350         return false;
    351     }
     363        psError(PS_ERR_BAD_PARAMETER_VALUE, false, "Unable to cleanly read MDC file with file list.");
     364        return false;
     365    }
     366
    352367
    353368    if (!psDBTransaction(config->dbh)) {
    … …  
    356371    }
    357372
    358     psListIterator *iter = psListIteratorAlloc(files->data.list, PS_LIST_HEAD, false); // Iterator
    359     psMetadataItem *item = NULL;        // Item from iteration
    360     while ((item = psListGetAndIncrement(iter))) {
    361         psAssert(item && item->data.V && item->type == PS_DATA_STRING, "Argument is bad");
    362 
    363         if (!receiveFileInsert(config->dbh, 0, fileset_id, item->data.str)) {
     373    psMetadataIterator *iter = psMetadataIteratorAlloc(files, PS_LIST_HEAD, NULL); // Iterator
     374    psMetadataItem *item;
     375    while ((item = psMetadataGetAndIncrement(iter))) {
     376        psMetadata *md = item->data.md;
     377        psString file = psMetadataLookupStr(NULL, md, "file");
     378        psS64    bytes = psMetadataLookupS64(NULL, md, "bytes");
     379        psString md5sum = psMetadataLookupStr(NULL, md, "md5sum");
     380        psString file_type = psMetadataLookupStr(NULL, md, "file_type");
     381        psString component = psMetadataLookupStr(NULL, md, "component");
     382       
     383        if (!file) {
     384            psError(PS_ERR_UNKNOWN, false, "failed to find value for file");
     385            return false;
     386        }
     387        if (!component) {
     388            psError(PS_ERR_UNKNOWN, false, "failed to find value for component");
     389            return false;
     390        }
     391
     392        if (!receiveFileInsert(config->dbh, 0, fileset_id, file, bytes, md5sum, file_type, component)) {
    364393            psError(PS_ERR_UNKNOWN, false, "Unable to add file");
    365             if (!psDBTransaction(config->dbh)) {
     394            if (!psDBRollback(config->dbh)) {
    366395                psError(PS_ERR_UNKNOWN, false, "Database error");
    367396                return false;
    … …  
    371400        }
    372401    }
     402
    373403    psFree(iter);
    374404
    … …  
    391421    PXOPT_COPY_STR(config->args, where, "-product", "receiveSource.product", "==");
    392422    PXOPT_COPY_STR(config->args, where, "-comment", "receiveSource.comment", "LIKE");
    393     PXOPT_COPY_S64(config->args, where, "-fileset_id", "receiveFile.file_id", "==");
     423    PXOPT_COPY_S64(config->args, where, "-fileset_id", "receiveFile.fileset_id", "==");
     424    PXOPT_COPY_S64(config->args, where, "-file_id", "receiveFile.file_id", "==");
    394425
    395426    // optional
    … …  
    411442    psFree(where);
    412443
     444    // make sure that the data is processed in the order that the filesets
     445    // were posted
     446    psStringAppend(&query, "\nORDER BY fileset_id");
     447
    413448    if (limit) {
    414449        psString limitString = psDBGenerateLimitSQL(limit);
    … …  
    417452    }
    418453
    419     if (!p_psDBRunQueryF(config->dbh, query)) {
     454    if (!p_psDBRunQuery(config->dbh, query)) {
    420455        psError(PS_ERR_UNKNOWN, false, "Database error");
    421456        psFree(query);
    … …  
    485520    if (psListLength(where->list)) {
    486521        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    487         psStringAppend(&query, " WHERE %s", whereClause);
     522        psStringAppend(&query, " AND %s", whereClause);
    488523        psFree(whereClause);
    489524    }
    490525    psFree(where);
    491526
    492     if (!p_psDBRunQueryF(config->dbh, query)) {
     527    if (!p_psDBRunQuery(config->dbh, query)) {
    493528        psError(PS_ERR_UNKNOWN, false, "Database error");
    494529        psFree(query);
    … …  
    499534    return true;
    500535}
     536static bool toadvanceMode(pxConfig *config)
     537{
     538    PS_ASSERT_PTR_NON_NULL(config, false);
     539
     540    psMetadata *where = psMetadataAlloc(); // WHERE conditions
     541
     542    // optional
     543    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     544    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     545
     546    psString query = pxDataGet("receivetool_toadvance.sql");
     547    if (!query) {
     548        psError(PXTOOLS_ERR_DATA, false, "Failed to retreive SQL statement");
     549        psFree(where);
     550        return false;
     551    }
     552
     553    if (psListLength(where->list)) {
     554        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     555        psStringAppend(&query, " AND %s", whereClause);
     556        psFree(whereClause);
     557    }
     558    psFree(where);
     559
     560    if (limit) {
     561        psString limitString = psDBGenerateLimitSQL(limit);
     562        psStringAppend(&query, " %s", limitString);
     563        psFree(limitString);
     564    }
     565
     566    if (!p_psDBRunQuery(config->dbh, query)) {
     567        psError(PS_ERR_UNKNOWN, false, "Database error");
     568        psFree(query);
     569        return false;
     570    }
     571    psFree(query);
     572
     573    psArray *output = p_psDBFetchResult(config->dbh);
     574    if (!output) {
     575        psError(PS_ERR_UNKNOWN, false, "Database error");
     576        return false;
     577    }
     578    if (!psArrayLength(output)) {
     579        psTrace("receivetool", PS_LOG_INFO, "No rows found");
     580        psFree(output);
     581        return true;
     582    }
     583    if (!ippdbPrintMetadatas(stdout, output, "toadvanceFilesets", !simple)) {
     584        psError(PS_ERR_UNKNOWN, false, "Failed to print array");
     585        psFree(output);
     586        return false;
     587    }
     588    psFree(output);
     589
     590    return true;
     591}
     592
     593static bool updatefilesetMode(pxConfig *config)
     594{
     595    PS_ASSERT_PTR_NON_NULL(config, false);
     596
     597    // required
     598    PXOPT_LOOKUP_S64(fileset_id, config->args, "-fileset_id", true, false);
     599
     600    // to chanage
     601    PXOPT_LOOKUP_S32(fault, config->args, "-fault", false, false);
     602    PXOPT_LOOKUP_STR(destdir, config->args, "-destdir", false, false);
     603    PXOPT_LOOKUP_STR(dirinfo, config->args, "-dirinfo", false, false);
     604    PXOPT_LOOKUP_STR(dbinfo, config->args, "-dbinfo", false, false);
     605    PXOPT_LOOKUP_STR(state, config->args, "-set_state", false, false);
     606
     607    if (!fault && !dirinfo &&!dbinfo && !state) {
     608        psError(PS_ERR_UNKNOWN, true, "at least one of -fault, -dirinfo, -dbinfo, -set_state are required");
     609        return false;
     610    }
     611
     612    psString query = NULL;              // Query to execute
     613    psStringAppend(&query, "UPDATE receiveFileset SET ");
     614   
     615    psString sep = "";
     616    if (fault) {
     617        psStringAppend(&query, "%s fault = %d", sep, fault);
     618        sep = ",";
     619    }
     620    if (dirinfo) {
     621        psStringAppend(&query, "%s dirinfo = '%s'", sep, dirinfo);
     622        sep = ",";
     623    }
     624    if (dbinfo) {
     625        psStringAppend(&query, "%s dbinfo = '%s'", sep, dbinfo);
     626        sep = ",";
     627    }
     628    if (state) {
     629        psStringAppend(&query, "%s state = '%s'", sep, state);
     630        sep = ",";
     631    }
     632   
     633    psStringAppend(&query, " WHERE fileset_id = %" PRId64, fileset_id);
     634
     635    if (!p_psDBRunQuery(config->dbh, query)) {
     636        psError(PS_ERR_UNKNOWN, false, "Database error");
     637        psFree(query);
     638        return false;
     639    }
     640    psFree(query);
     641
     642    return true;
     643}

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

    r23885 r25027  
    3030    RECEIVETOOL_MODE_UPDATELAST,
    3131    RECEIVETOOL_MODE_PENDINGFILESET,
     32    RECEIVETOOL_MODE_UPDATEFILESET,
     33    RECEIVETOOL_MODE_TOADVANCE,
    3234    RECEIVETOOL_MODE_ADDFILE,
    3335    RECEIVETOOL_MODE_PENDINGFILE,

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

    r23898 r25027  
    5050    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-comment", 0, "define comment", NULL);
    5151    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-last", 0, "define last fileset", NULL);
     52    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-status_product", 0, "define status_product", NULL);
     53    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-ds_dbname", 0, "define ds_dbname", NULL);
     54    psMetadataAddStr(definesourceArgs, PS_LIST_TAIL, "-ds_dbhost", 0, "define ds_dbhost", NULL);
    5255
    5356    // -list
    … …  
    7477    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-product", 0, "search on product", NULL);
    7578    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
     79    psMetadataAddBool(pendingfilesetArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
    7680    psMetadataAddU64(pendingfilesetArgs, PS_LIST_TAIL, "-limit",  0, "limit result set", 0);
    77     psMetadataAddBool(pendingfilesetArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
     81    psMetadataAddStr(pendingfilesetArgs, PS_LIST_TAIL, "-label", 0, "search on label", NULL);
     82
     83    // -updatefileset
     84    psMetadata *updatefilesetArgs = psMetadataAlloc();
     85    psMetadataAddS64(updatefilesetArgs, PS_LIST_TAIL, "-fileset_id", 0, "define fileset_id (required)", 0);
     86    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-set_state", 0, "define state", NULL);
     87    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-destdir", 0, "define destdir", NULL);
     88    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-dirinfo", 0, "define dirinfo", NULL);
     89    psMetadataAddStr(updatefilesetArgs, PS_LIST_TAIL, "-dbinfo", 0, "define dbinfo", NULL);
     90    psMetadataAddS32(updatefilesetArgs, PS_LIST_TAIL, "-fault", 0, "define fault code", 0);
    7891
    7992    // -addfile
    8093    psMetadata *addfileArgs = psMetadataAlloc();
    8194    psMetadataAddS64(addfileArgs, PS_LIST_TAIL, "-fileset_id", 0, "define fileset_id (required)", 0);
    82     psMetadataAddStr(addfileArgs, PS_LIST_TAIL, "-file", PS_META_DUPLICATE_OK, "define file (multiple OK, required)", NULL);
     95    psMetadataAddStr(addfileArgs, PS_LIST_TAIL, "-file_list", 0, "define file list (required)", NULL);
    8396
    8497    // -pendingfile
    … …  
    88101    psMetadataAddStr(pendingfileArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
    89102    psMetadataAddS64(pendingfileArgs, PS_LIST_TAIL, "-fileset_id", 0, "search on fileset_id", 0);
     103    psMetadataAddS64(pendingfileArgs, PS_LIST_TAIL, "-file_id", 0, "search on file_id", 0);
    90104    psMetadataAddU64(pendingfileArgs, PS_LIST_TAIL, "-limit",  0, "limit result set", 0);
    91105    psMetadataAddBool(pendingfileArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
     106    psMetadataAddStr(pendingfileArgs, PS_LIST_TAIL, "-label", 0, "search on label", NULL);
    92107
    93108    // -addresult
    94109    psMetadata *addresultArgs = psMetadataAlloc();
    95110    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-file_id", 0, "define receive_id (required)", 0);
     111    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "path_base for component", NULL);
    96112    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_copy", 0, "define time to copy", NAN);
    97113    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_extract", 0, "define time to extract", NAN);
    … …  
    107123    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-comment", 0, "search on comment (LIKE)", NULL);
    108124
     125    // -toadvance
     126    psMetadata *toadvanceArgs = psMetadataAlloc();
     127    psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-fileset_id", 0, "search on fileset_id", 0);
     128    psMetadataAddS64(toadvanceArgs, PS_LIST_TAIL, "-source_id", 0, "search on source_id", 0);
     129    psMetadataAddU64(toadvanceArgs, PS_LIST_TAIL, "-limit",  0, "limit result set", 0);
     130    psMetadataAddBool(toadvanceArgs, PS_LIST_TAIL, "-simple",  0, "use simple output format?", false);
     131    // label is not used but pantasks requires it
     132    psMetadataAddStr(toadvanceArgs, PS_LIST_TAIL, "-label", 0, "search on label", NULL);
     133
    109134    psMetadata *argSets = psMetadataAlloc();
    110135    psMetadata *modes = psMetadataAlloc();
    … …  
    114139    PXOPT_ADD_MODE("-addfileset", "", RECEIVETOOL_MODE_ADDFILESET, addfilesetArgs);
    115140    PXOPT_ADD_MODE("-updatelast", "", RECEIVETOOL_MODE_UPDATELAST, updatelastArgs);
     141    PXOPT_ADD_MODE("-updatefileset", "", RECEIVETOOL_MODE_UPDATEFILESET, updatefilesetArgs);
    116142    PXOPT_ADD_MODE("-pendingfileset", "", RECEIVETOOL_MODE_PENDINGFILESET, pendingfilesetArgs);
     143    PXOPT_ADD_MODE("-toadvance", "", RECEIVETOOL_MODE_TOADVANCE, toadvanceArgs);
    117144    PXOPT_ADD_MODE("-addfile", "", RECEIVETOOL_MODE_ADDFILE, addfileArgs);
    118145    PXOPT_ADD_MODE("-pendingfile", "", RECEIVETOOL_MODE_PENDINGFILE, pendingfileArgs);

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

    r23701 r25027  
    455455    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    456456
    457     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     457    PXOPT_LOOKUP_S16(fault, config->args, "-fault",   false, false);
    458458    PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    459459
    … …  
    887887    // XX test this out; need to make this consistent with the list in regtoolConfig.c
    888888    psMetadata *where = psMetadataAlloc();
    889     PXOPT_COPY_S64(config->args, where,  "-exp_id", "exp_id", "==");
    890     PXOPT_COPY_STR(config->args, where,  "-exp_name", "exp_name", "==");
    891     PXOPT_COPY_STR(config->args, where,  "-inst", "camera", "==");
    892     PXOPT_COPY_STR(config->args, where,  "-telescope", "telescope", "==");
    893     PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "dateobs", ">=");
    894     PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "dateobs", "<=");
    895     PXOPT_COPY_STR(config->args, where,  "-exp_tag", "exp_tag", "==");
    896     PXOPT_COPY_STR(config->args, where,  "-exp_type", "exp_type", "==");
    897     PXOPT_COPY_STR(config->args, where,  "-filelevel", "filelevel", "==");
    898     PXOPT_COPY_STR(config->args, where,  "-reduction", "reduction", "==");
    899     PXOPT_COPY_STR(config->args, where,  "-filter", "filter", "==");
    900     PXOPT_COPY_F32(config->args, where,  "-airmass_min", "airmass", ">=");
    901     PXOPT_COPY_F32(config->args, where,  "-airmass_max", "airmass", "<");
    902     PXOPT_COPY_F64(config->args, where,  "-ra_min", "ra", ">=");
    903     PXOPT_COPY_F64(config->args, where,  "-ra_max", "ra", "<");
    904     PXOPT_COPY_F64(config->args, where,  "-decl_min", "decl", ">=");
    905     PXOPT_COPY_F64(config->args, where,  "-decl_max", "decl", "<");
    906     PXOPT_COPY_F32(config->args, where,  "-exp_time_min", "exp_time", ">=");
    907     PXOPT_COPY_F32(config->args, where,  "-exp_time_max", "exp_time", "<");
    908     PXOPT_COPY_F32(config->args, where,  "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
    909     PXOPT_COPY_F32(config->args, where,  "-sat_pixel_frac_max", "sat_pixel_frac", "<");
    910     PXOPT_COPY_F64(config->args, where,  "-bg_min", "bg", ">=");
    911     PXOPT_COPY_F64(config->args, where,  "-bg_max", "bg", "<");
    912     PXOPT_COPY_F64(config->args, where,  "-bg_stdev_min", "bg_stdev", ">=");
    913     PXOPT_COPY_F64(config->args, where,  "-bg_stdev_max", "bg_stdev", "<");
    914     PXOPT_COPY_F64(config->args, where,  "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
    915     PXOPT_COPY_F64(config->args, where,  "-bg_mean_stdev_max", "bg_mean_stdev", "<");
    916     PXOPT_COPY_F64(config->args, where,  "-alt_min", "alt", ">=");
    917     PXOPT_COPY_F64(config->args, where,  "-alt_max", "alt", "<");
    918     PXOPT_COPY_F64(config->args, where,  "-az_min", "az", ">=");
    919     PXOPT_COPY_F64(config->args, where,  "-az_max", "az", "<");
    920     PXOPT_COPY_F64(config->args, where,  "-ccd_temp_min", "ccd_temp", ">=");
    921     PXOPT_COPY_F64(config->args, where,  "-ccd_temp_max", "ccd_temp", "<");
    922     PXOPT_COPY_F64(config->args, where,  "-posang_min", "posang", ">=");
    923     PXOPT_COPY_F64(config->args, where,  "-posang_max", "posang", "<");
    924     PXOPT_COPY_STR(config->args, where,  "-object", "object", "==");
    925     PXOPT_COPY_F32(config->args, where,  "-solang_min", "solang", ">=");
    926     PXOPT_COPY_F32(config->args, where,  "-solang_max", "solang", "<");
     889    PXOPT_COPY_S64(config->args,   where,  "-exp_id", "exp_id", "==");
     890    PXOPT_COPY_STR(config->args,   where,  "-exp_name", "exp_name", "==");
     891    PXOPT_COPY_STR(config->args,   where,  "-inst", "camera", "==");
     892    PXOPT_COPY_STR(config->args,   where,  "-telescope", "telescope", "==");
     893    PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "dateobs", ">=");
     894    PXOPT_COPY_TIME(config->args,  where, "-dateobs_end", "dateobs", "<=");
     895    PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "exp_tag", "==");
     896    PXOPT_COPY_STR(config->args,   where,  "-exp_type", "exp_type", "==");
     897    PXOPT_COPY_STR(config->args,   where,  "-filelevel", "filelevel", "==");
     898    PXOPT_COPY_STR(config->args,   where,  "-reduction", "reduction", "==");
     899    PXOPT_COPY_STR(config->args,   where,  "-filter", "filter", "==");
     900    PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "airmass", ">=");
     901    PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "airmass", "<");
     902    PXOPT_COPY_RADEC(config->args, where,  "-ra_min", "ra", ">=");
     903    PXOPT_COPY_RADEC(config->args, where,  "-ra_max", "ra", "<");
     904    PXOPT_COPY_RADEC(config->args, where,  "-decl_min", "decl", ">=");
     905    PXOPT_COPY_RADEC(config->args, where,  "-decl_max", "decl", "<");
     906    PXOPT_COPY_F32(config->args,   where,  "-exp_time_min", "exp_time", ">=");
     907    PXOPT_COPY_F32(config->args,   where,  "-exp_time_max", "exp_time", "<");
     908    PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_min", "sat_pixel_frac", ">=");
     909    PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_max", "sat_pixel_frac", "<");
     910    PXOPT_COPY_F64(config->args,   where,  "-bg_min", "bg", ">=");
     911    PXOPT_COPY_F64(config->args,   where,  "-bg_max", "bg", "<");
     912    PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_min", "bg_stdev", ">=");
     913    PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_max", "bg_stdev", "<");
     914    PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_min", "bg_mean_stdev", ">=");
     915    PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_max", "bg_mean_stdev", "<");
     916    PXOPT_COPY_F64(config->args,   where,  "-alt_min", "alt", ">=");
     917    PXOPT_COPY_F64(config->args,   where,  "-alt_max", "alt", "<");
     918    PXOPT_COPY_F64(config->args,   where,  "-az_min", "az", ">=");
     919    PXOPT_COPY_F64(config->args,   where,  "-az_max", "az", "<");
     920    PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_min", "ccd_temp", ">=");
     921    PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_max", "ccd_temp", "<");
     922    PXOPT_COPY_F64(config->args,   where,  "-posang_min", "posang", ">=");
     923    PXOPT_COPY_F64(config->args,   where,  "-posang_max", "posang", "<");
     924    PXOPT_COPY_STR(config->args,   where,  "-object", "object", "==");
     925    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "sun_angle", ">=");
     926    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
    927927
    928928    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);

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

    r23688 r25027  
    7474    ADD_OPT(Str,  addprocessedimfileArgs, "-obs_group",      "define observing group (set of associated observations)",             NULL);
    7575
     76    // Note: RA & DEC are supplied here in radians, but the query options use degrees.  This
     77    // can be justified by the fact that this option (addprocessedimfile) is a software
     78    // interface, but the query mechanisms are human user interfaces.
     79    ADD_OPT(F64,  addprocessedimfileArgs, "-ra",             "define RA (NOTE: radians)", NAN);
     80    ADD_OPT(F64,  addprocessedimfileArgs, "-decl",           "define DEC (NOTE: radians)", NAN);
    7681    ADD_OPT(F32,  addprocessedimfileArgs, "-airmass",        "define airmass",                 NAN);
    77     ADD_OPT(F64,  addprocessedimfileArgs, "-ra",             "define RA",                 NAN);
    78     ADD_OPT(F64,  addprocessedimfileArgs, "-decl",           "define DEC",                 NAN);
    7982    ADD_OPT(F32,  addprocessedimfileArgs, "-exp_time",       "define exposure time",             NAN);
    8083    ADD_OPT(F32,  addprocessedimfileArgs, "-sat_pixel_frac", "define fraction of saturated pixels",     NAN);
    … …  
    135138    ADD_OPT(Bool, processedimfileArgs, "-faulted",   "only return imfiles with a fault status set", false);
    136139    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);
     140    ADD_OPT(Bool, processedimfileArgs, "-ordered_by_date", "force output to be in DATE order", false);
    137141
    138142    // -revertprocessedimfile
    … …  
    150154    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    151155    ADD_OPT(F64, updateprocessedimfileArgs, "-user_1",        "set user stat (1)", NAN);
    152     ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code (required)", INT16_MAX);
     156    ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code", INT16_MAX);
    153157
    154158    // -pendingexp
    … …  
    181185    ADD_OPT(Str,  addprocessedexpArgs, "-obs_group",        "define observing group (set of associated observations)",             NULL);
    182186
     187    // Note: RA & DEC are supplied here in radians, but the query options use degrees.  This
     188    // can be justified by the fact that this option (addprocessedexp) is a software
     189    // interface, but the query mechanisms are human user interfaces.
     190    ADD_OPT(F64,  addprocessedexpArgs, "-ra",               "define RA (NOTE: radians)", NAN);
     191    ADD_OPT(F64,  addprocessedexpArgs, "-decl",             "define DEC (NOTE: radians)", NAN);
    183192    ADD_OPT(F32,  addprocessedexpArgs, "-airmass",          "define airmass", NAN);
    184     ADD_OPT(F64,  addprocessedexpArgs, "-ra",               "define RA", NAN);
    185     ADD_OPT(F64,  addprocessedexpArgs, "-decl",             "define DEC", NAN);
    186193    ADD_OPT(F32,  addprocessedexpArgs, "-exp_time",         "define exposure time", NAN);
    187194    ADD_OPT(F32,  addprocessedexpArgs, "-sat_pixel_frac",   "define fraction of saturated pixels", NAN);
    … …  
    244251    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-airmass_min",   0,            "search by min airmass", NAN);
    245252    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-airmass_max",   0,            "search by max airmass", NAN);
    246     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ra_min",        0,            "search by min", NAN);
    247     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ra_max",        0,            "search by max", NAN);
    248     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-decl_min",      0,            "search by min", NAN);
    249     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-decl_max",      0,            "search by max", NAN);
    250     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-exp_time_min",  0,            "search by min", NAN);
    251     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-exp_time_max",  0,            "search by max", NAN);
    252     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min",  0,      "search by max fraction of saturated pixels", NAN);
    253     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max",  0,      "search by min fraction of saturated pixels", NAN);
    254     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_min",        0,            "search by max", NAN);
    255     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_max",        0,            "search by max", NAN);
    256     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_stdev_min",  0,            "search by max", NAN);
    257     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_stdev_max",  0,            "search by max", NAN);
    258     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0,       "search by max", NAN);
    259     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0,       "search by max", NAN);
    260     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-alt_min",       0,            "search by min", NAN);
    261     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-alt_max",       0,            "search by max", NAN);
    262     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-az_min",        0,            "search by min", NAN);
    263     psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-az_max",        0,            "search by max", NAN);
     253    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ra_min",        0,            "search by min RA (degrees) ", NAN);
     254    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ra_max",        0,            "search by max RA (degrees) ", NAN);
     255    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-decl_min",      0,            "search by min DEC (degrees)", NAN);
     256    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-decl_max",      0,            "search by max DEC (degrees)", NAN);
     257    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-exp_time_min",  0,            "search by min exposure time", NAN);
     258    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-exp_time_max",  0,            "search by max exposure time", NAN);
     259    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min",  0,      "search by min fraction of saturated pixels", NAN);
     260    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max",  0,      "search by max fraction of saturated pixels", NAN);
     261    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_min",        0,            "search by min background", NAN);
     262    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_max",        0,            "search by max background", NAN);
     263    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_stdev_min",  0,            "search by min background standard deviation", NAN);
     264    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_stdev_max",  0,            "search by max background standard deviation", NAN);
     265    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0,       "search by min background mean standard deviation (across imfiles)", NAN);
     266    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0,       "search by max background mean standard deviation (across imfiles)", NAN);
     267    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-alt_min",       0,            "search by min altitude", NAN);
     268    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-alt_max",       0,            "search by max altitude", NAN);
     269    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-az_min",        0,            "search by min azimuth ", NAN);
     270    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-az_max",        0,            "search by max azimuth ", NAN);
    264271    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ccd_temp_min",  0,            "search by min ccd tempature", NAN);
    265272    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-ccd_temp_max",  0,            "search by max ccd tempature", NAN);
    … …  
    267274    psMetadataAddF64(processedexpArgs,  PS_LIST_TAIL, "-posang_max",    0,            "search by max rotator position angle", NAN);
    268275    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-object",        0,            "search by exposure object", NULL);
    269     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_min",    0,            "define min solar angle", NAN);
    270     psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-solang_max",    0,            "define max solar angle", NAN);
     276    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "define min solar angle", NAN);
     277    psMetadataAddF32(processedexpArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "define max solar angle", NAN);
    271278
    272279    psMetadataAddU64(processedexpArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);

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

    r23921 r25027  
    133133    PXOPT_COPY_F32(config->args,  where, "-select_posang_min",         "rawExp.posang", ">=");
    134134    PXOPT_COPY_F32(config->args,  where, "-select_posang_max",         "rawExp.posang", "<=");
    135     PXOPT_COPY_F32(config->args,  where, "-select_solang_min",         "rawExp.solang", ">=");
    136     PXOPT_COPY_F32(config->args,  where, "-select_solang_max",         "rawExp.solang", "<=");
     135    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_min",      "rawExp.sun_angle", ">=");
     136    PXOPT_COPY_F32(config->args,  where, "-select_sun_angle_max",      "rawExp.sun_angle", "<=");
     137    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_min",     "camProcessedExp.fwhm_major", ">=");
     138    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_major_max",     "camProcessedExp.fwhm_major", "<=");
     139    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_min",     "camProcessedExp.fwhm_minor", ">=");
     140    PXOPT_COPY_F32(config->args,  where, "-select_fwhm_minor_max",     "camProcessedExp.fwhm_minor", "<=");
    137141    PXOPT_COPY_STR(config->args,  where, "-select_exp_type",           "rawExp.exp_type", "==");
    138142    PXOPT_COPY_F32(config->args,  where, "-select_good_frac_min",      "warpSkyfile.good_frac", ">=");
    139143    PXOPT_COPY_STR(config->args,  where, "-select_skycell_id",         "warpSkyfile.skycell_id", "==");
    140     PXOPT_COPY_STR(config->args,  where, "-select_label",              "warpRun.label", "==");
     144    pxAddLabelSearchArgs (config, where, "-select_label",              "warpRun.label", "LIKE");
    141145
    142146    // these are used to build the HAVING restriction
    … …  
    149153
    150154    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     155    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    151156    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    152157
    … …  
    232237    }
    233238    if (!psArrayLength(output)) {
    234         psTrace("stacktool", PS_LOG_INFO, "no rows found");
     239        psWarning("stacktool: no rows found");
     240        psFree(output);
     241        psFree(where);
     242        return true;
     243    }
     244    if (pretend) {
     245        // negative simple so the default is true
     246        if (!ippdbPrintMetadatas(stdout, output, "stackSkycells", !simple)) {
     247            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     248            psFree(output);
     249            psFree(where);
     250            return false;
     251        }
    235252        psFree(output);
    236253        psFree(where);
    … …  
    358375        psFree(idString);
    359376
     377        // replace @FILTER@, @SKYCELL_ID@, @RANDOM_LIMIT@
     378        psStringSubstitute(&thisInsert, filter, "@FILTER@");
     379        psStringSubstitute(&thisInsert, skycell_id, "@SKYCELL_ID@");
     380
     381        if (randomLimit > 0) {
     382          psString limString = NULL;
     383          psStringAppend(&limString, "%d", randomLimit);
     384          psStringSubstitute(&thisInsert, limString, "@RANDOM_LIMIT@");
     385          psFree(limString);
     386        }
     387
    360388        // XXX this insert uses a select to generate the list of warp_ids for the stack,
    361389        // we have applied a set of criteria above (WHERE) to select the relevant warps
    362390        // this insert needs to use exactly the same restrictions (race condition is probably not critical)
    363391        // the insert below seems to only restrict matches to the skycell, tess, and filter
    364         if ((randomLimit > 0 && !p_psDBRunQueryF(config->dbh, thisInsert, skycell_id, filter, randomLimit)) ||
    365             (randomLimit <= 0 && !p_psDBRunQueryF(config->dbh, thisInsert, skycell_id, filter))) {
     392        if (!p_psDBRunQuery(config->dbh, thisInsert)) {
    366393            psError(PS_ERR_UNKNOWN, false, "database error");
    367394            psFree(thisInsert);
    … …  
    375402        }
    376403        psFree(thisInsert);
     404
     405# if (0)
     406        {
     407          psArray *output = p_psDBFetchResult(config->dbh);
     408          if (!output) {
     409            psErrorCode err = psErrorCodeLast();
     410            switch (err) {
     411            case PS_ERR_DB_CLIENT:
     412              psError(PXTOOLS_ERR_SYS, false, "database error");
     413            case PS_ERR_DB_SERVER:
     414              psError(PXTOOLS_ERR_PROG, false, "database error");
     415            default:
     416              psError(PXTOOLS_ERR_PROG, false, "unknown error");
     417            }
     418            psFree(where);
     419            return false;
     420          }
     421          if (!psArrayLength(output)) {
     422            psWarning("stacktool (definebyquery, insert): no rows found");
     423            psFree(output);
     424            psFree(where);
     425            return true;
     426          }
     427          // negative simple so the default is true
     428          if (!ippdbPrintMetadatas(stdout, output, "stackSkycells", !simple)) {
     429            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     430            psFree(output);
     431            psFree(where);
     432            return false;
     433          }
     434          psFree(output);
     435          psFree(where);
     436          return true;
     437        }
     438# endif
     439
    377440    }
    378441    psFree(output);
    … …  
    765828    }
    766829
    767     if (!setstackRunState(config, stack_id, "full")) {
    768         if (!psDBRollback(config->dbh)) {
    769             psError(PS_ERR_UNKNOWN, false, "database error");
    770         }
    771         psError(PS_ERR_UNKNOWN, false, "failed to change stackRun's state");
    772         return false;
     830    if (fault == 0) {
     831        if (!setstackRunState(config, stack_id, "full")) {
     832            if (!psDBRollback(config->dbh)) {
     833                psError(PS_ERR_UNKNOWN, false, "database error");
     834            }
     835            psError(PS_ERR_UNKNOWN, false, "failed to change stackRun's state");
     836            return false;
     837        }
    773838    }
    774839
    … …  
    792857    PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    793858    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     859    PXOPT_COPY_STR(config->args, where, "-tess_id", "stackRun.tess_id", "==");
     860    PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
    794861
    795862    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    866933    PXOPT_COPY_S16(config->args, where, "-fault", "stackSumSkyfile.fault", "==");
    867934
    868     if (!psDBTransaction(config->dbh)) {
    869         psError(PS_ERR_UNKNOWN, false, "database error");
     935    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    870936        psFree(where);
    871         return false;
    872     }
    873 
    874     int numStacks;                      // Number of stacks affected
    875 
    876     // Update state to 'new'
    877     {
    878         psString update = pxDataGet("stacktool_revertsumskyfile_update.sql");
    879         if (!update) {
    880             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    881             if (!psDBRollback(config->dbh)) {
    882                 psError(PS_ERR_UNKNOWN, false, "database error");
    883             }
    884             return false;
    885         }
    886 
    887         if (psListLength(where->list)) {
    888             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    889             psStringAppend(&update, " AND %s", whereClause);
    890             psFree(whereClause);
    891         }
    892 
    893         if (!p_psDBRunQuery(config->dbh, update)) {
    894             psError(PS_ERR_UNKNOWN, false, "database error");
    895             psFree(update);
    896             psFree(where);
    897             if (!psDBRollback(config->dbh)) {
    898                 psError(PS_ERR_UNKNOWN, false, "database error");
    899             }
    900             return false;
    901         }
    902         psFree(update);
    903 
    904         numStacks = psDBAffectedRows(config->dbh);
    905 
    906         if (numStacks < 1) {
    907             psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    908             if (!psDBRollback(config->dbh)) {
    909                 psError(PS_ERR_UNKNOWN, false, "database error");
    910             }
    911             return false;
    912         }
     937        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     938        return false;
    913939    }
    914940
    915941    // Delete product
    916     {
    917         psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
    918         if (!delete) {
    919             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    920             if (!psDBRollback(config->dbh)) {
    921                 psError(PS_ERR_UNKNOWN, false, "database error");
    922             }
    923             return false;
    924         }
    925 
    926         if (psListLength(where->list)) {
    927             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    928             psStringAppend(&delete, " AND %s", whereClause);
    929             psFree(whereClause);
    930         }
    931 
    932         if (!p_psDBRunQuery(config->dbh, delete)) {
    933             psError(PS_ERR_UNKNOWN, false, "database error");
    934             psFree(delete);
    935             psFree(where);
    936             if (!psDBRollback(config->dbh)) {
    937                 psError(PS_ERR_UNKNOWN, false, "database error");
    938             }
    939             return false;
    940         }
     942    psString delete = pxDataGet("stacktool_revertsumskyfile_delete.sql");
     943    if (!delete) {
     944        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     945        return false;
     946    }
     947
     948    if (psListLength(where->list)) {
     949        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     950        psStringAppend(&delete, " AND %s", whereClause);
     951        psFree(whereClause);
     952    }
     953
     954    if (!p_psDBRunQuery(config->dbh, delete)) {
     955        psError(PS_ERR_UNKNOWN, false, "database error");
    941956        psFree(delete);
    942 
    943         if (psDBAffectedRows(config->dbh) != numStacks) {
    944             psError(PS_ERR_UNKNOWN, true, "Updated and deleted different number of entries!");
    945             psFree(where);
    946             if (!psDBRollback(config->dbh)) {
    947                 psError(PS_ERR_UNKNOWN, false, "database error");
    948             }
    949             return false;
    950         }
    951 
    952     }
    953 
    954     if (!psDBCommit(config->dbh)) {
    955         psError(PS_ERR_UNKNOWN, false, "database error");
    956         return false;
    957     }
     957        psFree(where);
     958        return false;
     959    }
     960    psFree(delete);
     961
     962    int numRows = psDBAffectedRows(config->dbh); // Number of row affected
     963    psLogMsg("stacktool", PS_LOG_INFO, "Deleted %d rows", numRows);
    958964
    959965    psFree(where);
    … …  
    991997
    992998    psMetadata *where = psMetadataAlloc();
    993     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     999    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    9941000
    9951001    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
    … …  
    10551061        PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
    10561062    }
    1057     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1063    pxAddLabelSearchArgs (config, where, "-label", "stackRun.label", "==");
    10581064
    10591065    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");

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

    r23921 r25027  
    5555    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    5656    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type", 0, "search for exp_type", "object");
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", 0, "search for label", NULL);
     57    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by warpRun label (LIKE comparison, multiple OK)", NULL);
    5858    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst", 0, "search for camera", NULL);
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_telescope", 0, "search for telescope", NULL);
    … …  
    7171    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_min", 0, "define min rotator position angle", NAN);
    7272    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_posang_max", 0, "define max rotator position angle", NAN);
    73     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_min", 0, "define min solar angle", NAN);
    74     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_solang_max", 0, "define max solar angle", NAN);
     73    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_min", 0, "define min solar angle", NAN);
     74    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_sun_angle_max", 0, "define max solar angle", NAN);
     75    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_min", 0, "define min fwhm (major axis)", NAN);
     76    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_major_max", 0, "define max fwhm (major axis)", NAN);
     77    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_minor_min", 0, "define min fwhm (minor axis)", NAN);
     78    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-select_fwhm_minor_max", 0, "define max fwhm (minor axis)", NAN);
    7579    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-random", 0, "use this number of random elements", 0);
    7680    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all", 0, "allow everything to be queued without search terms", false);
    … …  
    7882    psMetadataAddS32(definebyqueryArgs, PS_LIST_TAIL, "-min_new", 0, "minimum number of new inputs", 0);
    7983    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-min_frac", 0, "minumum fraction of new inputs", NAN);
     84    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
    8085    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    8186
    … …  
    154159    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,            "search by stack ID", 0);
    155160    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warp ID", 0);
     161    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-tess_id", 0,            "search by tess ID", 0);
     162    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,         "search by skycell ID", 0);
    156163    psMetadataAddS64(sumskyfileArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure ID", 0);
    157164    psMetadataAddStr(sumskyfileArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure name", NULL);
    … …  
    164171    psMetadataAddStr(revertsumskyfileArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
    165172    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     173    psMetadataAddBool(revertsumskyfileArgs, PS_LIST_TAIL, "-all",  0, "allow no search terms", 0);
    166174
    167175    // -pendingcleanuprun

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

    r23921 r25027  
    3838static bool tooverlapMode(pxConfig *config);
    3939static bool addoverlapMode(pxConfig *config);
     40static bool revertoverlapMode(pxConfig *config);
    4041static bool scmapMode(pxConfig *config);
    4142static bool towarpedMode(pxConfig *config);
    4243static bool addwarpedMode(pxConfig *config);
     44static bool advancerunMode(pxConfig *config);
    4345static bool warpedMode(pxConfig *config);
    4446static bool revertwarpedMode(pxConfig *config);
    … …  
    8587        MODECASE(WARPTOOL_MODE_TOOVERLAP,          tooverlapMode);
    8688        MODECASE(WARPTOOL_MODE_ADDOVERLAP,         addoverlapMode);
     89        MODECASE(WARPTOOL_MODE_REVERTOVERLAP,      revertoverlapMode);
    8790        MODECASE(WARPTOOL_MODE_SCMAP,              scmapMode);
    8891        MODECASE(WARPTOOL_MODE_TOWARPED,           towarpedMode);
    8992        MODECASE(WARPTOOL_MODE_ADDWARPED,          addwarpedMode);
     93        MODECASE(WARPTOOL_MODE_ADVANCERUN,         advancerunMode);
    9094        MODECASE(WARPTOOL_MODE_WARPED,             warpedMode);
    9195        MODECASE(WARPTOOL_MODE_REVERTWARPED,       revertwarpedMode);
    … …  
    135139    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    136140    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required (no default TESS)
     141    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // required (no default TESS)
    137142    PXOPT_LOOKUP_STR(end_stage, config->args, "-end_stage", false, false);
    138143    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    … …  
    155160            dvodb,
    156161            tess_id,
     162            reduction,
    157163            end_stage,
    158164            registered,
    159             false       // magicked
     165            0       // magicked
    160166    );
    161167    if (!warpRun) {
    … …  
    190196
    191197    psMetadata *where = psMetadataAlloc();
    192     PXOPT_COPY_S64(config->args, where, "-fake_id",            "fakeRun.fake_id",       "==");
    193     PXOPT_COPY_S64(config->args, where, "-cam_id",             "camRun.cam_id",         "==");
    194     PXOPT_COPY_S64(config->args, where, "-chip_id",            "chipRun.chip_id",       "==");
    195     PXOPT_COPY_S64(config->args, where, "-exp_id",             "rawExp.exp_id",         "==");
    196     PXOPT_COPY_STR(config->args, where, "-exp_name",           "rawExp.exp_name",       "==");
    197     PXOPT_COPY_STR(config->args, where, "-inst",               "rawExp.camera",         "==");
    198     PXOPT_COPY_STR(config->args, where, "-telescope",          "rawExp.telescope",      "==");
    199     PXOPT_COPY_TIME(config->args, where, "-dateobs_begin",     "rawExp.dateobs",        ">=");
    200     PXOPT_COPY_TIME(config->args, where, "-dateobs_end",       "rawExp.dateobs",        "<=");
    201     PXOPT_COPY_STR(config->args, where, "-exp_tag",            "rawExp.exp_tag",        "==");
    202     PXOPT_COPY_STR(config->args, where, "-exp_type",           "rawExp.exp_type",       "==");
    203     PXOPT_COPY_STR(config->args, where, "-filelevel",          "rawExp.filelevel",      "==");
    204     PXOPT_COPY_STR(config->args, where, "-filter",             "rawExp.filter",         "==");
    205     PXOPT_COPY_F64(config->args, where, "-airmass_min",        "rawExp.airmass",        ">=");
    206     PXOPT_COPY_F64(config->args, where, "-airmass_max",        "rawExp.airmass",        "<");
    207     PXOPT_COPY_F64(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
    208     PXOPT_COPY_F64(config->args, where, "-ra_max",             "rawExp.ra",             "<");
    209     PXOPT_COPY_F64(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
    210     PXOPT_COPY_F64(config->args, where, "-decl_max",           "rawExp.decl",           "<");
    211     PXOPT_COPY_F32(config->args, where, "-exp_time_min",       "rawExp.exp_time",       ">=");
    212     PXOPT_COPY_F32(config->args, where, "-exp_time_max",       "rawExp.exp_time",       "<");
    213     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
    214     PXOPT_COPY_F32(config->args, where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
    215     PXOPT_COPY_F64(config->args, where, "-bg_min",             "rawExp.bg",             ">=");
    216     PXOPT_COPY_F64(config->args, where, "-bg_max",             "rawExp.bg",             "<");
    217     PXOPT_COPY_F64(config->args, where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
    218     PXOPT_COPY_F64(config->args, where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
    219     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
    220     PXOPT_COPY_F64(config->args, where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
    221     PXOPT_COPY_F64(config->args, where, "-alt_min",            "rawExp.alt",            ">=");
    222     PXOPT_COPY_F64(config->args, where, "-alt_max",            "rawExp.alt",            "<");
    223     PXOPT_COPY_F64(config->args, where, "-az_min",             "rawExp.az",             ">=");
    224     PXOPT_COPY_F64(config->args, where, "-az_max",             "rawExp.az",             "<");
    225     PXOPT_COPY_F32(config->args, where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
    226     PXOPT_COPY_F32(config->args, where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
    227     PXOPT_COPY_F64(config->args, where, "-posang_min",         "rawExp.posang",         ">=");
    228     PXOPT_COPY_F64(config->args, where, "-posang_max",         "rawExp.posang",         "<");
    229     PXOPT_COPY_STR(config->args, where, "-object",             "rawExp.object",         "==");
    230     PXOPT_COPY_F32(config->args, where, "-solang_min",         "rawExp.solang",         ">=");
    231     PXOPT_COPY_F32(config->args, where, "-solang_max",         "rawExp.solang",         "<");
    232     PXOPT_COPY_STR(config->args, where, "-reduction",          "fakeRun.reduction",     "==");
    233     pxAddLabelSearchArgs (config, where, "-label",             "fakeRun.label",         "==");
     198    PXOPT_COPY_S64(config->args,   where, "-fake_id",            "fakeRun.fake_id",       "==");
     199    PXOPT_COPY_S64(config->args,   where, "-cam_id",             "camRun.cam_id",         "==");
     200    PXOPT_COPY_S64(config->args,   where, "-chip_id",            "chipRun.chip_id",       "==");
     201    PXOPT_COPY_S64(config->args,   where, "-exp_id",             "rawExp.exp_id",         "==");
     202    PXOPT_COPY_STR(config->args,   where, "-exp_name",           "rawExp.exp_name",       "==");
     203    PXOPT_COPY_STR(config->args,   where, "-inst",               "rawExp.camera",         "==");
     204    PXOPT_COPY_STR(config->args,   where, "-telescope",          "rawExp.telescope",      "==");
     205    PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin",     "rawExp.dateobs",        ">=");
     206    PXOPT_COPY_TIME(config->args,  where, "-dateobs_end",       "rawExp.dateobs",        "<=");
     207    PXOPT_COPY_STR(config->args,   where, "-exp_tag",            "rawExp.exp_tag",        "==");
     208    PXOPT_COPY_STR(config->args,   where, "-exp_type",           "rawExp.exp_type",       "==");
     209    PXOPT_COPY_STR(config->args,   where, "-filelevel",          "rawExp.filelevel",      "==");
     210    PXOPT_COPY_STR(config->args,   where, "-filter",             "rawExp.filter",         "==");
     211    PXOPT_COPY_F64(config->args,   where, "-airmass_min",        "rawExp.airmass",        ">=");
     212    PXOPT_COPY_F64(config->args,   where, "-airmass_max",        "rawExp.airmass",        "<");
     213    PXOPT_COPY_RADEC(config->args, where, "-ra_min",             "rawExp.ra",             ">=");
     214    PXOPT_COPY_RADEC(config->args, where, "-ra_max",             "rawExp.ra",             "<");
     215    PXOPT_COPY_RADEC(config->args, where, "-decl_min",           "rawExp.decl",           ">=");
     216    PXOPT_COPY_RADEC(config->args, where, "-decl_max",           "rawExp.decl",           "<");
     217    PXOPT_COPY_F32(config->args,   where, "-exp_time_min",       "rawExp.exp_time",       ">=");
     218    PXOPT_COPY_F32(config->args,   where, "-exp_time_max",       "rawExp.exp_time",       "<");
     219    PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
     220    PXOPT_COPY_F32(config->args,   where, "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
     221    PXOPT_COPY_F64(config->args,   where, "-bg_min",             "rawExp.bg",             ">=");
     222    PXOPT_COPY_F64(config->args,   where, "-bg_max",             "rawExp.bg",             "<");
     223    PXOPT_COPY_F64(config->args,   where, "-bg_stdev_min",       "rawExp.bg_stdev",       ">=");
     224    PXOPT_COPY_F64(config->args,   where, "-bg_stdev_max",       "rawExp.bg_stdev",       "<");
     225    PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_min",  "rawExp.bg_mean_stdev",  ">=");
     226    PXOPT_COPY_F64(config->args,   where, "-bg_mean_stdev_max",  "rawExp.bg_mean_stdev",  "<");
     227    PXOPT_COPY_F64(config->args,   where, "-alt_min",            "rawExp.alt",            ">=");
     228    PXOPT_COPY_F64(config->args,   where, "-alt_max",            "rawExp.alt",            "<");
     229    PXOPT_COPY_F64(config->args,   where, "-az_min",             "rawExp.az",             ">=");
     230    PXOPT_COPY_F64(config->args,   where, "-az_max",             "rawExp.az",             "<");
     231    PXOPT_COPY_F32(config->args,   where, "-ccd_temp_min",       "rawExp.ccd_temp",       ">=");
     232    PXOPT_COPY_F32(config->args,   where, "-ccd_temp_max",       "rawExp.ccd_temp",       "<");
     233    PXOPT_COPY_F64(config->args,   where, "-posang_min",         "rawExp.posang",         ">=");
     234    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
     235    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
     236    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
     237    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
     238    PXOPT_COPY_STR(config->args,   where, "-reduction",          "fakeRun.reduction",     "==");
     239    pxAddLabelSearchArgs (config,  where, "-label",             "fakeRun.label",         "==");
    234240
    235241    if (!psListLength(where->list) &&
    … …  
    245251    PXOPT_LOOKUP_STR(dvodb, config->args, "-set_dvodb", false, false);
    246252    PXOPT_LOOKUP_STR(tess_id, config->args, "-set_tess_id", false, false);
     253    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    247254    PXOPT_LOOKUP_STR(end_stage, config->args, "-set_end_stage", false, false);
    248255
    … …  
    306313        }
    307314
    308         if (!tess_id  && !row->tess_id) {
    309             psError(PS_ERR_UNKNOWN, false, "cannot queue warp run without a defined tess id: label: %s, fake_id %" PRId64, row->label, row->fake_id);
     315        if (!tess_id  && !row->tess_id) {
     316            psError(PS_ERR_UNKNOWN, false, "cannot queue warp run without a defined tess id: label: %s, fake_id %" PRId64, row->label, row->fake_id);
    310317            psFree(output);
    311318            return false;
    312         }
     319        }
    313320
    314321        psFree(row);
    315322    }
    316     psFree(output);
    317323
    318324    // loop over our list of fakeRun rows
    … …  
    329335        // queue the exp
    330336        if (!pxwarpQueueByFakeID(config,
    331                     row->fake_id,
    332                     workdir     ? workdir   : row->workdir,
    333                     label       ? label     : row->label,
    334                     dvodb       ? dvodb     : row->dvodb,
    335                     tess_id     ? tess_id   : row->tess_id,
    336                     end_stage   ? end_stage : row->end_stage))
     337                                 row->fake_id,
     338                                 workdir     ? workdir   : row->workdir,
     339                                 label       ? label     : row->label,
     340                                 dvodb       ? dvodb     : row->dvodb,
     341                                 tess_id     ? tess_id   : row->tess_id,
     342                                 reduction   ? reduction : row->reduction,
     343                                 end_stage   ? end_stage : row->end_stage))
    337344          {
    338345            psError(PS_ERR_UNKNOWN, false, "failed to trying to queue fake_id: %" PRId64, row->fake_id);
    … …  
    649656        warpSkyCellMapInsert(config->dbh,
    650657            warp_id,
    651             NULL,   // skycell_id
    652             NULL,   // tess_id
    653             NULL,   // class_id
     658            "faulted",   // skycell_id
     659            "faulted",   // tess_id
     660            "faulted",   // class_id
    654661            fault    // fault
    655662        );
    … …  
    664671    return true;
    665672}
     673
     674static bool revertoverlapMode(pxConfig *config)
     675{
     676    PS_ASSERT_PTR_NON_NULL(config, false);
     677
     678    psMetadata *where = psMetadataAlloc();
     679    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyCellMap.warp_id", "==");
     680    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyCellMap.skycell_id", "==");
     681    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyCellMap.tess_id", "==");
     682    // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
     683    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
     684    PXOPT_COPY_S16(config->args, where, "-fault",      "warpSkyCellMap.fault", "==");
     685
     686    if (!psListLength(where->list)
     687        && !psMetadataLookupBool(NULL, config->args, "-all")) {
     688        psFree(where);
     689        psError(PXTOOLS_ERR_DATA, false, "search parameters are required");
     690        return false;
     691    }
     692
     693    int numDeleted;                     // Number deleted
     694    {
     695        psString query = pxDataGet("warptool_revertoverlap.sql");
     696        if (!query) {
     697            psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     698            if (!psDBRollback(config->dbh)) {
     699                psError(PS_ERR_UNKNOWN, false, "database error");
     700            }
     701            return false;
     702        }
     703
     704        if (psListLength(where->list)) {
     705            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     706            psStringAppend(&query, " AND %s", whereClause);
     707            psFree(whereClause);
     708        }
     709
     710        if (!p_psDBRunQuery(config->dbh, query)) {
     711            psError(PS_ERR_UNKNOWN, false, "database error");
     712            psFree(query);
     713            if (!psDBRollback(config->dbh)) {
     714                psError(PS_ERR_UNKNOWN, false, "database error");
     715            }
     716            return false;
     717        }
     718        psFree(query);
     719
     720        numDeleted = psDBAffectedRows(config->dbh);
     721    }
     722
     723    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkycellMap", numDeleted);
     724
     725    psFree(where);
     726
     727    return true;
     728}
     729
    666730
    667731
    … …  
    917981    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    918982    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    919     PXOPT_LOOKUP_BOOL(magicked, config->args, "-magicked", false);
     983    PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
    920984
    921985    // default values
    … …  
    9591023    }
    9601024
    961     if (!warpCompletedRuns(config)) {
    962         if (!psDBRollback(config->dbh)) {
    963             psError(PS_ERR_UNKNOWN, false, "database error");
    964         }
    965         psError(PS_ERR_UNKNOWN, false, "database error");
    966         return false;
    967     }
    968 
    9691025    // point of no return
    9701026    if (!psDBCommit(config->dbh)) {
    … …  
    9761032}
    9771033
    978 bool warpCompletedRuns(pxConfig *config)
    979 {
    980     PS_ASSERT_PTR_NON_NULL(config, false);
     1034static bool advancerunMode(pxConfig *config)
     1035{
     1036    PS_ASSERT_PTR_NON_NULL(config, false);
     1037
     1038    psMetadata *where = psMetadataAlloc();
     1039    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     1040    pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1041
     1042    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    9811043
    9821044    psString query = pxDataGet("warptool_finished_run_select.sql");
    … …  
    9851047        return false;
    9861048    }
     1049
     1050    if (psListLength(where->list)) {
     1051        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1052        psStringAppend(&query, " %s", whereClause);
     1053        psFree(whereClause);
     1054    }
     1055    psFree(where);
    9871056
    9881057    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    10161085            return false;
    10171086        }
     1087        psS64 magicked = psMetadataLookupS64(&status, row, "magicked");
     1088        if (!status) {
     1089            psError(PS_ERR_UNKNOWN, false, "failed to look up value for magicked");
     1090            psFree(output);
     1091            psFree(query);
     1092            return false;
     1093        }
     1094        if (!p_psDBRunQueryF(config->dbh, query, magicked, warp_id)) {
     1095            psError(PS_ERR_UNKNOWN, false, "database error");
     1096            psFree(output);
     1097            psFree(query);
     1098            return false;
     1099        }
     1100
     1101        psS64 numUpdated = psDBAffectedRows(config->dbh);
     1102
     1103        if (numUpdated != 1) {
     1104            psError(PS_ERR_UNKNOWN, false, "should have affected 1 row");
     1105            psFree(query);
     1106            psFree(output);
     1107            return false;
     1108        }
     1109    }
     1110    psFree(output);
     1111    psFree(query);
     1112
     1113    return true;
     1114}
     1115
     1116bool warpCompletedRuns(pxConfig *config)
     1117{
     1118    PS_ASSERT_PTR_NON_NULL(config, false);
     1119
     1120    psString query = pxDataGet("warptool_finished_run_select.sql");
     1121    if (!query) {
     1122        psError(PXTOOLS_ERR_DATA, false, "failed to retrieve SQL statement");
     1123        return false;
     1124    }
     1125
     1126    if (!p_psDBRunQuery(config->dbh, query)) {
     1127        psError(PS_ERR_UNKNOWN, false, "database error");
     1128        psFree(query);
     1129        return false;
     1130    }
     1131    psFree(query);
     1132
     1133    psArray *output = p_psDBFetchResult(config->dbh);
     1134    if (!output) {
     1135        psError(PS_ERR_UNKNOWN, false, "database error");
     1136        return false;
     1137    }
     1138    if (!psArrayLength(output)) {
     1139        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1140        psFree(output);
     1141        return true;
     1142    }
     1143
     1144    query = pxDataGet("warptool_finish_run.sql");
     1145    for (long i = 0; i < psArrayLength(output); i++) {
     1146        psMetadata *row = output->data[i];
     1147
     1148        bool status;
     1149        psS64 warp_id = psMetadataLookupS64(&status, row, "warp_id");
     1150        if (!status) {
     1151            psError(PS_ERR_UNKNOWN, false, "failed to look up value for warp_id");
     1152            psFree(output);
     1153            psFree(query);
     1154            return false;
     1155        }
    10181156        psS32 magicked = psMetadataLookupS64(&status, row, "magicked");
    10191157        if (!status) {
    … …  
    10511189    psMetadata *where = psMetadataAlloc();
    10521190    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpSkyfile.warp_id", "==");
     1191    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1192    PXOPT_COPY_S64(config->args, where, "-warp_skyfile_id", "warpImfile.warp_skyfile_id", "==");
    10531193    PXOPT_COPY_STR(config->args, where, "-skycell_id", "warpSkyfile.skycell_id", "==");
    10541194    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    … …  
    11321272    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpSkyfile.tess_id", "==");
    11331273    PXOPT_COPY_STR(config->args, where, "-reduction",  "rawExp.reduction", "==");
    1134     PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
     1274    // PXOPT_COPY_STR(config->args, where, "-label",      "warpRun.label", "==");
     1275    pxAddLabelSearchArgs (config, where, "-label",     "warpRun.label", "==");
    11351276    PXOPT_COPY_S16(config->args, where, "-fault",       "warpSkyfile.fault", "==");
    11361277
    … …  
    11471288        return false;
    11481289    }
    1149 
    1150 
    1151     // Update state to 'new'
    1152     int numUpdated;                     // Number updated
    1153     {
    1154         // This query is no longer necessary because we do not set warpRun's to full statte
    1155         // if they have faulted skyfiles.
    1156         // We do have runs in the DB that follow the old convention so we leave this in for
    1157         // now
    1158         psString query = pxDataGet("warptool_revertwarped_update.sql");
    1159         if (!query) {
    1160             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1161             if (!psDBRollback(config->dbh)) {
    1162                 psError(PS_ERR_UNKNOWN, false, "database error");
    1163             }
    1164             return false;
    1165         }
    1166 
    1167         if (psListLength(where->list)) {
    1168             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1169             psStringAppend(&query, " AND %s", whereClause);
    1170             psFree(whereClause);
    1171         }
    1172 
    1173         if (!p_psDBRunQuery(config->dbh, query)) {
    1174             psError(PS_ERR_UNKNOWN, false, "database error");
    1175             psFree(query);
    1176             if (!psDBRollback(config->dbh)) {
    1177                 psError(PS_ERR_UNKNOWN, false, "database error");
    1178             }
    1179             return false;
    1180         }
    1181         psFree(query);
    1182 
    1183         numUpdated = psDBAffectedRows(config->dbh);
    1184 
    1185 #ifdef notdef
    1186         // new warpRuns won't get changed (they're already new) so don't require an update
    1187         if (numUpdated < 1) {
    1188             psError(PS_ERR_UNKNOWN, false, "should have affected at least 1 row");
    1189             if (!psDBRollback(config->dbh)) {
    1190                 psError(PS_ERR_UNKNOWN, false, "database error");
    1191             }
    1192             return false;
    1193         }
    1194 #endif
    1195     }
    1196 
    1197     psLogMsg("warptool", PS_LOG_INFO, "Updated %d warp runs", numUpdated);
    11981290
    11991291    // Delete product
    … …  
    13181410
    13191411    psMetadata *where = psMetadataAlloc();
    1320     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1412    pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    13211413
    13221414    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
    … …  
    13811473    psMetadata *where = psMetadataAlloc();
    13821474    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
    1383     pxAddLabelSearchArgs (config, where, "-label", "label", "==");
     1475    pxAddLabelSearchArgs (config, where, "-label", "warpRun.label", "==");
    13841476
    13851477    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
    … …  
    16681760
    16691761    if (clean) {
    1670         bool success = true; 
     1762        bool success = true;
    16711763        if (!strcmp(tables[i].tableName, "warpRun")) {
    16721764            success = pxSetStateCleaned("warpRun", "state", output);

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

    r23310 r25027  
    3434    WARPTOOL_MODE_TOOVERLAP,
    3535    WARPTOOL_MODE_ADDOVERLAP,
     36    WARPTOOL_MODE_REVERTOVERLAP,
    3637    WARPTOOL_MODE_SCMAP,
    3738    WARPTOOL_MODE_TOWARPED,
    3839    WARPTOOL_MODE_ADDWARPED,
     40    WARPTOOL_MODE_ADVANCERUN,
    3941    WARPTOOL_MODE_WARPED,
    4042    WARPTOOL_MODE_REVERTWARPED,

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

    r23921 r25027  
    6666    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-airmass_min",        0, "search by min airmass", NAN);
    6767    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-airmass_max",        0, "search by max airmass", NAN);
    68     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_min",             0, "search by min", NAN);
    69     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_max",             0, "search by max", NAN);
    70     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_min",           0, "search by min", NAN);
    71     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_max",           0, "search by max", NAN);
    72     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",       0, "search by min", NAN);
    73     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",       0, "search by max", NAN);
    74     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by max fraction of saturated pixels", NAN);
    75     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by min fraction of saturated pixels", NAN);
    76     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_min",             0, "search by max", NAN);
    77     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_max",             0, "search by max", NAN);
    78     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "search by max", NAN);
    79     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max", NAN);
    80     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by max", NAN);
    81     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max", NAN);
    82     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_min",            0, "search by min", NAN);
    83     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_max",            0, "search by max", NAN);
    84     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_min",             0, "search by min", NAN);
    85     psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_max",             0, "search by max", NAN);
     68    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_min",             0, "search by min RA (degrees) ", NAN);
     69    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-ra_max",             0, "search by max RA (degrees) ", NAN);
     70    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_min",           0, "search by min DEC (degrees)", NAN);
     71    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-decl_max",           0, "search by max DEC (degrees)", NAN);
     72    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_min",       0, "search by min exposure time", NAN);
     73    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-exp_time_max",       0, "search by max exposure time", NAN);
     74    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_min", 0, "search by min fraction of saturated pixels", NAN);
     75    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sat_pixel_frac_max", 0, "search by max fraction of saturated pixels", NAN);
     76    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_min",             0, "search by min background", NAN);
     77    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_max",             0, "search by max background", NAN);
     78    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_min",       0, "search by min background standard deviation", NAN);
     79    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_stdev_max",       0, "search by max background standard deviation", NAN);
     80    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0, "search by min background mean standard deviation (across imfiles)", NAN);
     81    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0, "search by max background mean standard deviation (across imfiles)", NAN);
     82    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_min",            0, "search by min altitude", NAN);
     83    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-alt_max",            0, "search by max altitude", NAN);
     84    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_min",             0, "search by min azimuth ", NAN);
     85    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-az_max",             0, "search by max azimuth ", NAN);
    8686    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_min",       0, "search by min ccd tempature", NAN);
    8787    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-ccd_temp_max",       0, "search by max ccd tempature", NAN);
    … …  
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    9090    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    91     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_min",         0, "search by min solar angle", NAN);
    92     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-solang_max",         0, "search by max solar angle", NAN);
     91    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
     92    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    9393    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    9494    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", NULL);
    … …  
    9898    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dvodb",          0, "define DVO db", NULL);
    9999    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_tess_id",        0, "define tess ID", NULL);
     100    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction",      0, "define reduction class", NULL);
    100101    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_end_stage",      0, "define end stage", NULL);
    101102    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-all",               0, "allow everything to be queued without search terms", false);
    … …  
    111112    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,            "define label", NULL);
    112113    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,            "define dvodb", NULL);
    113     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id", NULL);
     114    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-tess_id", 0,            "define tess_id (required)", NULL);
     115    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-reduction", 0,            "define reduction class", NULL);
    114116    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-end_stage", 0,            "define end stage", NULL);
    115117    psMetadataAddTime(definerunArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    … …  
    156158    psMetadataAddS64(addoverlapArgs, PS_LIST_TAIL, "-warp_id",  0,            "set warp ID", 0);
    157159    psMetadataAddS16(addoverlapArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
     160
     161    // -revertoverlap
     162    psMetadata *revertoverlapArgs = psMetadataAlloc();
     163    psMetadataAddS64(revertoverlapArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
     164    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-skycell_id",  0,            "search by skycell ID", NULL);
     165    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-tess_id",  0,            "search by tessellation ID", NULL);
     166    psMetadataAddStr(revertoverlapArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     167    psMetadataAddS16(revertoverlapArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
     168    psMetadataAddBool(revertoverlapArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     169
    158170
    159171    // -scmap
    … …  
    196208    // -warped
    197209    psMetadata *warpedArgs = psMetadataAlloc();
    198     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,            "search by warptool ID", 0);
    199     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,            "define skycell ID", NULL);
    200     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "define tessellation ID", NULL);
    201     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "define exposure tag", 0);
    202     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "define exposure tag", 0);
    203     psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,            "define phase 3 version of exposure tag", 0);
     210    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     211    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by skycell ID", NULL);
     212    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-warp_skyfile_id", 0,   "search by skyfile ID", 0);
     213    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     214    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     215    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     216    psMetadataAddS64(warpedArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
    204217    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    205     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     218    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    206219
    207220    // -revertwarped
    … …  
    215228    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,            "search by tessellation ID", NULL);
    216229    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-reduction",  0,            "search by warpRun reduction class", NULL);
    217     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-label",  0,            "search by warpRun label", NULL);
     230    psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
    218231    psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "search by fault code", 0);
    219232    psMetadataAddBool(revertwarpedArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     233
     234    // -advancerun
     235    psMetadata *advancerunArgs = psMetadataAlloc();
     236    psMetadataAddS64(advancerunArgs, PS_LIST_TAIL, "-warp_id", 0,      "search by warp ID", 0);
     237    psMetadataAddStr(advancerunArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label ", NULL);
     238    psMetadataAddU64(advancerunArgs, PS_LIST_TAIL, "-limit",  0,       "limit exposures to advance to N items", 0);
    220239
    221240    // -block
    … …  
    294313    PXOPT_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
    295314    PXOPT_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
     315    PXOPT_ADD_MODE("-revertoverlap",   "", WARPTOOL_MODE_REVERTOVERLAP,  revertoverlapArgs);
    296316    PXOPT_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
    297317    PXOPT_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
    298318    PXOPT_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
     319    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    299320    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    300321    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
Note: See TracChangeset for help on using the changeset viewer.