IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 5, 2013, 2:24:05 PM (13 years ago)
Author:
eugene
Message:

merge changes from trunk

Location:
branches/eam_branches/ipp-20130207
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20130207

  • branches/eam_branches/ipp-20130207/ippTools/src

  • branches/eam_branches/ipp-20130207/ippTools/src/releasetool.c

    r35048 r35236  
    4141static bool listreleaseMode(pxConfig *config);
    4242static bool definerelexpMode(pxConfig *config);
     43static bool tocalibexpMode(pxConfig *config);
    4344static bool updaterelexpMode(pxConfig *config);
    4445static bool listrelexpMode(pxConfig *config);
     46static bool definerelstackMode(pxConfig *config);
     47static bool updaterelstackMode(pxConfig *config);
     48static bool listrelstackMode(pxConfig *config);
     49static bool definerelgroupMode(pxConfig *config);
     50static bool pendingrelgroupMode(pxConfig *config);
     51static bool updaterelgroupMode(pxConfig *config);
     52static bool listrelgroupMode(pxConfig *config);
    4553
    4654# define MODECASE(caseName, func) \
    … …  
    6674        MODECASE(RELEASETOOL_MODE_DEFINERELEASE,    definereleaseMode);
    6775        MODECASE(RELEASETOOL_MODE_UPDATERELEASE,    updatereleaseMode);
     76        MODECASE(RELEASETOOL_MODE_TOCALIBEXP,       tocalibexpMode);
    6877        MODECASE(RELEASETOOL_MODE_LISTRELEASE,      listreleaseMode);
    6978
    … …  
    7180        MODECASE(RELEASETOOL_MODE_UPDATERELEXP,     updaterelexpMode);
    7281        MODECASE(RELEASETOOL_MODE_LISTRELEXP,       listrelexpMode);
     82
     83        MODECASE(RELEASETOOL_MODE_DEFINERELSTACK,   definerelstackMode);
     84        MODECASE(RELEASETOOL_MODE_UPDATERELSTACK,   updaterelstackMode);
     85        MODECASE(RELEASETOOL_MODE_LISTRELSTACK,     listrelstackMode);
     86
     87        MODECASE(RELEASETOOL_MODE_DEFINERELGROUP,   definerelgroupMode);
     88        MODECASE(RELEASETOOL_MODE_UPDATERELGROUP,   updaterelgroupMode);
     89        MODECASE(RELEASETOOL_MODE_PENDINGRELGROUP,  pendingrelgroupMode);
     90        MODECASE(RELEASETOOL_MODE_LISTRELGROUP,     listrelgroupMode);
    7391        default:
    7492            psAbort("invalid option (this should not happen)");
    … …  
    163181
    164182    PXOPT_LOOKUP_S32(surveyID,    config->args, "-set_surveyID", true, false);
    165     PXOPT_LOOKUP_STR(releaseName, config->args, "-set_releaseName", true, false);
     183    PXOPT_LOOKUP_STR(release_name, config->args, "-set_release_name", true, false);
    166184    PXOPT_LOOKUP_STR(release_state, config->args, "-set_release_state",  true, false);
    167185    PXOPT_LOOKUP_S32(dataRelease, config->args, "-set_dataRelease", false, false);
    … …  
    171189        0,      // rel_id (auto_increment)
    172190        surveyID,
    173         releaseName,
     191        release_name,
    174192        release_state,
    175193        dataRelease,
    … …  
    187205    PS_ASSERT_PTR_NON_NULL(config, false);
    188206
    189     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
     207    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
    190208    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
    191209
    192     if (!releaseName && !rel_id) {
    193         psError(PXTOOLS_ERR_CONFIG, true, "either -releaseName or -rel_id is required\n");
    194         return false;
    195     }
    196     PXOPT_LOOKUP_STR(release_state,       config->args, "-set_release_state",  true, false);
     210    if (!release_name && !rel_id) {
     211        psError(PXTOOLS_ERR_CONFIG, true, "either -release_name or -rel_id is required\n");
     212        return false;
     213    }
     214    PXOPT_LOOKUP_STR(release_state,    config->args, "-set_release_state",  false, false);
     215    PXOPT_LOOKUP_S32(priority,         config->args, "-set_priority",  false, false);
     216    PXOPT_LOOKUP_S32(dataRelease,      config->args, "-set_dataRelease",  false, false);
     217    if (!release_state && priority == 0 && dataRelease == -1) {
     218        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -set_release_state -set_priority and -set_dataRelease is required\n");
     219        return false;
     220    }
    197221
    198222    psMetadata *where = psMetadataAlloc();
    199223
    200224    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    201     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "==");
    202 
    203     psString query = NULL;
    204     psStringAppend(&query, "UPDATE ippRelease SET release_state = '%s'", release_state);
     225    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
     226
     227    psString sep = "";
     228    psString comma = ", ";
     229    psString query = psStringCopy("UPDATE ippRelease SET");
     230    if (release_state) {
     231        psStringAppend(&query, "%s release_state = '%s'", sep, release_state);
     232        sep = comma;
     233    }
     234    if (priority != 0) {
     235        psStringAppend(&query, "%s priority = %d", sep, priority);
     236        sep = comma;
     237    }
     238    if (dataRelease != -1) {
     239        psStringAppend(&query, "%s dataRelease = %d", sep, dataRelease);
     240        sep = comma;
     241    }
    205242
    206243    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    … …  
    232269
    233270    PXOPT_COPY_STR(config->args, where, "-surveyName",  "surveyName", "LIKE");
    234     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "LIKE");
     271    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "LIKE");
    235272    PXOPT_COPY_STR(config->args, where, "-release_state", "release_state", "==");
    236273    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    … …  
    313350    // insure that at least one of these is supplied to select the release
    314351    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
    315     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
    316     if (!rel_id && !releaseName) {
    317         psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -releaseName is required");
    318         return false;
    319     }
    320 
    321     // limit query to the target release. (Note: this will select nothing of releaseName and rel_id don't match)
     352    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     353    if (!rel_id && !release_name) {
     354        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     355        return false;
     356    }
     357
     358    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
    322359    // note: we add these after above to insure that search args are supplied
    323     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "==");
     360    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
    324361    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
    325362
    … …  
    327364    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", true, false);
    328365    PXOPT_LOOKUP_U32(flags, config->args,     "-set_flags", false, false);
     366    PXOPT_LOOKUP_F32(user_zpt_obs, config->args,   "-set_zpt_obs", false, false);
     367    PXOPT_LOOKUP_F32(user_zpt_stdev, config->args, "-set_zpt_stdev", false, false);
    329368    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     369    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
    330370
    331371    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    … …  
    391431        psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id");
    392432        psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id");
    393         psF32 zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
    394         psF32 zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     433
     434        // if zpt_obs or zpt_stdev were not supplied use the results from the camRun
     435        psF32 zpt_obs, zpt_stdev;
     436        if (!isfinite(user_zpt_obs)) {
     437            zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
     438        } else {
     439            zpt_obs = user_zpt_obs;
     440        }
     441        if (!isfinite(user_zpt_stdev)) {
     442            zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     443        } else {
     444            zpt_stdev = user_zpt_stdev;
     445        }
    395446
    396447        if (!relExpInsert(config->dbh,
    … …  
    400451            chip_id,
    401452            cam_id,
     453            0,          // group_id
    402454            state,
    403455            flags,
    … …  
    405457            zpt_stdev,
    406458            path_base,
     459            fault,
    407460            now,       // registered
    408461            now        // time_stamp
    … …  
    430483static bool updaterelexpMode(pxConfig *config)
    431484{
    432     psError(PS_ERR_UNKNOWN, true, "not yet implemented");
    433     return false;
    434 }
    435 
    436 static bool listrelexpMode(pxConfig *config)
     485    PS_ASSERT_PTR_NON_NULL(config, false);
     486
     487    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     488    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
     489    PXOPT_LOOKUP_S32(relexp_id, config->args,   "-relexp_id", false, false);
     490
     491    if (!relexp_id && !release_name && !rel_id) {
     492        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -relexp_id, -release_name, and -rel_id is required\n");
     493        return false;
     494    }
     495
     496    PXOPT_LOOKUP_STR(state,    config->args, "-set_state",  false, false);
     497    PXOPT_LOOKUP_U32(flags,    config->args, "-set_flags",  false, false);
     498    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     499    PXOPT_LOOKUP_F32(zpt_obs,  config->args, "-set_zpt_obs",  false, false);
     500    PXOPT_LOOKUP_F32(zpt_stdev,config->args, "-set_zpt_stdev",  false, false);
     501    PXOPT_LOOKUP_S16(fault,    config->args, "-set_fault",  false, false);
     502    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault",  false);
     503    if (!state && !flags && !path_base && !isfinite(zpt_obs) && !isfinite(zpt_stdev) && !fault && !clearfault) {
     504        psError(PXTOOLS_ERR_CONFIG, true, "must set at least one column\n");
     505        return false;
     506    }
     507
     508    if (fault && clearfault) {
     509        psError(PXTOOLS_ERR_CONFIG, true, "cannot set and clear fault at same time\n");
     510        return false;
     511    }
     512
     513    psMetadata *where = psMetadataAlloc();
     514
     515    PXOPT_COPY_S64(config->args, where, "-exp_id", "relExp.exp_id", "==");
     516    PXOPT_COPY_S32(config->args, where, "-relexp_id", "relExp.relexp_id", "==");
     517    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     518    // make sure that we have enough parameters to identify the relExp to change
     519    if (!psListLength(where->list)){
     520        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     521        psFree(where);
     522        return false;
     523    }
     524
     525    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
     526    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
     527
     528    psString sep = "";
     529    psString comma = ", ";
     530    psString query = psStringCopy("UPDATE relExp JOIN ippRelease USING(rel_id) JOIN rawExp USING(exp_id) SET");
     531    if (state) {
     532        psStringAppend(&query, "%s relExp.state = '%s'", sep, state);
     533        sep = comma;
     534    }
     535    if (path_base) {
     536        psStringAppend(&query, "%s relExp.path_base = '%s'", sep, path_base);
     537        sep = comma;
     538    }
     539    if (flags) {
     540        psStringAppend(&query, "%s relExp.flags = %d", sep, flags);
     541        sep = comma;
     542    }
     543    if (isfinite(zpt_obs)) {
     544        psStringAppend(&query, "%s relExp.zpt_obs = %f", sep, zpt_obs);
     545        sep = comma;
     546    }
     547    if (isfinite(zpt_stdev)) {
     548        psStringAppend(&query, "%s relExp.zpt_stdev = %f", sep, zpt_stdev);
     549        sep = comma;
     550    }
     551    if (fault) {
     552        psStringAppend(&query, "%s relExp.fault = %d", sep, fault);
     553        sep = comma;
     554    }
     555    if (clearfault) {
     556        psStringAppend(&query, "%s relExp.fault = 0", sep);
     557        sep = comma;
     558    }
     559
     560    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     561    psStringAppend(&query, " WHERE %s", whereClause);
     562    psFree(whereClause);
     563
     564    if (!p_psDBRunQuery(config->dbh, query)) {
     565        psError(PS_ERR_UNKNOWN, false, "database error");
     566        psFree(query);
     567        return false;
     568    }
     569
     570    psU64 affected = psDBAffectedRows(config->dbh);
     571    psLogMsg("releasetool", PS_LOG_INFO, "Updated %" PRIu64 " ippReleases", affected);
     572
     573
     574    psFree(query);
     575
     576    return true;
     577}
     578
     579static bool tocalibexpMode(pxConfig *config)
    437580{
    438581    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    440583    psMetadata *where = psMetadataAlloc();
    441584
    442     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "LIKE");
     585    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     586    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     587#ifdef notdef
     588    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    443589    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
    444590    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
    … …  
    458604
    459605    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     606
     607    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     608#endif
     609
     610    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     611    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     612
     613    psString query = pxDataGet("releasetool_tocalibexp.sql");
     614    if (!query) {
     615        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     616        return false;
     617    }
     618
     619    psString where2 = NULL;
     620#ifdef notdef
     621    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     622        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     623        return false;
     624    }
     625#endif
     626
     627    if (psListLength(where->list)) {
     628        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     629        psStringAppend(&query, "\nAND %s", whereClause);
     630        psFree(whereClause);
     631#ifdef notdef
     632    } else if (where2) {
     633        psStringAppend(&query, "\nAND ");
     634#endif
     635    } else {
     636        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     637        psFree(where);
     638        return false;
     639    }
     640
     641    if (where2) {
     642        psStringAppend(&query, "\n%s", where2);
     643        psFree(where2);
     644    }
     645
     646    if (limit) {
     647        psString limitString = psDBGenerateLimitSQL(limit);
     648        psStringAppend(&query, " %s", limitString);
     649        psFree(limitString);
     650    }
     651
     652    if (!p_psDBRunQuery(config->dbh, query)) {
     653        psError(PS_ERR_UNKNOWN, false, "database error");
     654        psFree(query);
     655        return false;
     656    }
     657    psFree(query);
     658
     659    psArray *output = p_psDBFetchResult(config->dbh);
     660    if (!output) {
     661        psError(PS_ERR_UNKNOWN, false, "database error");
     662        return false;
     663    }
     664
     665    if (!psArrayLength(output)) {
     666        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     667        psFree(output);
     668        return true;
     669    }
     670
     671    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     672        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     673        psFree(output);
     674        return false;
     675    }
     676
     677    psFree(output);
     678
     679    return true;
     680}
     681static bool listrelexpMode(pxConfig *config)
     682{
     683    PS_ASSERT_PTR_NON_NULL(config, NULL);
     684
     685    psMetadata *where = psMetadataAlloc();
     686
     687    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     688    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     689    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     690    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     691    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     692    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     693    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     694    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "camProcessedExp.fwhm_major", ">=");
     695    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "camProcessedExp.fwhm_major", "<=");
     696    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_name", "==");
     697    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     698    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     699    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     700    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     701    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     702    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     703    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     704
     705    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
    460706    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    461707
    … …  
    533779    return true;
    534780}
    535 
     781static bool definerelstackMode(pxConfig *config)
     782{
     783    PS_ASSERT_PTR_NON_NULL(config, NULL);
     784
     785    psMetadata *where = psMetadataAlloc();
     786
     787    bool includeSkycal = false;
     788
     789    PXOPT_COPY_S64(config->args, where, "-skycal_id",  "skycalRun.skycal_id", "==");
     790    PXOPT_COPY_STR(config->args, where, "-skycal_label", "skycalRun.label", "==");
     791    PXOPT_COPY_STR(config->args, where, "-skycal_data_group", "skycalRun.data_group", "==");
     792    if (psListLength(where->list)) {
     793        includeSkycal = true;
     794    }
     795
     796    PXOPT_COPY_STR(config->args, where, "-label",      "stackRun.label", "==");
     797    PXOPT_COPY_STR(config->args, where, "-data_group", "stackRun.data_group", "==");
     798    PXOPT_COPY_S64(config->args, where, "-stack_id",   "stackRun.stack_id", "==");
     799
     800    // Insure that at least one of the skycalRun selectors is supplied
     801    if (!psListLength(where->list)) {
     802        psFree(where);
     803        psError(PXTOOLS_ERR_CONFIG, false, "at least one of -label, -data_group, or -skycal_id is required");
     804        return false;
     805    }
     806
     807    // PXOPT_COPY_STR(config->args, where, "-tess_id",    "stackRun.tess_id", "==");
     808    // PXOPT_COPY_STR(config->args, where, "-skycell_id", "stackRun.skycell_id", "==");
     809
     810    // insure that at least one of these is supplied to select the release
     811    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
     812    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     813    if (!rel_id && !release_name) {
     814        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     815        return false;
     816    }
     817
     818    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
     819    // note: we add these after above to insure that search args are supplied
     820    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
     821    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
     822
     823
     824    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", true, false);
     825    PXOPT_LOOKUP_STR(stack_type, config->args,"-set_stack_type", true, false);
     826    PXOPT_LOOKUP_U32(flags, config->args,     "-set_flags", false, false);
     827    PXOPT_LOOKUP_F32(zpt_obs, config->args,   "-set_zpt_obs", false, false);
     828    PXOPT_LOOKUP_F32(zpt_stdev, config->args, "-set_zpt_stdev", false, false);
     829    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     830    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
     831
     832    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     833    PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false);
     834
     835    // find the parameters of all the exposures that we want to add to the release
     836    psString query;
     837   
     838    if (includeSkycal) {
     839        query = pxDataGet("releasetool_definerelstack_with_skycal.sql");
     840    } else {
     841        query = pxDataGet("releasetool_definerelstack.sql");
     842    }
     843    if (!query) {
     844        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     845        psFree(where);
     846        return false;
     847    }
     848
     849    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     850    psStringAppend(&query, " AND %s", whereClause);
     851    psFree(whereClause);
     852
     853    psFree(where);
     854
     855    if (!p_psDBRunQuery(config->dbh, query)) {
     856        psError(PS_ERR_UNKNOWN, false, "database error");
     857        psFree(query);
     858        return false;
     859    }
     860    psFree(query);
     861
     862    psArray *output = p_psDBFetchResult(config->dbh);
     863    if (!output) {
     864        psError(PS_ERR_UNKNOWN, false, "database error");
     865        return false;
     866    }
     867    if (!psArrayLength(output)) {
     868        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     869        psFree(output);
     870        return true;
     871    }
     872
     873    if (pretend) {
     874        // negative simple so the default is true
     875        if (!ippdbPrintMetadatas(stdout, output, "relstack", !simple)) {
     876            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     877            psFree(output);
     878            return false;
     879        }
     880        psFree(output);
     881        return true;
     882    }
     883
     884    if (!psDBTransaction(config->dbh)) {
     885        psError(PS_ERR_UNKNOWN, false, "database error");
     886        psFree(output);
     887        return false;
     888    }
     889
     890    psTime *now = psTimeGetNow(PS_TIME_TAI);
     891    // loop over our list of  exposures
     892    for (long i = 0; i < psArrayLength(output); i++) {
     893        psMetadata *md = output->data[i];
     894
     895        bool status = true;
     896        psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id");
     897        psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id");
     898        psS64 skycal_id = psMetadataLookupS64(&status, md, "skycal_id");
     899        psString skycell_id = psMetadataLookupStr(&status, md, "skycell_id");
     900        psString tess_id = psMetadataLookupStr(&status, md, "tess_id");
     901        psString filter = psMetadataLookupStr(&status, md, "filter");
     902
     903        // use skycal zero point measurement if not supplied with arguments
     904        psF32 sc_zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs");
     905        psF32 sc_zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev");
     906        psF32 stack_mjd_obs = psMetadataLookupF32(&status, md, "mjd_obs");
     907
     908        psU32 mjd_obs = 0;
     909        if (!strcmp(stack_type, "nightly")) {
     910            // only for nightly stacks do we set mjd_obs to a non zero value
     911            // We use integer day because this is part of the key that is used
     912            // to make sure entries are unique
     913            //      KEY (rel_id, tess_id, skycell_id, filter, mjd_obs),
     914            // 1 entry per release, skycell, filter and mjd_obs.
     915            // mjd_obs is zero for deep and reference stacks
     916            mjd_obs = (psU32) stack_mjd_obs;
     917        }
     918
     919        if (!relStackInsert(config->dbh,
     920            0,          // relstack_id (auto increment)
     921            rel_id,
     922            stack_id,
     923            skycal_id,
     924            skycell_id,
     925            tess_id,
     926            filter,
     927            state,
     928            flags,
     929            stack_type,
     930            isfinite(zpt_obs)   ? zpt_obs   : sc_zpt_obs,
     931            isfinite(zpt_stdev) ? zpt_stdev : sc_zpt_stdev,
     932            mjd_obs,
     933            path_base,
     934            fault,
     935            now,       // registered
     936            now        // time_stamp
     937        )) {
     938            if (!psDBRollback(config->dbh)) {
     939                psError(PS_ERR_UNKNOWN, false, "database error");
     940            }
     941            psError(PS_ERR_UNKNOWN, false,
     942                    "failed to trying to insert relStack for stack_id %" PRId64, stack_id);
     943            psFree(output);
     944            psFree(now);
     945            return false;
     946        }
     947    }
     948    psFree(output);
     949
     950    if (!psDBCommit(config->dbh)) {
     951        psError(PS_ERR_UNKNOWN, false, "database error");
     952        return false;
     953    }
     954
     955    return true;
     956}
     957
     958static bool updaterelstackMode(pxConfig *config)
     959{
     960    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     961    return false;
     962}
     963
     964static bool listrelstackMode(pxConfig *config)
     965{
     966    PS_ASSERT_PTR_NON_NULL(config, NULL);
     967
     968    psMetadata *where = psMetadataAlloc();
     969
     970    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     971    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     972    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     973    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     974    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     975    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     976    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "skycalResult.fwhm_major", ">=");
     977    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "skycalresult.fwhm_major", "<=");
     978    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_ame", "==");
     979    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     980    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     981    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     982    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     983    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     984    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     985    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     986
     987    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     988    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     989
     990    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     991
     992    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     993    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     994
     995    psString query = pxDataGet("releasetool_listrelexp.sql");
     996    if (!query) {
     997        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     998        return false;
     999    }
     1000
     1001    psString where2 = NULL;
     1002    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1003        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1004        return false;
     1005    }
     1006
     1007    if (psListLength(where->list)) {
     1008        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1009        psStringAppend(&query, "\nWHERE %s", whereClause);
     1010        psFree(whereClause);
     1011    } else if (where2) {
     1012        psStringAppend(&query, "\nWHERE ");
     1013    } else {
     1014        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1015        psFree(where);
     1016        return false;
     1017    }
     1018
     1019    if (where2) {
     1020        psStringAppend(&query, "\n%s", where2);
     1021        psFree(where2);
     1022    }
     1023
     1024    if (priority_order) {
     1025        psStringAppend(&query, "\nAND priority > 0 order by exp_id, priority");
     1026    }
     1027
     1028    if (limit) {
     1029        psString limitString = psDBGenerateLimitSQL(limit);
     1030        psStringAppend(&query, " %s", limitString);
     1031        psFree(limitString);
     1032    }
     1033
     1034    if (!p_psDBRunQuery(config->dbh, query)) {
     1035        psError(PS_ERR_UNKNOWN, false, "database error");
     1036        psFree(query);
     1037        return false;
     1038    }
     1039    psFree(query);
     1040
     1041    psArray *output = p_psDBFetchResult(config->dbh);
     1042    if (!output) {
     1043        psError(PS_ERR_UNKNOWN, false, "database error");
     1044        return false;
     1045    }
     1046
     1047    if (!psArrayLength(output)) {
     1048        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1049        psFree(output);
     1050        return true;
     1051    }
     1052
     1053    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1054        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1055        psFree(output);
     1056        return false;
     1057    }
     1058
     1059    psFree(output);
     1060
     1061    return true;
     1062}
     1063
     1064static bool definerelgroupMode(pxConfig *config)
     1065{
     1066    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1067
     1068    PXOPT_LOOKUP_STR(group_type, config->args, "-set_group_type", true, false);
     1069    PXOPT_LOOKUP_STR(group_name, config->args, "-set_group_name", false, false);
     1070    PXOPT_LOOKUP_STR(label, config->args,     "-set_label", true, false);
     1071
     1072    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", false, false);
     1073    PXOPT_LOOKUP_STR(exp_list_path, config->args, "-set_exp_list_path", false, false);
     1074    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
     1075
     1076    psString query = NULL;
     1077
     1078    psMetadata *where = psMetadataAlloc();
     1079
     1080    // select sql and paramters based on group type
     1081    bool type_lap = false;
     1082    if (!strcmp(group_type, "lap")) {
     1083        type_lap = true;
     1084        if (group_name) {
     1085            psError(PXTOOLS_ERR_CONFIG, true, "group_name is not allowed with group_type lap");
     1086            psFree(where);
     1087            return false;
     1088        }
     1089        PXOPT_COPY_S64(config->args, where, "-select_seq_id", "lapRun.seq_id", "==");
     1090        PXOPT_COPY_S64(config->args, where, "-select_lap_id", "lapRun.lap_id", "==");
     1091        query = pxDataGet("releasetool_definerelgroup_select_lap.sql");
     1092        if (!query) {
     1093            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1094            psFree(where);
     1095            return false;
     1096        }
     1097    } else {
     1098        if (!strcmp(group_type, "date")) {
     1099            // group_type ok
     1100        } else if (!strcmp(group_type, "data_group")) {
     1101            // group_type ok
     1102        } else {
     1103            psError(PXTOOLS_ERR_CONFIG, true, "%s is not valid group_type", group_type);
     1104            return false;
     1105        }
     1106        if (!group_name) {
     1107            psError(PXTOOLS_ERR_CONFIG, true, "group_name is required allowed with group_type %s", group_type);
     1108            psFree(where);
     1109            return false;
     1110        }
     1111        pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1112        query = pxDataGet("releasetool_definerelgroup_select_data_group.sql");
     1113        if (!query) {
     1114            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1115            psFree(where);
     1116            return false;
     1117        }
     1118    }
     1119
     1120    // Insure that at least one of the exposure selectors is supplied
     1121    if (!psListLength(where->list)) {
     1122        psFree(where);
     1123        psError(PXTOOLS_ERR_CONFIG, false, "search arguments are required");
     1124        return false;
     1125    }
     1126
     1127    // insure that at least one of these is supplied to select the release
     1128    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
     1129    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     1130    if (!rel_id && !release_name) {
     1131        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     1132        return false;
     1133    }
     1134
     1135    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
     1136    // note: we add these after above to insure that search args are supplied
     1137    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
     1138    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
     1139
     1140    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1141    PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false);
     1142
     1143    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1144    psStringAppend(&query, " AND %s", whereClause);
     1145    psFree(whereClause);
     1146
     1147    psFree(where);
     1148
     1149    if (!type_lap) {
     1150        psStringAppend(&query, "\nHAVING COUNT(exp_id) > 0");
     1151    }
     1152
     1153    if (!p_psDBRunQuery(config->dbh, query)) {
     1154        psError(PS_ERR_UNKNOWN, false, "database error");
     1155        psFree(query);
     1156        return false;
     1157    }
     1158    psFree(query);
     1159
     1160    psArray *output = p_psDBFetchResult(config->dbh);
     1161    if (!output) {
     1162        psError(PS_ERR_UNKNOWN, false, "database error");
     1163        return false;
     1164    }
     1165    if (!psArrayLength(output)) {
     1166        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1167        psFree(output);
     1168        return true;
     1169    }
     1170
     1171    if (pretend) {
     1172        // negative simple so the default is true
     1173        if (!ippdbPrintMetadatas(stdout, output, "relGroupToQueue", !simple)) {
     1174            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1175            psFree(output);
     1176            return false;
     1177        }
     1178        psFree(output);
     1179        return true;
     1180    }
     1181
     1182    if (!psDBTransaction(config->dbh)) {
     1183        psError(PS_ERR_UNKNOWN, false, "database error");
     1184        psFree(output);
     1185        return false;
     1186    }
     1187
     1188    psTime *now = psTimeGetNow(PS_TIME_TAI);
     1189    // loop over our list of  exposures
     1190    for (long i = 0; i < psArrayLength(output); i++) {
     1191        psMetadata *md = output->data[i];
     1192
     1193        bool status = true;
     1194        psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id");
     1195        psS64 lap_id = 0;
     1196        if (type_lap) {
     1197            lap_id = psMetadataLookupS64(&status, md, "lap_id");
     1198        }
     1199
     1200        if (!relGroupInsert(config->dbh,
     1201            0,          // group_id (auto increment)
     1202            rel_id,
     1203            group_type,
     1204            lap_id,
     1205            group_name,
     1206            "reg",      // state
     1207            label,
     1208            exp_list_path,
     1209            fault,
     1210            now        // registered
     1211        )) {
     1212            if (!psDBRollback(config->dbh)) {
     1213                psError(PS_ERR_UNKNOWN, false, "database error");
     1214            }
     1215            psError(PS_ERR_UNKNOWN, false, "failed to trying to insert relGroup");
     1216            psFree(output);
     1217            psFree(now);
     1218            return false;
     1219        }
     1220        // Here's our new group_id
     1221        psS32 group_id = psDBLastInsertID(config->dbh);
     1222
     1223        psString query;
     1224        if (type_lap) {
     1225            query = pxDataGet("releasetool_definerelgroup_select_exp_lap.sql");
     1226            if (!query) {
     1227                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1228                psFree(where);
     1229                return false;
     1230            }
     1231            psStringAppend(&query, " AND relExp.rel_id = %d AND lap_id = %" PRId64, rel_id, lap_id);
     1232        } else {
     1233            query = pxDataGet("releasetool_definerelgroup_select_exp_data_group.sql");
     1234            if (!query) {
     1235                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1236                psFree(where);
     1237                return false;
     1238            }
     1239            psStringAppend(&query, " AND relExp.rel_id = %d", rel_id);
     1240
     1241            psMetadata *where = psMetadataAlloc();
     1242            pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1243            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1244            psStringAppend(&query, " AND %s", whereClause);
     1245            psFree(whereClause);
     1246            psFree(where);
     1247        }
     1248
     1249        if (!p_psDBRunQuery(config->dbh, query)) {
     1250            psError(PS_ERR_UNKNOWN, false, "database error");
     1251            psFree(query);
     1252            psFree(output);
     1253            psFree(now);
     1254            if (!psDBRollback(config->dbh)) {
     1255                psError(PS_ERR_UNKNOWN, false, "database error");
     1256            }
     1257            return false;
     1258        }
     1259        psFree(query);
     1260
     1261        psArray *exposures = p_psDBFetchResult(config->dbh);
     1262        if (!exposures) {
     1263            psFree(now);
     1264            psFree(output);
     1265            psError(PS_ERR_UNKNOWN, false, "database error");
     1266            if (!psDBRollback(config->dbh)) {
     1267                psError(PS_ERR_UNKNOWN, false, "database error");
     1268            }
     1269            return false;
     1270        }
     1271        if (!psArrayLength(exposures)) {
     1272            psFree(now);
     1273            psFree(output);
     1274            psFree(exposures);
     1275            psError(PS_ERR_UNKNOWN, false, "no exposures found error");
     1276            if (!psDBRollback(config->dbh)) {
     1277                psError(PS_ERR_UNKNOWN, false, "database error");
     1278            }
     1279            return false;
     1280        }
     1281
     1282        // assign the relExps to this new group
     1283        char *updateQuery = "UPDATE relExp SET group_id = %d WHERE relexp_id = %" PRId64;
     1284        for (int j = 0; j < psArrayLength(exposures); j++) {
     1285            psMetadata *md = exposures->data[j];
     1286
     1287            bool status = true;
     1288            psS32 relexp_id = psMetadataLookupS32(&status, md, "relexp_id");
     1289            if (!p_psDBRunQueryF(config->dbh, updateQuery, group_id, relexp_id)) {
     1290                psError(PS_ERR_UNKNOWN, false, "database error");
     1291                psFree(now);
     1292                psFree(output);
     1293                psFree(exposures);
     1294
     1295                if (!psDBRollback(config->dbh)) {
     1296                    psError(PS_ERR_UNKNOWN, false, "database error");
     1297                }
     1298                return false;
     1299            }
     1300        }
     1301        psFree(exposures);
     1302
     1303        // set state of relGroup to 'new'
     1304        if (!p_psDBRunQueryF(config->dbh, "UPDATE relGroup set state = 'new' WHERE group_id = %d", group_id)) {
     1305            psError(PS_ERR_UNKNOWN, false, "database error");
     1306            psFree(now);
     1307            psFree(output);
     1308            if (!psDBRollback(config->dbh)) {
     1309                psError(PS_ERR_UNKNOWN, false, "database error");
     1310            }
     1311            return false;
     1312        }
     1313    }
     1314    psFree(output);
     1315    psFree(now);
     1316
     1317    if (!psDBCommit(config->dbh)) {
     1318        psError(PS_ERR_UNKNOWN, false, "database error");
     1319        return false;
     1320    }
     1321
     1322    return true;
     1323}
     1324
     1325static bool updaterelgroupMode(pxConfig *config)
     1326{
     1327    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     1328    return false;
     1329}
     1330
     1331static bool pendingrelgroupMode(pxConfig *config)
     1332{
     1333    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1334
     1335    psMetadata *where = psMetadataAlloc();
     1336
     1337    pxAddLabelSearchArgs (config, where, "-label",      "relGroup.label", "==");
     1338    PXOPT_COPY_S32(config->args, where, "-group_id",    "relGroup.group_id", "==");
     1339    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1340    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1341
     1342    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1343    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1344
     1345    psString query = pxDataGet("releasetool_pendingrelgroup.sql");
     1346    if (!query) {
     1347        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1348        return false;
     1349    }
     1350
     1351    if (psListLength(where->list)) {
     1352        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1353        psStringAppend(&query, "\nAND %s", whereClause);
     1354        psFree(whereClause);
     1355    } else {
     1356        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1357        psFree(where);
     1358        return false;
     1359    }
     1360
     1361    if (limit) {
     1362        psString limitString = psDBGenerateLimitSQL(limit);
     1363        psStringAppend(&query, " %s", limitString);
     1364        psFree(limitString);
     1365    }
     1366
     1367    if (!p_psDBRunQuery(config->dbh, query)) {
     1368        psError(PS_ERR_UNKNOWN, false, "database error");
     1369        psFree(query);
     1370        return false;
     1371    }
     1372    psFree(query);
     1373
     1374    psArray *output = p_psDBFetchResult(config->dbh);
     1375    if (!output) {
     1376        psError(PS_ERR_UNKNOWN, false, "database error");
     1377        return false;
     1378    }
     1379
     1380    if (!psArrayLength(output)) {
     1381        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1382        psFree(output);
     1383        return true;
     1384    }
     1385
     1386    if (!ippdbPrintMetadatas(stdout, output, "pending_relGroup", !simple)) {
     1387        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1388        psFree(output);
     1389        return false;
     1390    }
     1391
     1392    psFree(output);
     1393
     1394    return true;
     1395}
     1396
     1397static bool listrelgroupMode(pxConfig *config)
     1398{
     1399    return false;
     1400#ifdef notdef
     1401    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1402
     1403    psMetadata *where = psMetadataAlloc();
     1404
     1405    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1406    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     1407    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     1408    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     1409    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     1410    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     1411    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "skycalResult.fwhm_major", ">=");
     1412    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "skycalresult.fwhm_major", "<=");
     1413    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_ame", "==");
     1414    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     1415    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     1416    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     1417    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     1418    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     1419    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     1420    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     1421
     1422    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     1423    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1424
     1425    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     1426
     1427    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1428    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1429
     1430    psString query = pxDataGet("releasetool_listrelexp.sql");
     1431    if (!query) {
     1432        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1433        return false;
     1434    }
     1435
     1436    psString where2 = NULL;
     1437    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1438        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1439        return false;
     1440    }
     1441
     1442    if (psListLength(where->list)) {
     1443        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1444        psStringAppend(&query, "\nWHERE %s", whereClause);
     1445        psFree(whereClause);
     1446    } else if (where2) {
     1447        psStringAppend(&query, "\nWHERE ");
     1448    } else {
     1449        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1450        psFree(where);
     1451        return false;
     1452    }
     1453
     1454    if (where2) {
     1455        psStringAppend(&query, "\n%s", where2);
     1456        psFree(where2);
     1457    }
     1458
     1459    if (priority_order) {
     1460        psStringAppend(&query, "\nAND priority > 0 order by exp_id, priority");
     1461    }
     1462
     1463    if (limit) {
     1464        psString limitString = psDBGenerateLimitSQL(limit);
     1465        psStringAppend(&query, " %s", limitString);
     1466        psFree(limitString);
     1467    }
     1468
     1469    if (!p_psDBRunQuery(config->dbh, query)) {
     1470        psError(PS_ERR_UNKNOWN, false, "database error");
     1471        psFree(query);
     1472        return false;
     1473    }
     1474    psFree(query);
     1475
     1476    psArray *output = p_psDBFetchResult(config->dbh);
     1477    if (!output) {
     1478        psError(PS_ERR_UNKNOWN, false, "database error");
     1479        return false;
     1480    }
     1481
     1482    if (!psArrayLength(output)) {
     1483        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1484        psFree(output);
     1485        return true;
     1486    }
     1487
     1488    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1489        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1490        psFree(output);
     1491        return false;
     1492    }
     1493
     1494    psFree(output);
     1495
     1496    return true;
     1497#endif //notdef
     1498}
     1499
Note: See TracChangeset for help on using the changeset viewer.