IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 27149


Ignore:
Timestamp:
Mar 2, 2010, 6:29:45 PM (16 years ago)
Author:
watersc1
Message:

Code and regtool rewrites to enable the lossy compression of old data that aren't scientifically useful.

Location:
trunk
Files:
6 added
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/dbconfig/changes.txt

    r27042 r27149  
    15271527ALTER TABLE publishClient ADD COLUMN magicked TINYINT DEFAULT 1 AFTER stage;
    15281528
     1529ALTER TABLE rawExp ADD COLUMN state VARCHAR(64) AFTER workdir, ADD KEY(state);
     1530UPDATE rawExp SET state = 'full';
     1531
     1532ALTER TABLE rawImfile ADD COLUMN data_state VARCHAR(64) AFTER uri, ADD KEY(data_state);
     1533UPDATE rawImfile SET data_state = 'full';
     1534
     1535-- Not updating schema_version to not break distribution bundles.
     1536-- UPDATE dbversion set schema_version = '1.1.65', updated= CURRENT_TIMESTAMP();
     1537
     1538-- Version 1.1.66
     1539

  • trunk/dbconfig/raw.md

    r25420 r27149  
    1010    filelevel   STR         64
    1111    workdir     STR         255     # destination for output files
     12    state       STR         64      # Key
    1213    reduction   STR         64      # Reduction class
    1314    dvodb       STR         255
    … …  
    7778    class_id    STR         64      # Primary Key
    7879    uri         STR         255
     80    data_state  STR         64      # Key
    7981    exp_type    STR         64
    8082# This field is used to set the per exp filelevel. Thus the values for all of

  • trunk/ippScripts/Build.PL

    r26901 r27149  
    101101        scripts/whichimage
    102102        scripts/automate_stacks.pl
     103        scripts/lossy_compress_imfile.pl
    103104        scripts/ipp_apply_burntool.pl
    104105        scripts/make_burntool_pcontrol.pl

  • trunk/ippScripts/MANIFEST

    r26901 r27149  
    3737scripts/ds9_cmf_regions.pl
    3838scripts/automate_stacks.pl
     39scripts/lossy_compress_imfile.pl
    3940scripts/ipp_apply_burntool.pl
    4041scripts/make_burntool_pcontrol.pl

  • trunk/ippScripts/scripts/automate_stacks.pl

    r26990 r27149  
    426426        my ($trash,$start,$end);
    427427        ($trash,$trash,$start,$end) = (split /\s+/,$row);
    428         $metadata_out{"btBegin${N}"} = $start;
    429         $metadata_out{"btEnd${N}"} = $end;
    430         $metadata_out{"btCounter${N}"} = 0;
    431         $N++;
    432         print STDERR "define_burntool: $row\n";
     428       
     429        for (my $class_counter = 0; $class_counter < 60; $class_counter++) {
     430            $metadata_out{"bt${N}Begin"} = $start;
     431            $metadata_out{"bt${N}End"} = $end;
     432            $metadata_out{"bt${N}Class"} = $class_counter;
     433            $metadata_out{"bt${N}Status"} = 'NEW';
     434            $N++;
     435        }
     436        print STDERR "define_burntool: $row\n";
    433437    }
    434438    $metadata_out{btN} = $N - 1;
    … …  
    793797    print STDOUT "autoStack METADATA\n";
    794798    print STDOUT "   date                  STR          $date\n";
    795     foreach my $k (keys %metadata_out) {
     799    foreach my $k (sort(keys %metadata_out)) {
    796800        print STDOUT "   $k                STR          $metadata_out{$k}\n";
    797801    }

  • trunk/ippTasks/Makefile.am

    r26670 r27149  
    3131        dqstats.pro \
    3232        science.cleanup.pro \
    33         nightly_stacks.pro
     33        nightly_stacks.pro \
     34        lossy_compress.pro
    3435
    3536other_files = \

  • trunk/ippTools/share/Makefile.am

    r27017 r27149  
    256256     regtool_revertprocessedimfile.sql \
    257257     regtool_updateprocessedimfile.sql \
     258     regtool_pendingcompressimfile.sql \
     259     regtool_finishcompressexp.sql \
     260     regtool_updatebyquery.sql \
     261     regtool_updatebyqueryimfile.sql \
    258262     stacktool_definebyquery_insert.sql \
    259263     stacktool_definebyquery_insert_random_part1.sql \

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r27116 r27149  
    117117    filelevel VARCHAR(64),
    118118    workdir VARCHAR(255),
     119    state VARCHAR(64),
    119120    reduction VARCHAR(64),
    120121    dvodb VARCHAR(255),
    … …  
    189190    class_id VARCHAR(64),
    190191    uri VARCHAR(255),
     192    data_state VARCHAR(64),
    191193    exp_type VARCHAR(64),
    192194    filelevel VARCHAR(64),

  • trunk/ippTools/share/regtool_updateprocessedimfile.sql

    r25425 r27149  
    11UPDATE rawImfile
    2   SET burntool_state = %d
     2    SET %s
    33  WHERE
    44    rawImfile.exp_id = %lld

  • trunk/ippTools/src/pxregister.c

    r21402 r27149  
    5858    return true;
    5959}
     60
     61bool pxrawExpSetState(pxConfig *config, psS64 exp_id, const char *state)
     62{
     63    if (!exp_id) {
     64        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     65        return false;
     66    }
     67    PS_ASSERT_PTR_NON_NULL(state, false);
     68
     69    // check that state is a valid string value
     70    if (!(
     71            (strncmp(state, "full", 5) == 0)
     72            || (strncmp(state, "new", 4) == 0)
     73            || (strncmp(state, "goto_compressed", 14) == 0)
     74            || (strncmp(state, "compressed", 11) == 0)
     75            || (strncmp(state, "goto_lossy", 11) == 0)
     76            || (strncmp(state, "lossy", 6) == 0)
     77        )
     78    ) {
     79        psError(PS_ERR_UNKNOWN, false,
     80                "invalid rawExp state: %s", state);
     81        return false;
     82    }
     83
     84    char *query = "UPDATE rawExp SET state = '%s' WHERE exp_id = %"PRId64;
     85    if (!p_psDBRunQueryF(config->dbh, query, state, exp_id)) {
     86        psError(PS_ERR_UNKNOWN, false,
     87                "failed to change state for exp_id %"PRId64, exp_id);
     88        return false;
     89    }
     90
     91    return true;
     92}
     93bool pxrawImfileSetState(pxConfig *config, psS64 exp_id, const char *class_id, const char *state)
     94{
     95    if (!exp_id) {
     96        psError(PS_ERR_UNKNOWN, true, "0 is not a valid exp_id");
     97        return false;
     98    }
     99    PS_ASSERT_PTR_NON_NULL(state, false);
     100
     101    // check that state is a valid string value
     102    if (!(
     103            (strncmp(state, "full", 5) == 0)
     104            || (strncmp(state, "new", 4) == 0)
     105            || (strncmp(state, "goto_compressed", 14) == 0)
     106            || (strncmp(state, "compressed", 11) == 0)
     107            || (strncmp(state, "goto_lossy", 11) == 0)
     108            || (strncmp(state, "lossy", 6) == 0)
     109        )
     110    ) {
     111        psError(PS_ERR_UNKNOWN, false,
     112                "invalid rawImfile data_state: %s", state);
     113        return false;
     114    }
     115
     116    char *query = "UPDATE rawImfile SET data_state = '%s' WHERE class_id = %s AND exp_id = %"PRId64;
     117    if (!p_psDBRunQueryF(config->dbh, query, state, class_id, exp_id)) {
     118        psError(PS_ERR_UNKNOWN, false,
     119                "failed to change state for exp_id %"PRId64, exp_id);
     120        return false;
     121    }
     122
     123    return true;
     124}

  • trunk/ippTools/src/pxregister.h

    r18336 r27149  
    2626
    2727bool pxnewExpSetState(pxConfig *config, psS64 exp_id, const char *state);
     28bool pxrawExpSetState(pxConfig *config, psS64 exp_id, const char *state);
     29bool pxrawImfileSetState(pxConfig *config, psS64 exp_id, const char *class_id, const char *state);
    2830
    2931#endif // PXREGISTER_H

  • trunk/ippTools/src/regtool.c

    r27132 r27149  
    3737static bool revertprocessedimfileMode(pxConfig *config);
    3838static bool updateprocessedimfileMode(pxConfig *config);
     39static bool pendingcompressimfileMode(pxConfig *config);
    3940// exp
    4041static bool pendingexpMode(pxConfig *config);
    … …  
    4445static bool updateprocessedexpMode(pxConfig *config);
    4546static bool cleardupexpMode(pxConfig *config);
     47static bool finishcompressexpMode(pxConfig *config);
     48
     49static bool updatebyqueryMode(pxConfig *config);
     50
    4651static bool exportrunMode(pxConfig *config);
    4752static bool importrunMode(pxConfig *config);
    … …  
    7782        MODECASE(REGTOOL_MODE_REVERTPROCESSEDEXP,    revertprocessedexpMode);
    7883        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
     84        MODECASE(REGTOOL_MODE_UPDATEBYQUERY,         updatebyqueryMode);
     85        MODECASE(REGTOOL_MODE_PENDINGCOMPRESSIMFILE, pendingcompressimfileMode);
     86        MODECASE(REGTOOL_MODE_FINISHCOMPRESSEXP,     finishcompressexpMode);
    7987        MODECASE(REGTOOL_MODE_CLEARDUPEXP,           cleardupexpMode);
    8088        MODECASE(REGTOOL_MODE_EXPORTRUN,             exportrunMode);
    … …  
    189197    PXOPT_LOOKUP_STR(obs_mode, config->args, "-obs_mode", false, false);
    190198    PXOPT_LOOKUP_STR(obs_group, config->args, "-obs_group", false, false);
     199    PXOPT_LOOKUP_STR(data_state, config->args, "-data_state", false, false);
    191200
    192201    PXOPT_LOOKUP_F32(airmass, config->args, "-airmass", false, false);
    … …  
    255264        class_id,
    256265        uri,
     266        data_state,
    257267        exp_type,
    258268        filelevel,
    … …  
    336346    PXOPT_COPY_STR(config->args, where,  "-exp_type",      "exp_type", "==");
    337347    PXOPT_COPY_STR(config->args, where,  "-obs_mode",      "obs_mode", "==");
    338     PXOPT_COPY_S64(config->args, where,  "-magicked",      "magicked", "==");
     348    PXOPT_COPY_STR(config->args, where,  "-data_state",    "data_state", "==");
    339349
    340350    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    491501
    492502    PXOPT_LOOKUP_S16(fault, config->args, "-fault",   false, false);
    493 /*     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false); */
    494503    PXOPT_LOOKUP_S16(burntool_state, config->args, "-burntool_state", false, false);
    495 
    496     if ((fault == INT16_MAX) && !isfinite(burntool_state)) {
    497         psError(PS_ERR_UNKNOWN, false, "one of -fault or -burntool_state must be selected");
     504    PXOPT_LOOKUP_S32(set_bytes, config->args, "-set_bytes", false, false);
     505    PXOPT_LOOKUP_STR(set_md5sum, config->args, "-set_md5sum", false, false);
     506    PXOPT_LOOKUP_STR(set_state, config->args, "-set_state", false, false);
     507   
     508    if ((fault == INT16_MAX) && !isfinite(burntool_state) && !(set_state)) {
     509        psError(PS_ERR_UNKNOWN, false, "one of -fault or -burntool_state or -set_state must be selected");
    498510        return false;
    499511    }
    … …  
    514526            return false;
    515527        }
    516     }
    517 
    518     if (isfinite(burntool_state)) {
    519         psString query = pxDataGet("regtool_updateprocessedimfile.sql");
    520         if (!query) {
    521             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    522             return false;
    523         }
    524 
    525         if (!p_psDBRunQueryF(config->dbh, query, burntool_state, exp_id, class_id)) {
    526             psError(PS_ERR_UNKNOWN, false, "database error");
    527             psFree(query);
    528             return false;
    529         }
    530         psFree(query);
     528        psFree (where);
     529        return(true);
    531530    }
    532531    psFree (where);
     532   
     533    psString setvalues = NULL;
     534    if (burntool_state != INT16_MAX) {
     535      psStringAppend(&setvalues,"rawImfile.burntool_state = %d",burntool_state);
     536    }
     537    if (set_bytes != INT32_MAX) {
     538      if (setvalues) {
     539        psStringAppend(&setvalues,",");
     540      }
     541      psStringAppend(&setvalues,"rawImfile.bytes = %d",set_bytes);
     542    }
     543    if (set_md5sum) {
     544      if (setvalues) {
     545        psStringAppend(&setvalues,",");
     546      }
     547      psStringAppend(&setvalues,"rawImfile.md5sum = '%s'",set_md5sum);
     548    }
     549    if (set_state) {
     550      if (setvalues) {
     551        psStringAppend(&setvalues,",");
     552      }
     553      psStringAppend(&setvalues,"rawImfile.data_state = '%s'",set_state);
     554    }
     555   
     556    psString query = pxDataGet("regtool_updateprocessedimfile.sql");
     557    if (!query) {
     558      psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     559      return false;
     560    }
     561
     562    //    printf(query,setvalues,exp_id,class_id);
     563    if (!p_psDBRunQueryF(config->dbh, query, setvalues, exp_id,class_id)) {
     564      psError(PS_ERR_UNKNOWN, false, "database error");
     565      psFree(query);
     566      psFree(setvalues);
     567      return false;
     568    }
     569    psFree(setvalues);
     570    psFree(query);
    533571
    534572    return true;
    535573}
    536574
     575static bool pendingcompressimfileMode(pxConfig *config) {
     576  PS_ASSERT_PTR_NON_NULL(config, false);
     577
     578  psMetadata *where = psMetadataAlloc();
     579  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     580  PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
     581
     582  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     583  if (whereClause) {
     584    psStringPrepend(&whereClause, "\n AND ");
     585  }
     586 
     587  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     588  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     589
     590  psString query = pxDataGet("regtool_pendingcompressimfile.sql");
     591  if (!query) {
     592    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     593    return(false);
     594  }
     595  psString limitString = NULL;
     596  if (limit) {
     597    limitString = psDBGenerateLimitSQL(limit);
     598    psStringPrepend(&limitString, "\n");
     599  }
     600  //  printf(query,whereClause,limitString);
     601  if (!p_psDBRunQueryF(config->dbh, query, whereClause, limitString ? limitString : "")) {
     602    psError(PXTOOLS_ERR_PROG, false, "database error");
     603    psFree(limitString);
     604    psFree(query);
     605    psFree(whereClause);
     606    psFree(where);
     607    return(false);
     608  }
     609  psFree(limitString);
     610  psFree(query);
     611  psFree(whereClause);
     612  psFree(where);
     613 
     614  psArray *output = p_psDBFetchResult(config->dbh);
     615  if (!output) {
     616    psErrorCode err = psErrorCodeLast();
     617    switch (err) {
     618    case PS_ERR_DB_CLIENT:
     619      psError(PXTOOLS_ERR_SYS, false, "database error");
     620    case PS_ERR_DB_SERVER:
     621      psError(PXTOOLS_ERR_PROG, false, "database error");
     622    default:
     623      psError(PXTOOLS_ERR_PROG, false, "unknown error");
     624    }
     625   
     626    return false;
     627  }
     628  if (!psArrayLength(output)) {
     629    psTrace("regtool", PS_LOG_INFO, "no rows found");
     630    psFree(output);
     631    return true;
     632  }
     633 
     634  // negate simple so the default is true
     635  if (!ippdbPrintMetadatas(stdout, output, "regPendingCompressImfile", !simple)) {
     636    psError(PXTOOLS_ERR_PROG, false, "failed to print array");
     637    psFree(output);
     638    return false;
     639  }
     640 
     641  psFree(output);
     642 
     643  return true;
     644}
     645 
    537646
    538647static bool pendingexpMode(pxConfig *config)
    … …  
    626735    PXOPT_LOOKUP_STR(exp_type, config->args, "-exp_type", false, false);
    627736    PXOPT_LOOKUP_STR(workdir, config->args, "-workdir", false, false);
     737    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    628738    PXOPT_LOOKUP_STR(dvodb, config->args, "-dvodb", false, false);
    629739    PXOPT_LOOKUP_STR(tess_id, config->args, "-tess_id", false, false);
    … …  
    787897        filelevel,
    788898        workdir,
     899        state,
    789900        reduction,
    790901        dvodb,
    … …  
    9301041    PXOPT_COPY_STR(config->args,   where,  "-inst", "camera", "==");
    9311042    PXOPT_COPY_STR(config->args,   where,  "-telescope", "telescope", "==");
    932     PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "dateobs", ">=");
    933     PXOPT_COPY_TIME(config->args,  where, "-dateobs_end", "dateobs", "<=");
     1043    PXOPT_COPY_TIME(config->args,  where,  "-dateobs_begin", "dateobs", ">=");
     1044    PXOPT_COPY_TIME(config->args,  where,  "-dateobs_end", "dateobs", "<=");
     1045    PXOPT_COPY_STR(config->args,   where,  "-state", "state", "==");
    9341046    PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "exp_tag", "==");
    9351047    PXOPT_COPY_STR(config->args,   where,  "-exp_type", "exp_type", "==");
    … …  
    9641076    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "sun_angle", ">=");
    9651077    PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "sun_angle", "<");
    966 
     1078   
    9671079    psString where2 = NULL;
    9681080    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
    … …  
    9741086    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    9751087    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    976 
     1088   
    9771089    if (psListLength(where->list)) {
    978         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    979         psStringAppend(&query, " AND %s", whereClause);
    980         psFree(whereClause);
     1090      psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1091      psStringAppend(&query, " AND %s", whereClause);
     1092      psFree(whereClause);
    9811093    }
    9821094    psFree(where);
    983 
     1095   
    9841096    if (where2) {
    9851097        psStringAppend(&query, " %s ", where2);
    … …  
    9881100
    9891101    if (faulted) {
    990         // list only faulted rows
    991         psStringAppend(&query, " %s", "AND rawExp.fault != 0");
     1102      // list only faulted rows
     1103      psStringAppend(&query, " %s", "AND rawExp.fault != 0");
    9921104    } else {
    993         // don't list faulted rows
    994         psStringAppend(&query, " %s", "AND rawExp.fault = 0");
    995     }
    996 
     1105      // don't list faulted rows
     1106      psStringAppend(&query, " %s", "AND rawExp.fault = 0");
     1107    }
     1108   
    9971109    // treat limit == 0 as "no limit"
    9981110    if (limit) {
    999         psString limitString = psDBGenerateLimitSQL(limit);
    1000         psStringAppend(&query, " %s", limitString);
    1001         psFree(limitString);
    1002     }
    1003 
     1111      psString limitString = psDBGenerateLimitSQL(limit);
     1112      psStringAppend(&query, " %s", limitString);
     1113      psFree(limitString);
     1114    }
     1115   
    10041116    if (!p_psDBRunQuery(config->dbh, query)) {
    1005         psError(PS_ERR_UNKNOWN, false, "database error");
    1006         return false;
     1117      psError(PS_ERR_UNKNOWN, false, "database error");
     1118      return false;
    10071119    }
    10081120    psFree(query);
    1009 
     1121   
    10101122    psArray *output = p_psDBFetchResult(config->dbh);
    10111123    if (!output) {
    1012         psErrorCode err = psErrorCodeLast();
    1013         switch (err) {
    1014             case PS_ERR_DB_CLIENT:
    1015                 psError(PXTOOLS_ERR_SYS, false, "database error");
    1016             case PS_ERR_DB_SERVER:
    1017                 psError(PXTOOLS_ERR_PROG, false, "database error");
    1018             default:
    1019                 psError(PXTOOLS_ERR_PROG, false, "unknown error");
    1020         }
    1021 
    1022         return false;
     1124      psErrorCode err = psErrorCodeLast();
     1125      switch (err) {
     1126      case PS_ERR_DB_CLIENT:
     1127        psError(PXTOOLS_ERR_SYS, false, "database error");
     1128      case PS_ERR_DB_SERVER:
     1129        psError(PXTOOLS_ERR_PROG, false, "database error");
     1130      default:
     1131        psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1132      }
     1133     
     1134      return false;
    10231135    }
    10241136    if (!psArrayLength(output)) {
    1025         psTrace("regtool", PS_LOG_INFO, "no rows found");
    1026         psFree(output);
    1027         return true;
    1028     }
    1029 
     1137      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1138      psFree(output);
     1139      return true;
     1140    }
     1141   
    10301142    if (psArrayLength(output)) {
    1031         // negative simple so the default is true
    1032         if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
    1033             psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1034             psFree(output);
    1035             return false;
    1036         }
    1037     }
    1038 
     1143      // negative simple so the default is true
     1144      if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     1145        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1146        psFree(output);
     1147        return false;
     1148      }
     1149    }
     1150   
    10391151    psFree(output);
    1040 
     1152   
    10411153    return true;
    10421154}
    … …  
    10441156static bool revertprocessedexpMode(pxConfig *config)
    10451157{
    1046     PS_ASSERT_PTR_NON_NULL(config, false);
    1047 
    1048     psMetadata *where = psMetadataAlloc();
    1049     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1050     PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
    1051     PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
    1052     PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
    1053 
    1054     psString query = pxDataGet("regtool_revertprocessedexp.sql");
    1055     if (!query) {
    1056         psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1057         psFree(where);
    1058         return false;
    1059     }
    1060 
    1061     if (psListLength(where->list)) {
    1062         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
    1063         psStringAppend(&query, " AND %s", whereClause);
    1064         psFree(whereClause);
    1065     } else {
    1066         psFree(where);
    1067         psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
    1068         return false;
    1069     }
     1158  PS_ASSERT_PTR_NON_NULL(config, false);
     1159 
     1160  psMetadata *where = psMetadataAlloc();
     1161  PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     1162  PXOPT_COPY_S16(config->args, where,  "-fault",         "fault", "==");
     1163  PXOPT_COPY_S64(config->args, where,  "-exp_id_begin", "exp_id", ">=");
     1164  PXOPT_COPY_S64(config->args, where,  "-exp_id_end", "exp_id", "<=");
     1165 
     1166  psString query = pxDataGet("regtool_revertprocessedexp.sql");
     1167  if (!query) {
     1168    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    10701169    psFree(where);
    1071 
    1072     if (!p_psDBRunQuery(config->dbh, query)) {
    1073         psError(PS_ERR_UNKNOWN, false, "database error");
    1074         psFree(query);
    1075         return false;
    1076     }
     1170    return false;
     1171  }
     1172 
     1173  if (psListLength(where->list)) {
     1174    psString whereClause = psDBGenerateWhereConditionSQL(where, "rawExp");
     1175    psStringAppend(&query, " AND %s", whereClause);
     1176    psFree(whereClause);
     1177  } else {
     1178    psFree(where);
     1179    psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1180    return false;
     1181  }
     1182  psFree(where);
     1183 
     1184  if (!p_psDBRunQuery(config->dbh, query)) {
     1185    psError(PS_ERR_UNKNOWN, false, "database error");
    10771186    psFree(query);
    1078 
    1079     int numUpdated = psDBAffectedRows(config->dbh);
    1080 
    1081     psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
    1082 
    1083     return true;
     1187    return false;
     1188  }
     1189  psFree(query);
     1190 
     1191  int numUpdated = psDBAffectedRows(config->dbh);
     1192 
     1193  psLogMsg("regtool", PS_LOG_INFO, "Updated %d rawExp", numUpdated);
     1194 
     1195  return true;
    10841196}
    10851197
    … …  
    10871199static bool updateprocessedexpMode(pxConfig *config)
    10881200{
    1089     PS_ASSERT_PTR_NON_NULL(config, false);
    1090 
    1091     psMetadata *where = psMetadataAlloc();
    1092     PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
    1093 
    1094     PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
    1095 
    1096     if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
    1097         psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    1098         psFree(where);
    1099         return false;
    1100     }
     1201  PS_ASSERT_PTR_NON_NULL(config, false);
     1202 
     1203  psMetadata *where = psMetadataAlloc();
     1204  PXOPT_COPY_S64(config->args, where,  "-exp_id",       "exp_id", "==");
     1205 
     1206  PXOPT_LOOKUP_S16(fault, config->args, "-fault", true, false);
     1207 
     1208  if (!pxSetFaultCode(config->dbh, "rawExp", where, fault)) {
     1209    psError(PS_ERR_UNKNOWN, false, "failed to set set fault flag");
    11011210    psFree(where);
    1102 
    1103     return true;
    1104 }
    1105 
     1211    return false;
     1212  }
     1213  psFree(where);
     1214 
     1215  return true;
     1216}
     1217
     1218
     1219static bool finishcompressexpMode(pxConfig *config) {
     1220 
     1221  PS_ASSERT_PTR_NON_NULL(config, false);
     1222 
     1223  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1224 
     1225  psMetadata *where = psMetadataAlloc();
     1226  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1227 
     1228  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1229 
     1230  psString query = pxDataGet("regtool_finishcompressexp.sql");
     1231  if (!query) {
     1232    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1233    return(false);
     1234  }
     1235  if (where && psListLength(where->list)) {
     1236    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1237    psStringAppend(&query, " %s ", whereClause);
     1238    psFree(whereClause);
     1239  }
     1240  psFree(where);
     1241 
     1242  if (limit) {
     1243    psString limitString = psDBGenerateLimitSQL(limit);
     1244    psStringAppend(&query, " %s ", limitString);
     1245    psFree(limitString);
     1246  }
     1247  //  printf(query);
     1248  //  return(false);
     1249  if (!p_psDBRunQuery(config->dbh, query)) {
     1250    psError(PS_ERR_UNKNOWN, false, "database error");
     1251    psFree(query);
     1252    return(false);
     1253  }
     1254  psFree(query);
     1255 
     1256  psArray *output = p_psDBFetchResult(config->dbh);
     1257  if (!output) {
     1258    psError(PS_ERR_UNKNOWN, false, "database error");
     1259    return(false);
     1260  }
     1261  if (!psArrayLength(output)) {
     1262    psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1263    psFree(output);
     1264    return(true);
     1265  }
     1266 
     1267  for (long i = 0; i < psArrayLength(output); i++) {
     1268    psMetadata *md = output->data[i];
     1269   
     1270    rawExpRow *row = rawExpObjectFromMetadata(md);
     1271    if (!psDBTransaction(config->dbh)) {
     1272      psError(PS_ERR_UNKNOWN, false, "database error");
     1273      return(false);
     1274    }
     1275   
     1276    if (strcmp(row->state,"goto_compressed") == 0) {
     1277      if (!pxrawExpSetState(config,row->exp_id, "compressed")) {
     1278        psError(PS_ERR_UNKNOWN, false, "failed to set rawExp.state for exp_id: %" PRId64, row->exp_id);
     1279        psFree(row);
     1280        psFree(output);
     1281        return(false);
     1282      }
     1283    }
     1284    else if (strcmp(row->state,"goto_lossy") == 0) {
     1285      if (!pxrawExpSetState(config,row->exp_id, "lossy")) {
     1286        psError(PS_ERR_UNKNOWN, false, "failed to set rawExp.state for exp_id: %" PRId64, row->exp_id);
     1287        psFree(row);
     1288        psFree(output);
     1289        return(false);
     1290      }
     1291    }
     1292    if (!psDBCommit(config->dbh)) {
     1293      psError(PS_ERR_UNKNOWN, false, "database error");
     1294      return false;
     1295    }
     1296    psFree(row);
     1297  }
     1298 
     1299  psFree(output);
     1300  return(true);
     1301}
     1302
     1303static bool updatebyqueryMode(pxConfig *config) {
     1304  PS_ASSERT_PTR_NON_NULL(config, false);
     1305
     1306  PXOPT_LOOKUP_STR(set_state, config->args, "-set_state", true, false);
     1307 
     1308  // XX test this out; need to make this consistent with the list in regtoolConfig.c
     1309  psMetadata *where = psMetadataAlloc();
     1310  PXOPT_COPY_S64(config->args,   where,  "-exp_id", "rawExp.exp_id", "==");
     1311  PXOPT_COPY_STR(config->args,   where,  "-exp_name", "rawExp.exp_name", "==");
     1312  PXOPT_COPY_STR(config->args,   where,  "-inst", "rawExp.camera", "==");
     1313  PXOPT_COPY_STR(config->args,   where,  "-telescope", "rawExp.telescope", "==");
     1314  PXOPT_COPY_TIME(config->args,  where, "-dateobs_begin", "rawExp.dateobs", ">=");
     1315  PXOPT_COPY_TIME(config->args,  where, "-dateobs_end", "rawExp.dateobs", "<=");
     1316  PXOPT_COPY_STR(config->args,   where,  "-exp_tag", "rawExp.exp_tag", "==");
     1317  PXOPT_COPY_STR(config->args,   where,  "-exp_type", "rawExp.exp_type", "==");
     1318  PXOPT_COPY_STR(config->args,   where,  "-filelevel", "rawExp.filelevel", "==");
     1319  PXOPT_COPY_STR(config->args,   where,  "-reduction", "rawExp.reduction", "==");
     1320  PXOPT_COPY_STR(config->args,   where,  "-filter", "rawExp.filter", "==");
     1321  PXOPT_COPY_F32(config->args,   where,  "-airmass_min", "rawExp.airmass", ">=");
     1322  PXOPT_COPY_F32(config->args,   where,  "-airmass_max", "rawExp.airmass", "<");
     1323  PXOPT_COPY_RADEC(config->args, where,  "-ra_min", "rawExp.ra", ">=");
     1324  PXOPT_COPY_RADEC(config->args, where,  "-ra_max", "rawExp.ra", "<");
     1325  PXOPT_COPY_RADEC(config->args, where,  "-decl_min", "rawExp.decl", ">=");
     1326  PXOPT_COPY_RADEC(config->args, where,  "-decl_max", "rawExp.decl", "<");
     1327  PXOPT_COPY_F32(config->args,   where,  "-exp_time_min", "rawExp.exp_time", ">=");
     1328  PXOPT_COPY_F32(config->args,   where,  "-exp_time_max", "rawExp.exp_time", "<");
     1329  PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_min", "rawExp.sat_pixel_frac", ">=");
     1330  PXOPT_COPY_F32(config->args,   where,  "-sat_pixel_frac_max", "rawExp.sat_pixel_frac", "<");
     1331  PXOPT_COPY_F64(config->args,   where,  "-bg_min", "rawExp.bg", ">=");
     1332  PXOPT_COPY_F64(config->args,   where,  "-bg_max", "rawExp.bg", "<");
     1333  PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_min", "rawExp.bg_stdev", ">=");
     1334  PXOPT_COPY_F64(config->args,   where,  "-bg_stdev_max", "rawExp.bg_stdev", "<");
     1335  PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_min", "rawExp.bg_mean_stdev", ">=");
     1336  PXOPT_COPY_F64(config->args,   where,  "-bg_mean_stdev_max", "rawExp.bg_mean_stdev", "<");
     1337  PXOPT_COPY_F64(config->args,   where,  "-alt_min", "rawExp.alt", ">=");
     1338  PXOPT_COPY_F64(config->args,   where,  "-alt_max", "rawExp.alt", "<");
     1339  PXOPT_COPY_F64(config->args,   where,  "-az_min", "rawExp.az", ">=");
     1340  PXOPT_COPY_F64(config->args,   where,  "-az_max", "rawExp.az", "<");
     1341  PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_min", "rawExp.ccd_temp", ">=");
     1342  PXOPT_COPY_F64(config->args,   where,  "-ccd_temp_max", "rawExp.ccd_temp", "<");
     1343  PXOPT_COPY_F64(config->args,   where,  "-posang_min", "rawExp.posang", ">=");
     1344  PXOPT_COPY_F64(config->args,   where,  "-posang_max", "rawExp.posang", "<");
     1345  PXOPT_COPY_F32(config->args,   where,  "-sun_angle_min", "rawExp.sun_angle", ">=");
     1346  PXOPT_COPY_F32(config->args,   where,  "-sun_angle_max", "rawExp.sun_angle", "<");
     1347  PXOPT_COPY_STR(config->args,   where,  "-object", "rawExp.object", "==");
     1348  PXOPT_COPY_STR(config->args,   where,  "-comment", "rawExp.comment", "LIKE");
     1349  PXOPT_COPY_STR(config->args,   where,  "-obs_mode", "rawExp.obs_mode", "LIKE");
     1350
     1351
     1352  psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1353  psStringPrepend(&whereClause,"\n AND ");
     1354  PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1355  PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1356
     1357  psString query = pxDataGet("regtool_updatebyquery.sql");
     1358  if (!query) {
     1359    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1360    return(false);
     1361  }
     1362  psString limitString = NULL;
     1363  if (limit) {
     1364    limitString = psDBGenerateLimitSQL(limit);
     1365    psStringPrepend(&limitString, "\n");
     1366  }
     1367  //  printf(query,set_state,whereClause,limitString);
     1368  if (!p_psDBRunQueryF(config->dbh, query, set_state, whereClause, limitString ? limitString : "")) {
     1369    psError(PXTOOLS_ERR_PROG, false, "database error");
     1370    psFree(limitString);
     1371    psFree(query);
     1372    psFree(whereClause);
     1373    psFree(where);
     1374    return(false);
     1375  }
     1376
     1377  psFree(query);
     1378  // Now up date the imfiles.
     1379  query = pxDataGet("regtool_updatebyqueryimfile.sql");
     1380  if (!query) {
     1381    psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1382    return(false);
     1383  }
     1384  if (!p_psDBRunQueryF(config->dbh, query, set_state,whereClause, limitString ? limitString : "")) {
     1385    psError(PXTOOLS_ERR_PROG, false, "database error");
     1386    psFree(limitString);
     1387    psFree(query);
     1388    psFree(whereClause);
     1389    psFree(where);
     1390    return(false);
     1391  }
     1392 
     1393  psFree(limitString);
     1394  psFree(query);
     1395  psFree(whereClause);
     1396  psFree(where);
     1397 
     1398  return true;
     1399}
     1400
     1401 
    11061402
    11071403static bool cleardupexpMode(pxConfig *config)

  • trunk/ippTools/src/regtool.h

    r23310 r27149  
    3636    REGTOOL_MODE_UPDATEPROCESSEDEXP,
    3737    REGTOOL_MODE_CLEARDUPEXP,
     38    REGTOOL_MODE_UPDATEBYQUERY,
     39    REGTOOL_MODE_PENDINGCOMPRESSIMFILE,
     40    REGTOOL_MODE_FINISHCOMPRESSEXP,
    3841    REGTOOL_MODE_EXPORTRUN,
    3942    REGTOOL_MODE_IMPORTRUN

  • trunk/ippTools/src/regtoolConfig.c

    r27131 r27149  
    7272    ADD_OPT(Str,  addprocessedimfileArgs, "-comment",        "define comment ",             NULL);
    7373    ADD_OPT(Str,  addprocessedimfileArgs, "-obs_mode",       "define observing mode (data usage goal)",             NULL);
    74     ADD_OPT(Str,  addprocessedimfileArgs, "-obs_group",      "define observing group (set of associated observations)",             NULL);
    75 
     74    ADD_OPT(Str,  addprocessedimfileArgs, "-obs_group",      "define observing group (set of associated observations)",   NULL);
     75    ADD_OPT(Str,  addprocessedimfileArgs, "-data_state",     "define the data_state",       "full");
    7676    // Note: RA & DEC are supplied here in radians, but the query options use degrees.  This
    7777    // can be justified by the fact that this option (addprocessedimfile) is a software
    … …  
    139139    ADD_OPT(Str,  processedimfileArgs, "-obs_mode",  "search by obs_mod",                        NULL);
    140140    ADD_OPT(Str,  processedimfileArgs, "-exp_type",  "search by exposure type",                        NULL);
     141    ADD_OPT(Str,  processedimfileArgs, "-data_state", "search by data_state",                 NULL);
    141142    ADD_OPT(Time, processedimfileArgs, "-dateobs_begin", "search for exposures by time (>=)", NULL);
    142143    ADD_OPT(Time, processedimfileArgs, "-dateobs_end", "search for exposures by time (<)", NULL);
    … …  
    162163    ADD_OPT(S64, updateprocessedimfileArgs, "-exp_id",        "search by exposure ID", 0);
    163164    ADD_OPT(Str, updateprocessedimfileArgs, "-class_id",      "search by class ID", NULL);
    164     ADD_OPT(S16, updateprocessedimfileArgs, "-burntool_state",        "set burntool state", 0);
     165    ADD_OPT(S16, updateprocessedimfileArgs, "-burntool_state",        "set burntool state", INT16_MAX);
    165166    ADD_OPT(S16, updateprocessedimfileArgs, "-fault",          "set fault code", INT16_MAX);
    166 
     167    ADD_OPT(S32, updateprocessedimfileArgs, "-set_bytes",      "set bytes", INT32_MAX);
     168    ADD_OPT(Str, updateprocessedimfileArgs, "-set_md5sum",     "set md5sum", NULL);
     169    ADD_OPT(Str, updateprocessedimfileArgs, "-set_state",      "set data state", NULL);
     170
     171   
    167172    // -pendingexp
    168173    psMetadata *pendingexpArgs = psMetadataAlloc();
    … …  
    185190    ADD_OPT(Str,  addprocessedexpArgs, "-exp_type",         "define exposure type", NULL);
    186191    ADD_OPT(Str,  addprocessedexpArgs, "-workdir",          "define the \"default\" workdir for this exposure", NULL);
     192    ADD_OPT(Str,  addprocessedexpArgs, "-state",            "define the state for this exposure", NULL);
    187193    ADD_OPT(Str,  addprocessedexpArgs, "-dvodb",            "define the dvodb for the next processing step", NULL);
    188194    ADD_OPT(Str,  addprocessedexpArgs, "-tess_id",          "define the tess_id for the next processing step", NULL);
    … …  
    253259    psMetadataAddTime(processedexpArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
    254260    psMetadataAddTime(processedexpArgs, PS_LIST_TAIL, "-dateobs_end",   0,            "search for exposures by time (<)", NULL);
     261    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-state",         0,            "search by exposure state", NULL);
    255262    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_tag",       0,            "search by exp_tag", NULL);
    256263    psMetadataAddStr(processedexpArgs,  PS_LIST_TAIL, "-exp_type",      0,            "search by exp_type", "object");
    … …  
    302309    psMetadataAddS64(updatedprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    303310    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-fault",    0,            "set fault code (required)", INT16_MAX);
    304 
     311    psMetadataAddStr(updatedprocessedexpArgs, PS_LIST_TAIL, "-set_state", 0,           "set state", NULL);
    305312    // -exportrun
    306313    psMetadata *exportrunArgs = psMetadataAlloc();
    … …  
    313320    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
    314321
    315 
    316322    // -cleardupexp
    317323    psMetadata *cleardupexpArgs = psMetadataAlloc();
    318324
     325    // -updatebyquery
     326    psMetadata *updatebyqueryArgs = psMetadataAlloc();
     327   
     328    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-set_state",     0,            "set the state", NULL);
     329                     
     330    psMetadataAddS64(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_id",        0,            "search by exposure ID", 0);
     331    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_name",      0,            "search by exp_name", NULL);
     332    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-inst",          0,            "search for camera", NULL);
     333    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-telescope",     0,            "search for telescope", NULL);
     334    psMetadataAddTime(updatebyqueryArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     335    psMetadataAddTime(updatebyqueryArgs, PS_LIST_TAIL, "-dateobs_end",   0,            "search for exposures by time (<)", NULL);
     336    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_tag",       0,            "search by exp_tag", NULL);
     337    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_type",      0,            "search by exp_type", NULL);
     338    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-filelevel",     0,            "search by filelevel", NULL);
     339    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-reduction",     0,            "search by reduction class", NULL);
     340    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-filter",        0,            "search for filter", NULL);
     341    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-airmass_min",   0,            "search by min airmass", NAN);
     342    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-airmass_max",   0,            "search by max airmass", NAN);
     343    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ra_min",        0,            "search by min RA (degrees) ", NAN);
     344    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ra_max",        0,            "search by max RA (degrees) ", NAN);
     345    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-decl_min",      0,            "search by min DEC (degrees)", NAN);
     346    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-decl_max",      0,            "search by max DEC (degrees)", NAN);
     347    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_time_min",  0,            "search by min exposure time", NAN);
     348    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-exp_time_max",  0,            "search by max exposure time", NAN);
     349    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sat_pixel_frac_min",  0,      "search by min fraction of saturated pixels", NAN);
     350    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sat_pixel_frac_max",  0,      "search by max fraction of saturated pixels", NAN);
     351    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_min",        0,            "search by min background", NAN);
     352    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_max",        0,            "search by max background", NAN);
     353    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_stdev_min",  0,            "search by min background standard deviation", NAN);
     354    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_stdev_max",  0,            "search by max background standard deviation", NAN);
     355    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_mean_stdev_min",  0,       "search by min background mean standard deviation (across imfiles)", NAN);
     356    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-bg_mean_stdev_max",  0,       "search by max background mean standard deviation (across imfiles)", NAN);
     357    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-alt_min",       0,            "search by min altitude", NAN);
     358    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-alt_max",       0,            "search by max altitude", NAN);
     359    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-az_min",        0,            "search by min azimuth ", NAN);
     360    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-az_max",        0,            "search by max azimuth ", NAN);
     361    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ccd_temp_min",  0,            "search by min ccd tempature", NAN);
     362    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-ccd_temp_max",  0,            "search by max ccd tempature", NAN);
     363    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-posang_min",    0,            "search by min rotator position angle", NAN);
     364    psMetadataAddF64(updatebyqueryArgs,  PS_LIST_TAIL, "-posang_max",    0,            "search by max rotator position angle", NAN);
     365    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sun_angle_min",    0,         "search by min solar angle", NAN);
     366    psMetadataAddF32(updatebyqueryArgs,  PS_LIST_TAIL, "-sun_angle_max",    0,         "search by max solar angle", NAN);
     367    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-object",        0,            "search by exposure object", NULL);
     368    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-comment",        0,            "search by comment", NULL);
     369    psMetadataAddStr(updatebyqueryArgs,  PS_LIST_TAIL, "-obs_mode",       0,            "search by obs_mode", NULL);
     370   
     371    psMetadataAddU64(updatebyqueryArgs,  PS_LIST_TAIL, "-limit",         0,            "limit result set to N items", 0);
     372    psMetadataAddBool(updatebyqueryArgs, PS_LIST_TAIL, "-simple",        0,            "use the simple output format", false);
     373
     374   
     375    // -pendingcompressimfile
     376    psMetadata *pendingcompressimfileArgs = psMetadataAlloc();
     377    psMetadataAddS64(pendingcompressimfileArgs, PS_LIST_TAIL, "-exp_id", 0,      "search by exp_id", 0);
     378    psMetadataAddStr(pendingcompressimfileArgs, PS_LIST_TAIL, "-class_id", 0,    "search by class ID",                    NULL);
     379    psMetadataAddBool(pendingcompressimfileArgs, PS_LIST_TAIL, "-simple", 0,     "use the simple output format", false);
     380    psMetadataAddU64(pendingcompressimfileArgs, PS_LIST_TAIL, "-limit",   0,     "limit result set to N items", 0);
     381
     382   
     383    // -finishcompressexp
     384    psMetadata *finishcompressexpArgs = psMetadataAlloc();
     385    psMetadataAddS64(finishcompressexpArgs, PS_LIST_TAIL, "-exp_id", 0,       "search by exp_id", 0);
     386    psMetadataAddBool(finishcompressexpArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
     387    psMetadataAddU64(finishcompressexpArgs, PS_LIST_TAIL, "-limit",   0,   "limit result set to N items", 0);
     388   
    319389    psMetadata *argSets = psMetadataAlloc();
    320390    psMetadata *modes = psMetadataAlloc();
    … …  
    331401    PXOPT_ADD_MODE("-updateprocessedexp",      "", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    332402    PXOPT_ADD_MODE("-cleardupexp",             "", REGTOOL_MODE_CLEARDUPEXP,      cleardupexpArgs);
     403    PXOPT_ADD_MODE("-updatebyquery",           "", REGTOOL_MODE_UPDATEBYQUERY, updatebyqueryArgs);
     404    PXOPT_ADD_MODE("-pendingcompressimfile",   "", REGTOOL_MODE_PENDINGCOMPRESSIMFILE, pendingcompressimfileArgs);
     405    PXOPT_ADD_MODE("-finishcompressexp",       "", REGTOOL_MODE_FINISHCOMPRESSEXP, finishcompressexpArgs);
    333406    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", REGTOOL_MODE_EXPORTRUN, exportrunArgs);
    334407    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           REGTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.