IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 3, 2010, 8:45:22 AM (16 years ago)
Author:
eugene
Message:

updates from trunk

Location:
branches/simmosaic_branches
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • branches/simmosaic_branches

  • branches/simmosaic_branches/ippTools/src

    • Property svn:ignore

      •  

        old new  
         1*.la
         2*.lo
        13.deps
        24.gdb_history
        … …  
        46Makefile
        57Makefile.in
         8addtool
         9caltool
         10camtool
         11chiptool
        612config.h
        713config.h.in
        8 stamp-h1
        9 *.la
        10 *.lo
         14detselect
         15dettool
         16difftool
         17disttool
         18dqstatstool
         19faketool
         20flatcorr
         21guidetool
         22magicdstool
         23magictool
         24pstamptool
         25pubtool
         26pxadmin
         27pxdata.c
         28pxinject
        1129pxtoolsErrorCodes.c
        1230pxtoolsErrorCodes.h
        13 pxadmin
        14 pxinject
        15 pztool
        1631pzgetexp
        1732pzgetimfiles
         33pztool
         34receivetool
        1835regtool
        19 guidetool
        20 chiptool
        21 camtool
         36stacktool
         37stamp-h1
        2238warptool
        23 difftool
        24 stacktool
        25 faketool
        26 dettool
        27 detselect
        28 pxdata.c
        29 magictool
        30 magicdstool
        31 caltool
        32 flatcorr
        33 pstamptool
        34 disttool
        35 receivetool
        36 
        37 pubtool

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

    r24676 r27839  
    3737static bool todiffskyfileMode(pxConfig *config);
    3838static bool adddiffskyfileMode(pxConfig *config);
     39static bool advanceMode(pxConfig *config);
    3940static bool diffskyfileMode(pxConfig *config);
    4041static bool revertdiffskyfileMode(pxConfig *config);
    … …  
    4243static bool definewarpstackMode(pxConfig *config);
    4344static bool definewarpwarpMode(pxConfig *config);
     45static bool definestackstackMode(pxConfig *config);
    4446static bool pendingcleanuprunMode(pxConfig *config);
    4547static bool pendingcleanupskyfileMode(pxConfig *config);
    … …  
    5052
    5153static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state, psS64 magicked);
    52 static bool diffRunComplete(pxConfig *config);
     54static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state);
     55static bool tocleanedskyfileMode(pxConfig *config);
     56static bool topurgedskyfileMode(pxConfig *config);
     57static bool toscrubbedskyfileMode(pxConfig *config);
     58static bool tofullskyfileMode(pxConfig *config);
     59static bool listrunMode(pxConfig *config);
     60static bool setskyfiletoupdateMode(pxConfig *config);
     61
     62
    5363
    5464# define MODECASE(caseName, func) \
    … …  
    7686        MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE,         todiffskyfileMode);
    7787        MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE,        adddiffskyfileMode);
     88        MODECASE(DIFFTOOL_MODE_ADVANCE,               advanceMode);
    7889        MODECASE(DIFFTOOL_MODE_DIFFSKYFILE,           diffskyfileMode);
    7990        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE,     revertdiffskyfileMode);
    8091        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,          definepoprunMode);
    81         MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,         definewarpstackMode);
     92        MODECASE(DIFFTOOL_MODE_DEFINEWARPSTACK,       definewarpstackMode);
    8293        MODECASE(DIFFTOOL_MODE_DEFINEWARPWARP,        definewarpwarpMode);
     94        MODECASE(DIFFTOOL_MODE_DEFINESTACKSTACK,      definestackstackMode);
    8395        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
    8496        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
    … …  
    8799        MODECASE(DIFFTOOL_MODE_EXPORTRUN,             exportrunMode);
    88100        MODECASE(DIFFTOOL_MODE_IMPORTRUN,             importrunMode);
     101        MODECASE(DIFFTOOL_MODE_TOCLEANEDSKYFILE,      tocleanedskyfileMode);
     102        MODECASE(DIFFTOOL_MODE_TOPURGEDSKYFILE,       topurgedskyfileMode);
     103        MODECASE(DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,     toscrubbedskyfileMode);
     104        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
     105        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     106        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
     107
    89108        default:
    90109            psAbort("invalid option (this should not happen)");
    … …  
    114133
    115134    // required options
    116     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false);
     135    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false);
    117136    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false);
    118137    PXOPT_LOOKUP_BOOL(bothways, config->args, "-bothways", false);
    119138    PXOPT_LOOKUP_BOOL(exposure, config->args, "-exposure", false);
    120     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    121     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
     139    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     140    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     141    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     142    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
     143    PXOPT_LOOKUP_S16(diff_mode, config->args, "-set_diff_mode", false, false);
     144    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    122145
    123146    // default
    … …  
    130153            workdir,
    131154            label,
     155            data_group ? data_group : label,
     156            dist_group,
    132157            reduction,
    133158            NULL,       // dvodb
    … …  
    136161            bothways,
    137162            exposure,
    138             false
     163            false,
     164            diff_mode,
     165            note
    139166    );
    140167    if (!run) {
    … …  
    167194    PS_ASSERT_PTR_NON_NULL(config, false);
    168195
    169     // required options
    170     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    171     PXOPT_LOOKUP_STR(state, config->args, "-state", true, false);
    172 
    173     if (state) {
    174         // set detRun.state to state
    175         return setdiffRunState(config, diff_id, state, false);
    176     }
    177 
    178     return true;
     196    psMetadata *where = psMetadataAlloc();
     197
     198    PXOPT_COPY_S64(config->args, where, "-diff_id",  "diff_id",   "==");
     199    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     200    PXOPT_COPY_STR(config->args, where, "-data_group","data_group",     "==");
     201    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
     202    if (!psListLength(where->list)) {
     203        psFree(where);
     204        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     205        return false;
     206    }
     207
     208    psString query = psStringCopy("UPDATE diffRun");
     209
     210    // pxUpdateRun gets parameters from config->args and updates
     211    bool result = pxUpdateRun(config, where, &query, "diffRun", "diff_id", "diffSkyfile", true);
     212
     213    psFree(query);
     214    psFree(where);
     215
     216    return result;
    179217}
    180218
    … …  
    331369    psString query = pxDataGet("difftool_inputskyfile.sql");
    332370    if (!query) {
    333         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    334         return false;
    335     }
    336 
    337     psString whereClause = NULL;
     371        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     372        return false;
     373    }
     374
     375    psString whereClause = psStringCopy("");
    338376    if (psListLength(where->list)) {
    339377        whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    340         psStringPrepend(&whereClause, "\n AND ");
     378        psStringPrepend(&whereClause, "\n WHERE ");
    341379    }
    342380    psFree(where);
    343381
    344382    // Add condition to get only templates or only inputs
     383    psString templateClause = psStringCopy("");
    345384    {
    346         psString templateClause = NULL;
    347385        if (template) {
    348             psStringAppend(&templateClause, " %s", " template != 0");
     386            psStringAppend(&templateClause, "\n WHERE %s", " template != 0");
    349387        } else if (input) {
    350             psStringAppend(&templateClause, " %s", " template = 0");
    351         }
    352         if (templateClause) {
    353             psStringAppend(&whereClause, "\n AND %s", templateClause);
    354         }
    355         psFree(templateClause);
     388            psStringAppend(&templateClause, "\n WHERE %s", " template = 0");
     389        }
    356390    }
    357391
    … …  
    364398    }
    365399
    366     if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause, whereClause)) {
    367         psError(PS_ERR_UNKNOWN, false, "database error");
     400    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause, whereClause, whereClause, templateClause)) {
     401        psError(PS_ERR_UNKNOWN, false, "database error");
     402        psFree(templateClause);
    368403        psFree(whereClause);
    369404        psFree(query);
    370405        return false;
    371406    }
     407    psFree(templateClause);
    372408    psFree(whereClause);
    373409    psFree(query);
    … …  
    421457    psString query = pxDataGet("difftool_todiffskyfile.sql");
    422458    if (!query) {
    423         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     459        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    424460        return false;
    425461    }
    … …  
    555591    }
    556592
    557     if (!diffRunComplete(config)) {
    558         if (!psDBRollback(config->dbh)) {
    559             psError(PS_ERR_UNKNOWN, false, "database error");
    560         }
    561         psError(PS_ERR_UNKNOWN, false, "database error");
    562         return false;
    563     }
    564 
    565593    // point of no return
    566594    if (!psDBCommit(config->dbh)) {
    … …  
    569597    }
    570598
     599
     600    return true;
     601}
     602
     603static bool advanceMode(pxConfig *config)
     604{
     605    PS_ASSERT_PTR_NON_NULL(config, false);
     606
     607    psMetadata *where = psMetadataAlloc();
     608    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
     609    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "==");
     610
     611    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     612
     613    // look for completed diffRuns
     614    psString query = pxDataGet("difftool_completed_runs.sql");
     615    if (!query) {
     616        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     617        return false;
     618    }
     619
     620    psString whereString = psStringCopy("");
     621    if (psListLength(where->list)) {
     622        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     623        psStringAppend(&whereString, "\n AND %s", whereClause);
     624        psFree(whereClause);
     625    }
     626    psFree(where);
     627
     628    // treat limit == 0 as "no limit"
     629    if (limit) {
     630        psString limitString = psDBGenerateLimitSQL(limit);
     631        psStringAppend(&query, " %s", limitString);
     632        psFree(limitString);
     633    }
     634
     635    if (!psDBTransaction(config->dbh)) {
     636        psError(PS_ERR_UNKNOWN, false, "database error");
     637        psFree(whereString);
     638        return false;
     639    }
     640
     641    if (!p_psDBRunQueryF(config->dbh, query, whereString)) {
     642        psError(PS_ERR_UNKNOWN, false, "database error");
     643        psFree(query);
     644        psFree(whereString);
     645        if (!psDBRollback(config->dbh)) {
     646            psError(PS_ERR_UNKNOWN, false, "database error");
     647        }
     648        return false;
     649    }
     650    psFree(query);
     651    psFree(whereString);
     652
     653    psArray *output = p_psDBFetchResult(config->dbh);
     654    if (!output) {
     655        psError(PS_ERR_UNKNOWN, false, "database error");
     656        if (!psDBRollback(config->dbh)) {
     657            psError(PS_ERR_UNKNOWN, false, "database error");
     658        }
     659        return false;
     660    }
     661    if (!psArrayLength(output)) {
     662        psTrace("difftool", PS_LOG_INFO, "no rows found");
     663        psFree(output);
     664        return true;
     665    }
     666
     667    for (long i = 0; i < psArrayLength(output); i++) {
     668        psMetadata *row = output->data[i];
     669
     670        psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
     671        psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
     672
     673        // set diffRun.state to 'full'
     674        if (!setdiffRunState(config, diff_id, "full", magicked)) {
     675            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
     676                diff_id);
     677            psFree(output);
     678            if (!psDBRollback(config->dbh)) {
     679                psError(PS_ERR_UNKNOWN, false, "database error");
     680            }
     681            return false;
     682        }
     683    }
     684    psFree(output);
     685
     686    if (!psDBCommit(config->dbh)) {
     687        psError(PS_ERR_UNKNOWN, false, "database error");
     688        return false;
     689    }
    571690
    572691    return true;
    … …  
    581700    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    582701    PXOPT_COPY_STR(config->args, where, "-skycell_id", "diffInputSkyfile.skycell_id", "==");
    583     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", "==");
     702    PXOPT_COPY_S64(config->args, where, "-diff_skyfile_id", "diffInputSkyfile.diff_skyfile_id", "==");
     703    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
    585704    PXOPT_COPY_S16(config->args, where, "-fault", "diffSkyfile.fault", "==");
    586     PXOPT_COPY_S64(config->args, where, "-exp_id", "rawExp.exp_id", "==");
    587     PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
    588     PXOPT_COPY_STR(config->args, where, "-warp_id", "warpRun.warp_id", "==");
    589 
     705    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffSkyfile.magicked", "==");
     706    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     707    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     708
     709    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     710    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     711    if (!template) {
     712        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawInput.exp_id", "==");
     713        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawInput.exp_name", "==");
     714        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpInput.warp_id", "==");
     715        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
     716        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
     717        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
     718    } else {
     719        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
     720        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawTemplate.exp_name", "==");
     721        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpTemplate.warp_id", "==");
     722        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
     723        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
     724        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
     725    }
     726
     727    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    590728    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    591729    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    592730
     731
     732    psString where2 = NULL;
     733    pxmagicAddWhere(config, &where2, "diffSkyfile");
     734    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
    593735    psString query = pxDataGet("difftool_skyfile.sql");
    594736    if (!query) {
    595         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     737        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    596738        return false;
    597739    }
    … …  
    601743        psStringAppend(&query, " WHERE %s", whereClause);
    602744        psFree(whereClause);
     745    } else if (where2) {
     746        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
     747    } else if (!all) {
     748        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     749        return false;
    603750    }
    604751    psFree(where);
    605752
     753    if (pstamp_order) {
     754        if (template) {
     755            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     756        } else {
     757            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     758        }
     759    }
     760           
    606761    // treat limit == 0 as "no limit"
    607762    if (limit) {
    … …  
    659814    psMetadata *where = psMetadataAlloc();
    660815    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffSkyfile.diff_id", "==");
    661     PXOPT_COPY_STR(config->args, where,  "-label", "diffRun.label", "==");
     816    PXOPT_COPY_STR(config->args, where,  "-skycell_id", "diffSkyfile.skycell_id", "==");
     817    pxAddLabelSearchArgs(config, where, "-label", "diffRun.label", "==");
    662818    PXOPT_COPY_S16(config->args, where, "-fault",     "fault", "==");
    663819
    664     if (!psDBTransaction(config->dbh)) {
    665         psError(PS_ERR_UNKNOWN, false, "database error");
     820    if (!psListLength(where->list) && !psMetadataLookupBool(NULL, config->args, "-all")) {
    666821        psFree(where);
    667         return false;
    668     }
    669 
    670     // Update state to 'new'
     822        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     823        return false;
     824    }
     825
    671826    {
    672         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
     827        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    673828        if (!query) {
    674             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    675             if (!psDBRollback(config->dbh)) {
    676                 psError(PS_ERR_UNKNOWN, false, "database error");
    677             }
     829            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     830            return false;
     831        }
     832        psString query_updated = pxDataGet("difftool_revertdiffskyfile_updated.sql");
     833        if (!query_updated) {
     834            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    678835            return false;
    679836        }
    … …  
    682839            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    683840            psStringAppend(&query, " AND %s", whereClause);
     841            psStringAppend(&query_updated, " AND %s", whereClause);
    684842            psFree(whereClause);
    685843        }
    … …  
    688846            psError(PS_ERR_UNKNOWN, false, "database error");
    689847            psFree(query);
    690             if (!psDBRollback(config->dbh)) {
    691                 psError(PS_ERR_UNKNOWN, false, "database error");
    692             }
    693848            return false;
    694849        }
    695850        psFree(query);
     851        psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     852
     853        if (!p_psDBRunQuery(config->dbh, query_updated)) {
     854            psError(PS_ERR_UNKNOWN, false, "database error");
     855            psFree(query_updated);
     856            return false;
     857        }
     858        psFree(query_updated);
    696859
    697860        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    698861    }
    699862
    700     // Delete product
    701     {
    702         psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    703         if (!query) {
    704             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    705             if (!psDBRollback(config->dbh)) {
    706                 psError(PS_ERR_UNKNOWN, false, "database error");
    707             }
    708             return false;
    709         }
    710 
    711         if (psListLength(where->list)) {
    712             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    713             psStringAppend(&query, " AND %s", whereClause);
    714             psFree(whereClause);
    715         }
    716 
    717         if (!p_psDBRunQuery(config->dbh, query)) {
    718             psError(PS_ERR_UNKNOWN, false, "database error");
    719             psFree(query);
    720             if (!psDBRollback(config->dbh)) {
    721                 psError(PS_ERR_UNKNOWN, false, "database error");
    722             }
    723             return false;
    724         }
    725         psFree(query);
    726 
    727         psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    728     }
    729 
    730863    psFree(where);
    731864
    732     if (!psDBCommit(config->dbh)) {
    733         psError(PS_ERR_UNKNOWN, false, "database error");
    734         return false;
    735     }
    736865
    737866    return true;
    … …  
    749878    }
    750879
    751     char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
    752 
    753     if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
     880    if (magicked) {
     881      char *query = "UPDATE diffRun SET state = '%s', magicked = %" PRId64 " WHERE diff_id = %"PRId64;
     882
     883      if (!p_psDBRunQueryF(config->dbh, query, state, magicked, diff_id)) {
    754884        psError(PS_ERR_UNKNOWN, false,
    755885                "failed to change state for diff_id %"PRId64, diff_id);
    756886        return false;
     887      }
     888    }
     889    else {
     890      char *query = "UPDATE diffRun SET state = '%s' WHERE diff_id = %"PRId64;
     891
     892      if (!p_psDBRunQueryF(config->dbh, query, state, diff_id)) {
     893        psError(PS_ERR_UNKNOWN, false,
     894                "failed to change state for diff_id %"PRId64, diff_id);
     895        return false;
     896      }
    757897    }
    758898
    759899    return true;
    760900}
     901
     902
     903#ifdef notdef
     904static bool setdiffRunStateByLabel(pxConfig *config, const char *label, const char *state) {
     905  PS_ASSERT_PTR_NON_NULL(state,false);
     906
     907  // check that state is a valid string value
     908  if (!pxIsValidState(state)) {
     909    psError(PS_ERR_UNKNOWN, false, "invalid diffRun state: %s", state);
     910    return false;
     911  }
     912
     913  char *query = "UPDATE diffRun SET state = '%s' WHERE label = '%s'";
     914  if (!p_psDBRunQueryF(config->dbh,query,state,label)) {
     915    psError(PS_ERR_UNKNOWN, false,
     916            "failed to change state for label %s", label);
     917    return(false);
     918  }
     919
     920  return true;
     921}
     922#endif
    761923
    762924// Generate a single populated run
    … …  
    766928                         const char *tess_id, // Tessellation identifier
    767929                         const char *label, // label
     930                         const char *data_group, // data_group
     931                         const char *dist_group, // dist_group
    768932                         const char *reduction, // reduction
     933                         const char *note,      // note
    769934                         psS64 input_warp_id, // Warp identifier for input image, PS_MAX_S64 for none
    770935                         psS64 input_stack_id, // Stack identifier for input image, PS_MAX_S64 for none
    … …  
    787952        return false;
    788953    }
     954    psS16 diff_mode = IPP_DIFF_MODE_UNDEFINED;
     955    if ((input_warp_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
     956      diff_mode = IPP_DIFF_MODE_WARP_WARP;
     957    }
     958    else if ((input_warp_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
     959      diff_mode = IPP_DIFF_MODE_WARP_STACK;
     960    }
     961    else if ((input_stack_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
     962      diff_mode = IPP_DIFF_MODE_STACK_WARP;
     963    }
     964    else if ((input_stack_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
     965      diff_mode = IPP_DIFF_MODE_STACK_STACK;
     966    }
     967
    789968
    790969    // default
    … …  
    797976            workdir,
    798977            label,
     978            data_group ? data_group : label,
     979            dist_group,
    799980            reduction,
    800981            NULL,       // dvodb
    … …  
    803984            false,
    804985            false,
    805             0       // magicked
     986            0,       // magicked
     987            diff_mode, // diff_mode
     988            note
    806989    );
    807990
    … …  
    8771060    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", true, false); // required options
    8781061    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
     1062    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1063    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    8791064    PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false);
    8801065    PXOPT_LOOKUP_S64(template_warp_id, config->args, "-template_warp_id", false, false);
    … …  
    8831068    PXOPT_LOOKUP_S64(input_stack_id, config->args, "-input_stack_id", false, false);
    8841069    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1070    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
    8851071
    8861072    if (template_stack_id && template_warp_id) {
    … …  
    9051091
    9061092    psArray *list = psArrayAllocEmpty(16); // List of runs, to print
    907 
    908     if (!populatedrun(list, workdir, skycell_id, tess_id, label, reduction,
     1093    // Populated Run will generate the diff_mode value
     1094    if (!populatedrun(list, workdir, skycell_id, tess_id, label, data_group ? data_group : label, dist_group, reduction, note,
    9091095                      input_warp_id ? input_warp_id : PS_MAX_S64,
    9101096                      input_stack_id ? input_stack_id : PS_MAX_S64,
    … …  
    9331119
    9341120    psMetadata *expWhere = psMetadataAlloc();
    935     psMetadata *warpWhere = psMetadataAlloc();
     1121    psMetadata *warp1Where = psMetadataAlloc(); // First set of restrictions on warp
     1122    psMetadata *warp2Where = psMetadataAlloc(); // Second set of restriction on warp
    9361123    psMetadata *stackWhere = psMetadataAlloc();
    9371124
    9381125    PXOPT_COPY_S64(config->args, expWhere, "-exp_id", "exp_id", "==");
    9391126    PXOPT_COPY_STR(config->args, expWhere, "-filter", "filter", "==");
    940     PXOPT_COPY_S64(config->args, warpWhere, "-warp_id", "warpRun.warp_id", "==");
    941     PXOPT_COPY_STR(config->args, warpWhere, "-skycell_id", "warpSkyfile.skycell_id", "==");
    942     PXOPT_COPY_STR(config->args, warpWhere, "-tess_id", "warpRun.tess_id", "==");
    943     PXOPT_COPY_STR(config->args, warpWhere, "-warp_label", "warpRun.label", "==");
    944     PXOPT_COPY_F32(config->args, warpWhere,  "-good_frac", "warpSkyfile.good_frac", ">=");
     1127    PXOPT_COPY_STR(config->args, expWhere, "-comment", "comment", "LIKE");
     1128    PXOPT_COPY_S64(config->args, warp1Where, "-warp_id", "warpRun.warp_id", "==");
     1129    PXOPT_COPY_STR(config->args, warp1Where, "-warp_label", "warpRun.label", "==");
     1130    PXOPT_COPY_STR(config->args, warp1Where, "-tess_id", "warpRun.tess_id", "==");
     1131    PXOPT_COPY_STR(config->args, warp1Where, "-data_group", "warpRun.data_group", "==");
     1132    PXOPT_COPY_S64(config->args, warp2Where, "-warp_id", "warpRun.warp_id", "==");
     1133    PXOPT_COPY_STR(config->args, warp2Where, "-tess_id", "warpRun.tess_id", "==");
     1134    PXOPT_COPY_STR(config->args, warp2Where, "-data_group", "warpRun.data_group", "==");
     1135    PXOPT_COPY_STR(config->args, warp2Where, "-skycell_id", "warpSkyfile.skycell_id", "==");
     1136    PXOPT_COPY_STR(config->args, warp2Where, "-warp_label", "warpRun.label", "==");
     1137    PXOPT_COPY_F32(config->args, warp2Where,  "-good_frac", "warpSkyfile.good_frac", ">=");
    9451138    PXOPT_COPY_STR(config->args, stackWhere, "-stack_label", "stackRun.label", "==");
    9461139
    947     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    948     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    949     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    950     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1140    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1141    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1142    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1143    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1144    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1145    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1146    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1147
    9511148    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9521149    PXOPT_LOOKUP_BOOL(newTemplates, config->args, "-new-templates", false);
    … …  
    9581155    psString query = pxDataGet("difftool_definewarpstack_part1.sql");
    9591156    if (!query) {
    960         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    961         return false;
    962     }
    963 
    964     psString warpQuery = NULL;
     1157        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1158        return false;
     1159    }
     1160
     1161    psString warp1Query = NULL;
     1162    psString warp2Query = NULL;
    9651163    psString stackQuery = NULL;
    9661164    psString expQuery = NULL;
    … …  
    9741172    }
    9751173    psFree(expWhere);
    976     if (psListLength(warpWhere->list)) {
    977         psString whereClause = psDBGenerateWhereConditionSQL(warpWhere, NULL);
    978         psStringAppend(&warpQuery, "\n AND %s", whereClause);
     1174    if (psListLength(warp1Where->list)) {
     1175        psString whereClause = psDBGenerateWhereConditionSQL(warp1Where, NULL);
     1176        psStringAppend(&warp1Query, "\n AND %s", whereClause);
    9791177        psFree(whereClause);
    9801178    } else {
    981         warpQuery = psStringCopy("\n");
    982     }
    983     psFree(warpWhere);
    984 
    985     if (!available) {
    986         // diff what's available, even if warp run has some faults and is incomplete
    987         psStringAppend(&warpQuery, " AND warpRun.state = 'full'");
    988     }
     1179        warp1Query = psStringCopy("\n");
     1180    }
     1181    psFree(warp1Where);
     1182    if (psListLength(warp2Where->list)) {
     1183        psString whereClause = psDBGenerateWhereConditionSQL(warp2Where, NULL);
     1184        psStringAppend(&warp2Query, "\n AND %s", whereClause);
     1185        psFree(whereClause);
     1186    } else {
     1187        warp2Query = psStringCopy("\n");
     1188    }
     1189    psFree(warp2Where);
    9891190
    9901191    // don't queue for exposures that have already been diff'd unless requested
    … …  
    10051206    psFree(stackWhere);
    10061207
    1007     psTrace("difftool", 1, query, warpQuery, diffQuery, expQuery, stackQuery);
     1208    psTrace("difftool", 1, query, warp1Query, warp2Query, diffQuery, expQuery, stackQuery);
    10081209
    10091210    if (!psDBTransaction(config->dbh)) {
    … …  
    10121213    }
    10131214
    1014     if (!p_psDBRunQueryF(config->dbh, query, warpQuery, expQuery, diffQuery)) {
     1215    if (!p_psDBRunQueryF(config->dbh, query, warp1Query, warp2Query, expQuery, diffQuery)) {
    10151216        psError(PS_ERR_UNKNOWN, false, "database error");
    10161217        psFree(query);
    … …  
    10721273        return false;
    10731274    }
     1275    psFree(warp1Query);
    10741276    psFree(query);
    10751277    query = NULL;
    … …  
    11031305        if (!p_psDBRunQuery(config->dbh, "DELETE FROM skycellsToDiff")) {
    11041306            psError(PS_ERR_UNKNOWN, false, "database error");
    1105             psFree(warpQuery);
     1307            psFree(warp2Query);
    11061308            psFree(stackQuery);
    11071309            psFree(skycell_query);
    … …  
    11141316        if (!mdok) {
    11151317            psError(PXTOOLS_ERR_PROG, false, "warp_id not found --- ignoring row %ld", i);
    1116             psFree(warpQuery);
     1318            psFree(warp2Query);
    11171319            psFree(stackQuery);
    11181320            psFree(skycell_query);
    … …  
    11251327        if (!mdok) {
    11261328            psError(PXTOOLS_ERR_PROG, false, "skycell_count not found");
    1127             psFree(warpQuery);
     1329            psFree(warp2Query);
    11281330            psFree(stackQuery);
    11291331            psFree(skycell_query);
    … …  
    11361338        if (!mdok) {
    11371339            psError(PXTOOLS_ERR_PROG, false, "tess_id not found");
    1138             psFree(warpQuery);
     1340            psFree(warp2Query);
    11391341            psFree(stackQuery);
    11401342            psFree(skycell_query);
    … …  
    11441346            return false;
    11451347        }
     1348
    11461349        psString filter = psMetadataLookupStr(&mdok, row, "filter");
    11471350        if (!mdok) {
    11481351            psError(PXTOOLS_ERR_PROG, false, "filter not found");
    1149             psFree(warpQuery);
     1352            psFree(warp2Query);
    11501353            psFree(stackQuery);
    11511354            psFree(skycell_query);
    … …  
    11551358            return false;
    11561359        }
    1157         if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warpQuery)) {
    1158             psError(PS_ERR_UNKNOWN, false, "database error");
    1159             psFree(warpQuery);
     1360
     1361        psString warp_data_group = psMetadataLookupStr(&mdok, row, "data_group");
     1362        if (!mdok) {
     1363          psError(PXTOOLS_ERR_PROG, false, "warp data_group not found");
     1364          psFree(warp2Query);
     1365          psFree(stackQuery);
     1366          psFree(skycell_query);
     1367          if (!psDBRollback(config->dbh)) {
     1368            psError(PS_ERR_UNKNOWN, false, "database error");
     1369          }
     1370          return false;
     1371        }
     1372        if (warp_data_group) {
     1373          data_group = warp_data_group;
     1374        }
     1375       
     1376        if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warp2Query)) {
     1377            psError(PS_ERR_UNKNOWN, false, "database error");
     1378            psFree(warp2Query);
    11601379            psFree(stackQuery);
    11611380            psFree(skycell_query);
    … …  
    11681387
    11691388        if (num == 0) {
    1170             psTrace("difftool", PS_LOG_INFO, "no skycells with stack found for %" PRId64, warp_id);
     1389            psTrace("difftool", PS_LOG_INFO, "no skycells with stack found for warp_id %" PRId64, warp_id);
    11711390            continue;
    11721391        }
    11731392
    11741393        if (!available && (num != skycell_count)) {
    1175             psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %"
    1176                 PRId64 " need %" PRId64, num, skycell_count, warp_id);
     1394            psTrace("difftool", PS_LOG_INFO, "%" PRId64 " skyfiles with stack found for warp_id %" PRId64
     1395                    " but need %" PRId64, num, warp_id, skycell_count);
    11771396            continue;
    11781397        }
    … …  
    11841403                workdir,
    11851404                label,
     1405                data_group ? data_group : label,
     1406                dist_group,
    11861407                reduction,
    11871408                NULL,       // dvodb
    … …  
    11901411                false,                  // bothways
    11911412                true,                   // exposure
    1192                 0       // magicked
     1413                0,       // magicked
     1414                IPP_DIFF_MODE_WARP_STACK,
     1415                note
    11931416        );
    11941417
    … …  
    12061429        if (!p_psDBRunQuery(config->dbh, query)) {
    12071430            psError(PS_ERR_UNKNOWN, false, "database error");
    1208             psFree(warpQuery);
     1431            psFree(warp2Query);
    12091432            psFree(stackQuery);
    12101433            psFree(skycell_query);
    … …  
    12201443        if (!p_psDBRunQuery(config->dbh, query)) {
    12211444            psError(PS_ERR_UNKNOWN, false, "database error");
    1222             psFree(warpQuery);
     1445            psFree(warp2Query);
    12231446            psFree(stackQuery);
    12241447            psFree(skycell_query);
    … …  
    12351458            psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    12361459                run->diff_id);
    1237             psFree(warpQuery);
     1460            psFree(warp2Query);
    12381461            psFree(stackQuery);
    12391462            psFree(skycell_query);
    … …  
    12491472    }
    12501473    psFree(output);
    1251     psFree(warpQuery);
     1474    psFree(warp2Query);
    12521475    psFree(stackQuery);
    12531476    psFree(skycell_query);
    … …  
    12591482    }
    12601483
    1261     if (!diffRunPrintObjects(stdout, list, !simple)) {
     1484    if (numGood && !diffRunPrintObjects(stdout, list, !simple)) {
    12621485        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    12631486        psFree(list);
    … …  
    12881511                   "ABS(TIME_TO_SEC(TIMEDIFF(inputRawExp.dateobs, templateRawExp.dateobs)))", "<=");
    12891512
     1513    // other where restrictions:
     1514    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_begin",      "inputRawExp.dateobs",        ">=");
     1515    PXOPT_COPY_TIME(config->args,  selectWhere, "-dateobs_end",        "inputRawExp.dateobs",        "<=");
     1516    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_min",             "inputRawExp.ra",             ">=");
     1517    PXOPT_COPY_RADEC(config->args, selectWhere, "-ra_max",             "inputRawExp.ra",             "<");
     1518    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_min",           "inputRawExp.decl",           ">=");
     1519    PXOPT_COPY_RADEC(config->args, selectWhere, "-decl_max",           "inputRawExp.decl",           "<");
     1520    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_min", "inputRawExp.sat_pixel_frac", ">=");
     1521    PXOPT_COPY_F32(config->args,   selectWhere, "-sat_pixel_frac_max", "inputRawExp.sat_pixel_frac", "<");
     1522    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_min",        "inputRawExp.airmass",        ">=");
     1523    PXOPT_COPY_F64(config->args,   selectWhere, "-airmass_max",        "inputRawExp.airmass",        "<");
     1524    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_min",       "inputRawExp.exp_time",       ">=");
     1525    PXOPT_COPY_F32(config->args,   selectWhere, "-exp_time_max",       "inputRawExp.exp_time",       "<");
     1526    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_min",             "inputRawExp.bg",             ">=");
     1527    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_max",             "inputRawExp.bg",             "<");
     1528    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_min",       "inputRawExp.bg_stdev",       ">=");
     1529    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_stdev_max",       "inputRawExp.bg_stdev",       "<");
     1530    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_min",  "inputRawExp.bg_mean_stdev",  ">=");
     1531    PXOPT_COPY_F64(config->args,   selectWhere, "-bg_mean_stdev_max",  "inputRawExp.bg_mean_stdev",  "<");
     1532    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_min",            "inputRawExp.alt",            ">=");
     1533    PXOPT_COPY_F64(config->args,   selectWhere, "-alt_max",            "inputRawExp.alt",            "<");
     1534    PXOPT_COPY_F64(config->args,   selectWhere, "-az_min",             "inputRawExp.az",             ">=");
     1535    PXOPT_COPY_F64(config->args,   selectWhere, "-az_max",             "inputRawExp.az",             "<");
     1536    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_min",       "inputRawExp.ccd_temp",       ">=");
     1537    PXOPT_COPY_F32(config->args,   selectWhere, "-ccd_temp_max",       "inputRawExp.ccd_temp",       "<");
     1538    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_min",         "inputRawExp.posang",         ">=");
     1539    PXOPT_COPY_F64(config->args,   selectWhere, "-posang_max",         "inputRawExp.posang",         "<");
     1540    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_min",      "inputRawExp.sun_angle",      ">=");
     1541    PXOPT_COPY_F32(config->args,   selectWhere, "-sun_angle_max",      "inputRawExp.sun_angle",      "<");
     1542    PXOPT_COPY_STR(config->args,   selectWhere, "-comment",            "inputRawExp.comment",        "LIKE");
     1543
    12901544    // Haversine formula for great circle distance
    12911545    PXOPT_COPY_F32(config->args, selectWhere, "-distance",
    … …  
    13061560    // Additional controls
    13071561    PXOPT_LOOKUP_BOOL(rerun, config->args, "-rerun", false);
    1308     PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
    13091562
    13101563    // Settings to apply to defined run
    1311     PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", true, false); // required options
    1312     PXOPT_LOOKUP_STR(reduction, config->args, "-reduction", false, false); // option
    1313     PXOPT_LOOKUP_STR(label, config->args, "-label", false, false); // option
    1314     PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
     1564    PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required options
     1565    PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1566    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1567    PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false); // option
     1568    PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false); // option
     1569    PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false); // option
     1570    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1571
    13151572    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    13161573    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    13271584        psString tempCreate = pxDataGet("difftool_definewarpwarp_temp_create.sql"); // Create temp table SQL
    13281585        if (!tempCreate) {
    1329             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1586            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13301587            psFree(selectWhere);
    13311588            psFree(insertWhere);
    … …  
    13501607        psString tempInsert = pxDataGet("difftool_definewarpwarp_temp_insert.sql"); // Insert to temp table
    13511608        if (!tempInsert) {
    1352             psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1609            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13531610            psFree(selectWhere);
    13541611            psFree(insertWhere);
    … …  
    13821639    psString select = pxDataGet("difftool_definewarpwarp_select.sql");
    13831640    if (!select) {
    1384         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1641        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    13851642        psFree(selectWhere);
    13861643        psFree(insertWhere);
    … …  
    13951652    if (psListLength(selectWhere->list)) {
    13961653        psString new = psDBGenerateWhereConditionSQL(selectWhere, NULL);
    1397         psStringAppend(&whereClause, "\n%s %s", whereClause ? "AND" : "WHERE", new);
     1654        psStringAppend(&whereClause, "\nAND %s", new);
    13981655        psFree(new);
    13991656    }
    14001657    psFree(selectWhere);
    14011658
    1402     if (!available) {
    1403         psStringAppend(&whereClause,
    1404                        "\n%s inputWarpRun.state = 'full'"
    1405                        "AND templateWarpRun.state = 'full'",
    1406                        whereClause ? "AND" : "WHERE");
    1407     }
    1408 
    14091659    if (!rerun) {
    1410         psStringAppend(&whereClause, "\n%s diffs.diff_id IS NULL", whereClause ? "AND" : "WHERE");
     1660        psStringAppend(&whereClause, "\nAND diffs.diff_id IS NULL");
    14111661    }
    14121662
    … …  
    14851735        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    14861736        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
     1737        psString input_data_group = psMetadataLookupStr(NULL, row, "input_data_group");
     1738        if (input_data_group) {
     1739          data_group = input_data_group;
     1740        }
     1741
    14871742        if (!input_id || !template || !tess_id) {
    14881743            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    … …  
    14951750            return false;
    14961751        }
    1497 
    1498         diffRunRow *run = diffRunRowAlloc(0, "reg", workdir, label, reduction, NULL, registered,
    1499                                           tess_id, true, true, false); // Run to insert
     1752       
     1753        diffRunRow *run = diffRunRowAlloc(0,
     1754                                          "reg",
     1755                                          workdir,
     1756                                          label,
     1757                                          data_group ? data_group : label,
     1758                                          dist_group,
     1759                                          reduction,
     1760                                          NULL,  // dvodb
     1761                                          registered,
     1762                                          tess_id,
     1763                                          true,  // bothways
     1764                                          true,  // exposure
     1765                                          false, // magicked
     1766                                          IPP_DIFF_MODE_WARP_WARP,
     1767                                          note); // Run to insert
    15001768        if (!diffRunInsertObject(config->dbh, run)) {
    15011769            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    15691837}
    15701838
     1839static bool definestackstackMode(pxConfig *config) {
     1840  PS_ASSERT_PTR_NON_NULL(config, false);
     1841
     1842  psMetadata *stack1Where = psMetadataAlloc();
     1843  psMetadata *stack2Where = psMetadataAlloc();
     1844
     1845  PXOPT_COPY_STR(config->args, stack1Where, "-tess_id", "stackRun.tess_id", "==");
     1846  PXOPT_COPY_STR(config->args, stack2Where, "-tess_id", "stackRun.tess_id", "==");
     1847  PXOPT_COPY_STR(config->args, stack1Where, "-filter", "stackRun.filter", "==");
     1848  PXOPT_COPY_STR(config->args, stack2Where, "-filter", "stackRun.filter", "==");
     1849  PXOPT_COPY_STR(config->args, stack1Where, "-skycell_id", "stackRun.skycell_id", "==");
     1850  PXOPT_COPY_STR(config->args, stack2Where, "-skycell_id", "stackRun.skycell_id", "==");
     1851  PXOPT_COPY_STR(config->args, stack1Where, "-input_label", "stackRun.label","==");
     1852  PXOPT_COPY_STR(config->args, stack2Where, "-template_label", "stackRun.label","==");
     1853  PXOPT_COPY_F32(config->args, stack1Where, "-good_frac", "stackSumSkyfile.good_frac", ">=");
     1854  PXOPT_COPY_F32(config->args, stack2Where, "-good_frac", "stackSumSkyfile.good_frac", ">=");
     1855
     1856  PXOPT_LOOKUP_STR(workdir, config->args, "-set_workdir", true, false); // required option
     1857  PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false); // option
     1858  PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false); // option
     1859  PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
     1860  PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
     1861  PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
     1862  PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     1863
     1864  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1865  PXOPT_LOOKUP_BOOL(reRun, config->args, "-rerun", false);
     1866  PXOPT_LOOKUP_BOOL(newTemplates,config->args,"-new-templates", false);
     1867
     1868  PXOPT_LOOKUP_BOOL(available, config->args, "-available", false);
     1869  PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1870
     1871  if (!(label)) {
     1872    PXOPT_LOOKUP_STR(label,config->args, "-input_label",true,false);
     1873  }
     1874
     1875  // Organize the config information into queries.
     1876  psString stack1Query = NULL;
     1877  psString stack2Query = NULL;
     1878
     1879  if (psListLength(stack1Where->list)) {
     1880    psString whereClause = psDBGenerateWhereConditionSQL(stack1Where, NULL);
     1881    psStringAppend(&stack1Query, "\n AND %s", whereClause);
     1882    psFree(whereClause);
     1883  } else {
     1884    stack1Query = psStringCopy("\n");
     1885  }
     1886  psFree(stack1Where);
     1887
     1888  if (psListLength(stack2Where->list)) {
     1889    psString whereClause = psDBGenerateWhereConditionSQL(stack2Where, NULL);
     1890    psStringAppend(&stack2Query, "\n AND %s", whereClause);
     1891    psFree(whereClause);
     1892  } else {
     1893    stack2Query = psStringCopy("\n");
     1894  }
     1895  psFree(stack2Where);
     1896
     1897  // don't queue for stacks that have already been diffed unless requested
     1898  psString diffQuery = NULL;
     1899  if (! (reRun || newTemplates) ) {
     1900    psStringAppend(&diffQuery, "\n AND diffExp.diff_id IS NULL");
     1901  } else {
     1902    diffQuery = psStringCopy("\n");
     1903  }
     1904
     1905  // find the distinct set of data_groups and filters
     1906  psString query = pxDataGet("difftool_definestackstack_part0.sql");
     1907  if (!query) {
     1908    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1909    return(false);
     1910  }
     1911  psTrace("difftool",1,query,stack2Query,stack1Query,diffQuery,stack1Query);
     1912/*   exit(10); */
     1913
     1914  if (!psDBTransaction(config->dbh)) {
     1915    psError(PS_ERR_UNKNOWN, false, "database error");
     1916    return(false);
     1917  }
     1918
     1919  if (!p_psDBRunQueryF(config->dbh, query, stack2Query, stack1Query, diffQuery, stack1Query)) {
     1920    psError(PS_ERR_UNKNOWN, false, "database error");
     1921    psFree(query);
     1922    if (!psDBRollback(config->dbh)) {
     1923      psError(PS_ERR_UNKNOWN, false, "database error");
     1924    }
     1925    return false;
     1926  }
     1927
     1928  psFree(query);
     1929
     1930  psArray *output = p_psDBFetchResult(config->dbh);
     1931  if (!output) {
     1932    psErrorCode err = psErrorCodeLast();
     1933    switch (err) {
     1934    case PS_ERR_DB_CLIENT:
     1935      psError(PXTOOLS_ERR_SYS, false, "database error");
     1936      break;
     1937    case PS_ERR_DB_SERVER:
     1938      psError(PXTOOLS_ERR_PROG, false, "database error");
     1939      break;
     1940    default:
     1941      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1942      break;
     1943    }
     1944    if (!psDBRollback(config->dbh)) {
     1945      psError(PS_ERR_UNKNOWN, false, "database error");
     1946    }
     1947    return false;
     1948  }
     1949  if (!psArrayLength(output)) {
     1950    psTrace("difftool", PS_LOG_INFO, "no rows found");
     1951    psFree(output);
     1952    if (!psDBCommit(config->dbh)) {
     1953      psError(PS_ERR_UNKNOWN, false, "database error");
     1954      return false;
     1955    }
     1956    return true;
     1957  }
     1958
     1959  query = pxDataGet("difftool_definestackstack_part1.sql");
     1960  if (pretend) {
     1961    // negative simple so the default is true
     1962    if (!ippdbPrintMetadatas(stdout, output, "diffRunTemp", !simple)) {
     1963      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1964      psFree(output);
     1965      return false;
     1966    }
     1967    psFree(output);
     1968    return true;
     1969  }
     1970
     1971  psArray *list = psArrayAllocEmpty(16); // List of runs defined, to print
     1972  for (long i = 0; i < output->n; i++) {
     1973    psMetadata *row = output->data[i]; // Output row from query
     1974    bool mdok;                      // Status of MD lookup
     1975
     1976    psString tess_id = psMetadataLookupStr(&mdok,row,"INPUT_tess_id");
     1977    psString this_data_group = psMetadataLookupStr(&mdok,row,"INPUT_data_group");
     1978    psString this_dist_group = psMetadataLookupStr(&mdok,row,"INPUT_dist_group");
     1979    psString this_label = psMetadataLookupStr(&mdok,row,"INPUT_label");
     1980
     1981    psString this_stack1Query = psStringCopy(stack1Query);
     1982
     1983    psString thisWhere = psDBGenerateWhereConditionSQL(row,NULL);
     1984    psStringSubstitute(&thisWhere,"stackRun.","INPUT_");
     1985    psStringAppend(&this_stack1Query,"\n AND %s", thisWhere);
     1986    psFree(thisWhere);
     1987
     1988    psTrace("difftool",1, query,stack2Query,this_stack1Query,diffQuery,this_stack1Query);
     1989    if (!psDBTransaction(config->dbh)) {
     1990      psError(PS_ERR_UNKNOWN, false, "database error");
     1991      return(false);
     1992    }
     1993
     1994    if (!p_psDBRunQueryF(config->dbh, query, stack2Query, this_stack1Query, diffQuery, this_stack1Query)) {
     1995      psError(PS_ERR_UNKNOWN, false, "database error");
     1996      psFree(query);
     1997      if (!psDBRollback(config->dbh)) {
     1998        psError(PS_ERR_UNKNOWN, false, "database error");
     1999      }
     2000      return false;
     2001    }
     2002    psFree(this_stack1Query);
     2003
     2004    psArray *diff_id_output = p_psDBFetchResult(config->dbh);
     2005    if (!diff_id_output) {
     2006      psErrorCode err = psErrorCodeLast();
     2007      switch (err) {
     2008      case PS_ERR_DB_CLIENT:
     2009        psError(PXTOOLS_ERR_SYS, false, "database error");
     2010        break;
     2011      case PS_ERR_DB_SERVER:
     2012        psError(PXTOOLS_ERR_PROG, false, "database error");
     2013        break;
     2014      default:
     2015        psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2016        break;
     2017      }
     2018      if (!psDBRollback(config->dbh)) {
     2019        psError(PS_ERR_UNKNOWN, false, "database error");
     2020      }
     2021      return false;
     2022    }
     2023    if (!psArrayLength(diff_id_output)) {
     2024      psTrace("difftool", PS_LOG_INFO, "no rows found");
     2025      psFree(diff_id_output);
     2026      if (!psDBCommit(config->dbh)) {
     2027        psError(PS_ERR_UNKNOWN, false, "database error");
     2028        return false;
     2029      }
     2030      return true;
     2031    }
     2032
     2033    // ok we've got one create the diffRun
     2034    diffRunRow *run = diffRunRowAlloc(
     2035                                      0,          // ID
     2036                                      "reg",      // state
     2037                                      workdir,
     2038                                      label ? label : this_label,
     2039                                      data_group ? data_group : this_data_group,
     2040                                      dist_group ? dist_group : this_dist_group,
     2041                                      reduction,
     2042                                      NULL,       // dvodb
     2043                                      registered,
     2044                                      tess_id,
     2045                                      false,                 // bothways
     2046                                      false,                 // exposure
     2047                                      0,       // magicked
     2048                                      IPP_DIFF_MODE_STACK_STACK, // diff_mode
     2049                                      note
     2050                                      );
     2051    // Commit to database
     2052    if (!diffRunInsertObject(config->dbh, run)) {
     2053      psError(PS_ERR_UNKNOWN, false, "database error");
     2054      psFree(run);
     2055      if (!psDBRollback(config->dbh)) {
     2056        psError(PS_ERR_UNKNOWN, false, "database error");
     2057      }
     2058      return false;
     2059    }
     2060/*     diffRunPrintObject(stdout,run,1); */
     2061    run->diff_id = psDBLastInsertID(config->dbh);
     2062    for (long j = 0; j < diff_id_output->n; j++) {
     2063      psMetadata *input_row = diff_id_output->data[j]; // Output row from query
     2064      bool mdok;
     2065      psString in_skycell_id  = psMetadataLookupStr(&mdok,input_row,"skycell_id");
     2066      psS64 in_input_stack_id = psMetadataLookupS64(&mdok,input_row,"stack_id");
     2067      psS64 in_template_stack_id = psMetadataLookupS64(&mdok,input_row,"max_stack_id");
     2068      psString in_tess_id = psMetadataLookupStr(&mdok,input_row,"tess_id");
     2069      psTrace("difftool",1,"%s %" PRId64 " %" PRId64 " %s\n",
     2070              in_skycell_id, in_input_stack_id, in_template_stack_id, in_tess_id);
     2071      diffInputSkyfileRow *input = diffInputSkyfileRowAlloc(
     2072                                                            run->diff_id,   // ID
     2073                                                            in_skycell_id,
     2074                                                            PS_MAX_S64, // warp1_id -> NULL
     2075                                                            in_input_stack_id, // stack1
     2076                                                            PS_MAX_S64, // warp2_id -> NULL
     2077                                                            in_template_stack_id, // stack2
     2078                                                            in_tess_id,
     2079                                                            0 // diff_skyfile_id
     2080                                                            );
     2081      // Commit to database the input
     2082      if (!diffInputSkyfileInsertObject(config->dbh, input)) {
     2083        psError(PS_ERR_UNKNOWN, false, "database error");
     2084        psFree(input);
     2085        if (!psDBRollback(config->dbh)) {
     2086          psError(PS_ERR_UNKNOWN, false, "database error");
     2087        }
     2088        return false;
     2089      }
     2090
     2091/*       diffInputSkyfilePrintObject(stdout,input,1); */
     2092      psFree(input);
     2093    }
     2094
     2095    if (!setdiffRunState(config, run->diff_id, "new", false)) {
     2096        psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64, run->diff_id);
     2097        psFree(stack1Query);
     2098        psFree(stack2Query);
     2099        psFree(diffQuery);
     2100        psFree(run);
     2101        psFree(list);
     2102        if (!psDBRollback(config->dbh)) {
     2103            psError(PS_ERR_UNKNOWN, false, "database error");
     2104        }
     2105        return false;
     2106    }
     2107    psArrayAdd(list, list->n, run);
     2108    psFree(run);
     2109  }
     2110
     2111  if (!psDBCommit(config->dbh)) {
     2112    psError(PS_ERR_UNKNOWN, false, "database error");
     2113    psFree(list);
     2114    return false;
     2115  }
     2116
     2117  if (!diffRunPrintObjects(stdout, list, !simple)) {
     2118    psError(PS_ERR_UNKNOWN, false, "failed to print object");
     2119    psFree(list);
     2120    return false;
     2121  }
     2122
     2123  psFree(query);
     2124  psFree(stack1Query);
     2125  psFree(stack2Query);
     2126  psFree(diffQuery);
     2127  psFree(output);
     2128  psFree(list);
     2129
     2130    if (!psDBCommit(config->dbh)) {
     2131        psError(PS_ERR_UNKNOWN, false, "database error");
     2132        psFree(list);
     2133        return false;
     2134    }
     2135
     2136  return(true);
     2137}
    15712138
    15722139static bool pendingcleanuprunMode(pxConfig *config)
    … …  
    15822149    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
    15832150    if (!query) {
    1584         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1585         return false;
    1586     }
     2151        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2152        return false;
     2153    }
     2154    // pxDataGet/psStringSubstitute workaround
     2155    psString queryCopy = psStringCopy(query);
     2156    psFree(query);
     2157    query = queryCopy;
    15872158
    15882159    if (where && psListLength(where->list)) {
    15892160        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1590         psStringAppend(&query, " AND %s", whereClause);
     2161        psStringAppend(&whereClause, " AND ");
     2162        psStringSubstitute(&query,whereClause,"@INNERCONSTRAINT@");
    15912163        psFree(whereClause);
     2164    }
     2165    else {
     2166      psStringSubstitute(&query,NULL,"@INNERCONSTRAINT@");
    15922167    }
    15932168    psFree(where);
    … …  
    15992174        psFree(limitString);
    16002175    }
    1601 
     2176    //    fprintf(stderr,"%s",query);
     2177
     2178    //fprintf(stderr,"%s",query);
    16022179    if (!p_psDBRunQuery(config->dbh, query)) {
    16032180        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    16472224    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
    16482225    if (!query) {
    1649         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2226        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    16502227        return false;
    16512228    }
    … …  
    17072284    psString query = pxDataGet("difftool_donecleanup.sql");
    17082285    if (!query) {
    1709         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2286        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    17102287        return false;
    17112288    }
    … …  
    17622339    psMetadata *where = psMetadataAlloc();
    17632340    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2341    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    17642342
    17652343    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    17732351}
    17742352
    1775 static bool diffRunComplete(pxConfig *config)
    1776 {
    1777     PS_ASSERT_PTR_NON_NULL(config, false);
    1778 
    1779     // look for completed diffRuns
    1780     psString query = pxDataGet("difftool_completed_runs.sql");
    1781     if (!query) {
    1782         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1783         return false;
    1784     }
    1785 
    1786     if (!p_psDBRunQuery(config->dbh, query)) {
    1787         psError(PS_ERR_UNKNOWN, false, "database error");
    1788         psFree(query);
    1789         return false;
    1790     }
    1791     psFree(query);
    1792 
    1793     psArray *output = p_psDBFetchResult(config->dbh);
    1794     if (!output) {
    1795         psError(PS_ERR_UNKNOWN, false, "database error");
    1796         return false;
    1797     }
    1798     if (!psArrayLength(output)) {
    1799         psTrace("difftool", PS_LOG_INFO, "no rows found");
    1800         psFree(output);
    1801         return true;
    1802     }
    1803     for (long i = 0; i < psArrayLength(output); i++) {
    1804         psMetadata *row = output->data[i];
    1805 
    1806         psS64 diff_id = psMetadataLookupS64(NULL, row, "diff_id");
    1807         psS64 magicked = psMetadataLookupS64(NULL, row, "magicked");
    1808 
    1809         // set diffRun.state to 'stop'
    1810         if (!setdiffRunState(config, diff_id, "full", magicked)) {
    1811             psError(PS_ERR_UNKNOWN, false, "failed to change diffRun.state for diff_id: %" PRId64,
    1812                 diff_id);
    1813             psFree(output);
    1814             return false;
    1815         }
    1816     }
    1817 
    1818     return true;
    1819 }
     2353static bool change_skyfile_data_state(pxConfig *config, psString data_state, psString run_state) {
     2354  PS_ASSERT_PTR_NON_NULL(config, false);
     2355
     2356  // diff_id, skycell_id are required
     2357  PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2358  PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", true, false);
     2359
     2360
     2361  psS64 magicked = 0;
     2362  if (!strcmp(data_state, "full")) {
     2363      PXOPT_LOOKUP_S64(set_magicked, config->args, "-magicked", 0, false);
     2364      magicked = set_magicked;
     2365  }
     2366
     2367  psString query = pxDataGet("difftool_change_skyfile_data_state.sql");
     2368
     2369  if (!psDBTransaction(config->dbh)) {
     2370    psError(PS_ERR_UNKNOWN, false, "database error");
     2371    return(false);
     2372  }
     2373
     2374  psString set_magicked_skyfile = psStringCopy("");
     2375  psString set_magicked_run = psStringCopy("");
     2376  if (magicked != 0 && !strcmp(data_state, "full")) {
     2377    psStringAppend(&set_magicked_skyfile,  "\n , diffSkyfile.magicked = %" PRId64, magicked);
     2378    psStringAppend(&set_magicked_run,      "\n , diffRun.magicked = %" PRId64, magicked);
     2379
     2380  } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
     2381    psStringAppend(&set_magicked_skyfile, "\n, diffSkyfile.magicked = IF(diffSkyfile.magicked = 0, 0, -1)");
     2382    psStringAppend(&set_magicked_run, "\n, diffRun.magicked = IF(diffRun.magicked = 0, 0, -1)");
     2383  }
     2384
     2385  // Uses the unconstrained (diffRun.state [NEED NOT EQUAL] run_state) version from warptool.c
     2386
     2387  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_skyfile, diff_id, skycell_id)) {
     2388    psError(PS_ERR_UNKNOWN, false, "database error");
     2389    // rollback
     2390    if (!psDBRollback(config->dbh)) {
     2391      psError(PS_ERR_UNKNOWN, false, "database error");
     2392    }
     2393    psError(PS_ERR_UNKNOWN, false, "database error");
     2394    psFree(set_magicked_skyfile);
     2395    return(false);
     2396  }
     2397  psFree(set_magicked_skyfile);
     2398  psFree(query);
     2399
     2400  query = pxDataGet("difftool_change_run_state.sql");
     2401  if (!p_psDBRunQueryF(config->dbh, query, data_state, set_magicked_run, diff_id, data_state)) {
     2402    // rollback
     2403    if (!psDBRollback(config->dbh)) {
     2404      psError(PS_ERR_UNKNOWN, false, "database error");
     2405    }
     2406    psError(PS_ERR_UNKNOWN, false, "database error");
     2407    psFree(set_magicked_run);
     2408    return(false);
     2409  }
     2410
     2411  if (!psDBCommit(config->dbh)) {
     2412    psError(PS_ERR_UNKNOWN, false, "database error");
     2413    psFree(set_magicked_run);
     2414    return(false);
     2415  }
     2416  psFree(set_magicked_run);
     2417
     2418  return(true);
     2419}
     2420
     2421static bool tocleanedskyfileMode(pxConfig *config) {
     2422  return change_skyfile_data_state(config, "cleaned","goto_cleaned");
     2423}
     2424static bool topurgedskyfileMode(pxConfig *config) {
     2425  return change_skyfile_data_state(config, "purged", "goto_purged");
     2426}
     2427static bool toscrubbedskyfileMode(pxConfig *config) {
     2428  return change_skyfile_data_state(config, "scrubbed", "goto_scrubbed");
     2429}
     2430static bool tofullskyfileMode(pxConfig *config) {
     2431  return change_skyfile_data_state(config, "full", "update");
     2432}
     2433
    18202434
    18212435bool exportrunMode(pxConfig *config)
    … …  
    18412455  }
    18422456
     2457  if (!pxExportVersion(config, f)) {
     2458    psError(PS_ERR_UNKNOWN, false, "failed to write dbversion output file");
     2459    return false;
     2460  }
    18432461  psMetadata *where = psMetadataAlloc();
    18442462  PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
    … …  
    18532471    psString query = pxDataGet(tables[i].sqlFilename);
    18542472    if (!query) {
    1855       psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2473      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    18562474      return false;
    18572475    }
    … …  
    19322550  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
    19332551
    1934   fprintf (stdout, "---- input ----\n");
     2552#ifdef notdef
     2553  fprintf (stderr, "---- input ----\n");
    19352554  psMetadataPrint (stderr, input, 1);
    1936 
     2555#endif
     2556
     2557  if (!pxCheckImportVersion(config, input)) {
     2558      psError(PS_ERR_UNKNOWN, false, "pxCheckImportVersion failed");
     2559      return false;
     2560  }
    19372561  psMetadataItem *item = psMetadataLookup (input, "diffRun");
    19382562  psAssert (item, "entry not in input?");
    … …  
    19842608  return true;
    19852609}
     2610
     2611static bool listrunMode(pxConfig *config)
     2612{
     2613    PS_ASSERT_PTR_NON_NULL(config, false);
     2614
     2615    psMetadata *where = psMetadataAlloc();
     2616    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
     2617    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
     2618    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffRun.magicked", "==");
     2619    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     2620    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     2621    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
     2622
     2623    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     2624    if (!template) {
     2625        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawInput.exp_id", "==");
     2626        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawInput.exp_name", "==");
     2627        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpInput.warp_id", "==");
     2628        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
     2629        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
     2630        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
     2631    } else {
     2632        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
     2633        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawTemplate.exp_name", "==");
     2634        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpTemplate.warp_id", "==");
     2635        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
     2636        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
     2637        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
     2638    }
     2639
     2640    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2641    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2642    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2643    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     2644
     2645
     2646    psString where2 = NULL;
     2647    pxmagicAddWhere(config, &where2, "diffRun");
     2648    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
     2649    psString query = pxDataGet("difftool_listrun.sql");
     2650    if (!query) {
     2651        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2652        return false;
     2653    }
     2654
     2655    if (psListLength(where->list)) {
     2656        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2657        psStringAppend(&query, " WHERE %s", whereClause);
     2658        psFree(whereClause);
     2659    } else if (where2) {
     2660        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
     2661    } else if (!all) {
     2662        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2663        return false;
     2664    }
     2665    psFree(where);
     2666
     2667    if (pstamp_order) {
     2668        if (template) {
     2669            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     2670        } else {
     2671            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     2672        }
     2673    }
     2674           
     2675    // treat limit == 0 as "no limit"
     2676    if (limit) {
     2677        psString limitString = psDBGenerateLimitSQL(limit);
     2678        psStringAppend(&query, " %s", limitString);
     2679        psFree(limitString);
     2680    }
     2681
     2682    if (!p_psDBRunQuery(config->dbh, query)) {
     2683        psError(PS_ERR_UNKNOWN, false, "database error");
     2684        psFree(query);
     2685        return false;
     2686    }
     2687    psFree(query);
     2688
     2689    psArray *output = p_psDBFetchResult(config->dbh);
     2690    if (!output) {
     2691        psErrorCode err = psErrorCodeLast();
     2692        switch (err) {
     2693            case PS_ERR_DB_CLIENT:
     2694                psError(PXTOOLS_ERR_SYS, false, "database error");
     2695            case PS_ERR_DB_SERVER:
     2696                psError(PXTOOLS_ERR_PROG, false, "database error");
     2697            default:
     2698                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2699        }
     2700
     2701        return false;
     2702    }
     2703    if (!psArrayLength(output)) {
     2704        psTrace("difftool", PS_LOG_INFO, "no rows found");
     2705        psFree(output);
     2706        return true;
     2707    }
     2708
     2709    if (psArrayLength(output)) {
     2710        // negative simple so the default is true
     2711        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     2712            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2713            psFree(output);
     2714            return false;
     2715        }
     2716    }
     2717
     2718    psFree(output);
     2719
     2720    return true;
     2721}
     2722// a very specfic function to queue a cleaned warpSkyfile to be updated
     2723static bool setskyfiletoupdateMode(pxConfig *config)
     2724{
     2725    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2726
     2727    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2728    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2729    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2730
     2731    psString query = pxDataGet("difftool_setskyfiletoupdate.sql");
     2732    if (!query) {
     2733        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2734        return false;
     2735    }
     2736
     2737    psString setHook = psStringCopy("");
     2738    if (label) {
     2739        psStringAppend(&setHook, "\n , diffRun.label = '%s'", label);
     2740    }
     2741
     2742    if (skycell_id) {
     2743        psStringAppend(&query, " AND (diffSkyfile.skycell_id = '%s')", skycell_id);
     2744    }
     2745
     2746    if (!p_psDBRunQueryF(config->dbh, query, setHook, diff_id)) {
     2747        psError(PS_ERR_UNKNOWN, false, "database error");
     2748        return false;
     2749    }
     2750
     2751    psFree(setHook);
     2752    psFree(query);
     2753
     2754    return true;
     2755}
Note: See TracChangeset for help on using the changeset viewer.