IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 35213 for trunk/ippTools


Ignore:
Timestamp:
Feb 28, 2013, 3:29:26 PM (13 years ago)
Author:
bills
Message:

Add tables relGroup and lapGroup
Add group_id to relExp
Rename releaseName release_name because I kept typing it wrong.

Location:
trunk/ippTools
Files:
6 added
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r35196 r35213  
    464464        sctool_list.sql \
    465465        releasetool_listsurvey.sql \
     466        releasetool_tocalibexp.sql \
    466467        releasetool_listrelease.sql \
    467468        releasetool_listrelexp.sql \
    468469        releasetool_definerelexp.sql \
    469470        releasetool_definerelstack.sql \
    470         releasetool_definerelstack_with_skycal.sql
     471        releasetool_definerelstack_with_skycal.sql \
     472        releasetool_definerelgroup_select_lap.sql \
     473        releasetool_definerelgroup_select_data_group.sql \
     474        releasetool_definerelgroup_select_exp_data_group.sql \
     475        releasetool_definerelgroup_select_exp_lap.sql
    471476

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r35196 r35213  
    21642164    rel_id      INT(8) AUTO_INCREMENT,
    21652165    surveyID    INT(8),
    2166     releaseName VARCHAR(64),
     2166    release_name VARCHAR(64),
    21672167    relase_state VARCHAR(16),   -- active, pending, archive, drop
    21682168    dataRelease INT(8),         -- PSPS dataRelease
    21692169    priority    INT(8),
    21702170    PRIMARY KEY(rel_id),
    2171     KEY(releaseName),
     2171    KEY(release_name),
    21722172    KEY(state),
    21732173    KEY(priority),
    … …  
    21812181    chip_id     BIGINT,         -- links to the runs that supplied the data
    21822182    cam_id      BIGINT,         -- for this release
     2183    group_id    INT(8),         -- id of relGroup that this exposure is contained in
    21832184    state       VARCHAR(16),    -- released, pending, archive, drop 
    21842185    flags       INT UNSIGNED,   -- flags for relphot, relastro, ??
    … …  
    22292230) ENGINE=innodb DEFAULT CHARSET=latin1;
    22302231
     2232CREATE TABLE relGroup (
     2233    group_id    INT(8) AUTO_INCREMENT,
     2234    rel_id      INT(8),
     2235    group_type  VARCHAR(16),
     2236    lap_id      BIGINT,
     2237    group_name  VARCHAR(16),
     2238    state       VARCHAR(16),    -- new full
     2239    label       VARCHAR(64),
     2240    exp_list_path   VARCHAR(255),
     2241    fault SMALLINT NOT NULL,
     2242    registered  DATETIME,
     2243    PRIMARY KEY (group_id),
     2244    KEY (rel_id, group_name),
     2245    KEY (group_type),
     2246    KEY (lap_id),
     2247    KEY (group_name),
     2248    KEY (state),
     2249    KEY (label),
     2250    KEY (fault),
     2251    FOREIGN KEY(rel_id) REFERENCES ippRelease(rel_id)
     2252) ENGINE=innodb DEFAULT CHARSET=latin1;
     2253
    22312254
    22322255

  • trunk/ippTools/share/releasetool_definerelexp.sql

    r34933 r35213  
    11SELECT
    22    ippRelease.rel_id,
    3     ippRelease.releaseName,
     3    ippRelease.release_name,
    44    rawExp.exp_name,
    55    rawExp.filter,

  • trunk/ippTools/share/releasetool_listrelexp.sql

    r35048 r35213  
    22    relexp_id,
    33    relExp.state,
    4     ippRelease.releaseName,
     4    relExp.fault,
     5    ippRelease.release_name,
    56    ippRelease.release_state,
    67    ippRelease.rel_id,
    … …  
    2122    camProcessedExp.path_base as cam_path_base,
    2223    camProcessedExp.fwhm_major,
     24    camProcessedExp.fwhm_minor,
    2325    warpRun.warp_id,
    2426    warpRun.state as warp_state,

  • trunk/ippTools/src/releasetool.c

    r35196 r35213  
    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);
    … …  
    4647static bool updaterelstackMode(pxConfig *config);
    4748static bool listrelstackMode(pxConfig *config);
     49static bool definerelgroupMode(pxConfig *config);
     50static bool pendingrelgroupMode(pxConfig *config);
     51static bool updaterelgroupMode(pxConfig *config);
     52static bool listrelgroupMode(pxConfig *config);
    4853
    4954# define MODECASE(caseName, func) \
    … …  
    6974        MODECASE(RELEASETOOL_MODE_DEFINERELEASE,    definereleaseMode);
    7075        MODECASE(RELEASETOOL_MODE_UPDATERELEASE,    updatereleaseMode);
     76        MODECASE(RELEASETOOL_MODE_TOCALIBEXP,       tocalibexpMode);
    7177        MODECASE(RELEASETOOL_MODE_LISTRELEASE,      listreleaseMode);
    7278
    … …  
    7884        MODECASE(RELEASETOOL_MODE_UPDATERELSTACK,   updaterelstackMode);
    7985        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);
    8091        default:
    8192            psAbort("invalid option (this should not happen)");
    … …  
    170181
    171182    PXOPT_LOOKUP_S32(surveyID,    config->args, "-set_surveyID", true, false);
    172     PXOPT_LOOKUP_STR(releaseName, config->args, "-set_releaseName", true, false);
     183    PXOPT_LOOKUP_STR(release_name, config->args, "-set_release_name", true, false);
    173184    PXOPT_LOOKUP_STR(release_state, config->args, "-set_release_state",  true, false);
    174185    PXOPT_LOOKUP_S32(dataRelease, config->args, "-set_dataRelease", false, false);
    … …  
    178189        0,      // rel_id (auto_increment)
    179190        surveyID,
    180         releaseName,
     191        release_name,
    181192        release_state,
    182193        dataRelease,
    … …  
    194205    PS_ASSERT_PTR_NON_NULL(config, false);
    195206
    196     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
     207    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
    197208    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
    198209
    199     if (!releaseName && !rel_id) {
    200         psError(PXTOOLS_ERR_CONFIG, true, "either -releaseName or -rel_id is required\n");
     210    if (!release_name && !rel_id) {
     211        psError(PXTOOLS_ERR_CONFIG, true, "either -release_name or -rel_id is required\n");
    201212        return false;
    202213    }
    … …  
    211222
    212223    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    213     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "==");
     224    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
    214225
    215226    psString sep = "";
    … …  
    253264
    254265    PXOPT_COPY_STR(config->args, where, "-surveyName",  "surveyName", "LIKE");
    255     PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "LIKE");
     266    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "LIKE");
    256267    PXOPT_COPY_STR(config->args, where, "-release_state", "release_state", "==");
    257268    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
    … …  
    334345    // insure that at least one of these is supplied to select the release
    335346    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
    336     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
    337     if (!rel_id && !releaseName) {
    338         psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -releaseName is required");
    339         return false;
    340     }
    341 
    342     // limit query to the target release. (Note: this will select nothing of releaseName and rel_id don't match)
     347    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     348    if (!rel_id && !release_name) {
     349        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     350        return false;
     351    }
     352
     353    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
    343354    // note: we add these after above to insure that search args are supplied
    344     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "==");
     355    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
    345356    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
    346357
    … …  
    429440            chip_id,
    430441            cam_id,
     442            0,          // group_id
    431443            state,
    432444            flags,
    … …  
    460472static bool updaterelexpMode(pxConfig *config)
    461473{
    462     psError(PS_ERR_UNKNOWN, true, "not yet implemented");
    463     return false;
     474    PS_ASSERT_PTR_NON_NULL(config, false);
     475
     476    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     477    PXOPT_LOOKUP_S32(rel_id, config->args,      "-rel_id", false, false);
     478    PXOPT_LOOKUP_S32(relexp_id, config->args,   "-relexp_id", false, false);
     479
     480    if (!relexp_id && !release_name && !rel_id) {
     481        psError(PXTOOLS_ERR_CONFIG, true, "at least one of -relexp_id, -release_name, and -rel_id is required\n");
     482        return false;
     483    }
     484
     485    PXOPT_LOOKUP_STR(state,    config->args, "-set_state",  false, false);
     486    PXOPT_LOOKUP_U32(flags,    config->args, "-set_flags",  false, false);
     487    PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false);
     488    PXOPT_LOOKUP_F32(zpt_obs,  config->args, "-set_zpt_obs",  false, false);
     489    PXOPT_LOOKUP_F32(zpt_stdev,config->args, "-set_zpt_stdev",  false, false);
     490    PXOPT_LOOKUP_S16(fault,    config->args, "-set_fault",  false, false);
     491    PXOPT_LOOKUP_BOOL(clearfault, config->args, "-clearfault",  false);
     492    if (!state && !flags && !path_base && !isfinite(zpt_obs) && !isfinite(zpt_stdev) && !fault && !clearfault) {
     493        psError(PXTOOLS_ERR_CONFIG, true, "must set at least one column\n");
     494        return false;
     495    }
     496
     497    if (fault && clearfault) {
     498        psError(PXTOOLS_ERR_CONFIG, true, "cannot set and clear fault at same time\n");
     499        return false;
     500    }
     501
     502    psMetadata *where = psMetadataAlloc();
     503
     504    PXOPT_COPY_S64(config->args, where, "-exp_id", "relExp.exp_id", "==");
     505    PXOPT_COPY_S32(config->args, where, "-relexp_id", "relExp.relexp_id", "==");
     506    PXOPT_COPY_STR(config->args, where, "-exp_name", "rawExp.exp_name", "==");
     507    // make sure that we have enough parameters to identify the relExp to change
     508    if (!psListLength(where->list)){
     509        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     510        psFree(where);
     511        return false;
     512    }
     513
     514    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "==");
     515    PXOPT_COPY_STR(config->args, where, "-release_name", "release_name", "==");
     516
     517    psString sep = "";
     518    psString comma = ", ";
     519    psString query = psStringCopy("UPDATE relExp JOIN ippRelease USING(rel_id) JOIN rawExp USING(exp_id) SET");
     520    if (state) {
     521        psStringAppend(&query, "%s relExp.state = '%s'", sep, state);
     522        sep = comma;
     523    }
     524    if (path_base) {
     525        psStringAppend(&query, "%s relExp.path_base = '%s'", sep, path_base);
     526        sep = comma;
     527    }
     528    if (flags) {
     529        psStringAppend(&query, "%s relExp.flags = %d", sep, flags);
     530        sep = comma;
     531    }
     532    if (isfinite(zpt_obs)) {
     533        psStringAppend(&query, "%s relExp.zpt_obs = %f", sep, zpt_obs);
     534        sep = comma;
     535    }
     536    if (isfinite(zpt_stdev)) {
     537        psStringAppend(&query, "%s relExp.zpt_stdev = %f", sep, zpt_stdev);
     538        sep = comma;
     539    }
     540    if (fault) {
     541        psStringAppend(&query, "%s relExp.fault = %d", sep, fault);
     542        sep = comma;
     543    }
     544    if (clearfault) {
     545        psStringAppend(&query, "%s relExp.fault = 0", sep);
     546        sep = comma;
     547    }
     548
     549    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     550    psStringAppend(&query, " WHERE %s", whereClause);
     551    psFree(whereClause);
     552
     553    if (!p_psDBRunQuery(config->dbh, query)) {
     554        psError(PS_ERR_UNKNOWN, false, "database error");
     555        psFree(query);
     556        return false;
     557    }
     558
     559    psU64 affected = psDBAffectedRows(config->dbh);
     560    psLogMsg("releasetool", PS_LOG_INFO, "Updated %" PRIu64 " ippReleases", affected);
     561
     562
     563    psFree(query);
     564
     565    return true;
    464566}
    465567
    466 static bool listrelexpMode(pxConfig *config)
     568static bool tocalibexpMode(pxConfig *config)
    467569{
    468570    PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    470572    psMetadata *where = psMetadataAlloc();
    471573
    472     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "LIKE");
     574    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     575    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     576#ifdef notdef
     577    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    473578    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
    474579    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
    … …  
    488593
    489594    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     595
     596    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     597#endif
     598
     599    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     600    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     601
     602    psString query = pxDataGet("releasetool_tocalibexp.sql");
     603    if (!query) {
     604        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     605        return false;
     606    }
     607
     608    psString where2 = NULL;
     609#ifdef notdef
     610    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     611        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     612        return false;
     613    }
     614#endif
     615
     616    if (psListLength(where->list)) {
     617        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     618        psStringAppend(&query, "\nAND %s", whereClause);
     619        psFree(whereClause);
     620#ifdef notdef
     621    } else if (where2) {
     622        psStringAppend(&query, "\nAND ");
     623#endif
     624    } else {
     625        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     626        psFree(where);
     627        return false;
     628    }
     629
     630    if (where2) {
     631        psStringAppend(&query, "\n%s", where2);
     632        psFree(where2);
     633    }
     634
     635    if (limit) {
     636        psString limitString = psDBGenerateLimitSQL(limit);
     637        psStringAppend(&query, " %s", limitString);
     638        psFree(limitString);
     639    }
     640
     641    if (!p_psDBRunQuery(config->dbh, query)) {
     642        psError(PS_ERR_UNKNOWN, false, "database error");
     643        psFree(query);
     644        return false;
     645    }
     646    psFree(query);
     647
     648    psArray *output = p_psDBFetchResult(config->dbh);
     649    if (!output) {
     650        psError(PS_ERR_UNKNOWN, false, "database error");
     651        return false;
     652    }
     653
     654    if (!psArrayLength(output)) {
     655        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     656        psFree(output);
     657        return true;
     658    }
     659
     660    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     661        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     662        psFree(output);
     663        return false;
     664    }
     665
     666    psFree(output);
     667
     668    return true;
     669}
     670static bool listrelexpMode(pxConfig *config)
     671{
     672    PS_ASSERT_PTR_NON_NULL(config, NULL);
     673
     674    psMetadata *where = psMetadataAlloc();
     675
     676    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     677    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     678    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     679    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     680    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     681    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     682    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     683    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "camProcessedExp.fwhm_major", ">=");
     684    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "camProcessedExp.fwhm_major", "<=");
     685    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_name", "==");
     686    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     687    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     688    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     689    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     690    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     691    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     692    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     693
     694    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
    490695    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
    491696
    … …  
    594799    // insure that at least one of these is supplied to select the release
    595800    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
    596     PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false);
    597     if (!rel_id && !releaseName) {
    598         psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -releaseName is required");
    599         return false;
    600     }
    601 
    602     // limit query to the target release. (Note: this will select nothing of releaseName and rel_id don't match)
     801    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     802    if (!rel_id && !release_name) {
     803        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     804        return false;
     805    }
     806
     807    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
    603808    // note: we add these after above to insure that search args are supplied
    604     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "==");
     809    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
    605810    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
    606811
    … …  
    752957    psMetadata *where = psMetadataAlloc();
    753958
    754     PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "LIKE");
     959    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
    755960    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
    756961    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
    … …  
    8461051}
    8471052
     1053static bool definerelgroupMode(pxConfig *config)
     1054{
     1055    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1056
     1057    PXOPT_LOOKUP_STR(group_type, config->args, "-set_group_type", true, false);
     1058    PXOPT_LOOKUP_STR(group_name, config->args, "-set_group_name", true, false);
     1059    PXOPT_LOOKUP_STR(label, config->args,     "-set_label", true, false);
     1060
     1061    PXOPT_LOOKUP_STR(state, config->args,     "-set_state", false, false);
     1062    PXOPT_LOOKUP_STR(exp_list_path, config->args, "-set_exp_list_path", false, false);
     1063    PXOPT_LOOKUP_S16(fault, config->args,     "-set_fault", false, false);
     1064
     1065    psString query = NULL;
     1066
     1067    psMetadata *where = psMetadataAlloc();
     1068
     1069    // select sql and paramters based on group type
     1070    bool type_lap = false;
     1071    if (!strcmp(group_type, "lap")) {
     1072        type_lap = true;
     1073        PXOPT_COPY_S64(config->args, where, "-select_seq_id", "lapRun.seq_id", "==");
     1074        PXOPT_COPY_S64(config->args, where, "-select_lap_id", "lapRun.lap_id", "==");
     1075        query = pxDataGet("releasetool_definerelgroup_select_lap.sql");
     1076        if (!query) {
     1077            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1078            psFree(where);
     1079            return false;
     1080        }
     1081    } else {
     1082        if (!strcmp(group_type, "date")) {
     1083            // group_type ok
     1084        } else if (!strcmp(group_type, "data_group")) {
     1085            // group_type ok
     1086        } else {
     1087            psError(PXTOOLS_ERR_CONFIG, true, "%s is not valid group_type", group_type);
     1088            return false;
     1089        }
     1090        pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1091        query = pxDataGet("releasetool_definerelgroup_select_data_group.sql");
     1092        if (!query) {
     1093            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1094            psFree(where);
     1095            return false;
     1096        }
     1097    }
     1098
     1099    // Insure that at least one of the exposure selectors is supplied
     1100    if (!psListLength(where->list)) {
     1101        psFree(where);
     1102        psError(PXTOOLS_ERR_CONFIG, false, "search arguments are required");
     1103        return false;
     1104    }
     1105
     1106    // insure that at least one of these is supplied to select the release
     1107    PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false);
     1108    PXOPT_LOOKUP_STR(release_name, config->args, "-release_name", false, false);
     1109    if (!rel_id && !release_name) {
     1110        psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -release_name is required");
     1111        return false;
     1112    }
     1113
     1114    // limit query to the target release. (Note: this will select nothing if release_name and rel_id don't match)
     1115    // note: we add these after above to insure that search args are supplied
     1116    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "==");
     1117    PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "==");
     1118
     1119    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
     1120    PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false);
     1121
     1122    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1123    psStringAppend(&query, " AND %s", whereClause);
     1124    psFree(whereClause);
     1125
     1126    psFree(where);
     1127
     1128    if (!type_lap) {
     1129        psStringAppend(&query, "\nHAVING COUNT(exp_id) > 0");
     1130    }
     1131
     1132    if (!p_psDBRunQuery(config->dbh, query)) {
     1133        psError(PS_ERR_UNKNOWN, false, "database error");
     1134        psFree(query);
     1135        return false;
     1136    }
     1137    psFree(query);
     1138
     1139    psArray *output = p_psDBFetchResult(config->dbh);
     1140    if (!output) {
     1141        psError(PS_ERR_UNKNOWN, false, "database error");
     1142        return false;
     1143    }
     1144    if (!psArrayLength(output)) {
     1145        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1146        psFree(output);
     1147        return true;
     1148    }
     1149
     1150    if (pretend) {
     1151        // negative simple so the default is true
     1152        if (!ippdbPrintMetadatas(stdout, output, "relGroupToQueue", !simple)) {
     1153            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1154            psFree(output);
     1155            return false;
     1156        }
     1157        psFree(output);
     1158        return true;
     1159    }
     1160
     1161    if (!psDBTransaction(config->dbh)) {
     1162        psError(PS_ERR_UNKNOWN, false, "database error");
     1163        psFree(output);
     1164        return false;
     1165    }
     1166
     1167    psTime *now = psTimeGetNow(PS_TIME_TAI);
     1168    // loop over our list of  exposures
     1169    for (long i = 0; i < psArrayLength(output); i++) {
     1170        psMetadata *md = output->data[i];
     1171
     1172        bool status = true;
     1173        psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id");
     1174        psS64 lap_id = 0;
     1175        if (type_lap) {
     1176            lap_id = psMetadataLookupS64(&status, md, "lap_id");
     1177        }
     1178
     1179        if (!relGroupInsert(config->dbh,
     1180            0,          // group_id (auto increment)
     1181            rel_id,
     1182            group_type,
     1183            lap_id,
     1184            group_name,
     1185            "reg",      // state
     1186            label,
     1187            exp_list_path,
     1188            fault,
     1189            now        // registered
     1190        )) {
     1191            if (!psDBRollback(config->dbh)) {
     1192                psError(PS_ERR_UNKNOWN, false, "database error");
     1193            }
     1194            psError(PS_ERR_UNKNOWN, false, "failed to trying to insert relGroup");
     1195            psFree(output);
     1196            psFree(now);
     1197            return false;
     1198        }
     1199        // Here's our new group_id
     1200        psS32 group_id = psDBLastInsertID(config->dbh);
     1201
     1202        psString query;
     1203        if (type_lap) {
     1204            query = pxDataGet("releasetool_definerelgroup_select_exp_lap.sql");
     1205            if (!query) {
     1206                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1207                psFree(where);
     1208                return false;
     1209            }
     1210            psStringAppend(&query, " AND relExp.rel_id = %d AND lap_id = %" PRId64, rel_id, lap_id);
     1211        } else {
     1212            query = pxDataGet("releasetool_definerelgroup_select_exp_data_group.sql");
     1213            if (!query) {
     1214                psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1215                psFree(where);
     1216                return false;
     1217            }
     1218            psStringAppend(&query, " AND relExp.rel_id = %d", rel_id);
     1219
     1220            psMetadata *where = psMetadataAlloc();
     1221            pxAddLabelSearchArgs (config, where, "-select_data_group", "camRun.data_group", "==");
     1222            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1223            psStringAppend(&query, " AND %s", whereClause);
     1224            psFree(whereClause);
     1225            psFree(where);
     1226        }
     1227
     1228        if (!p_psDBRunQuery(config->dbh, query)) {
     1229            psError(PS_ERR_UNKNOWN, false, "database error");
     1230            psFree(query);
     1231            psFree(output);
     1232            psFree(now);
     1233            if (!psDBRollback(config->dbh)) {
     1234                psError(PS_ERR_UNKNOWN, false, "database error");
     1235            }
     1236            return false;
     1237        }
     1238        psFree(query);
     1239
     1240        psArray *exposures = p_psDBFetchResult(config->dbh);
     1241        if (!exposures) {
     1242            psFree(now);
     1243            psFree(output);
     1244            psError(PS_ERR_UNKNOWN, false, "database error");
     1245            if (!psDBRollback(config->dbh)) {
     1246                psError(PS_ERR_UNKNOWN, false, "database error");
     1247            }
     1248            return false;
     1249        }
     1250        if (!psArrayLength(exposures)) {
     1251            psFree(now);
     1252            psFree(output);
     1253            psFree(exposures);
     1254            psError(PS_ERR_UNKNOWN, false, "no exposures found error");
     1255            if (!psDBRollback(config->dbh)) {
     1256                psError(PS_ERR_UNKNOWN, false, "database error");
     1257            }
     1258            return false;
     1259        }
     1260
     1261        // assign the relExps to this new group
     1262        char *updateQuery = "UPDATE relExp SET group_id = %d WHERE relexp_id = %" PRId64;
     1263        for (int j = 0; j < psArrayLength(exposures); j++) {
     1264            psMetadata *md = exposures->data[j];
     1265
     1266            bool status = true;
     1267            psS32 relexp_id = psMetadataLookupS32(&status, md, "relexp_id");
     1268            if (!p_psDBRunQueryF(config->dbh, updateQuery, group_id, relexp_id)) {
     1269                psError(PS_ERR_UNKNOWN, false, "database error");
     1270                psFree(now);
     1271                psFree(output);
     1272                psFree(exposures);
     1273
     1274                if (!psDBRollback(config->dbh)) {
     1275                    psError(PS_ERR_UNKNOWN, false, "database error");
     1276                }
     1277                return false;
     1278            }
     1279        }
     1280        psFree(exposures);
     1281
     1282        // set state of relGroup to 'new'
     1283        if (!p_psDBRunQueryF(config->dbh, "UPDATE relGroup set state = 'new' WHERE group_id = %d", group_id)) {
     1284            psError(PS_ERR_UNKNOWN, false, "database error");
     1285            psFree(now);
     1286            psFree(output);
     1287            if (!psDBRollback(config->dbh)) {
     1288                psError(PS_ERR_UNKNOWN, false, "database error");
     1289            }
     1290            return false;
     1291        }
     1292    }
     1293    psFree(output);
     1294    psFree(now);
     1295
     1296    if (!psDBCommit(config->dbh)) {
     1297        psError(PS_ERR_UNKNOWN, false, "database error");
     1298        return false;
     1299    }
     1300
     1301    return true;
     1302}
     1303
     1304static bool updaterelgroupMode(pxConfig *config)
     1305{
     1306    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     1307    return false;
     1308}
     1309
     1310static bool pendingrelgroupMode(pxConfig *config)
     1311{
     1312    psError(PS_ERR_UNKNOWN, true, "not yet implemented");
     1313    return false;
     1314#ifdef notdef
     1315    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1316
     1317    psMetadata *where = psMetadataAlloc();
     1318
     1319    pxAddLabelSearchArgs (config, where, "-label", "relGroup.label", "==");
     1320
     1321    PXOPT_COPY_S64(config->args, where, "-relexp_id",   "relExp.relexp_id", "==");
     1322    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1323#ifdef notdef
     1324    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1325    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     1326    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     1327    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     1328    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     1329    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     1330    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "camProcessedExp.fwhm_major", ">=");
     1331    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "camProcessedExp.fwhm_major", "<=");
     1332    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_name", "==");
     1333    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     1334    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     1335    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     1336    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     1337    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     1338    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     1339    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     1340
     1341    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     1342
     1343    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     1344#endif
     1345
     1346    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1347    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1348
     1349    psString query = pxDataGet("releasetool_tocalibexp.sql");
     1350    if (!query) {
     1351        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1352        return false;
     1353    }
     1354
     1355    psString where2 = NULL;
     1356#ifdef notdef
     1357    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1358        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1359        return false;
     1360    }
     1361#endif
     1362
     1363    if (psListLength(where->list)) {
     1364        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1365        psStringAppend(&query, "\nAND %s", whereClause);
     1366        psFree(whereClause);
     1367#ifdef notdef
     1368    } else if (where2) {
     1369        psStringAppend(&query, "\nAND ");
     1370#endif
     1371    } else {
     1372        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1373        psFree(where);
     1374        return false;
     1375    }
     1376
     1377    if (where2) {
     1378        psStringAppend(&query, "\n%s", where2);
     1379        psFree(where2);
     1380    }
     1381
     1382    if (limit) {
     1383        psString limitString = psDBGenerateLimitSQL(limit);
     1384        psStringAppend(&query, " %s", limitString);
     1385        psFree(limitString);
     1386    }
     1387
     1388    if (!p_psDBRunQuery(config->dbh, query)) {
     1389        psError(PS_ERR_UNKNOWN, false, "database error");
     1390        psFree(query);
     1391        return false;
     1392    }
     1393    psFree(query);
     1394
     1395    psArray *output = p_psDBFetchResult(config->dbh);
     1396    if (!output) {
     1397        psError(PS_ERR_UNKNOWN, false, "database error");
     1398        return false;
     1399    }
     1400
     1401    if (!psArrayLength(output)) {
     1402        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1403        psFree(output);
     1404        return true;
     1405    }
     1406
     1407    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1408        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1409        psFree(output);
     1410        return false;
     1411    }
     1412
     1413    psFree(output);
     1414
     1415    return true;
     1416#endif // notdef
     1417}
     1418
     1419static bool listrelgroupMode(pxConfig *config)
     1420{
     1421    return false;
     1422#ifdef notdef
     1423    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1424
     1425    psMetadata *where = psMetadataAlloc();
     1426
     1427    PXOPT_COPY_STR(config->args, where, "-release_name", "ippRelease.release_name", "LIKE");
     1428    pxAddLabelSearchArgs(config, where, "-release_state","ippRelease.state", "==");
     1429    PXOPT_COPY_STR(config->args, where, "-state",       "relExp.state", "==");
     1430    PXOPT_COPY_STR(config->args, where, "-filter",      "rawExp.filter", "LIKE");
     1431    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin","rawExp.dateobs", ">=");
     1432    PXOPT_COPY_TIME(config->args, where, "-dateobs_end", "rawExp.dateobs", "<=");
     1433    PXOPT_COPY_F32(config->args, where, "-fwhm_min",    "skycalResult.fwhm_major", ">=");
     1434    PXOPT_COPY_F32(config->args, where, "-fwhm_max",    "skycalresult.fwhm_major", "<=");
     1435    PXOPT_COPY_STR(config->args, where, "-exp_name",    "rawExp.exp_ame", "==");
     1436    PXOPT_COPY_S64(config->args, where, "-exp_id",      "relExp.exp_id", "==");
     1437    PXOPT_COPY_S64(config->args, where, "-chip_id",     "relExp.chip_id", "==");
     1438    PXOPT_COPY_S64(config->args, where, "-cam_id",      "relExp.cam_id", "==");
     1439    PXOPT_COPY_S64(config->args, where, "-warp_id",     "warpRun.warp_id", "==");
     1440    PXOPT_COPY_STR(config->args, where, "-chip_data_group", "chipRun.data_group", "LIKE");
     1441    PXOPT_COPY_STR(config->args, where, "-cam_data_group",  "camRun.data_group", "LIKE");
     1442    PXOPT_COPY_STR(config->args, where, "-warp_data_group", "warpRun.data_group", "LIKE");
     1443
     1444    PXOPT_COPY_STR(config->args, where, "-surveyName",  "survey.surveyName", "LIKE");
     1445    PXOPT_COPY_S32(config->args, where, "-rel_id",      "relExp.rel_id", "==");
     1446
     1447    PXOPT_LOOKUP_BOOL(priority_order, config->args, "-priority_order", false);
     1448
     1449    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1450    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1451
     1452    psString query = pxDataGet("releasetool_listrelexp.sql");
     1453    if (!query) {
     1454        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1455        return false;
     1456    }
     1457
     1458    psString where2 = NULL;
     1459    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1460        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed");
     1461        return false;
     1462    }
     1463
     1464    if (psListLength(where->list)) {
     1465        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1466        psStringAppend(&query, "\nWHERE %s", whereClause);
     1467        psFree(whereClause);
     1468    } else if (where2) {
     1469        psStringAppend(&query, "\nWHERE ");
     1470    } else {
     1471        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n");
     1472        psFree(where);
     1473        return false;
     1474    }
     1475
     1476    if (where2) {
     1477        psStringAppend(&query, "\n%s", where2);
     1478        psFree(where2);
     1479    }
     1480
     1481    if (priority_order) {
     1482        psStringAppend(&query, "\nAND priority > 0 order by exp_id, priority");
     1483    }
     1484
     1485    if (limit) {
     1486        psString limitString = psDBGenerateLimitSQL(limit);
     1487        psStringAppend(&query, " %s", limitString);
     1488        psFree(limitString);
     1489    }
     1490
     1491    if (!p_psDBRunQuery(config->dbh, query)) {
     1492        psError(PS_ERR_UNKNOWN, false, "database error");
     1493        psFree(query);
     1494        return false;
     1495    }
     1496    psFree(query);
     1497
     1498    psArray *output = p_psDBFetchResult(config->dbh);
     1499    if (!output) {
     1500        psError(PS_ERR_UNKNOWN, false, "database error");
     1501        return false;
     1502    }
     1503
     1504    if (!psArrayLength(output)) {
     1505        psTrace("releasetool", PS_LOG_INFO, "no rows found");
     1506        psFree(output);
     1507        return true;
     1508    }
     1509
     1510    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) {
     1511        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1512        psFree(output);
     1513        return false;
     1514    }
     1515
     1516    psFree(output);
     1517
     1518    return true;
     1519#endif //notdef
     1520}
     1521

  • trunk/ippTools/src/releasetool.h

    r35152 r35213  
    3232    RELEASETOOL_MODE_DEFINERELEXP,
    3333    RELEASETOOL_MODE_UPDATERELEXP,
     34    RELEASETOOL_MODE_TOCALIBEXP,
    3435    RELEASETOOL_MODE_LISTRELEXP,
    3536    RELEASETOOL_MODE_DEFINERELSTACK,
    3637    RELEASETOOL_MODE_UPDATERELSTACK,
     38    RELEASETOOL_MODE_TOCALIBSTACK,
    3739    RELEASETOOL_MODE_LISTRELSTACK,
     40    RELEASETOOL_MODE_DEFINERELGROUP,
     41    RELEASETOOL_MODE_PENDINGRELGROUP,
     42    RELEASETOOL_MODE_UPDATERELGROUP,
     43    RELEASETOOL_MODE_LISTRELGROUP,
    3844} releasetoolMode;
    3945

  • trunk/ippTools/src/releasetoolConfig.c

    r35196 r35213  
    6060    psMetadata *definereleaseArgs = psMetadataAlloc();
    6161    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_surveyID", 0,      "define survey ID (required)", 0);
    62     psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_releaseName", 0,   "define release name (required)", NULL);
     62    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_release_name", 0,   "define release name (required)", NULL);
    6363    psMetadataAddS32(definereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,   "define dataRelease", -1);
    6464    psMetadataAddStr(definereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0, "define release state", NULL);
    … …  
    6868    psMetadata *updatereleaseArgs = psMetadataAlloc();
    6969
    70     // releaseName and/or rel_id is required. This is handled in updatereleaseMode
    71     psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-releaseName", 0,        "select by release name", NULL);
     70    // release_name and/or rel_id is required. This is handled in updatereleaseMode
     71    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-release_name", 0,        "select by release name", NULL);
    7272    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-rel_id", 0,             "select by release ID", 0);
    7373
    74     // Only support changing state and priority for now
    7574    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_release_state", 0,  "define new release state", NULL);
    7675    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_priority", 0,       "define new release priority", 0);
    7776
     77    // Only support changing state and priority for now
    7878//    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_surveyID", 0,       "define surveyID (required)", 0);
    79 //    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_releaseName", 0,    "define release name (required)", NULL);
     79//    psMetadataAddStr(updatereleaseArgs, PS_LIST_TAIL, "-set_release_name", 0,    "define release name (required)", NULL);
    8080//    psMetadataAddS32(updatereleaseArgs, PS_LIST_TAIL, "-set_dataRelease", 0,    "define dataRelease", -1);
    8181
    … …  
    8484    psMetadata *listreleaseArgs = psMetadataAlloc();
    8585    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-surveyName", 0,  "select by survey name (LIKE comparision)", NULL);
    86     psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by release name (LIKE comparision)", NULL);
     86    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
    8787    psMetadataAddStr(listreleaseArgs,  PS_LIST_TAIL, "-release_state",  0, "select by release state", NULL);
    8888    psMetadataAddS32(listreleaseArgs, PS_LIST_TAIL,  "-rel_id", 0,      "select by release ID", 0);
    … …  
    9595
    9696        // set the target release
    97     psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "define release name", NULL);
     97    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
    9898    psMetadataAddS32(definerelexpArgs, PS_LIST_TAIL,  "-rel_id", 0,      "define release ID", 0);
    9999
    … …  
    112112    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define zero point", NAN);
    113113    psMetadataAddF32(definerelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define zero point stdev", NAN);
    114     psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state (required)", NULL);
     114    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state", NULL);
    115115    psMetadataAddS16(definerelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
    116116
    117117    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
    118     psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-simple",  0, "use the simpel output format", false);
    119 
    120 
     118    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
    121119
    122120    // -updaterelexp
    123121    psMetadata *updaterelexpArgs = psMetadataAlloc();
    124     psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by release name (LIKE comparision)", NULL);
     122    psMetadataAddS64(updaterelexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     123    psMetadataAddS64(updaterelexpArgs, PS_LIST_TAIL,  "-exp_id", 0,      "select by exposure ID", 0);
     124    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-exp_name", 0,    "select by exposure name", NULL);
     125    psMetadataAddS32(updaterelexpArgs, PS_LIST_TAIL,  "-rel_id", 0,      "select by release ID", 0);
     126    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
     127
     128    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-set_state", 0,      "define new state)", NULL);
     129    psMetadataAddU32(updaterelexpArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define new flags", 0);
     130    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_obs", 0,    "define new zero point", NAN);
     131    psMetadataAddF32(updaterelexpArgs,  PS_LIST_TAIL, "-set_zpt_stdev", 0,  "define new zero point stdev", NAN);
     132    psMetadataAddStr(updaterelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define path_base", NULL);
     133    psMetadataAddS16(updaterelexpArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define new fault", 0);
     134    psMetadataAddBool(updaterelexpArgs, PS_LIST_TAIL, "-clearfault",  0,   "set fault to zero", false);
     135
     136    // -tocalibexp
     137    psMetadata *tocalibexpArgs = psMetadataAlloc();
     138    psMetadataAddS64(tocalibexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     139    psMetadataAddStr(tocalibexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
     140
     141    psMetadataAddU64(tocalibexpArgs,  PS_LIST_TAIL, "-limit",       0, "limit result set to N items", 0);
     142    psMetadataAddBool(tocalibexpArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false);
    125143
    126144    // -listrelexp
    127145    psMetadata *listrelexpArgs = psMetadataAlloc();
    128     psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-releaseName", 0,  "select by release name (LIKE comparision)", NULL);
     146    psMetadataAddS64(listrelexpArgs, PS_LIST_TAIL,  "-relexp_id", 0,   "select by released exposure ID", 0);
     147    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-release_name", 0, "select by release name (LIKE comparision)", NULL);
    129148    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-release_state", PS_META_DUPLICATE_OK, "select by release state", NULL);
    130149    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-state", 0,        "select by released exposure state", NULL);
    … …  
    162181
    163182        // set the target release
    164     psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-releaseName", 0, "define release name", NULL);
     183    psMetadataAddStr(definerelstackArgs,  PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
    165184    psMetadataAddS32(definerelstackArgs, PS_LIST_TAIL,  "-rel_id", 0,      "define release ID", 0);
    166185
    … …  
    184203
    185204    psMetadataAddBool(definerelstackArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
    186     psMetadataAddBool(definerelstackArgs, PS_LIST_TAIL, "-simple",  0, "use the simpel output format", false);
     205    psMetadataAddBool(definerelstackArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     206
     207    // -definerelgroup
     208    psMetadata *definerelgroupArgs = psMetadataAlloc();
     209
     210        // set the target release
     211    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-release_name", 0, "define release name", NULL);
     212    psMetadataAddS32(definerelgroupArgs, PS_LIST_TAIL, "-rel_id", 0,      "define release ID", 0);
     213
     214        // select the members of the group
     215    psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-select_seq_id", 0,  "select by LAP sequence ID", 0);
     216    psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-select_lap_id", 0,  "select by LAP ID", 0);
     217    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-select_data_group", PS_META_DUPLICATE_OK,  "select by camRun.data_group", NULL);
     218    // do we want this?
     219    // psMetadataAddS64(definerelgroupArgs, PS_LIST_TAIL, "-lap_id", 0,  "select by LAP ID", NULL);
     220
     221        // parameters of the relGroup
     222    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_group_type", 0,  "define group_type (required)", NULL);
     223    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_group_name", 0,  "define group_name (required)", NULL);
     224    psMetadataAddStr(definerelgroupArgs, PS_LIST_TAIL, "-set_label", 0, "define relgroup label (required)", NULL);
     225    psMetadataAddStr(definerelgroupArgs,  PS_LIST_TAIL, "-set_state", 0,      "define state", NULL);
     226    psMetadataAddStr(definerelgroupArgs,  PS_LIST_TAIL, "-set_exp_list_path", 0, "define path in exposure list", NULL);
     227    psMetadataAddS16(definerelgroupArgs,  PS_LIST_TAIL, "-set_fault", 0,      "define fault", 0);
     228
     229        // options
     230    psMetadataAddBool(definerelgroupArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
     231    psMetadataAddBool(definerelgroupArgs, PS_LIST_TAIL, "-simple",  0, "use the simple output format", false);
     232
     233    // -pendingrelgroup
     234    psMetadata *pendingrelgroupArgs = psMetadataAlloc();
     235
     236    psMetadataAddS64(pendingrelgroupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,  "search by relGroup.label", 0);
     237    psMetadataAddS32(pendingrelgroupArgs, PS_LIST_TAIL,  "-rel_id", 0,      "select by release ID", 0);
     238    psMetadataAddS32(pendingrelgroupArgs, PS_LIST_TAIL,  "-group_id", 0,    "select by relGroup ID", 0);
     239    psMetadataAddStr(pendingrelgroupArgs, PS_LIST_TAIL,  "-release_name", 0, "select by release name", 0);
     240   
     241    // -updaterelgroup
     242    psMetadata *updaterelgroupArgs = psMetadataAlloc();
     243
     244        // set the target release
     245    psMetadataAddS32(updaterelgroupArgs,  PS_LIST_TAIL, "-group_id", 0,   "select by group ID (required)", 0);
     246
     247        // parameters of the relGroup
     248    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_state", 0,  "define state", NULL);
     249    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_exp_list_path", 0, "define path in exposure list", NULL);
     250    psMetadataAddStr(updaterelgroupArgs,  PS_LIST_TAIL, "-set_label", 0,  "define relgroup label", NULL);
     251    psMetadataAddS16(updaterelgroupArgs,  PS_LIST_TAIL, "-set_fault", 0,  "define fault", 0);
     252    psMetadataAddBool(updaterelgroupArgs, PS_LIST_TAIL, "-clearfault",  0, "set fault to zero", false);
     253
     254    psMetadata *listrelgroupArgs = psMetadataAlloc();
     255    psMetadataAddS32(listrelgroupArgs,  PS_LIST_TAIL, "-group_id", 0,   "select by group ID", 0);
     256    psMetadataAddS32(listrelgroupArgs,  PS_LIST_TAIL, "-rel_id", 0,   "select by release ID", 0);
     257    psMetadataAddStr(listrelgroupArgs, PS_LIST_TAIL,  "-release_name", 0, "select by release name", 0);
    187258
    188259    // ******************************************************************
    … …  
    200271    PXOPT_ADD_MODE("-definerelexp",     "define a released exposure",   RELEASETOOL_MODE_DEFINERELEXP,  definerelexpArgs);
    201272    PXOPT_ADD_MODE("-updaterelexp",     "update a released exposure",   RELEASETOOL_MODE_UPDATERELEXP,  updaterelexpArgs);
     273    PXOPT_ADD_MODE("-tocalibexp",       "list relExps pending calibration",  RELEASETOOL_MODE_TOCALIBEXP,  tocalibexpArgs);
    202274    PXOPT_ADD_MODE("-listrelexp",       "list released exposures",      RELEASETOOL_MODE_LISTRELEXP,    listrelexpArgs);
    203275
    204276    PXOPT_ADD_MODE("-definerelstack",     "define a released stack",    RELEASETOOL_MODE_DEFINERELSTACK,  definerelstackArgs);
     277
     278    PXOPT_ADD_MODE("-definerelgroup",     "define a group of exposures", RELEASETOOL_MODE_DEFINERELGROUP,  definerelgroupArgs);
     279    PXOPT_ADD_MODE("-pendingrelgroup",     "list relGroups pending processing",    RELEASETOOL_MODE_PENDINGRELGROUP,  pendingrelgroupArgs);
     280    PXOPT_ADD_MODE("-updaterelgroup",     "update a relGroup",          RELEASETOOL_MODE_UPDATERELGROUP,  updaterelgroupArgs);
     281    PXOPT_ADD_MODE("-listrelgroup",     "define a group of exposures", RELEASETOOL_MODE_LISTRELGROUP,  listrelgroupArgs);
     282
    205283
    206284
Note: See TracChangeset for help on using the changeset viewer.