Changeset 34933

Show
Ignore:
Timestamp:
01/15/13 17:12:54 (5 years ago)
Author:
bills
Message:

implement releasetool -definerelexp
start implementation of releasetool -listrelexp

Location:
trunk/ippTools
Files:
1 added
4 modified

Legend:

Unmodified
Added
Removed
  • trunk/ippTools/share/Makefile.am

    r34909 r34933  
    464464        releasetool_listsurvey.sql \ 
    465465        releasetool_listrelease.sql \ 
    466         releasetool_listrelexp.sql 
     466        releasetool_listrelexp.sql \ 
     467        releasetool_definerelexp.sql 
    467468 
  • trunk/ippTools/share/releasetool_listrelexp.sql

    r34909 r34933  
    1 SELECT *  
     1SELECT 
     2    relexp_id, 
     3    releaseName, 
     4    relExp.state, 
     5    rel_id, 
     6    survey.surveyName, 
     7    exp_name, 
     8    relExp.flags, 
     9    relExp.zpt_obs, 
     10    relExp.zpt_stdev, 
     11    relExp.path_base, 
     12    relExp.registered, 
     13    relExp.time_stamp, 
     14    exp_id, 
     15    chip_id, 
     16    chipRun.state as chip_state, 
     17    cam_id, 
     18    camRun.state as cam_state, 
     19    camProcessedExp.path_base as cam_path_base, 
     20    warp_id, 
     21    warpRun.state as warp_state, 
     22    rawExp.filter, 
     23    rawExp.dateobs, 
     24    TRUNCATE(DEGREES(rawExp.ra), 4) AS radeg, 
     25    TRUNCATE(DEGREES(rawExp.decl), 4) AS decdeg, 
     26    rawExp.object, 
     27    rawExp.comment 
    228FROM relExp  
    3 JOIN release USING(rel_id)  
    4 JOIN survey using(surveyID) 
     29JOIN ippRelease USING(rel_id)  
     30JOIN survey USING(surveyID) 
     31JOIN rawExp using(exp_id) 
     32JOIN chipRun using(chip_id, exp_id) 
     33JOIN camRun using(cam_id, chip_id) 
     34JOIN camProcessedExp using(cam_id) 
     35JOIN fakeRun using(cam_id) 
     36JOIN warpRun using(fake_id) 
  • trunk/ippTools/src/releasetool.c

    r34910 r34933  
    239239    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "=="); 
    240240 
    241     psString query = pxDataGet("releasetool_listrelease.sql"); 
     241        psString query = pxDataGet("releasetool_listrelease.sql"); 
     242        if (!query) { 
     243            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement"); 
     244            return false; 
     245        } 
     246 
     247        if (psListLength(where->list)) { 
     248            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL); 
     249            psStringAppend(&query, " WHERE %s", whereClause); 
     250            psFree(whereClause); 
     251        } else { 
     252            // The list of releases is short there is no need to require parameters 
     253    #ifdef notyet 
     254            psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n"); 
     255            psFree(where); 
     256            return false; 
     257    #endif 
     258        } 
     259 
     260        if (limit) { 
     261            psString limitString = psDBGenerateLimitSQL(limit); 
     262            psStringAppend(&query, " %s", limitString); 
     263            psFree(limitString); 
     264        } 
     265 
     266        if (!p_psDBRunQuery(config->dbh, query)) { 
     267            psError(PS_ERR_UNKNOWN, false, "database error"); 
     268            psFree(query); 
     269            return false; 
     270        } 
     271        psFree(query); 
     272 
     273        psArray *output = p_psDBFetchResult(config->dbh); 
     274        if (!output) { 
     275            psError(PS_ERR_UNKNOWN, false, "database error"); 
     276            return false; 
     277        } 
     278 
     279        if (!psArrayLength(output)) { 
     280            psTrace("releasetool", PS_LOG_INFO, "no rows found"); 
     281            psFree(output); 
     282            return true; 
     283        } 
     284 
     285        if (!ippdbPrintMetadatas(stdout, output, "ippRelease", !simple)) { 
     286            psError(PS_ERR_UNKNOWN, false, "failed to print array"); 
     287            psFree(output); 
     288            return false; 
     289        } 
     290 
     291        psFree(output); 
     292 
     293        return true; 
     294    } 
     295 
     296    static bool definerelexpMode(pxConfig *config) 
     297    { 
     298        PS_ASSERT_PTR_NON_NULL(config, NULL); 
     299 
     300        psMetadata *where = psMetadataAlloc(); 
     301 
     302        PXOPT_COPY_STR(config->args, where, "-label",      "camRun.label", "=="); 
     303        PXOPT_COPY_STR(config->args, where, "-data_group", "camRun.data_group", "=="); 
     304        PXOPT_COPY_S64(config->args, where, "-cam_id",     "camRun.cam_id", "=="); 
     305 
     306        // Insure that at least one of the camRun selectors is supplied 
     307        if (!psListLength(where->list)) { 
     308            psFree(where); 
     309            psError(PXTOOLS_ERR_CONFIG, false, "at least one of -label, -data_group, or -cam_id is required"); 
     310            return false; 
     311        } 
     312 
     313        PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "=="); 
     314        PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "=="); 
     315 
     316        // insure that at least one of these is supplied to select the release 
     317        PXOPT_LOOKUP_S64(rel_id, config->args,      "-rel_id", false, false); 
     318        PXOPT_LOOKUP_STR(releaseName, config->args, "-releaseName", false, false); 
     319        if (!rel_id && !releaseName) { 
     320            psError(PXTOOLS_ERR_CONFIG, true, "either -rel_id or -releaseName is required"); 
     321            return false; 
     322        } 
     323 
     324        // limit query to the target release. (Note: this will select nothing of releaseName and rel_id don't match) 
     325        // note: we add these after above to insure that search args are supplied 
     326        PXOPT_COPY_STR(config->args, where, "-releaseName", "ippRelease.releaseName", "=="); 
     327        PXOPT_COPY_S32(config->args, where, "-rel_id", "ippRelease.rel_id", "=="); 
     328 
     329 
     330        PXOPT_LOOKUP_STR(state, config->args,     "-set_state", true, false); 
     331        PXOPT_LOOKUP_U32(flags, config->args,     "-set_flags", false, false); 
     332        PXOPT_LOOKUP_STR(path_base, config->args, "-set_path_base", false, false); 
     333 
     334        PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false); 
     335        PXOPT_LOOKUP_BOOL(simple, config->args,  "-simple", false); 
     336 
     337        // find the parameters of all the exposures that we want to add to the release 
     338        psString query = pxDataGet("releasetool_definerelexp.sql"); 
     339        if (!query) { 
     340            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement"); 
     341            psFree(where); 
     342            return false; 
     343        } 
     344 
     345        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL); 
     346        psStringAppend(&query, " AND %s", whereClause); 
     347        psFree(whereClause); 
     348 
     349        psFree(where); 
     350 
     351        if (!p_psDBRunQuery(config->dbh, query)) { 
     352            psError(PS_ERR_UNKNOWN, false, "database error"); 
     353            psFree(query); 
     354            return false; 
     355        } 
     356        psFree(query); 
     357 
     358        psArray *output = p_psDBFetchResult(config->dbh); 
     359        if (!output) { 
     360            psError(PS_ERR_UNKNOWN, false, "database error"); 
     361            return false; 
     362        } 
     363        if (!psArrayLength(output)) { 
     364            psTrace("releasetool", PS_LOG_INFO, "no rows found"); 
     365            psFree(output); 
     366            return true; 
     367        } 
     368 
     369        if (pretend) { 
     370            // negative simple so the default is true 
     371            if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) { 
     372                psError(PS_ERR_UNKNOWN, false, "failed to print array"); 
     373                psFree(output); 
     374                return false; 
     375            } 
     376            psFree(output); 
     377            return true; 
     378        } 
     379 
     380        if (!psDBTransaction(config->dbh)) { 
     381            psError(PS_ERR_UNKNOWN, false, "database error"); 
     382            psFree(output); 
     383            return false; 
     384        } 
     385 
     386        psTime *now = psTimeGetNow(PS_TIME_TAI); 
     387        // loop over our list of  exposures 
     388        for (long i = 0; i < psArrayLength(output); i++) { 
     389            psMetadata *md = output->data[i]; 
     390 
     391            bool status = true; 
     392            psS32 rel_id = psMetadataLookupS32(&status, md, "rel_id"); 
     393            psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); 
     394            psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); 
     395            psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id"); 
     396            psF32 zpt_obs = psMetadataLookupF32(&status, md, "zpt_obs"); 
     397            psF32 zpt_stdev = psMetadataLookupF32(&status, md, "zpt_stdev"); 
     398 
     399            if (!relExpInsert(config->dbh, 
     400                0,          // relexp_id (auto increment) 
     401                rel_id, 
     402                exp_id, 
     403                chip_id, 
     404                cam_id, 
     405                state, 
     406                flags, 
     407                zpt_obs, 
     408                zpt_stdev, 
     409                path_base, 
     410                now,       // registered 
     411                now        // time_stamp 
     412            )) { 
     413                if (!psDBRollback(config->dbh)) { 
     414                    psError(PS_ERR_UNKNOWN, false, "database error"); 
     415                } 
     416                psError(PS_ERR_UNKNOWN, false, 
     417                        "failed to trying to insert relExp for cam_id %" PRId64, cam_id); 
     418                psFree(output); 
     419                psFree(now); 
     420                return false; 
     421            } 
     422        } 
     423        psFree(output); 
     424 
     425        if (!psDBCommit(config->dbh)) { 
     426            psError(PS_ERR_UNKNOWN, false, "database error"); 
     427            return false; 
     428        } 
     429 
     430        return true; 
     431    } 
     432 
     433    static bool updaterelexpMode(pxConfig *config) 
     434    { 
     435        psError(PS_ERR_UNKNOWN, true, "not yet implemented"); 
     436        return false; 
     437    } 
     438 
     439static bool listrelexpMode(pxConfig *config) 
     440{ 
     441    PS_ASSERT_PTR_NON_NULL(config, NULL); 
     442 
     443    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false); 
     444    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); 
     445    psMetadata *where = psMetadataAlloc(); 
     446 
     447//    PXOPT_COPY_STR(config->args, where, "-surveyName",  "surveyName", "LIKE"); 
     448    PXOPT_COPY_STR(config->args, where, "-releaseName", "releaseName", "LIKE"); 
     449//    PXOPT_COPY_STR(config->args, where, "-state", "state", "=="); 
     450//    PXOPT_COPY_S32(config->args, where, "-rel_id",  "rel_id", "=="); 
     451//    PXOPT_COPY_S64(config->args, where, "-exp_id",  "exp_id", "=="); 
     452 
     453    psString query = pxDataGet("releasetool_listrelexp.sql"); 
    242454    if (!query) { 
    243455        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement"); 
     456        return false; 
     457    } 
     458 
     459    psString where2 = NULL; 
     460    if (!pxspaceAddWhere(config, &where2, "rawExp")) { 
     461        psError(psErrorCodeLast(), false, "pxspaceAddWhere failed"); 
    244462        return false; 
    245463    } 
     
    250468        psFree(whereClause); 
    251469    } else { 
    252         // The list of releases is short there is no need to require parameters 
    253 #ifdef notdef 
    254470        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required\n"); 
    255471        psFree(where); 
    256472        return false; 
    257 #endif 
     473    } 
     474 
     475    if (where2) { 
     476        psStringAppend(&query, "\n%s", where2); 
     477        psFree(where2); 
    258478    } 
    259479 
     
    283503    } 
    284504 
    285     if (!ippdbPrintMetadatas(stdout, output, "ippRelease", !simple)) { 
     505    if (!ippdbPrintMetadatas(stdout, output, "relExp", !simple)) { 
    286506        psError(PS_ERR_UNKNOWN, false, "failed to print array"); 
    287507        psFree(output); 
     
    292512 
    293513    return true; 
    294 } 
    295  
    296 static bool definerelexpMode(pxConfig *config) 
    297 { 
    298     psError(PS_ERR_UNKNOWN, true, "not yet implemented"); 
    299     return false; 
    300 } 
    301  
    302 static bool updaterelexpMode(pxConfig *config) 
    303 { 
    304     psError(PS_ERR_UNKNOWN, true, "not yet implemented"); 
    305     return false; 
    306 } 
    307  
    308 static bool listrelexpMode(pxConfig *config) 
    309 { 
    310     psError(PS_ERR_UNKNOWN, true, "not yet implemented"); 
    311     return false; 
    312514} 
    313515 
  • trunk/ippTools/src/releasetoolConfig.c

    r34910 r34933  
    22 * releasetoolConfig.c 
    33 * 
    4  * Copyright (C) 2012 IfA University of Hawaii 
     4 * Copyright (C) 2013 IfA University of Hawaii 
    55 * 
    66 * This program is free software; you can redistribute it and/or modify it 
     
    8989    psMetadataAddBool(listreleaseArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false); 
    9090 
     91    // -definerelexp 
    9192    psMetadata *definerelexpArgs = psMetadataAlloc(); 
    92     psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by survey name (LIKE comparision)", NULL); 
     93 
     94        // to set the target release 
     95    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "define release name", NULL); 
     96    psMetadataAddS32(definerelexpArgs, PS_LIST_TAIL,  "-rel_id", 0,      "define release ID", 0); 
     97 
     98        // to select the processing 
     99    psMetadataAddS64(definerelexpArgs, PS_LIST_TAIL,  "-cam_id", 0,      "select by cam ID", 0); 
     100    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-label",  0,      "select by camRun.label", NULL); 
     101    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-data_group", 0,  "select by camRun.data_group", NULL); 
     102 
     103        // to select a specific exposure from the "processing" 
     104    psMetadataAddS64(definerelexpArgs, PS_LIST_TAIL,  "-exp_id", 0,      "select by exposure ID", 0); 
     105    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-exp_name", 0,    "select by exposure name", NULL); 
     106 
     107        // parameters of the relExp 
     108    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_state", 0,      "define state (required)", NULL); 
     109    psMetadataAddStr(definerelexpArgs,  PS_LIST_TAIL, "-set_path_base", 0,  "define state", NULL); 
     110    psMetadataAddU32(definerelexpArgs,  PS_LIST_TAIL, "-set_flags", 0,      "define flags", 0); 
     111 
     112    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-pretend",  0, "do not actual modify the database", false); 
     113    psMetadataAddBool(definerelexpArgs, PS_LIST_TAIL, "-simple",  0, "use the simpel output format", false); 
     114 
     115 
    93116 
    94117    psMetadata *updaterelexpArgs = psMetadataAlloc(); 
     
    97120    psMetadata *listrelexpArgs = psMetadataAlloc(); 
    98121    psMetadataAddStr(listrelexpArgs,  PS_LIST_TAIL, "-releaseName", 0, "select by survey name (LIKE comparision)", NULL); 
     122    pxspaceAddArguments(listrelexpArgs); 
    99123 
     124    psMetadataAddU64(listrelexpArgs,  PS_LIST_TAIL, "-limit",       0, "limit result set to N items", 0); 
     125    psMetadataAddBool(listrelexpArgs, PS_LIST_TAIL, "-simple",      0, "use the simple output format", false); 
    100126 
    101127    psMetadata *argSets = psMetadataAlloc();