IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 19092


Ignore:
Timestamp:
Aug 16, 2008, 1:27:58 PM (18 years ago)
Author:
eugene
Message:

extensive changes from eam_branch_20080719:

  • added the 'cleanup' options to camtool, faketool, warptool, difftool, stacktool
  • added corresponding sql code
  • changed the states for camera, fake, warp, diff, and stack to the new set of states: new, full, goto_cleaned, cleaned, update, goto_purged, and purged
  • added 'data_state' entries to the detrend tables and the detRunSummary
  • added 'cleanup' options to dettool using the detRunSummary data_state as the control
  • moved dettool supporting code to dettool_STAGE, where stage is processedimfile, processedexp, etc.
  • converted dettool to use S64 for det_id and exp_id entries
Location:
trunk/ippTools
Files:
32 added
3 deleted
51 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/notes.txt

    r18561 r19092  
     1
     22008.07.19 EAM
     3
     4  * need to add cleanup modes to all stages.  here is the minimum list
     5    of stages that need the cleanups:
     6
     7    * chiptool - DONE
     8    * camtool
     9    * faketool
     10    * warptool
     11    * difftool
     12    * stacktool
     13    * dettool processedimfile
     14    * dettool processedexp
     15    * dettool stackedimfile
     16    * dettool normalizedstat
     17    * dettool normalizedimfile
     18    * dettool normalizedexp
     19    * dettool residimfile
     20    * dettool residexp
     21
     22    * I am modifiying the tools to use the new states: new, full, goto_cleaned, etc.
     23      I am NOT changing: regtool, pztool, magictool, flatcorr, pxregister, pstamptool
     24
     25    * for dettool, I have added a new field, 'data_state' to the
     26      detRunSummary.  My plan here is that a complete detRunIteration
     27      is cleaned at once.  I've added functions to all of the dettool
     28      major modes to list pending entries to be cleaned and a function
     29      to update the data_state when cleaning is done.
    130
    2312008.07.11 EAM

  • trunk/ippTools/share/Makefile.am

    r19038 r19092  
    11dist_pkgdata_DATA = \
    2         camtool_find_chip_id.sql \
    3         camtool_find_pendingexp.sql \
    4         camtool_find_pendingimfile.sql \
    5         camtool_find_processedexp.sql \
    6         camtool_queue_chip_id.sql \
    7         camtool_reset_faulted_runs.sql \
    8         camtool_revertprocessedexp.sql \
    9         chiptool_completely_processed_exp.sql \
    10         chiptool_donecleanup.sql \
    11         chiptool_find_rawexp.sql \
    12         chiptool_pendingcleanupimfile.sql \
    13         chiptool_pendingcleanuprun.sql \
    14         chiptool_pendingimfile.sql \
    15         chiptool_processedimfile.sql \
    16         chiptool_revertprocessedimfile.sql \
    17         chiptool_run.sql \
    18         chiptool_unmasked.sql \
    19         detselect_search.sql \
    20         detselect_select.sql \
    21         dettool_addprocessedexp.sql \
    22         dettool_childlessrun.sql \
    23         dettool_definebydetrun.sql \
    24         dettool_detrunsummary.sql \
    25         dettool_find_completed_runs.sql \
    26         dettool_input.sql \
    27         dettool_normalizedexp.sql \
    28         dettool_normalizedimfile.sql \
    29         dettool_normalizedstat.sql \
    30         dettool_pending.sql \
    31         dettool_processedimfile.sql \
    32         dettool_raw.sql \
    33         dettool_residexp.sql \
    34         dettool_residimfile.sql \
    35         dettool_revertdetrunsummary.sql \
    36         dettool_revertnormalizedexp.sql \
    37         dettool_revertnormalizedimfile.sql \
    38         dettool_revertnormalizedstat.sql \
    39         dettool_revertprocessedexp.sql \
    40         dettool_revertprocessedimfile.sql \
    41         dettool_revertresidexp.sql \
    42         dettool_revertresidimfile.sql\
    43         dettool_revertstacked.sql \
    44         dettool_runs.sql \
    45         dettool_stacked.sql \
    46         dettool_start_new_iteration.sql \
    47         dettool_stop_completed_correct_runs.sql \
    48         dettool_tocorrectexp.sql \
    49         dettool_tocorrectimfile.sql \
    50         dettool_todetrunsummary.sql \
    51         dettool_tonormalize.sql \
    52         dettool_tonormalizedexp.sql \
    53         dettool_tonormalizedstat.sql \
    54         dettool_toprocessedexp.sql \
    55         dettool_toprocessedimfile.sql \
    56         dettool_toresidexp.sql \
    57         dettool_toresidimfile.sql \
    58         dettool_tostacked.sql \
    59         difftool_inputskyfile.sql \
    60         difftool_definebyquery.sql \
    61         difftool_revertdiffskyfile_update.sql \
    62         difftool_revertdiffskyfile_delete.sql \
    63         difftool_skyfile.sql \
    64         difftool_todiffskyfile.sql \
    65         faketool_completely_processed_exp.sql \
    66         faketool_find_camrun.sql \
    67         faketool_find_pendingexp.sql \
    68         faketool_pendingimfile.sql \
    69         faketool_processedimfile.sql \
    70         faketool_queue_cam_id.sql \
    71         faketool_revertprocessedimfile.sql \
    72         faketool_unmasked.sql \
    73         flatcorr_completely_processed_chiprun.sql \
    74         flatcorr_create_tmp_chiprundone.sql \
    75         flatcorr_find_completed_floatcorruns.sql \
    76         flatcorr_find_processedimfiles.sql \
    77         flatcorr_pending.sql \
    78         magictool_definebyquery_temp_create.sql \
    79         magictool_definebyquery_temp_insert.sql \
    80         magictool_definebyquery_temp_insert_groupby.sql \
    81         magictool_definebyquery_select_part1.sql \
    82         magictool_definebyquery_select_part2.sql \
    83         magictool_definebyquery_insert.sql \
    84         magictool_inputskyfile.sql \
    85         magictool_totree.sql \
    86         magictool_tomask.sql \
    87         magictool_toprocess_inputs.sql \
    88         magictool_toprocess_tree.sql \
    89         magictool_toskyfilemask.sql \
    90         magictool_inputs.sql \
    91         magictool_addmask.sql \
    92         magictool_mask.sql \
    93         pstamptool_addjob_otherjob.sql \
    94         pstamptool_addjob_stampjob.sql \
    95         pstamptool_datastore.sql \
    96         pstamptool_pendingjob.sql \
    97         pstamptool_pendingreq.sql \
    98         pxadmin_create_tables.sql \
    99         pxadmin_drop_tables.sql \
    100         pztool_find_completed_exp.sql \
    101         pztool_pendingimfile.sql \
    102         pztool_revert_downloadimfile_faults.sql \
    103         pztool_revert_fileset_faults.sql \
    104         pztool_revertcopied.sql \
    105         regtool_create_dup_table.sql \
    106         regtool_pendingexp.sql \
    107         regtool_pendingimfile.sql \
    108         regtool_populate_dup_table.sql \
    109         regtool_processedexp.sql \
    110         regtool_processedimfile.sql \
    111         regtool_revertprocessedexp.sql \
    112         regtool_revertprocessedimfile.sql \
    113         stacktool_definebyquery_part1.sql \
    114         stacktool_definebyquery_part2.sql \
    115         stacktool_definebyquery_insert.sql \
    116         stacktool_definebyquery_insert_random.sql \
    117         stacktool_inputskyfile.sql \
    118         stacktool_revertsumskyfile_update.sql \
    119         stacktool_revertsumskyfile_delete.sql \
    120         stacktool_sumskyfile.sql \
    121         stacktool_tosum.sql \
    122         warptool_exp.sql \
    123         warptool_imfile.sql \
    124         warptool_revertwarped.sql \
    125         warptool_scmap.sql \
    126         warptool_tooverlap.sql \
    127         warptool_towarped.sql \
    128         warptool_warped.sql
     2     camtool_donecleanup.sql \
     3     camtool_find_chip_id.sql \
     4     camtool_find_pendingexp.sql \
     5     camtool_find_pendingimfile.sql \
     6     camtool_find_processedexp.sql \
     7     camtool_pendingcleanupexp.sql \
     8     camtool_pendingcleanuprun.sql \
     9     camtool_queue_chip_id.sql \
     10     camtool_reset_faulted_runs.sql \
     11     camtool_revertprocessedexp.sql \
     12     chiptool_completely_processed_exp.sql \
     13     chiptool_donecleanup.sql \
     14     chiptool_find_rawexp.sql \
     15     chiptool_pendingcleanupimfile.sql \
     16     chiptool_pendingcleanuprun.sql \
     17     chiptool_pendingimfile.sql \
     18     chiptool_processedimfile.sql \
     19     chiptool_revertprocessedimfile.sql \
     20     chiptool_run.sql \
     21     chiptool_unmasked.sql \
     22     detselect_search.sql \
     23     detselect_select.sql \
     24     dettool_addprocessedexp.sql \
     25     dettool_childlessrun.sql \
     26     dettool_definebydetrun.sql \
     27     dettool_detrunsummary.sql \
     28     dettool_find_completed_runs.sql \
     29     dettool_input.sql \
     30     dettool_normalizedexp.sql \
     31     dettool_normalizedimfile.sql \
     32     dettool_normalizedstat.sql \
     33     dettool_pending.sql \
     34     dettool_pendingcleanup_normalizedexp.sql \
     35     dettool_pendingcleanup_normalizedimfile.sql \
     36     dettool_pendingcleanup_normalizedstat.sql \
     37     dettool_pendingcleanup_processedexp.sql \
     38     dettool_pendingcleanup_processedimfile.sql \
     39     dettool_pendingcleanup_residexp.sql \
     40     dettool_pendingcleanup_residimfile.sql \
     41     dettool_pendingcleanup_stacked.sql \
     42     dettool_processedimfile.sql \
     43     dettool_raw.sql \
     44     dettool_residexp.sql \
     45     dettool_residimfile.sql \
     46     dettool_revertdetrunsummary.sql \
     47     dettool_revertnormalizedexp.sql \
     48     dettool_revertnormalizedimfile.sql \
     49     dettool_revertnormalizedstat.sql \
     50     dettool_revertprocessedexp.sql \
     51     dettool_revertprocessedimfile.sql \
     52     dettool_revertresidexp.sql \
     53     dettool_revertresidimfile.sql \
     54     dettool_revertstacked.sql \
     55     dettool_runs.sql \
     56     dettool_stacked.sql \
     57     dettool_start_new_iteration.sql \
     58     dettool_stop_completed_correct_runs.sql \
     59     dettool_tocorrectexp.sql \
     60     dettool_tocorrectimfile.sql \
     61     dettool_todetrunsummary.sql \
     62     dettool_tonormalize.sql \
     63     dettool_tonormalizedexp.sql \
     64     dettool_tonormalizedstat.sql \
     65     dettool_toprocessedexp.sql \
     66     dettool_toprocessedimfile.sql \
     67     dettool_toresidexp.sql \
     68     dettool_toresidimfile.sql \
     69     dettool_tostacked.sql \
     70     difftool_definebyquery.sql \
     71     difftool_donecleanup.sql \
     72     difftool_inputskyfile.sql \
     73     difftool_pendingcleanuprun.sql \
     74     difftool_pendingcleanupskyfile.sql \
     75     difftool_revertdiffskyfile_delete.sql \
     76     difftool_revertdiffskyfile_update.sql \
     77     difftool_skyfile.sql \
     78     difftool_todiffskyfile.sql \
     79     faketool_completely_processed_exp.sql \
     80     faketool_donecleanup.sql \
     81     faketool_find_camrun.sql \
     82     faketool_find_pendingexp.sql \
     83     faketool_pendingcleanupimfile.sql \
     84     faketool_pendingcleanuprun.sql \
     85     faketool_pendingimfile.sql \
     86     faketool_processedimfile.sql \
     87     faketool_queue_cam_id.sql \
     88     faketool_revertprocessedimfile.sql \
     89     faketool_unmasked.sql \
     90     flatcorr_completely_processed_chiprun.sql \
     91     flatcorr_create_tmp_chiprundone.sql \
     92     flatcorr_find_completed_floatcorruns.sql \
     93     flatcorr_find_processedimfiles.sql \
     94     flatcorr_pending.sql \
     95     magictool_addmask.sql \
     96     magictool_create_tmp_warpcomplete.sql \
     97     magictool_definebyquery.sql \
     98     magictool_definebyquery_insert.sql \
     99     magictool_definebyquery_select_part1.sql \
     100     magictool_definebyquery_select_part2.sql \
     101     magictool_definebyquery_select_test.sql \
     102     magictool_definebyquery_temp_create.sql \
     103     magictool_definebyquery_temp_insert.sql \
     104     magictool_definebyquery_temp_insert_groupby.sql \
     105     magictool_inputs.sql \
     106     magictool_inputskyfile.sql \
     107     magictool_mask.sql \
     108     magictool_tomask.sql \
     109     magictool_toprocess_inputs.sql \
     110     magictool_toprocess_tree.sql \
     111     magictool_toskyfilemask.sql \
     112     magictool_totree.sql \
     113     pstamptool_addjob_otherjob.sql \
     114     pstamptool_addjob_stampjob.sql \
     115     pstamptool_datastore.sql \
     116     pstamptool_pendingjob.sql \
     117     pstamptool_pendingreq.sql \
     118     pxadmin_create_tables.sql \
     119     pxadmin_drop_tables.sql \
     120     pztool_find_completed_exp.sql \
     121     pztool_pendingimfile.sql \
     122     pztool_revert_downloadimfile_faults.sql \
     123     pztool_revert_fileset_faults.sql \
     124     pztool_revertcopied.sql \
     125     regtool_create_dup_table.sql \
     126     regtool_pendingexp.sql \
     127     regtool_pendingimfile.sql \
     128     regtool_populate_dup_table.sql \
     129     regtool_processedexp.sql \
     130     regtool_processedimfile.sql \
     131     regtool_revertprocessedexp.sql \
     132     regtool_revertprocessedimfile.sql \
     133     stacktool_definebyquery_insert.sql \
     134     stacktool_definebyquery_insert_random.sql \
     135     stacktool_definebyquery_part1.sql \
     136     stacktool_definebyquery_part2.sql \
     137     stacktool_definebyquery_test.sql \
     138     stacktool_donecleanup.sql \
     139     stacktool_find_complete_warps.sql \
     140     stacktool_inputskyfile.sql \
     141     stacktool_pendingcleanuprun.sql \
     142     stacktool_pendingcleanupskyfile.sql \
     143     stacktool_revertsumskyfile_delete.sql \
     144     stacktool_revertsumskyfile_update.sql \
     145     stacktool_sumskyfile.sql \
     146     stacktool_tosum.sql \
     147     warptool_donecleanup.sql \
     148     warptool_exp.sql \
     149     warptool_imfile.sql \
     150     warptool_pendingcleanuprun.sql \
     151     warptool_pendingcleanupskyfile.sql \
     152     warptool_revertwarped.sql \
     153     warptool_scmap.sql \
     154     warptool_tooverlap.sql \
     155     warptool_towarped.sql \
     156     warptool_warped.sql

  • trunk/ippTools/share/camtool_find_pendingexp.sql

    r18366 r19092  
    2525    WHERE
    2626        chipRun.state = 'full'
    27         AND camRun.state = 'run'
     27        AND camRun.state = 'new'
    2828        AND camMask.label IS NULL
    2929        AND camProcessedExp.cam_id IS NULL

  • trunk/ippTools/share/camtool_reset_faulted_runs.sql

    r17216 r19092  
    11UPDATE camRun, camProcessedExp, chipRun, rawExp
    2 SET camRun.state = 'run'
     2SET camRun.state = 'new'
    33WHERE
    44    camRun.cam_id = camProcessedExp.cam_id

  • trunk/ippTools/share/dettool_addprocessedexp.sql

    r18561 r19092  
    2525  AND detProcessedExp.exp_id IS NULL
    2626  AND detInputExp.include = 1
    27   AND detRun.det_id = %s
    28   AND detProcessedImfile.exp_id = '%s'
     27  AND detRun.det_id = %lld
     28  AND detProcessedImfile.exp_id = %lld
    2929GROUP BY
    3030   detProcessedImfile.class_id,

  • trunk/ippTools/share/dettool_definebydetrun.sql

    r18561 r19092  
    33INSERT INTO detInputExp
    44   SELECT
    5        %d,
     5       %lld,
    66       0,
    77       detResidExp.exp_id,
    … …  
    1010   JOIN rawExp
    1111       USING(exp_id)
    12    WHERE det_id = %d
     12   WHERE det_id = %lld

  • trunk/ippTools/share/difftool_inputskyfile.sql

    r18448 r19092  
    3030        ON chipRun.exp_id = rawExp.exp_id
    3131    WHERE
    32         diffRun.state = 'run'
    33         AND warpRun.state = 'stop'
    34         AND fakeRun.state = 'stop'
    35         AND camRun.state = 'stop'
     32        diffRun.state = 'new'
     33        AND warpRun.state = 'full'
     34        AND fakeRun.state = 'full'
     35        AND camRun.state = 'full'
    3636        AND chipRun.state = 'full'
    3737    UNION
    … …  
    6666        ON chipRun.exp_id = rawExp.exp_id
    6767    WHERE
    68         diffRun.state = 'run'
    69         AND warpRun.state = 'stop'
    70         AND fakeRun.state = 'stop'
    71         AND camRun.state = 'stop'
     68        diffRun.state = 'new'
     69        AND warpRun.state = 'full'
     70        AND fakeRun.state = 'full'
     71        AND camRun.state = 'full'
    7272        AND chipRun.state = 'full'
    7373    ) as Foo

  • trunk/ippTools/share/difftool_skyfile.sql

    r18975 r19092  
    99JOIN diffSkyfile
    1010    USING(diff_id)
    11 -- my new stuff begins here
     11-- WS: my new stuff begins here
    1212JOIN diffInputSkyfile
    1313    ON diffInputSkyfile.diff_id = diffRun.diff_id
    … …  
    2323JOIN rawExp
    2424    ON chipRun.exp_id = rawExp.exp_id
    25 -- my new stuff ends here
     25-- WS: my new stuff ends here
    2626    WHERE
    2727    -- bogus test to allow appending conditionals
     28    -- XXX EAM : this is not needed if we modify the difftool.c code : fix
    2829    diffRun.diff_id IS NOT NULL
    29 

  • trunk/ippTools/share/difftool_todiffskyfile.sql

    r18448 r19092  
    2525    ON diffInputSkyfile.diff_id = diffSkyfile.diff_id
    2626WHERE
    27   diffRun.state = 'run'
    28   AND warpRun.state = 'stop'
    29   AND fakeRun.state = 'stop'
    30   AND camRun.state = 'stop'
     27  diffRun.state = 'new'
     28  AND warpRun.state = 'full'
     29  AND fakeRun.state = 'full'
     30  AND camRun.state = 'full'
    3131  AND chipRun.state = 'full'
    3232  AND diffSkyfile.diff_id IS NULL

  • trunk/ippTools/share/faketool_completely_processed_exp.sql

    r17938 r19092  
    3131        AND rawImfile.class_id = fakeProcessedImfile.class_id
    3232    WHERE
    33         fakeRun.state = 'run'
     33        fakeRun.state = 'new'
    3434    GROUP BY
    3535        fakeRun.fake_id,

  • trunk/ippTools/share/faketool_find_camrun.sql

    r18448 r19092  
    3232        using(exp_id)
    3333    WHERE
    34         camRun.state = 'stop'
     34        camRun.state = 'full'
    3535        AND chipRun.state = 'full'
    3636) as Foo

  • trunk/ippTools/share/faketool_find_pendingexp.sql

    r18688 r19092  
    2525        ON fakeRun.label = fakeMask.label
    2626    WHERE
    27         fakeRun.state = 'run'
    28         AND camRun.state = 'stop'
     27        fakeRun.state = 'new'
     28        AND camRun.state = 'full'
    2929        AND chipRun.state = 'full'
    3030        AND fakeMask.label IS NULL

  • trunk/ippTools/share/faketool_queue_cam_id.sql

    r17938 r19092  
    1414    FROM camRun
    1515    WHERE
    16         camRun.state = 'stop'
     16        camRun.state = 'full'
    1717        AND camRun.cam_id = %lld

  • trunk/ippTools/share/pxadmin_create_tables.sql

    r18764 r19092  
    485485    user_5 DOUBLE,
    486486    path_base VARCHAR(255),
     487    data_state VARCHAR(64),
    487488    fault SMALLINT NOT NULL,
    488489    PRIMARY KEY(det_id, exp_id, class_id),
    … …  
    512513    user_5 DOUBLE,
    513514    path_base VARCHAR(255),
     515    data_state VARCHAR(64),
    514516    fault SMALLINT NOT NULL,
    515517    PRIMARY KEY(det_id, exp_id),
    … …  
    535537    user_4 DOUBLE,
    536538    user_5 DOUBLE,
     539    data_state VARCHAR(64),
    537540    fault SMALLINT NOT NULL,
    538541    PRIMARY KEY(det_id, iteration, class_id),
    … …  
    549552    class_id VARCHAR(64),
    550553    norm FLOAT,
     554    data_state VARCHAR(64),
    551555    fault SMALLINT NOT NULL,
    552556    PRIMARY KEY(det_id, iteration, class_id),
    … …  
    572576    user_5 DOUBLE,
    573577    path_base VARCHAR(255),
     578    data_state VARCHAR(64),
    574579    fault SMALLINT NOT NULL,
    575580    PRIMARY KEY(det_id, iteration, class_id),
    … …  
    595600    user_5 DOUBLE,
    596601    path_base VARCHAR(255),
     602    data_state VARCHAR(64),
    597603    fault SMALLINT NOT NULL,
    598604    PRIMARY KEY(det_id, iteration),
    … …  
    629635    user_5 DOUBLE,
    630636    path_base VARCHAR(255),
     637    data_state VARCHAR(64),
    631638    fault SMALLINT NOT NULL,
    632639    PRIMARY KEY(det_id, iteration, exp_id, class_id),
    … …  
    641648) ENGINE=innodb DEFAULT CHARSET=latin1;
    642649
    643 CREATE TABLE detResidExp (det_id BIGINT, iteration INT, exp_id BIGINT, recipe VARCHAR(64), bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, bg_skewness DOUBLE, bg_kurtosis DOUBLE, bin_stdev DOUBLE, fringe_0 DOUBLE, fringe_1 DOUBLE, fringe_2 DOUBLE, fringe_resid_0 DOUBLE, fringe_resid_1 DOUBLE, fringe_resid_2 DOUBLE, user_1 DOUBLE, user_2 DOUBLE, user_3 DOUBLE, user_4 DOUBLE, user_5 DOUBLE, path_base VARCHAR(255), accept TINYINT, fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration, exp_id), KEY(fault), INDEX(det_id, iteration), FOREIGN KEY (det_id, iteration, exp_id)  REFERENCES  detInputExp(det_id, iteration, exp_id), FOREIGN KEY (det_id, iteration, exp_id)  REFERENCES  detResidImfile(det_id, iteration, exp_id)) ENGINE=innodb DEFAULT CHARSET=latin1;
    644 CREATE TABLE detRunSummary (det_id BIGINT, iteration INT, bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, accept TINYINT, fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration), KEY(fault), FOREIGN KEY (det_id, iteration)  REFERENCES  detInputExp(det_id, iteration), FOREIGN KEY (det_id, iteration)  REFERENCES  detResidExp(det_id, iteration)) ENGINE=innodb DEFAULT CHARSET=latin1;
    645 CREATE TABLE detRegisteredImfile (det_id BIGINT, iteration INT, class_id VARCHAR(64), uri VARCHAR(255), bg DOUBLE, bg_stdev DOUBLE, bg_mean_stdev DOUBLE, user_1 DOUBLE, user_2 DOUBLE, user_3 DOUBLE, user_4 DOUBLE, user_5 DOUBLE, path_base VARCHAR(255), fault SMALLINT NOT NULL, PRIMARY KEY(det_id, iteration, class_id), KEY(fault), FOREIGN KEY (det_id, iteration)  REFERENCES  detRun(det_id, iteration)) ENGINE=innodb DEFAULT CHARSET=latin1;
     650CREATE TABLE detResidExp (
     651       det_id BIGINT,
     652       iteration INT,
     653       exp_id BIGINT,
     654       recipe VARCHAR(64),
     655       bg DOUBLE,
     656       bg_stdev DOUBLE,
     657       bg_mean_stdev DOUBLE,
     658       bg_skewness DOUBLE,
     659       bg_kurtosis DOUBLE,
     660       bin_stdev DOUBLE,
     661       fringe_0 DOUBLE,
     662       fringe_1 DOUBLE,
     663       fringe_2 DOUBLE,
     664       fringe_resid_0 DOUBLE,
     665       fringe_resid_1 DOUBLE,
     666       fringe_resid_2 DOUBLE,
     667       user_1 DOUBLE,
     668       user_2 DOUBLE,
     669       user_3 DOUBLE,
     670       user_4 DOUBLE,
     671       user_5 DOUBLE,
     672       path_base VARCHAR(255),
     673       data_state VARCHAR(64),
     674       accept TINYINT,
     675       fault SMALLINT NOT NULL,
     676       PRIMARY KEY(det_id, iteration, exp_id),
     677       KEY(fault),
     678       INDEX(det_id, iteration),
     679       FOREIGN KEY (det_id, iteration, exp_id) 
     680       REFERENCES  detInputExp(det_id, iteration, exp_id),
     681       FOREIGN KEY (det_id, iteration, exp_id) 
     682       REFERENCES  detResidImfile(det_id, iteration, exp_id)
     683) ENGINE=innodb DEFAULT CHARSET=latin1;
     684
     685CREATE TABLE detRunSummary (
     686       det_id BIGINT,
     687       iteration INT,
     688       data_state VARCHAR(64),
     689       bg DOUBLE,
     690       bg_stdev DOUBLE,
     691       bg_mean_stdev DOUBLE,
     692       accept TINYINT,
     693       fault SMALLINT NOT NULL,
     694       PRIMARY KEY(det_id, iteration),
     695       KEY(fault),
     696       FOREIGN KEY (det_id, iteration) 
     697         REFERENCES  detInputExp(det_id, iteration),
     698       FOREIGN KEY (det_id, iteration) 
     699         REFERENCES  detResidExp(det_id, iteration)
     700) ENGINE=innodb DEFAULT CHARSET=latin1;
     701
     702CREATE TABLE detRegisteredImfile (
     703       det_id BIGINT,
     704       iteration INT,
     705       class_id VARCHAR(64),
     706       uri VARCHAR(255),
     707       bg DOUBLE,
     708       bg_stdev DOUBLE,
     709       bg_mean_stdev DOUBLE,
     710       user_1 DOUBLE,
     711       user_2 DOUBLE,
     712       user_3 DOUBLE,
     713       user_4 DOUBLE,
     714       user_5 DOUBLE,
     715       path_base VARCHAR(255),
     716       data_state VARCHAR(64),
     717       fault SMALLINT NOT NULL,
     718       PRIMARY KEY(det_id, iteration, class_id),
     719       KEY(fault),
     720       FOREIGN KEY (det_id, iteration) 
     721         REFERENCES  detRun(det_id, iteration)
     722) ENGINE=innodb DEFAULT CHARSET=latin1;
    646723
    647724CREATE TABLE warpRun (

  • trunk/ippTools/share/stacktool_definebyquery_part1.sql

    r18609 r19092  
    2323        JOIN rawExp USING(exp_id, tess_id)
    2424    WHERE
    25         warpRun.state = 'stop'
     25        warpRun.state = 'full'
    2626    AND warpSkyfile.ignored = 0
    2727    AND warpSkyfile.fault = 0

  • trunk/ippTools/share/stacktool_definebyquery_test.sql

    r18609 r19092  
    3030        JOIN rawExp USING(exp_id, tess_id)
    3131    WHERE
    32         warpRun.state = 'stop'
     32        warpRun.state = 'full'
    3333    AND warpSkyfile.ignored = 0
    3434    AND warpSkyfile.fault = 0

  • trunk/ippTools/share/stacktool_find_complete_warps.sql

    r18574 r19092  
    2323    AND stackRun.stack_id = stackInputSkyfile.stack_id
    2424WHERE
    25     warpRun.state = 'stop'
     25    warpRun.state = 'full'
    2626    AND warpSkyfile.ignored = 0
    2727GROUP BY

  • trunk/ippTools/share/stacktool_inputskyfile.sql

    r18029 r19092  
    2222    ON chipProcessedImfile.exp_id = rawExp.exp_id
    2323WHERE
    24     stackRun.state = 'run'
     24    stackRun.state = 'new'

  • trunk/ippTools/share/stacktool_sumskyfile.sql

    r18975 r19092  
    2020WHERE
    2121-- bogus test; just here so there there is a 'WHERE' stmt to append conditionals too
     22-- XXX EAM : this is not needed : fix the stacktool code.
    2223    stackRun.stack_id is NOT NULL

  • trunk/ippTools/share/stacktool_tosum.sql

    r18483 r19092  
    2525    USING(stack_id)
    2626WHERE
    27     stackRun.state = 'run'
     27    stackRun.state = 'new'
    2828    AND stackSumSkyfile.stack_id IS NULL

  • trunk/ippTools/share/warptool_exp.sql

    r18029 r19092  
    55    USING(fake_id)
    66WHERE
    7     warpRun.state = 'run'
    8     AND fakeRun.state = 'stop'
     7    warpRun.state = 'new'
     8    AND fakeRun.state = 'full'

  • trunk/ippTools/share/warptool_imfile.sql

    r18448 r19092  
    2121    AND chipProcessedImfile.class_id = rawImfile.class_id
    2222WHERE
    23     warpRun.state = 'run'
    24     AND fakeRun.state = 'stop'
    25     AND camRun.state = 'stop'
     23    warpRun.state = 'new'
     24    AND fakeRun.state = 'full'
     25    AND camRun.state = 'full'
    2626    AND chipRun.state = 'full'
    2727

  • trunk/ippTools/share/warptool_scmap.sql

    r18448 r19092  
    1919    AND warpSkyCellMap.class_id = chipProcessedImfile.class_id
    2020WHERE
    21 --    warpRun.state = 'run'
    22     fakeRun.state = 'stop'
    23     AND camRun.state = 'stop'
     21--    warpRun.state = 'new'
     22    fakeRun.state = 'full'
     23    AND camRun.state = 'full'
    2424    AND chipRun.state = 'full'

  • trunk/ippTools/share/warptool_tooverlap.sql

    r18915 r19092  
    2323    ON warpRun.label = warpMask.label
    2424WHERE
    25     warpRun.state = 'run'
    26     AND fakeRun.state = 'stop'
    27     AND camRun.state = 'stop'
     25    warpRun.state = 'new'
     26    AND fakeRun.state = 'full'
     27    AND camRun.state = 'full'
    2828    AND chipRun.state = 'full'
    2929    AND warpSkyCellMap.warp_id IS NULL

  • trunk/ippTools/share/warptool_towarped.sql

    r18448 r19092  
    2727    ON warpRun.label = warpMask.label
    2828WHERE
    29     warpRun.state = 'run'
    30     AND fakeRun.state = 'stop'
    31     AND camRun.state = 'stop'
     29    warpRun.state = 'new'
     30    AND fakeRun.state = 'full'
     31    AND camRun.state = 'full'
    3232    AND chipRun.state = 'full'
    3333    AND warpSkyfile.warp_id IS NULL

  • trunk/ippTools/share/warptool_warped.sql

    r18975 r19092  
    1717WHERE
    1818-- bogus test; just here so there there is a 'WHERE' stmt to append conditionals too
     19-- XXX EAM : not needed: fix warptool.c
    1920    warpRun.warp_id is NOT NULL

  • trunk/ippTools/src/Makefile.am

    r18765 r19092  
    173173    dettool.c \
    174174    dettoolConfig.c \
    175     dettool_correction.c
     175    dettool_correction.c \
     176    dettool_detrunsummary.c \
     177    dettool_normalizedexp.c \
     178    dettool_normalizedimfile.c \
     179    dettool_normalizedstat.c \
     180    dettool_processedexp.c \
     181    dettool_processedimfile.c \
     182    dettool_residexp.c \
     183    dettool_residimfile.c \
     184    dettool_stack.c
    176185
    177186detselect_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)

  • trunk/ippTools/src/camtool.c

    r18561 r19092  
    4141static bool maskedMode(pxConfig *config);
    4242static bool unblockMode(pxConfig *config);
     43static bool pendingcleanuprunMode(pxConfig *config);
     44static bool pendingcleanupexpMode(pxConfig *config);
     45static bool donecleanupMode(pxConfig *config);
    4346
    4447# define MODECASE(caseName, func) \
    … …  
    7174        MODECASE(CAMTOOL_MODE_MASKED,               maskedMode);
    7275        MODECASE(CAMTOOL_MODE_UNBLOCK,              unblockMode);
     76        MODECASE(CAMTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunMode);
     77        MODECASE(CAMTOOL_MODE_PENDINGCLEANUPEXP,    pendingcleanupexpMode);
     78        MODECASE(CAMTOOL_MODE_DONECLEANUP,          donecleanupMode);
    7379        default:
    7480            psAbort("invalid option (this should not happen)");
    … …  
    570576
    571577    // since there is only one exp per 'run' set camRun.state = 'stop'
    572     if (!pxcamRunSetState(config, row->cam_id, "stop")) {
     578    if (!pxcamRunSetState(config, row->cam_id, "full")) {
    573579        psError(PS_ERR_UNKNOWN, false, "failed to change camRun.state for cam_id: %" PRId64, row->cam_id);
    574580        psFree(row);
    … …  
    914920    return true;
    915921}
     922
     923static bool pendingcleanuprunMode(pxConfig *config)
     924{
     925    PS_ASSERT_PTR_NON_NULL(config, NULL);
     926
     927    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     928    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     929
     930    psMetadata *where = psMetadataAlloc();
     931    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     932
     933    psString query = pxDataGet("camtool_pendingcleanuprun.sql");
     934    if (!query) {
     935        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     936        return false;
     937    }
     938
     939    if (where && psListLength(where->list)) {
     940        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     941        psStringAppend(&query, " AND %s", whereClause);
     942        psFree(whereClause);
     943    }
     944    psFree(where);
     945
     946    // treat limit == 0 as "no limit"
     947    if (limit) {
     948        psString limitString = psDBGenerateLimitSQL(limit);
     949        psStringAppend(&query, " %s", limitString);
     950        psFree(limitString);
     951    }
     952
     953    if (!p_psDBRunQuery(config->dbh, query)) {
     954        psError(PS_ERR_UNKNOWN, false, "database error");
     955        psFree(query);
     956        return false;
     957    }
     958    psFree(query);
     959
     960    psArray *output = p_psDBFetchResult(config->dbh);
     961    if (!output) {
     962        psError(PS_ERR_UNKNOWN, false, "database error");
     963        return false;
     964    }
     965    if (!psArrayLength(output)) {
     966        psTrace("camtool", PS_LOG_INFO, "no rows found");
     967        psFree(output);
     968        return true;
     969    }
     970
     971    // negative simple so the default is true
     972    if (!ippdbPrintMetadatas(stdout, output, "camPendingCleanupRun", !simple)) {
     973        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     974        psFree(output);
     975        return false;
     976    }
     977
     978    psFree(output);
     979
     980    return true;
     981}
     982
     983
     984static bool pendingcleanupexpMode(pxConfig *config)
     985{
     986    PS_ASSERT_PTR_NON_NULL(config, NULL);
     987
     988    PXOPT_LOOKUP_S64(cam_id, config->args, "-cam_id", false, false);
     989    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     990    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     991
     992    psMetadata *where = psMetadataAlloc();
     993    if (cam_id) {
     994        PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     995    }
     996    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     997
     998    psString query = pxDataGet("camtool_pendingcleanupexp.sql");
     999    if (!query) {
     1000        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1001        return false;
     1002    }
     1003
     1004    if (where && psListLength(where->list)) {
     1005        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1006        psStringAppend(&query, " AND %s", whereClause);
     1007        psFree(whereClause);
     1008    }
     1009    psFree(where);
     1010
     1011    // treat limit == 0 as "no limit"
     1012    if (limit) {
     1013        psString limitString = psDBGenerateLimitSQL(limit);
     1014        psStringAppend(&query, " %s", limitString);
     1015        psFree(limitString);
     1016    }
     1017
     1018    if (!p_psDBRunQuery(config->dbh, query)) {
     1019        psError(PS_ERR_UNKNOWN, false, "database error");
     1020        psFree(query);
     1021        return false;
     1022    }
     1023    psFree(query);
     1024
     1025    psArray *output = p_psDBFetchResult(config->dbh);
     1026    if (!output) {
     1027        psError(PS_ERR_UNKNOWN, false, "database error");
     1028        return false;
     1029    }
     1030    if (!psArrayLength(output)) {
     1031        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1032        psFree(output);
     1033        return true;
     1034    }
     1035
     1036    // negative simple so the default is true
     1037    if (!ippdbPrintMetadatas(stdout, output, "camPendingCleanupExp", !simple)) {
     1038        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1039        psFree(output);
     1040        return false;
     1041    }
     1042
     1043    psFree(output);
     1044
     1045    return true;
     1046}
     1047
     1048
     1049static bool donecleanupMode(pxConfig *config)
     1050{
     1051    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1052
     1053    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1054    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1055
     1056    psMetadata *where = psMetadataAlloc();
     1057    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1058
     1059    psString query = pxDataGet("camtool_donecleanup.sql");
     1060    if (!query) {
     1061        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1062        return false;
     1063    }
     1064
     1065    if (where && psListLength(where->list)) {
     1066        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1067        psStringAppend(&query, " AND %s", whereClause);
     1068        psFree(whereClause);
     1069    }
     1070    psFree(where);
     1071
     1072    // treat limit == 0 as "no limit"
     1073    if (limit) {
     1074        psString limitString = psDBGenerateLimitSQL(limit);
     1075        psStringAppend(&query, " %s", limitString);
     1076        psFree(limitString);
     1077    }
     1078
     1079    if (!p_psDBRunQuery(config->dbh, query)) {
     1080        psError(PS_ERR_UNKNOWN, false, "database error");
     1081        psFree(query);
     1082        return false;
     1083    }
     1084    psFree(query);
     1085
     1086    psArray *output = p_psDBFetchResult(config->dbh);
     1087    if (!output) {
     1088        psError(PS_ERR_UNKNOWN, false, "database error");
     1089        return false;
     1090    }
     1091    if (!psArrayLength(output)) {
     1092        psTrace("camtool", PS_LOG_INFO, "no rows found");
     1093        psFree(output);
     1094        return true;
     1095    }
     1096
     1097    // negative simple so the default is true
     1098    if (!ippdbPrintMetadatas(stdout, output, "camDoneCleanup", !simple)) {
     1099        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1100        psFree(output);
     1101        return false;
     1102    }
     1103
     1104    psFree(output);
     1105
     1106    return true;
     1107}

  • trunk/ippTools/src/camtool.h

    r18093 r19092  
    3535    CAMTOOL_MODE_BLOCK,
    3636    CAMTOOL_MODE_MASKED,
    37     CAMTOOL_MODE_UNBLOCK
     37    CAMTOOL_MODE_UNBLOCK,
     38    CAMTOOL_MODE_PENDINGCLEANUPRUN,
     39    CAMTOOL_MODE_PENDINGCLEANUPEXP,
     40    CAMTOOL_MODE_DONECLEANUP,
    3841} camtoolMode;
    3942

  • trunk/ippTools/src/camtoolConfig.c

    r18561 r19092  
    274274    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    275275
     276    // -pendingcleanuprun
     277    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     278    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     279    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     280    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     281
     282    // -pendingcleanupexp
     283    psMetadata *pendingcleanupexpArgs = psMetadataAlloc();
     284    psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     285    psMetadataAddS64(pendingcleanupexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camera ID", 0);
     286    psMetadataAddStr(pendingcleanupexpArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
     287    psMetadataAddBool(pendingcleanupexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     288    psMetadataAddU64(pendingcleanupexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     289
     290    // -donecleanup
     291    psMetadata *donecleanupArgs = psMetadataAlloc();
     292    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     293    psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     294    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     295
    276296    psMetadata *argSets = psMetadataAlloc();
    277297    psMetadata *modes = psMetadataAlloc();
    278298
    279     PXOPT_ADD_MODE("-definebyquery",       "", CAMTOOL_MODE_DEFINEBYQUERY, definebydefinebyqueryArgs);
    280     PXOPT_ADD_MODE("-updaterun",           "", CAMTOOL_MODE_UPDATERUN,      updaterunArgs);
    281     PXOPT_ADD_MODE("-pendingexp",          "", CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
    282     PXOPT_ADD_MODE("-pendingimfile",       "", CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    283     PXOPT_ADD_MODE("-addprocessedexp",     "", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    284     PXOPT_ADD_MODE("-processedexp",        "", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
    285     PXOPT_ADD_MODE("-revertprocessedexp",  "", CAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
    286     PXOPT_ADD_MODE("-updateprocessedexp",  "", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
    287     PXOPT_ADD_MODE("-block",               "", CAMTOOL_MODE_BLOCK,         blockArgs);
    288     PXOPT_ADD_MODE("-masked",              "", CAMTOOL_MODE_MASKED,        maskedArgs);
    289     PXOPT_ADD_MODE("-unblock",             "", CAMTOOL_MODE_UNBLOCK,       unblockArgs);
     299    PXOPT_ADD_MODE("-definebyquery",        "create runs from chip stage",          CAMTOOL_MODE_DEFINEBYQUERY, definebydefinebyqueryArgs);
     300    PXOPT_ADD_MODE("-updaterun",            "change cam run properties",            CAMTOOL_MODE_UPDATERUN,      updaterunArgs);
     301    PXOPT_ADD_MODE("-pendingexp",           "show pending exposures",               CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
     302    PXOPT_ADD_MODE("-pendingimfile",        "show pending imfiles",                 CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     303    PXOPT_ADD_MODE("-addprocessedexp",      "add a processed exposure",             CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     304    PXOPT_ADD_MODE("-processedexp",         "show processed exposures",             CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
     305    PXOPT_ADD_MODE("-revertprocessedexp",   "change procesed exp properties",       CAMTOOL_MODE_REVERTPROCESSEDEXP,  revertprocessedexpArgs);
     306    PXOPT_ADD_MODE("-updateprocessedexp",   "undo a processed exposure",            CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
     307    PXOPT_ADD_MODE("-block",                "set a label block",                    CAMTOOL_MODE_BLOCK,         blockArgs);
     308    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  CAMTOOL_MODE_MASKED,        maskedArgs);
     309    PXOPT_ADD_MODE("-unblock",              "remove a label block",                 CAMTOOL_MODE_UNBLOCK,       unblockArgs);
     310    PXOPT_ADD_MODE("-pendingcleanuprun",    "show runs that need to be cleaned up", CAMTOOL_MODE_PENDINGCLEANUPRUN, pendingcleanuprunArgs);
     311    PXOPT_ADD_MODE("-pendingcleanupexp",    "show exposures for cleanup runs",      CAMTOOL_MODE_PENDINGCLEANUPEXP, pendingcleanupexpArgs);
     312    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CAMTOOL_MODE_DONECLEANUP,       donecleanupArgs);
    290313
    291314    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/chiptoolConfig.c

    r18976 r19092  
    280280    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    281281
    282     // -pendingcleanupifmile
     282    // -pendingcleanupimfile
    283283    psMetadata *pendingcleanupimfileArgs = psMetadataAlloc();
    284284    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
    285     psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-chip_id", 0,
    286         "search by chip ID", 0);
     285    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-chip_id", 0,          "search by chip ID", 0);
    287286    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-exp_id",                 0,            "search by exp_id", NULL);
    288287    psMetadataAddBool(pendingcleanupimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    289288    psMetadataAddU64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    290289
    291     // -doneclenaup
     290    // -donecleanup
    292291    psMetadata *donecleanupArgs = psMetadataAlloc();
    293292    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);

  • trunk/ippTools/src/dettool.c

    r18561 r19092  
    2828static bool inputMode(pxConfig *config);
    2929static bool rawMode(pxConfig *config);
    30 // processedimfile
    31 static bool toprocessedimfileMode(pxConfig *config);
    32 static bool addprocessedimfileMode(pxConfig *config);
    33 static bool processedimfileMode(pxConfig *config);
    34 static bool revertprocessedimfileMode(pxConfig *config);
    35 // processedexp
    36 static bool toprocessedexpMode(pxConfig *config);
    37 static bool addprocessedexpMode(pxConfig *config);
    38 static bool processedexpMode(pxConfig *config);
    39 static bool revertprocessedexpMode(pxConfig *config);
    40 // stackedimfile
    41 static bool tostackedMode(pxConfig *config);
    42 static bool addstackedMode(pxConfig *config);
    43 static bool stackedMode(pxConfig *config);
    44 static bool revertstackedMode(pxConfig *config);
    45 // normalizedstat
    46 static bool tonormalizedstatMode(pxConfig *config);
    47 static bool addnormalizedstatMode(pxConfig *config);
    48 static bool normalizedstatMode(pxConfig *config);
    49 static bool revertnormalizedstatMode(pxConfig *config);
    50 // normalizedimfile
    51 static bool tonormalizeMode(pxConfig *config);
    52 static bool addnormalizedimfileMode(pxConfig *config);
    53 static bool normalizedimfileMode(pxConfig *config);
    54 static bool revertnormalizedimfileMode(pxConfig *config);
    55 // normalizedexp
    56 static bool tonormalizedexpMode(pxConfig *config);
    57 static bool addnormalizedexpMode(pxConfig *config);
    58 static bool normalizedexpMode(pxConfig *config);
    59 static bool revertnormalizedexpMode(pxConfig *config);
    60 // residimfile
    61 static bool toresidimfileMode(pxConfig *config);
    62 static bool addresidimfileMode(pxConfig *config);
    63 static bool residimfileMode(pxConfig *config);
    64 static bool revertresidimfileMode(pxConfig *config);
    65 // residexp
    66 static bool toresidexpMode(pxConfig *config);
    67 static bool addresidexpMode(pxConfig *config);
    68 static bool residexpMode(pxConfig *config);
    69 static bool revertresidexpMode(pxConfig *config);
    70 static bool updateresidexpMode(pxConfig *config);
    71 // detrunsummary
    72 static bool todetrunsummaryMode(pxConfig *config);
    73 static bool adddetrunsummaryMode(pxConfig *config);
    74 static bool detrunsummaryMode(pxConfig *config);
    75 static bool revertdetrunsummaryMode(pxConfig *config);
    76 static bool updatedetrunsummaryMode(pxConfig *config);
     30
    7731// run
    7832static bool updatedetrunMode(pxConfig *config);
    … …  
    8135static bool register_detrendMode(pxConfig *config);
    8236
    83 static detRunSummaryRow *mdToDetRunSummary(pxConfig *config, psMetadata *row);
    8437//static psArray *validDetInputClassIds(pxConfig *config, const char *det_id);
    8538//static psArray *searchInputImfiles(pxConfig *config, const char *det_id);
    8639static detInputExpRow *rawDetrenTodetInputExpRow(rawExpRow *rawExp, psS64 det_id, psS32 iteration);
    87 static psArray *searchRawImfiles(pxConfig *config);
    88 static bool startNewIteration(pxConfig *config, psS64 det_id);
    8940static psS32 incrementIteration(pxConfig *config, psS64 det_id);
    90 static bool setDetRunState(pxConfig *config, psS64 det_id, const char *state);
    91 static bool isValidMode(pxConfig *config, const char *mode);
    9241
    9342# define MODECASE(caseName, func) \
    … …  
    12776        MODECASE(DETTOOL_MODE_PROCESSEDIMFILE,  processedimfileMode);
    12877        MODECASE(DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileMode);
     78        MODECASE(DETTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
     79        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE, pendingcleanup_processedimfileMode);
     80        MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE, donecleanup_processedimfileMode);
    12981        // exp
    13082        MODECASE(DETTOOL_MODE_TOPROCESSEDEXP,   toprocessedexpMode);
    … …  
    13284        MODECASE(DETTOOL_MODE_PROCESSEDEXP,     processedexpMode);
    13385        MODECASE(DETTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpMode);
     86        MODECASE(DETTOOL_MODE_UPDATEPROCESSEDEXP, updateprocessedexpMode);
     87        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpMode);
     88        MODECASE(DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpMode);
    13489        // stacked
    13590        MODECASE(DETTOOL_MODE_TOSTACKED,        tostackedMode);
    … …  
    13792        MODECASE(DETTOOL_MODE_STACKED,          stackedMode);
    13893        MODECASE(DETTOOL_MODE_REVERTSTACKED,    revertstackedMode);
     94        MODECASE(DETTOOL_MODE_UPDATESTACKED,    updatestackedMode);
     95        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_STACKED, pendingcleanup_stackedMode);
     96        MODECASE(DETTOOL_MODE_DONECLEANUP_STACKED, donecleanup_stackedMode);
    13997        // normalizedstat
    14098        MODECASE(DETTOOL_MODE_TONORMALIZEDSTAT, tonormalizedstatMode);
    … …  
    142100        MODECASE(DETTOOL_MODE_NORMALIZEDSTAT,   normalizedstatMode);
    143101        MODECASE(DETTOOL_MODE_REVERTNORMALIZEDSTAT, revertnormalizedstatMode);
     102        MODECASE(DETTOOL_MODE_UPDATENORMALIZEDSTAT, updatenormalizedstatMode);
     103        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDSTAT, pendingcleanup_normalizedstatMode);
     104        MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDSTAT, donecleanup_normalizedstatMode);
    144105        // normalizedimfile
    145106        MODECASE(DETTOOL_MODE_TONORMALIZE,      tonormalizeMode);
    … …  
    147108        MODECASE(DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileMode);
    148109        MODECASE(DETTOOL_MODE_REVERTNORMALIZEDIMFILE, revertnormalizedimfileMode);
     110        MODECASE(DETTOOL_MODE_UPDATENORMALIZEDIMFILE, updatenormalizedimfileMode);
     111        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDIMFILE, pendingcleanup_normalizedimfileMode);
     112        MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDIMFILE, donecleanup_normalizedimfileMode);
    149113        // normalizedexp
    150114        MODECASE(DETTOOL_MODE_TONORMALIZEDEXP,  tonormalizedexpMode);
    … …  
    152116        MODECASE(DETTOOL_MODE_NORMALIZEDEXP,    normalizedexpMode);
    153117        MODECASE(DETTOOL_MODE_REVERTNORMALIZEDEXP, revertnormalizedexpMode);
     118        MODECASE(DETTOOL_MODE_UPDATENORMALIZEDEXP, updatenormalizedexpMode);
     119        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDEXP, pendingcleanup_normalizedexpMode);
     120        MODECASE(DETTOOL_MODE_DONECLEANUP_NORMALIZEDEXP, donecleanup_normalizedexpMode);
    154121        // residimfile
    155122        MODECASE(DETTOOL_MODE_TORESIDIMFILE,    toresidimfileMode);
    … …  
    157124        MODECASE(DETTOOL_MODE_RESIDIMFILE,      residimfileMode);
    158125        MODECASE(DETTOOL_MODE_REVERTRESIDIMFILE,revertresidimfileMode);
     126        MODECASE(DETTOOL_MODE_UPDATERESIDIMFILE, updateresidimfileMode);
     127        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDIMFILE, pendingcleanup_residimfileMode);
     128        MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDIMFILE, donecleanup_residimfileMode);
    159129        // residexp
    160130        MODECASE(DETTOOL_MODE_TORESIDEXP,       toresidexpMode);
    … …  
    163133        MODECASE(DETTOOL_MODE_REVERTRESIDEXP,   revertresidexpMode);
    164134        MODECASE(DETTOOL_MODE_UPDATERESIDEXP,   updateresidexpMode);
     135        MODECASE(DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpMode);
     136        MODECASE(DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpMode);
    165137        // detrunsummary
    166138        MODECASE(DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryMode);
    … …  
    208180   
    209181    psMetadata *where = psMetadataAlloc();
    210     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
     182    PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
    211183    PXOPT_COPY_STR(config->args, where, "-exp_type", "exp_type", "==");
    212184    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    722694
    723695   
    724     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     696    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    725697    PXOPT_LOOKUP_STR(det_type, config->args, "-set_det_type", false, false); // optional
    726698    PXOPT_LOOKUP_STR(mode, config->args, "-set_mode", false, false); // optional
    … …  
    758730    {
    759731        psMetadata *where = psMetadataAlloc();
    760         psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", (psS64)atoll(det_id));
     732        psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", det_id);
    761733        detRuns = detRunSelectRowObjects(config->dbh, where, 0);
    762734        psFree(where);
    … …  
    768740    // sanity check the result... we should have only found one det_id
    769741    if (psArrayLength(detRuns) != 1) {
    770         psAbort("found more then one detRun matching det_id %" PRId64 " (this should not happen)", (psS64)atoll(det_id));
     742        psAbort("found more then one detRun matching det_id %" PRId64 " (this should not happen)", det_id);
    771743        return false;                   // unreachable
    772744    }
    … …  
    939911    psFree(time_filter);
    940912
    941     if (!p_psDBRunQuery(config->dbh, query, (psS64)newDet_id, (psS64)atoll(det_id))) {
     913    if (!p_psDBRunQuery(config->dbh, query, (long long) newDet_id, (long long) det_id)) {
    942914        psError(PS_ERR_UNKNOWN, false, "database error");
    943915        psFree(query);
    … …  
    987959    psMetadata *where = psMetadataAlloc();
    988960    PXOPT_COPY_STR(config->args, where, "-det_type", "det_type", "==");
    989     PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
     961    PXOPT_COPY_S64(config->args, where, "-det_id",   "det_id", "==");
    990962
    991963    PXOPT_COPY_STR(config->args, where, "-inst", "camera", "==");
    … …  
    11521124
    11531125    psMetadata *where = psMetadataAlloc();
    1154     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
     1126    PXOPT_COPY_S64(config->args, where, "-det_id",    "det_id", "==");
    11551127    PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    11561128    PXOPT_COPY_S64(config->args, where, "-exp_id",    "exp_id", "==");
    … …  
    12511223}
    12521224
    1253 static bool toprocessedimfileMode(pxConfig *config)
    1254 {
    1255     PS_ASSERT_PTR_NON_NULL(config, false);
    1256 
    1257     psMetadata *where = psMetadataAlloc();
    1258     PXOPT_COPY_STR(config->args, where, "-det_id",   "det_id", "==");
    1259     PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
    1260     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    1261 
    1262     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1263     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1264 
    1265     psString query = pxDataGet("dettool_toprocessedimfile.sql");
    1266     if (!query) {
    1267         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1268         return false;
    1269     }
    1270 
    1271     if (psListLength(where->list)) {
    1272         psString whereClause = psDBGenerateWhereConditionSQL(where, "rawImfile");
    1273         psStringAppend(&query, " AND %s", whereClause);
    1274         psFree(whereClause);
    1275     }
    1276     psFree (where);
    1277 
    1278     // treat limit == 0 as "no limit"
    1279     if (limit) {
    1280         psString limitString = psDBGenerateLimitSQL(limit);
    1281         psStringAppend(&query, " %s", limitString);
    1282         psFree(limitString);
    1283     }
    1284 
    1285     if (!p_psDBRunQuery(config->dbh, query)) {
    1286         psError(PS_ERR_UNKNOWN, false, "database error");
    1287         psFree(query);
    1288         return false;
    1289     }
    1290     psFree(query);
    1291 
    1292     psArray *output = p_psDBFetchResult(config->dbh);
    1293     if (!output) {
    1294         psError(PS_ERR_UNKNOWN, false, "database error");
    1295         return false;
    1296     }
    1297     if (!psArrayLength(output)) {
    1298         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1299         psFree(output);
    1300         return true;
    1301     }
    1302 
    1303     // negative simple so the default is true
    1304     if (!ippdbPrintMetadatas(stdout, output, "detPendingProcessedImfile", !simple)) {
    1305         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1306         psFree(output);
    1307         return false;
    1308     }
    1309 
    1310     psFree(output);
    1311 
    1312     return true;
    1313 }
    1314 
    1315 static bool addprocessedimfileMode(pxConfig *config)
    1316 {
    1317     PS_ASSERT_PTR_NON_NULL(config, false);
    1318 
    1319     // det_id, exp_id, class_id, uri, recipe, -bg, -bg_stdev are required
    1320     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    1321     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    1322     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    1323 
    1324     // default values
    1325     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    1326 
    1327     // Required if code == 0
    1328     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    1329     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    1330 
    1331     // optional
    1332     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    1333     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    1334     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    1335     PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    1336     PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    1337     PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
    1338     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    1339     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    1340     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    1341     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    1342     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    1343     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    1344 
    1345     // find the matching rawImfile by exp_id/class_id
    1346     psMetadata *where = psMetadataAlloc();
    1347     PXOPT_COPY_STR(config->args, where, "-exp_id",   "exp_id", "==");
    1348     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    1349 
    1350     psArray *rawImfiles = rawImfileSelectRowObjects(config->dbh, where, 0);
    1351     psFree(where);
    1352 
    1353     if (!rawImfiles) {
    1354         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found ");
    1355         return false;
    1356     }
    1357 
    1358     // create a new detProcessedImfile object
    1359     detProcessedImfileRow *detRow = detProcessedImfileRowAlloc(
    1360         (psS64)atoll(det_id),
    1361         (psS64)atoll(exp_id),
    1362         class_id,
    1363         uri,
    1364         recipe,
    1365         bg,
    1366         bg_stdev,
    1367         bg_mean_stdev,
    1368         fringe_0,
    1369         fringe_1,
    1370         fringe_2,
    1371         user_1,
    1372         user_2,
    1373         user_3,
    1374         user_4,
    1375         user_5,
    1376         path_base,
    1377         code
    1378     );
    1379     psFree(rawImfiles);
    1380 
    1381     // insert the new row into the detProcessedImfile table
    1382     if (!detProcessedImfileInsertObject(config->dbh, detRow)) {
    1383         psError(PS_ERR_UNKNOWN, false, "database error");
    1384         psFree(detRow);
    1385         return false;
    1386     }
    1387 
    1388     psFree(detRow);
    1389 
    1390     return true;
    1391 }
    1392 
    1393 static bool processedimfileMode(pxConfig *config)
    1394 {
    1395     PS_ASSERT_PTR_NON_NULL(config, false);
    1396 
    1397     char *value = NULL;
    1398 
    1399     PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
    1400     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    1401     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1402     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1403 
    1404     psMetadata *where = psMetadataAlloc();
    1405     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    1406     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    1407     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    1408 
    1409     psString query = pxDataGet("dettool_processedimfile.sql");
    1410     if (!query) {
    1411         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1412         psFree(where);
    1413         return false;
    1414     }
    1415 
    1416     // add the two required restrictions: detRun.state and detRun.mode
    1417     // NOTE the above query requires one of the following two WHERE statements
    1418     {
    1419         bool status;
    1420         if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    1421             psStringAppend(&query, " WHERE detRun.state = '%s'", value);
    1422         } else {
    1423             psStringAppend(&query, " WHERE detRun.state = 'run'");
    1424         }
    1425         if ((value = psMetadataLookupStr(&status, config->args, "-select_mode"))) {
    1426             psStringAppend(&query, " AND detRun.mode = '%s'", value);
    1427         } else {
    1428             psStringAppend(&query, " AND detRun.mode = 'master'");
    1429         }
    1430     }
    1431 
    1432     if (psListLength(where->list)) {
    1433         psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
    1434         psStringAppend(&query, " AND %s", whereClause);
    1435         psFree(whereClause);
    1436     }
    1437     psFree (where);
    1438 
    1439     // restrict search to included imfiles
    1440     if (included) {
    1441         psStringAppend(&query, " AND detInputExp.include = 1");
    1442     }
    1443 
    1444     if (faulted) {
    1445         // list only faulted rows
    1446         psStringAppend(&query, " %s", "AND detProcessedImfile.fault != 0");
    1447     } else {
    1448         // don't list faulted rows
    1449         psStringAppend(&query, " %s", "AND detProcessedImfile.fault = 0");
    1450     }
    1451 
    1452     // treat limit == 0 as "no limit"
    1453     if (limit) {
    1454         psString limitString = psDBGenerateLimitSQL(limit);
    1455         psStringAppend(&query, " %s", limitString);
    1456         psFree(limitString);
    1457     }
    1458 
    1459     if (!p_psDBRunQuery(config->dbh, query)) {
    1460         psError(PS_ERR_UNKNOWN, false, "database error");
    1461         psFree(query);
    1462         return false;
    1463     }
    1464     psFree(query);
    1465 
    1466     psArray *output = p_psDBFetchResult(config->dbh);
    1467     if (!output) {
    1468         psError(PS_ERR_UNKNOWN, false, "database error");
    1469         return false;
    1470     }
    1471     if (!psArrayLength(output)) {
    1472         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1473         psFree(output);
    1474         return true;
    1475     }
    1476 
    1477     // negative simple so the default is true
    1478     if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    1479         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1480         psFree(output);
    1481         return false;
    1482     }
    1483 
    1484     psFree(output);
    1485 
    1486     return true;
    1487 }
    1488 
    1489 static bool revertprocessedimfileMode(pxConfig *config)
    1490 {
    1491     PS_ASSERT_PTR_NON_NULL(config, false);
    1492 
    1493     psMetadata *where = psMetadataAlloc();
    1494     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    1495     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    1496     PXOPT_COPY_STR(config->args, where, "-class_id", "class_id", "==");
    1497     PXOPT_COPY_S16(config->args, where, "-code", "fault", "==");
    1498 
    1499     psString query = pxDataGet("dettool_revertprocessedimfile.sql");
    1500     if (!query) {
    1501         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1502         return false;
    1503     }
    1504 
    1505     if (psListLength(where->list)) {
    1506         psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedImfile");
    1507         psStringAppend(&query, " AND %s", whereClause);
    1508         psFree(whereClause);
    1509     }
    1510     psFree(where);
    1511 
    1512     if (!p_psDBRunQuery(config->dbh, query)) {
    1513         psError(PS_ERR_UNKNOWN, false, "database error");
    1514         psFree(query);
    1515         return false;
    1516     }
    1517     psFree(query);
    1518 
    1519     if (psDBAffectedRows(config->dbh) < 1) {
    1520         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1521         return false;
    1522     }
    1523 
    1524     return true;
    1525 }
    1526 
    1527 static bool toprocessedexpMode(pxConfig *config)
    1528 {
    1529     PS_ASSERT_PTR_NON_NULL(config, false);
    1530 
    1531     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1532     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1533 
    1534     psString query = pxDataGet("dettool_toprocessedexp.sql");
    1535     if (!query) {
    1536         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1537         return false;
    1538     }
    1539 
    1540     // treat limit == 0 as "no limit"
    1541     if (limit) {
    1542         psString limitString = psDBGenerateLimitSQL(limit);
    1543         psStringAppend(&query, " %s", limitString);
    1544         psFree(limitString);
    1545     }
    1546 
    1547     if (!p_psDBRunQuery(config->dbh, query)) {
    1548         psError(PS_ERR_UNKNOWN, false, "database error");
    1549         psFree(query);
    1550         return false;
    1551     }
    1552     psFree(query);
    1553 
    1554     psArray *output = p_psDBFetchResult(config->dbh);
    1555     if (!output) {
    1556         psError(PS_ERR_UNKNOWN, false, "database error");
    1557         return false;
    1558     }
    1559     if (!psArrayLength(output)) {
    1560         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1561         psFree(output);
    1562         return true;
    1563     }
    1564 
    1565     // negative simple so the default is true
    1566     if (!ippdbPrintMetadatas(stdout, output, "detPendingProcessedExp", !simple)) {
    1567         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1568         psFree(output);
    1569         return false;
    1570     }
    1571 
    1572     psFree(output);
    1573 
    1574     return true;
    1575 }
    1576 
    1577 static bool addprocessedexpMode(pxConfig *config)
    1578 {
    1579     PS_ASSERT_PTR_NON_NULL(config, false);
    1580 
    1581     // det_id, exp_id, recip, -bg, -bg_stdev
    1582     // are required
    1583     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    1584     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false);
    1585 
    1586     // default values
    1587     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    1588 
    1589     // Required if code == 0
    1590     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    1591 
    1592     // optional
    1593     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    1594     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    1595     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    1596     PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    1597     PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    1598     PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
    1599     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    1600     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    1601     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    1602     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    1603     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    1604     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", true, false);
    1605 
    1606     psString query = pxDataGet("dettool_addprocessedexp.sql");
    1607     if (!query) {
    1608         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1609         return false;
    1610     }
    1611 
    1612     if (!p_psDBRunQuery(config->dbh, query, det_id, exp_id)) {
    1613         psError(PS_ERR_UNKNOWN, false, "database error");
    1614         psFree(query);
    1615         return false;
    1616     }
    1617     psFree(query);
    1618 
    1619     psArray *output = p_psDBFetchResult(config->dbh);
    1620     if (!output) {
    1621         psError(PS_ERR_UNKNOWN, false, "database error");
    1622         return false;
    1623     }
    1624     if (!psArrayLength(output)) {
    1625         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1626         psFree(output);
    1627         return true;
    1628     }
    1629     psFree(output);
    1630 
    1631     // create a new detProcessedImfile object
    1632     detProcessedExpRow *detRow = detProcessedExpRowAlloc(
    1633         (psS64)atoll(det_id),
    1634         (psS64)atoll(exp_id),
    1635         recipe,
    1636         bg,
    1637         bg_stdev,
    1638         bg_mean_stdev,
    1639         fringe_0,
    1640         fringe_1,
    1641         fringe_2,
    1642         user_1,
    1643         user_2,
    1644         user_3,
    1645         user_4,
    1646         user_5,
    1647         path_base,
    1648         code
    1649     );
    1650 
    1651     // insert the new row into the detProcessedImfile table
    1652     if (!detProcessedExpInsertObject(config->dbh, detRow)) {
    1653         psError(PS_ERR_UNKNOWN, false, "database error");
    1654         psFree(detRow);
    1655         return false;
    1656     }
    1657 
    1658     psFree(detRow);
    1659 
    1660     return true;
    1661 }
    1662 
    1663 static bool processedexpMode(pxConfig *config)
    1664 {
    1665     PS_ASSERT_PTR_NON_NULL(config, false);
    1666 
    1667     psMetadata *where = psMetadataAlloc();
    1668     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    1669     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    1670 
    1671     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1672     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    1673     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1674 
    1675     psString query = psStringCopy("SELECT * FROM detProcessedExp");
    1676 
    1677     if (psListLength(where->list)) {
    1678         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1679         psStringAppend(&query, " %s", whereClause);
    1680         psFree(whereClause);
    1681     }
    1682     psFree(where);
    1683 
    1684     if (faulted) {
    1685         // list only faulted rows
    1686         psStringAppend(&query, " %s", "AND detProcessedExp.fault != 0");
    1687     } else {
    1688         // don't list faulted rows
    1689         psStringAppend(&query, " %s", "AND detProcessedExp.fault = 0");
    1690     }
    1691 
    1692     // treat limit == 0 as "no limit"
    1693     if (limit) {
    1694         psString limitString = psDBGenerateLimitSQL(limit);
    1695         psStringAppend(&query, " %s", limitString);
    1696         psFree(limitString);
    1697     }
    1698 
    1699     if (!p_psDBRunQuery(config->dbh, query)) {
    1700         psError(PS_ERR_UNKNOWN, false, "database error");
    1701         psFree(query);
    1702         return false;
    1703     }
    1704     psFree(query);
    1705 
    1706     psArray *output = p_psDBFetchResult(config->dbh);
    1707     if (!output) {
    1708         psError(PS_ERR_UNKNOWN, false, "database error");
    1709         return false;
    1710     }
    1711     if (!psArrayLength(output)) {
    1712         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1713         psFree(output);
    1714         return true;
    1715     }
    1716 
    1717     // negative simple so the default is true
    1718     if (!ippdbPrintMetadatas(stdout, output, "detProcessedExp", !simple)) {
    1719         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1720         psFree(output);
    1721         return false;
    1722     }
    1723 
    1724     psFree(output);
    1725 
    1726     return true;
    1727 }
    1728 
    1729 
    1730 static bool revertprocessedexpMode(pxConfig *config)
    1731 {
    1732     PS_ASSERT_PTR_NON_NULL(config, false);
    1733 
    1734     psMetadata *where = psMetadataAlloc();
    1735     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    1736     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    1737     PXOPT_COPY_S16(config->args, where, "-code",   "fault", "==");
    1738 
    1739     psString query = pxDataGet("dettool_revertprocessedexp.sql");
    1740     if (!query) {
    1741         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1742         return false;
    1743     }
    1744 
    1745     if (psListLength(where->list)) {
    1746         psString whereClause = psDBGenerateWhereConditionSQL(where, "detProcessedExp");
    1747         psStringAppend(&query, " AND %s", whereClause);
    1748         psFree(whereClause);
    1749     }
    1750     psFree(where);
    1751 
    1752     if (!p_psDBRunQuery(config->dbh, query)) {
    1753         psError(PS_ERR_UNKNOWN, false, "database error");
    1754         psFree(query);
    1755         return false;
    1756     }
    1757     psFree(query);
    1758 
    1759     if (psDBAffectedRows(config->dbh) < 1) {
    1760         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    1761         return false;
    1762     }
    1763 
    1764     return true;
    1765 }
    1766 
    1767 
    1768 static bool tostackedMode(pxConfig *config)
    1769 {
    1770     PS_ASSERT_PTR_NON_NULL(config, false);
    1771 
    1772     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1773     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1774 
    1775     psString query = pxDataGet("dettool_tostacked.sql");
    1776     if (!query) {
    1777         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1778         return false;
    1779     }
    1780 
    1781     // treat limit == 0 as "no limit"
    1782     if (limit) {
    1783         psString limitString = psDBGenerateLimitSQL(limit);
    1784         psStringAppend(&query, " %s", limitString);
    1785         psFree(limitString);
    1786     }
    1787 
    1788     if (!p_psDBRunQuery(config->dbh, query)) {
    1789         psError(PS_ERR_UNKNOWN, false, "database error");
    1790         psFree(query);
    1791         return false;
    1792     }
    1793     psFree(query);
    1794 
    1795     psArray *output = p_psDBFetchResult(config->dbh);
    1796     if (!output) {
    1797         psError(PS_ERR_UNKNOWN, false, "database error");
    1798         return false;
    1799     }
    1800     if (!psArrayLength(output)) {
    1801         psTrace("dettool", PS_LOG_INFO, "no rows found");
    1802         psFree(output);
    1803         return true;
    1804     }
    1805 
    1806     // negative simple so the default is true
    1807     if (!ippdbPrintMetadatas(stdout, output, "detPendingStackedImfile", !simple)) {
    1808         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1809         psFree(output);
    1810         return false;
    1811     }
    1812 
    1813     psFree(output);
    1814 
    1815     return true;
    1816 }
    1817 
    1818 // this is NOT a command-line mode : it is used by 'addstackedMode'
    1819 static psArray *searchRawImfiles(pxConfig *config)
    1820 {
    1821     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1822 
    1823     psMetadata *where = psMetadataAlloc();
    1824     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    1825     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    1826 
    1827     // select exp_ids from detInputExp matching det_id & iteration
    1828     // where query should be pre-generated
    1829     psArray *detInputExp = detInputExpSelectRowObjects(config->dbh, where, 0);
    1830     psFree (where);
    1831 
    1832     if (!detInputExp) {
    1833         psError(PS_ERR_UNKNOWN, false, "no rawExp rows found");
    1834         return NULL;
    1835     }
    1836 
    1837     // generate where query with just the exp_ids
    1838     psMetadata *where_exp_ids = psMetadataAlloc();
    1839     for (long i = 0; i < psArrayLength(detInputExp); i++) {
    1840         detInputExpRow *row = detInputExp->data[i];
    1841         if (!psMetadataAddS64(where_exp_ids, PS_LIST_TAIL, "exp_id",
    1842                 PS_META_DUPLICATE_OK, "==", row->exp_id)
    1843         ) {
    1844             psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    1845             psFree(detInputExp);
    1846             psFree(where_exp_ids);
    1847             return NULL;
    1848         }
    1849     }
    1850     psFree(detInputExp);
    1851 
    1852     // select rawImfiles with matching exp_ids
    1853     psArray *rawImfiles =
    1854         rawImfileSelectRowObjects(config->dbh, where_exp_ids, 0);
    1855     psFree(where_exp_ids);
    1856     if (!rawImfiles) {
    1857         psError(PS_ERR_UNKNOWN, false, "no rawImfile rows found");
    1858         return NULL;
    1859     }
    1860 
    1861     return rawImfiles;
    1862 }
    1863 
    1864 static bool addstackedMode(pxConfig *config)
    1865 {
    1866     PS_ASSERT_PTR_NON_NULL(config, false);
    1867 
    1868     // det_id, iteration, class_id, uri, & recipe are required
    1869     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    1870     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", true, false);
    1871     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    1872 
    1873     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    1874 
    1875     // Required if code == 0
    1876     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    1877     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false);
    1878 
    1879     // optional
    1880     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    1881     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    1882     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    1883     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    1884     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    1885     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    1886     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    1887     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    1888 
    1889     // correlate the class_id against the input exposure(s)
    1890     // searchRawImfiles defines a where clause to search by det_id and iteration
    1891     psArray *rawImfiles = searchRawImfiles(config);
    1892 
    1893     if (!rawImfiles) {
    1894         psError(PS_ERR_UNKNOWN, false, "failed to get rawImfiles from db");
    1895         return false;
    1896     }
    1897 
    1898     bool valid_class_id = false;
    1899     if (rawImfiles) {
    1900         for (long i = 0; i < psArrayLength(rawImfiles); i++) {
    1901             if (!rawImfiles->data[i]) {
    1902                 fprintf (stderr, "*");
    1903                 continue;
    1904             }
    1905             if (strcmp(class_id, ((rawImfileRow *)rawImfiles->data[i])->class_id) == 0) {
    1906                 valid_class_id = true;
    1907                 break;
    1908             }
    1909         }
    1910         psFree(rawImfiles);
    1911     }
    1912 
    1913     if (!valid_class_id) {
    1914         psError(PS_ERR_UNKNOWN, true,
    1915             "class_id can not be correlated with the input exposures");
    1916         return false;
    1917     }
    1918 
    1919     // create a new detStackedImfile object
    1920     detStackedImfileRow *stackedImfile = detStackedImfileRowAlloc(
    1921             (psS64)atoll(det_id),
    1922             iteration,
    1923             class_id,
    1924             uri,
    1925             recipe,
    1926             bg,
    1927             bg_stdev,
    1928             bg_mean_stdev,
    1929             user_1,
    1930             user_2,
    1931             user_3,
    1932             user_4,
    1933             user_5,
    1934             code
    1935         );
    1936 
    1937     // insert the new row into the detProcessedImfile table
    1938     if (!detStackedImfileInsertObject(config->dbh, stackedImfile)) {
    1939         psError(PS_ERR_UNKNOWN, false, "database error");
    1940         psFree(stackedImfile);
    1941         return false;
    1942     }
    1943 
    1944     psFree(stackedImfile);
    1945 
    1946     return true;
    1947 }
    1948 
    1949 static bool stackedMode(pxConfig *config)
    1950 {
    1951     PS_ASSERT_PTR_NON_NULL(config, false);
    1952 
    1953     psMetadata *where = psMetadataAlloc();
    1954     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    1955     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    1956     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    1957     PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
    1958 
    1959     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    1960     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    1961     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    1962 
    1963     psString query = pxDataGet("dettool_stacked.sql");
    1964     if (!query) {
    1965         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1966         psFree(where);
    1967         return false;
    1968     }
    1969 
    1970     if (psListLength(where->list)) {
    1971         psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    1972         psStringAppend(&query, " AND %s", whereClause);
    1973         psFree(whereClause);
    1974     }
    1975     psFree(where);
    1976 
    1977     if (faulted) {
    1978         // list only faulted rows
    1979         psStringAppend(&query, " %s", "AND detStackedImfile.fault != 0");
    1980     } else {
    1981         // don't list faulted rows
    1982         psStringAppend(&query, " %s", "AND detStackedImfile.fault = 0");
    1983     }
    1984 
    1985     // treat limit == 0 as "no limit"
    1986     if (limit) {
    1987         psString limitString = psDBGenerateLimitSQL(limit);
    1988         psStringAppend(&query, " %s", limitString);
    1989         psFree(limitString);
    1990     }
    1991 
    1992     if (!p_psDBRunQuery(config->dbh, query)) {
    1993         psError(PS_ERR_UNKNOWN, false, "database error");
    1994         psFree(query);
    1995         return false;
    1996     }
    1997     psFree(query);
    1998 
    1999     psArray *output = p_psDBFetchResult(config->dbh);
    2000     if (!output) {
    2001         psError(PS_ERR_UNKNOWN, false, "database error");
    2002         return false;
    2003     }
    2004     if (!psArrayLength(output)) {
    2005         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2006         psFree(output);
    2007         return true;
    2008     }
    2009 
    2010     // negative simple so the default is true
    2011     if (!ippdbPrintMetadatas(stdout, output, "rawImfile", !simple)) {
    2012         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2013         psFree(output);
    2014         return false;
    2015     }
    2016 
    2017     psFree(output);
    2018 
    2019     return true;
    2020 }
    2021 
    2022 
    2023 static bool revertstackedMode(pxConfig *config)
    2024 {
    2025     PS_ASSERT_PTR_NON_NULL(config, false);
    2026 
    2027     psMetadata *where = psMetadataAlloc();
    2028     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2029     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2030     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2031     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    2032 
    2033     psString query = pxDataGet("dettool_revertstacked.sql");
    2034     if (!query) {
    2035         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2036         return false;
    2037     }
    2038 
    2039     if (psListLength(where->list)) {
    2040         psString whereClause = psDBGenerateWhereConditionSQL(where, "detStackedImfile");
    2041         psStringAppend(&query, " AND %s", whereClause);
    2042         psFree(whereClause);
    2043     }
    2044     psFree(where);
    2045 
    2046     if (!p_psDBRunQuery(config->dbh, query)) {
    2047         psError(PS_ERR_UNKNOWN, false, "database error");
    2048         psFree(query);
    2049         return false;
    2050     }
    2051     psFree(query);
    2052 
    2053     if (psDBAffectedRows(config->dbh) < 1) {
    2054         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2055         return false;
    2056     }
    2057 
    2058     return true;
    2059 }
    2060 
    2061 static bool tonormalizedstatMode(pxConfig *config)
    2062 {
    2063     PS_ASSERT_PTR_NON_NULL(config, false);
    2064 
    2065     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2066     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2067 
    2068     psString query = pxDataGet("dettool_tonormalizedstat.sql");
    2069     if (!query) {
    2070         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2071         return false;
    2072     }
    2073 
    2074     // treat limit == 0 as "no limit"
    2075     if (limit) {
    2076         psString limitString = psDBGenerateLimitSQL(limit);
    2077         psStringAppend(&query, " %s", limitString);
    2078         psFree(limitString);
    2079     }
    2080 
    2081     if (!p_psDBRunQuery(config->dbh, query)) {
    2082         psError(PS_ERR_UNKNOWN, false, "database error");
    2083         psFree(query);
    2084         return false;
    2085     }
    2086     psFree(query);
    2087 
    2088     psArray *output = p_psDBFetchResult(config->dbh);
    2089     if (!output) {
    2090         psError(PS_ERR_UNKNOWN, false, "database error");
    2091         return false;
    2092     }
    2093     if (!psArrayLength(output)) {
    2094         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2095         psFree(output);
    2096         return true;
    2097     }
    2098 
    2099     // negative simple so the default is true
    2100     if (!ippdbPrintMetadatas(stdout, output, "detPendingNormStatImfile", !simple)) {
    2101         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2102         psFree(output);
    2103         return false;
    2104     }
    2105 
    2106     psFree(output);
    2107 
    2108     return true;
    2109 }
    2110 
    2111 static bool addnormalizedstatMode(pxConfig *config)
    2112 {
    2113     PS_ASSERT_PTR_NON_NULL(config, NULL);
    2114 
    2115     // required
    2116     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    2117     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    2118 
    2119     // optional
    2120     PXOPT_LOOKUP_F32(norm, config->args, "-norm", false, false);
    2121 
    2122     // default
    2123     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    2124     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2125 
    2126     if (!detNormalizedStatImfileInsert(config->dbh,
    2127         (psS64)atoll(det_id),
    2128         iteration,
    2129         class_id,
    2130         norm,
    2131         code
    2132     )) {
    2133         psError(PS_ERR_UNKNOWN, false, "database error");
    2134         return false;
    2135     }
    2136 
    2137     return true;
    2138 }
    2139 
    2140 
    2141 static bool normalizedstatMode(pxConfig *config)
    2142 {
    2143     PS_ASSERT_PTR_NON_NULL(config, false);
    2144 
    2145     psMetadata *where = psMetadataAlloc();
    2146     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2147     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2148     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2149 
    2150     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2151     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2152     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2153 
    2154     psString query = pxDataGet("dettool_normalizedstat.sql");
    2155     if (!query) {
    2156         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2157         return false;
    2158     }
    2159 
    2160     if (faulted) {
    2161         // list only faulted rows
    2162         psStringAppend(&query, " %s", "WHERE fault != 0");
    2163     } else {
    2164         // don't list faulted rows
    2165         psStringAppend(&query, " %s", "WHERE fault = 0");
    2166     }
    2167 
    2168     if (psListLength(where->list)) {
    2169         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    2170         psStringAppend(&query, " AND %s", whereClause);
    2171         psFree(whereClause);
    2172     }
    2173     psFree(where);
    2174 
    2175     // treat limit == 0 as "no limit"
    2176     if (limit) {
    2177         psString limitString = psDBGenerateLimitSQL(limit);
    2178         psStringAppend(&query, " %s", limitString);
    2179         psFree(limitString);
    2180     }
    2181 
    2182     if (!p_psDBRunQuery(config->dbh, query)) {
    2183         psError(PS_ERR_UNKNOWN, false, "database error");
    2184         psFree(query);
    2185         return false;
    2186     }
    2187     psFree(query);
    2188 
    2189     psArray *output = p_psDBFetchResult(config->dbh);
    2190     if (!output) {
    2191         psError(PS_ERR_UNKNOWN, false, "database error");
    2192         return false;
    2193     }
    2194     if (!psArrayLength(output)) {
    2195         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2196         psFree(output);
    2197         return true;
    2198     }
    2199 
    2200     // negative simple so the default is true
    2201     if (!ippdbPrintMetadatas(stdout, output, "detNormalizedStatImfile", !simple)) {
    2202         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2203         psFree(output);
    2204         return false;
    2205     }
    2206 
    2207     psFree(output);
    2208 
    2209     return true;
    2210 }
    2211 
    2212 static bool revertnormalizedstatMode(pxConfig *config)
    2213 {
    2214     PS_ASSERT_PTR_NON_NULL(config, false);
    2215 
    2216     psMetadata *where = psMetadataAlloc();
    2217     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2218     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2219     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2220     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    2221 
    2222     psString query = pxDataGet("dettool_revertnormalizedstat.sql");
    2223     if (!query) {
    2224         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2225         return false;
    2226     }
    2227 
    2228     if (psListLength(where->list)) {
    2229         psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedStatImfile");
    2230         psStringAppend(&query, " AND %s", whereClause);
    2231         psFree(whereClause);
    2232     }
    2233     psFree(where);
    2234 
    2235     if (!p_psDBRunQuery(config->dbh, query)) {
    2236         psError(PS_ERR_UNKNOWN, false, "database error");
    2237         psFree(query);
    2238         return false;
    2239     }
    2240     psFree(query);
    2241 
    2242     if (psDBAffectedRows(config->dbh) < 1) {
    2243         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2244         return false;
    2245     }
    2246 
    2247     return true;
    2248 }
    2249 
    2250 static bool tonormalizeMode(pxConfig *config)
    2251 {
    2252     PS_ASSERT_PTR_NON_NULL(config, false);
    2253 
    2254     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2255     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2256 
    2257     psString query = pxDataGet("dettool_tonormalize.sql");
    2258     if (!query) {
    2259         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2260         return false;
    2261     }
    2262 
    2263     // treat limit == 0 as "no limit"
    2264     if (limit) {
    2265         psString limitString = psDBGenerateLimitSQL(limit);
    2266         psStringAppend(&query, " %s", limitString);
    2267         psFree(limitString);
    2268     }
    2269 
    2270     if (!p_psDBRunQuery(config->dbh, query)) {
    2271         psError(PS_ERR_UNKNOWN, false, "database error");
    2272         psFree(query);
    2273         return false;
    2274     }
    2275     psFree(query);
    2276 
    2277     psArray *output = p_psDBFetchResult(config->dbh);
    2278     if (!output) {
    2279         psError(PS_ERR_UNKNOWN, false, "database error");
    2280         return false;
    2281     }
    2282     if (!psArrayLength(output)) {
    2283         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2284         psFree(output);
    2285         return true;
    2286     }
    2287 
    2288     // negative simple so the default is true
    2289     if (!ippdbPrintMetadatas(stdout, output, "detPendingNormImfile", !simple)) {
    2290         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2291         psFree(output);
    2292         return false;
    2293     }
    2294 
    2295     psFree(output);
    2296 
    2297     return true;
    2298 }
    2299 
    2300 static bool addnormalizedimfileMode(pxConfig *config)
    2301 {
    2302     PS_ASSERT_PTR_NON_NULL(config, false);
    2303 
    2304     // required
    2305     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
    2306     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    2307     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false);
    2308 
    2309     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2310 
    2311     // Required if code == 0
    2312     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false);
    2313 
    2314     // optional
    2315     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    2316     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    2317     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    2318     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    2319     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    2320     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    2321     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    2322     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    2323     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    2324 
    2325     if (!detNormalizedImfileInsert(config->dbh,
    2326         (psS64)atoll(det_id),
    2327         iteration,
    2328         class_id,
    2329         uri,
    2330         bg,
    2331         bg_stdev,
    2332         bg_mean_stdev,
    2333         user_1,
    2334         user_2,
    2335         user_3,
    2336         user_4,
    2337         user_5,
    2338         path_base,
    2339         code
    2340     )) {
    2341         psError(PS_ERR_UNKNOWN, false, "database error");
    2342         return false;
    2343     }
    2344 
    2345     return true;
    2346 }
    2347 
    2348 static bool normalizedimfileMode(pxConfig *config)
    2349 {
    2350     PS_ASSERT_PTR_NON_NULL(config, false);
    2351 
    2352     psMetadata *where = psMetadataAlloc();
    2353     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2354     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2355     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2356     PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
    2357 
    2358     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2359     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2360     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2361 
    2362     psString query = pxDataGet("dettool_normalizedimfile.sql");
    2363     if (!query) {
    2364         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2365         return false;
    2366     }
    2367 
    2368     if (psListLength(where->list)) {
    2369         psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedImfile");
    2370         psStringAppend(&query, " AND %s", whereClause);
    2371         psFree(whereClause);
    2372     }
    2373     psFree(where);
    2374 
    2375     if (faulted) {
    2376         // list only faulted rows
    2377         psStringAppend(&query, " %s", "AND detNormalizedImfile.fault != 0");
    2378     } else {
    2379         // don't list faulted rows
    2380         psStringAppend(&query, " %s", "AND detNormalizedImfile.fault = 0");
    2381     }
    2382 
    2383     // treat limit == 0 as "no limit"
    2384     if (limit) {
    2385         psString limitString = psDBGenerateLimitSQL(limit);
    2386         psStringAppend(&query, " %s", limitString);
    2387         psFree(limitString);
    2388     }
    2389 
    2390     if (!p_psDBRunQuery(config->dbh, query)) {
    2391         psError(PS_ERR_UNKNOWN, false, "database error");
    2392         psFree(query);
    2393         return false;
    2394     }
    2395     psFree(query);
    2396 
    2397     psArray *output = p_psDBFetchResult(config->dbh);
    2398     if (!output) {
    2399         psError(PS_ERR_UNKNOWN, false, "database error");
    2400         return false;
    2401     }
    2402     if (!psArrayLength(output)) {
    2403         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2404         psFree(output);
    2405         return true;
    2406     }
    2407 
    2408     // negative simple so the default is true
    2409     if (!ippdbPrintMetadatas(stdout, output, "detNormalizedImfile", !simple)) {
    2410         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2411         psFree(output);
    2412         return false;
    2413     }
    2414 
    2415     psFree(output);
    2416 
    2417     return true;
    2418 }
    2419 
    2420 
    2421 static bool revertnormalizedimfileMode(pxConfig *config)
    2422 {
    2423     PS_ASSERT_PTR_NON_NULL(config, false);
    2424 
    2425     psMetadata *where = psMetadataAlloc();
    2426     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2427     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2428     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2429     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    2430 
    2431     psString query = pxDataGet("dettool_revertnormalizedimfile.sql");
    2432     if (!query) {
    2433         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2434         return false;
    2435     }
    2436 
    2437     if (psListLength(where->list)) {
    2438         psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedImfile");
    2439         psStringAppend(&query, " AND %s", whereClause);
    2440         psFree(whereClause);
    2441     }
    2442     psFree(where);
    2443 
    2444     if (!p_psDBRunQuery(config->dbh, query)) {
    2445         psError(PS_ERR_UNKNOWN, false, "database error");
    2446         psFree(query);
    2447         return false;
    2448     }
    2449     psFree(query);
    2450 
    2451     if (psDBAffectedRows(config->dbh) < 1) {
    2452         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2453         return false;
    2454     }
    2455 
    2456     return true;
    2457 }
    2458 
    2459 static bool tonormalizedexpMode(pxConfig *config)
    2460 {
    2461     PS_ASSERT_PTR_NON_NULL(config, false);
    2462 
    2463     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2464     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2465 
    2466     psString query = pxDataGet("dettool_tonormalizedexp.sql");
    2467     if (!query) {
    2468         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2469         return false;
    2470     }
    2471 
    2472     // treat limit == 0 as "no limit"
    2473     if (limit) {
    2474         psString limitString = psDBGenerateLimitSQL(limit);
    2475         psStringAppend(&query, " %s", limitString);
    2476         psFree(limitString);
    2477     }
    2478 
    2479     if (!p_psDBRunQuery(config->dbh, query)) {
    2480         psError(PS_ERR_UNKNOWN, false, "database error");
    2481         psFree(query);
    2482         return false;
    2483     }
    2484     psFree(query);
    2485 
    2486     psArray *output = p_psDBFetchResult(config->dbh);
    2487     if (!output) {
    2488         psError(PS_ERR_UNKNOWN, false, "database error");
    2489         return false;
    2490     }
    2491     if (!psArrayLength(output)) {
    2492         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2493         psFree(output);
    2494         return true;
    2495     }
    2496 
    2497     // negative simple so the default is true
    2498     if (!ippdbPrintMetadatas(stdout, output, "detPendingNormExp", !simple)) {
    2499         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2500         psFree(output);
    2501         return false;
    2502     }
    2503 
    2504     psFree(output);
    2505 
    2506     return true;
    2507 }
    2508 
    2509 static bool addnormalizedexpMode(pxConfig *config)
    2510 {
    2511     PS_ASSERT_PTR_NON_NULL(config, false);
    2512    
    2513     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    2514     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    2515     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2516     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    2517     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    2518     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    2519     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    2520     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    2521     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    2522     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    2523     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    2524     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    2525     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    2526 
    2527     psString query = pxDataGet("dettool_tonormalizedexp.sql");
    2528     if (!query) {
    2529         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2530         return false;
    2531     }
    2532 
    2533     // XXX in some other places, we put the arguments in the .sql and supply them to RunQuery
    2534     psStringAppend(&query, " WHERE det_id = %s AND iteration = %d", det_id, iteration);
    2535 
    2536     if (!p_psDBRunQuery(config->dbh, query)) {
    2537         psError(PS_ERR_UNKNOWN, false, "database error");
    2538         psFree(query);
    2539         return false;
    2540     }
    2541     psFree(query);
    2542 
    2543     psArray *output = p_psDBFetchResult(config->dbh);
    2544     if (!output) {
    2545         psError(PS_ERR_UNKNOWN, false, "database error");
    2546         return false;
    2547     }
    2548     if (!psArrayLength(output)) {
    2549         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2550         psFree(output);
    2551         return true;
    2552     }
    2553     psFree(output);
    2554 
    2555     // insert the new row into the detProcessedImfile table
    2556     if (!detNormalizedExpInsert(config->dbh,
    2557         (psS64)atoll(det_id),
    2558         iteration,
    2559         recipe,
    2560         bg,
    2561         bg_stdev,
    2562         bg_mean_stdev,
    2563         user_1,
    2564         user_2,
    2565         user_3,
    2566         user_4,
    2567         user_5,
    2568         path_base,
    2569         code
    2570     )) {
    2571         psError(PS_ERR_UNKNOWN, false, "database error");
    2572         return false;
    2573     }
    2574 
    2575     return true;
    2576 }
    2577 
    2578 
    2579 static bool normalizedexpMode(pxConfig *config)
    2580 {
    2581     PS_ASSERT_PTR_NON_NULL(config, false);
    2582 
    2583     psMetadata *where = psMetadataAlloc();
    2584     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2585     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2586     PXOPT_COPY_STR(config->args, where, "-recip",  "recipe", "==");
    2587 
    2588     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2589     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2590     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2591 
    2592     psString query = pxDataGet("dettool_normalizedexp.sql");
    2593     if (!query) {
    2594         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2595         return false;
    2596     }
    2597 
    2598     if (psListLength(where->list)) {
    2599         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    2600         psStringAppend(&query, " %s", whereClause);
    2601         psFree(whereClause);
    2602     }
    2603     psFree(where);
    2604 
    2605     if (faulted) {
    2606         // list only faulted rows
    2607         psStringAppend(&query, " %s", "AND detNormalizedExp.fault != 0");
    2608     } else {
    2609         // don't list faulted rows
    2610         psStringAppend(&query, " %s", "AND detNormalizedExp.fault = 0");
    2611     }
    2612 
    2613     // treat limit == 0 as "no limit"
    2614     if (limit) {
    2615         psString limitString = psDBGenerateLimitSQL(limit);
    2616         psStringAppend(&query, " %s", limitString);
    2617         psFree(limitString);
    2618     }
    2619 
    2620     if (!p_psDBRunQuery(config->dbh, query)) {
    2621         psError(PS_ERR_UNKNOWN, false, "database error");
    2622         psFree(query);
    2623         return false;
    2624     }
    2625     psFree(query);
    2626 
    2627     psArray *output = p_psDBFetchResult(config->dbh);
    2628     if (!output) {
    2629         psError(PS_ERR_UNKNOWN, false, "database error");
    2630         return false;
    2631     }
    2632     if (!psArrayLength(output)) {
    2633         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2634         psFree(output);
    2635         return true;
    2636     }
    2637 
    2638     // negative simple so the default is true
    2639     if (!ippdbPrintMetadatas(stdout, output, "detNormalizedExp", !simple)) {
    2640         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2641         psFree(output);
    2642         return false;
    2643     }
    2644 
    2645     psFree(output);
    2646 
    2647     return true;
    2648 }
    2649 
    2650 
    2651 
    2652 static bool revertnormalizedexpMode(pxConfig *config)
    2653 {
    2654     PS_ASSERT_PTR_NON_NULL(config, false);
    2655 
    2656     psMetadata *where = psMetadataAlloc();
    2657     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2658     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2659     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    2660 
    2661     psString query = pxDataGet("dettool_revertnormalizedexp.sql");
    2662     if (!query) {
    2663         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2664         return false;
    2665     }
    2666 
    2667     if (psListLength(where->list)) {
    2668         psString whereClause = psDBGenerateWhereConditionSQL(where, "detNormalizedExp");
    2669         psStringAppend(&query, " AND %s", whereClause);
    2670         psFree(whereClause);
    2671     }
    2672     psFree(where);
    2673 
    2674     if (!p_psDBRunQuery(config->dbh, query)) {
    2675         psError(PS_ERR_UNKNOWN, false, "database error");
    2676         psFree(query);
    2677         return false;
    2678     }
    2679     psFree(query);
    2680 
    2681     if (psDBAffectedRows(config->dbh) < 1) {
    2682         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2683         return false;
    2684     }
    2685 
    2686     return true;
    2687 }
    2688 
    2689 
    2690 static bool toresidimfileMode(pxConfig *config)
    2691 {
    2692     PS_ASSERT_PTR_NON_NULL(config, false);
    2693 
    2694     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2695     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2696 
    2697     psString query = pxDataGet("dettool_toresidimfile.sql");
    2698     if (!query) {
    2699         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2700         return false;
    2701     }
    2702 
    2703     // treat limit == 0 as "no limit"
    2704     if (limit) {
    2705         psString limitString = psDBGenerateLimitSQL(limit);
    2706         psStringAppend(&query, " %s", limitString);
    2707         psFree(limitString);
    2708     }
    2709 
    2710     if (!p_psDBRunQuery(config->dbh, query)) {
    2711         psError(PS_ERR_UNKNOWN, false, "database error");
    2712         psFree(query);
    2713         return false;
    2714     }
    2715     psFree(query);
    2716 
    2717     psArray *output = p_psDBFetchResult(config->dbh);
    2718     if (!output) {
    2719         psError(PS_ERR_UNKNOWN, false, "database error");
    2720         return false;
    2721     }
    2722     if (!psArrayLength(output)) {
    2723         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2724         psFree(output);
    2725         return true;
    2726     }
    2727 
    2728     // negative simple so the default is true
    2729     if (!ippdbPrintMetadatas(stdout, output, "detPendingResidImfile", !simple)) {
    2730         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2731         psFree(output);
    2732         return false;
    2733     }
    2734 
    2735     psFree(output);
    2736 
    2737     return true;
    2738 }
    2739 
    2740 
    2741 static bool addresidimfileMode(pxConfig *config)
    2742 {
    2743     PS_ASSERT_PTR_NON_NULL(config, false);
    2744 
    2745    
    2746     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    2747     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    2748     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false); // required
    2749     PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    2750     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    2751     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (code == 0), false); // Required if code == 0
    2752     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    2753     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    2754     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    2755     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    2756     PXOPT_LOOKUP_F64(bg_skewness, config->args, "-bg_skewness", false, false);
    2757     PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
    2758     PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
    2759     PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    2760     PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    2761     PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
    2762     PXOPT_LOOKUP_F64(fringe_resid_0, config->args, "-fringe_resid_0", false, false);
    2763     PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
    2764     PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
    2765     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    2766     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    2767     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    2768     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    2769     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    2770     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    2771 
    2772     if (!detResidImfileInsert(config->dbh,
    2773             (psS64)atoll(det_id),
    2774             iteration,
    2775             (psS64)atoll(exp_id),
    2776             class_id,
    2777             uri,
    2778             recipe,
    2779             bg,
    2780             bg_stdev,
    2781             bg_mean_stdev,
    2782             bg_skewness,
    2783             bg_kurtosis,
    2784             bin_stdev,
    2785             fringe_0,
    2786             fringe_1,
    2787             fringe_2,
    2788             fringe_resid_0,
    2789             fringe_resid_1,
    2790             fringe_resid_2,
    2791             user_1,
    2792             user_2,
    2793             user_3,
    2794             user_4,
    2795             user_5,
    2796             path_base,
    2797             code
    2798     )) {
    2799         psError(PS_ERR_UNKNOWN, false, "database error");
    2800         return false;
    2801     }
    2802 
    2803     return true;
    2804 }
    2805 
    2806 
    2807 static bool residimfileMode(pxConfig *config)
    2808 {
    2809     PS_ASSERT_PTR_NON_NULL(config, false);
    2810 
    2811     psMetadata *where = psMetadataAlloc();
    2812     PXOPT_COPY_STR(config->args, where, "-det_id",     "det_id", "==");
    2813     PXOPT_COPY_S32(config->args, where, "-iteration",  "iteration", "==");
    2814     PXOPT_COPY_STR(config->args, where, "-exp_id",     "exp_id", "==");
    2815     PXOPT_COPY_STR(config->args, where, "-class_id",   "class_id", "==");
    2816     PXOPT_COPY_STR(config->args, where, "-recip",      "recipe", "==");
    2817 
    2818     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2819     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2820     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    2821 
    2822     psString query = pxDataGet("dettool_residimfile.sql");
    2823     if (!query) {
    2824         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2825         return false;
    2826     }
    2827 
    2828     // NOTE: the query ends in a WHERE, add the required restriction on detRun.state
    2829     char *value = NULL;
    2830     bool status;
    2831     if ((value = psMetadataLookupStr(&status, config->args, "-select_state"))) {
    2832         psStringAppend(&query, " detRun.state = '%s'", value);
    2833     } else {
    2834         psStringAppend(&query, " detRun.state = 'run'");
    2835     }
    2836 
    2837     if (psListLength(where->list)) {
    2838         psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidImfile");
    2839         psStringAppend(&query, " AND %s", whereClause);
    2840         psFree(whereClause);
    2841     }
    2842     psFree(where);
    2843 
    2844     if (faulted) {
    2845         // list only faulted rows
    2846         psStringAppend(&query, " %s", "AND detResidImfile.fault != 0");
    2847     } else {
    2848         // don't list faulted rows
    2849         psStringAppend(&query, " %s", "AND detResidImfile.fault = 0");
    2850     }
    2851 
    2852     // treat limit == 0 as "no limit"
    2853     if (limit) {
    2854         psString limitString = psDBGenerateLimitSQL(limit);
    2855         psStringAppend(&query, " %s", limitString);
    2856         psFree(limitString);
    2857     }
    2858 
    2859     if (!p_psDBRunQuery(config->dbh, query)) {
    2860         psError(PS_ERR_UNKNOWN, false, "database error");
    2861         psFree(query);
    2862         return false;
    2863     }
    2864     psFree(query);
    2865 
    2866     psArray *output = p_psDBFetchResult(config->dbh);
    2867     if (!output) {
    2868         psError(PS_ERR_UNKNOWN, false, "database error");
    2869         return false;
    2870     }
    2871     if (!psArrayLength(output)) {
    2872         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2873         psFree(output);
    2874         return true;
    2875     }
    2876 
    2877     // negative simple so the default is true
    2878     if (!ippdbPrintMetadatas(stdout, output, "rawResidImfile", !simple)) {
    2879         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2880         psFree(output);
    2881         return false;
    2882     }
    2883 
    2884     psFree(output);
    2885 
    2886     return true;
    2887 }
    2888 
    2889 
    2890 static bool revertresidimfileMode(pxConfig *config)
    2891 {
    2892     PS_ASSERT_PTR_NON_NULL(config, false);
    2893 
    2894     psMetadata *where = psMetadataAlloc();
    2895     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    2896     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    2897     PXOPT_COPY_STR(config->args, where, "-exp_id",  "exp_id", "==");
    2898     PXOPT_COPY_STR(config->args, where, "-class_id",  "class_id", "==");
    2899     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    2900 
    2901     psString query = pxDataGet("dettool_revertresidimfile.sql");
    2902     if (!query) {
    2903         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2904         return false;
    2905     }
    2906 
    2907     if (psListLength(where->list)) {
    2908         psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidImfile");
    2909         psStringAppend(&query, " AND %s", whereClause);
    2910         psFree(whereClause);
    2911     }
    2912     psFree(where);
    2913 
    2914     if (!p_psDBRunQuery(config->dbh, query)) {
    2915         psError(PS_ERR_UNKNOWN, false, "database error");
    2916         psFree(query);
    2917         return false;
    2918     }
    2919     psFree(query);
    2920 
    2921     if (psDBAffectedRows(config->dbh) < 1) {
    2922         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    2923         return false;
    2924     }
    2925 
    2926     return true;
    2927 }
    2928 
    2929 
    2930 /*
    2931   The SQL returns a list of exposures for which all component class ids have had residuals
    2932   created.  This list includes the detrend id, iteration, exposure id, detrend type, and
    2933   whether the exposure was included in the stack for this iteration.
    2934 */
    2935 
    2936 static bool toresidexpMode(pxConfig *config)
    2937 {
    2938     PS_ASSERT_PTR_NON_NULL(config, false);
    2939 
    2940     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    2941     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    2942 
    2943     psString query = pxDataGet("dettool_toresidexp.sql");
    2944     if (!query) {
    2945         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    2946         return false;
    2947     }
    2948 
    2949     // treat limit == 0 as "no limit"
    2950     if (limit) {
    2951         psString limitString = psDBGenerateLimitSQL(limit);
    2952         psStringAppend(&query, " %s", limitString);
    2953         psFree(limitString);
    2954     }
    2955 
    2956     if (!p_psDBRunQuery(config->dbh, query)) {
    2957         psError(PS_ERR_UNKNOWN, false, "database error");
    2958         psFree(query);
    2959         return false;
    2960     }
    2961     psFree(query);
    2962 
    2963     psArray *output = p_psDBFetchResult(config->dbh);
    2964     if (!output) {
    2965         psError(PS_ERR_UNKNOWN, false, "database error");
    2966         return false;
    2967     }
    2968     if (!psArrayLength(output)) {
    2969         psTrace("dettool", PS_LOG_INFO, "no rows found");
    2970         psFree(output);
    2971         return true;
    2972     }
    2973 
    2974     // negative simple so the default is true
    2975     if (!ippdbPrintMetadatas(stdout, output, "detPendingResidExp", !simple)) {
    2976         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    2977         psFree(output);
    2978         return false;
    2979     }
    2980 
    2981     psFree(output);
    2982 
    2983     return true;
    2984 }
    2985 
    2986 /*
    2987   The SQL returns a list of exposures for which all component class ids have had residuals
    2988   created.  This list includes the detrend id, iteration, exposure id, detrend type, and
    2989   whether the exposure was included in the stack for this iteration.
    2990 */
    2991 
    2992 static bool addresidexpMode(pxConfig *config)
    2993 {
    2994     PS_ASSERT_PTR_NON_NULL(config, false);
    2995 
    2996     // limit search by det_id, iteration, exp_id
    2997     psMetadata *where = psMetadataAlloc();
    2998     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    2999     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3000     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    3001 
    3002     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    3003     PXOPT_LOOKUP_S32(iteration, config->args, "-iteration", false, false);
    3004     PXOPT_LOOKUP_STR(exp_id, config->args, "-exp_id", true, false); // required
    3005     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    3006     PXOPT_LOOKUP_STR(recipe, config->args, "-recip", (code == 0), false); // Required if code == 0
    3007     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    3008     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    3009     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    3010     PXOPT_LOOKUP_F64(bg_skewness, config->args, "-bg_skewness", false, false);
    3011     PXOPT_LOOKUP_F64(bg_kurtosis, config->args, "-bg_kurtosis", false, false);
    3012     PXOPT_LOOKUP_F64(bin_stdev, config->args, "-bin_stdev", false, false);
    3013     PXOPT_LOOKUP_F64(fringe_0, config->args, "-fringe_0", false, false);
    3014     PXOPT_LOOKUP_F64(fringe_1, config->args, "-fringe_1", false, false);
    3015     PXOPT_LOOKUP_F64(fringe_2, config->args, "-fringe_2", false, false);
    3016     PXOPT_LOOKUP_F64(fringe_resid_0, config->args, "-fringe_resid_0", false, false);
    3017     PXOPT_LOOKUP_F64(fringe_resid_1, config->args, "-fringe_resid_1", false, false);
    3018     PXOPT_LOOKUP_F64(fringe_resid_2, config->args, "-fringe_resid_2", false, false);
    3019     PXOPT_LOOKUP_F64(user_1, config->args, "-user_1", false, false);
    3020     PXOPT_LOOKUP_F64(user_2, config->args, "-user_2", false, false);
    3021     PXOPT_LOOKUP_F64(user_3, config->args, "-user_3", false, false);
    3022     PXOPT_LOOKUP_F64(user_4, config->args, "-user_4", false, false);
    3023     PXOPT_LOOKUP_F64(user_5, config->args, "-user_5", false, false);
    3024     PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    3025     PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    3026 
    3027     psString query = pxDataGet("dettool_toresidexp.sql");
    3028     if (!query) {
    3029         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3030         return false;
    3031     }
    3032 
    3033     if (psListLength(where->list)) {
    3034         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    3035         psStringAppend(&query, " WHERE %s", whereClause);
    3036         psFree(whereClause);
    3037     }
    3038     psFree(where);
    3039 
    3040     if (!p_psDBRunQuery(config->dbh, query)) {
    3041         psError(PS_ERR_UNKNOWN, false, "database error");
    3042         psFree(query);
    3043         return false;
    3044     }
    3045     psFree(query);
    3046 
    3047     psArray *output = p_psDBFetchResult(config->dbh);
    3048     if (!output) {
    3049         psError(PS_ERR_UNKNOWN, false, "database error");
    3050         return false;
    3051     }
    3052     if (!psArrayLength(output)) {
    3053         // XXX check psError here
    3054         psError(PS_ERR_UNKNOWN, false, "no detResidImfile rows found");
    3055         psFree(output);
    3056         return false;
    3057     }
    3058     psFree(output);
    3059 
    3060     if (!detResidExpInsert(config->dbh,
    3061             (psS64)atoll(det_id),
    3062             iteration,
    3063             (psS64)atoll(exp_id),
    3064             recipe,
    3065             bg,
    3066             bg_stdev,
    3067             bg_mean_stdev,
    3068             bg_skewness,
    3069             bg_kurtosis,
    3070             bin_stdev,
    3071             fringe_0,
    3072             fringe_1,
    3073             fringe_2,
    3074             fringe_resid_0,
    3075             fringe_resid_1,
    3076             fringe_resid_2,
    3077             user_1,
    3078             user_2,
    3079             user_3,
    3080             user_4,
    3081             user_5,
    3082             path_base,
    3083             !reject,
    3084             code
    3085         )) {
    3086         psError(PS_ERR_UNKNOWN, false, "database error");
    3087         return false;
    3088     }
    3089 
    3090     return true;
    3091 }
    3092 
    3093 static bool residexpMode(pxConfig *config)
    3094 {
    3095     PS_ASSERT_PTR_NON_NULL(config, false);
    3096 
    3097     psMetadata *where = psMetadataAlloc();
    3098     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    3099     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3100     PXOPT_COPY_STR(config->args, where, "-exp_id",    "exp_id", "==");
    3101     PXOPT_COPY_STR(config->args, where, "-recip",     "recipe", "==");
    3102 
    3103     PXOPT_LOOKUP_U64(limit,    config->args, "-limit", false, false);
    3104     PXOPT_LOOKUP_BOOL(simple,  config->args, "-simple", false);
    3105     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    3106     PXOPT_LOOKUP_BOOL(reject,  config->args, "-reject", false);
    3107 
    3108     psString query = pxDataGet("dettool_residexp.sql");
    3109     if (!query) {
    3110         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3111         return false;
    3112     }
    3113 
    3114     if (psListLength(where->list)) {
    3115         psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidExp");
    3116         psStringAppend(&query, " AND %s", whereClause);
    3117         psFree(whereClause);
    3118     }
    3119     psFree(where);
    3120 
    3121     if (faulted) {
    3122         // list only faulted rows
    3123         psStringAppend(&query, " %s", "AND detResidExp.fault != 0");
    3124     } else {
    3125         // don't list faulted rows
    3126         psStringAppend(&query, " %s", "AND detResidExp.fault = 0");
    3127     }
    3128 
    3129     // list only accepted rows
    3130     // XXX the usage of this flag is unclear : -reject means "accepted"?
    3131     if (reject) {
    3132         psStringAppend(&query, " %s", "AND detResidExp.accept != 0");
    3133     }
    3134 
    3135     // treat limit == 0 as "no limit"
    3136     if (limit) {
    3137         psString limitString = psDBGenerateLimitSQL(limit);
    3138         psStringAppend(&query, " %s", limitString);
    3139         psFree(limitString);
    3140     }
    3141 
    3142     if (!p_psDBRunQuery(config->dbh, query)) {
    3143         psError(PS_ERR_UNKNOWN, false, "database error");
    3144         psFree(query);
    3145         return false;
    3146     }
    3147     psFree(query);
    3148 
    3149     psArray *output = p_psDBFetchResult(config->dbh);
    3150     if (!output) {
    3151         psError(PS_ERR_UNKNOWN, false, "database error");
    3152         return false;
    3153     }
    3154     if (!psArrayLength(output)) {
    3155         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3156         psFree(output);
    3157         return true;
    3158     }
    3159 
    3160     // negative simple so the default is true
    3161     if (!ippdbPrintMetadatas(stdout, output, "detResidExp", !simple)) {
    3162         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    3163         psFree(output);
    3164         return false;
    3165     }
    3166 
    3167     psFree(output);
    3168 
    3169     return true;
    3170 }
    3171 
    3172 
    3173 static bool revertresidexpMode(pxConfig *config)
    3174 {
    3175     PS_ASSERT_PTR_NON_NULL(config, false);
    3176 
    3177     psMetadata *where = psMetadataAlloc();
    3178     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    3179     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3180     PXOPT_COPY_STR(config->args, where, "-exp_id",    "exp_id", "==");
    3181     PXOPT_COPY_S16(config->args, where, "-code",      "fault", "==");
    3182 
    3183     psString query = pxDataGet("dettool_revertresidexp.sql");
    3184     if (!query) {
    3185         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3186         return false;
    3187     }
    3188 
    3189     if (psListLength(where->list)) {
    3190         psString whereClause = psDBGenerateWhereConditionSQL(where, "detResidExp");
    3191         psStringAppend(&query, " AND %s", whereClause);
    3192         psFree(whereClause);
    3193     }
    3194     psFree(where);
    3195 
    3196     if (!p_psDBRunQuery(config->dbh, query)) {
    3197         psError(PS_ERR_UNKNOWN, false, "database error");
    3198         psFree(query);
    3199         return false;
    3200     }
    3201     psFree(query);
    3202 
    3203     if (psDBAffectedRows(config->dbh) < 1) {
    3204         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    3205         return false;
    3206     }
    3207 
    3208     return true;
    3209 }
    3210 
    3211 
    3212 static bool updateresidexpMode(pxConfig *config)
    3213 {
    3214     PS_ASSERT_PTR_NON_NULL(config, false);
    3215 
    3216     PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    3217 
    3218     // build a query to search by det_id, iteration, exp_id
    3219     psMetadata *where = psMetadataAlloc();
    3220     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    3221     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3222     PXOPT_COPY_STR(config->args, where, "-exp_id", "exp_id", "==");
    3223 
    3224     // find the values we're going to set
    3225     // copy everything but det_id, iteration, & exp_id from the args and
    3226     // remove the '-' prefix
    3227     psMetadata *set = psMetadataAlloc();
    3228     PXOPT_COPY_STR(config->args, set, "-recip", "recipe", "==");
    3229     PXOPT_COPY_F64(config->args, set, "-bg", "bg", "==");
    3230     PXOPT_COPY_F64(config->args, set, "-bg_stdev", "bg_stdev", "==");
    3231     PXOPT_COPY_F64(config->args, set, "-bg_mean_stdev", "bg_mean_stdev", "==");
    3232     PXOPT_COPY_STR(config->args, set, "-path_base", "path_base", "==");
    3233 
    3234     // this can't be PXOPT_ macro-ized as reject is !'d
    3235     if (!psMetadataAddBool(set, PS_LIST_TAIL, "accept", 0, "==", !reject)) {
    3236         psError(PS_ERR_UNKNOWN, false, "failed to add item accept");
    3237         psFree(set);
    3238         psFree(where);
    3239         return false;
    3240     }
    3241 
    3242     long changed = psDBUpdateRows(config->dbh, "detResidExp", where, set);
    3243     psFree(set);
    3244     psFree(where);
    3245 
    3246     if (changed < 0) {
    3247         psError(PS_ERR_UNKNOWN, false, "no rows were updated");
    3248         return false;
    3249     }
    3250 
    3251     return true;
    3252 }
    3253 
    3254 /* The SQL returns a list of detrend runs (with detrend id, iteration and detrend type) which
    3255  * have completed all residexps.
    3256  */
    3257 
    3258 static bool todetrunsummaryMode(pxConfig *config)
    3259 {
    3260     PS_ASSERT_PTR_NON_NULL(config, false);
    3261 
    3262     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    3263     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    3264 
    3265     psString query = pxDataGet("dettool_todetrunsummary.sql");
    3266     if (!query) {
    3267         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3268         return false;
    3269     }
    3270 
    3271     // treat limit == 0 as "no limit"
    3272     if (limit) {
    3273         psString limitString = psDBGenerateLimitSQL(limit);
    3274         psStringAppend(&query, " %s", limitString);
    3275         psFree(limitString);
    3276     }
    3277 
    3278     if (!p_psDBRunQuery(config->dbh, query)) {
    3279         psError(PS_ERR_UNKNOWN, false, "database error");
    3280         psFree(query);
    3281         return false;
    3282     }
    3283     psFree(query);
    3284 
    3285     psArray *output = p_psDBFetchResult(config->dbh);
    3286     if (!output) {
    3287         psError(PS_ERR_UNKNOWN, false, "database error");
    3288         return false;
    3289     }
    3290     if (!psArrayLength(output)) {
    3291         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3292         psFree(output);
    3293         return true;
    3294     }
    3295 
    3296     // negative simple so the default is true
    3297     if (!ippdbPrintMetadatas(stdout, output, "detRejectExp", !simple)) {
    3298         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    3299         psFree(output);
    3300         return false;
    3301     }
    3302 
    3303     psFree(output);
    3304 
    3305     return true;
    3306 }
    3307 
    3308 // this function is used to generate the detrunSummary entries used below
    3309 // XXX why is this a separate function?  roll it back into adddetrunsummary?
    3310 static detRunSummaryRow *mdToDetRunSummary(pxConfig *config, psMetadata *row)
    3311 {
    3312     PS_ASSERT_PTR_NON_NULL(config, false);
    3313 
    3314     bool status = false;
    3315     // from row
    3316     psS64 det_id = psMetadataLookupS64(&status, row, "det_id");
    3317     if (!status) {
    3318         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for det_id");
    3319         return false;
    3320     }
    3321     psS32 iteration = psMetadataLookupS32(&status, row, "iteration");
    3322     if (!status) {
    3323         psError(PS_ERR_UNKNOWN, false, "failed to lookup value for iteration");
    3324         return false;
    3325     }
    3326 
    3327     // optional
    3328     PXOPT_LOOKUP_F64(bg, config->args, "-bg", false, false);
    3329     PXOPT_LOOKUP_F64(bg_stdev, config->args, "-bg_stdev", false, false);
    3330     PXOPT_LOOKUP_F64(bg_mean_stdev, config->args, "-bg_mean_stdev", false, false);
    3331 
    3332     // default values
    3333     PXOPT_LOOKUP_S16(code, config->args, "-code", false, false);
    3334     PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    3335 
    3336     return detRunSummaryRowAlloc(
    3337             det_id,
    3338             iteration,
    3339             bg,
    3340             bg_stdev,
    3341             bg_mean_stdev,
    3342             accept,
    3343             code
    3344         );
    3345 }
    3346 
    3347 static bool adddetrunsummaryMode(pxConfig *config)
    3348 {
    3349     PS_ASSERT_PTR_NON_NULL(config, false);
    3350    
    3351     // build a query to search by det_id, iteration, exp_id
    3352     psMetadata *where = psMetadataAlloc();
    3353     PXOPT_COPY_STR(config->args, where, "-det_id", "det_id", "==");
    3354     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3355 
    3356     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    3357     PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
    3358 
    3359     // The values supplied as arguments on the command (eg, -bg) are parsed
    3360     // by mdToDetRunSummary below.
    3361     // XXX why is there ever more than one?
    3362 
    3363     psString query = pxDataGet("dettool_find_completed_runs.sql");
    3364     if (!query) {
    3365         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3366         return false;
    3367     }
    3368 
    3369     if (psListLength(where->list)) {
    3370         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    3371         psStringAppend(&query, " WHERE %s", whereClause);
    3372         psFree(whereClause);
    3373     }
    3374     psFree(where);
    3375 
    3376     if (!p_psDBRunQuery(config->dbh, query)) {
    3377         psError(PS_ERR_UNKNOWN, false, "database error");
    3378         psFree(query);
    3379         return false;
    3380     }
    3381     psFree(query);
    3382 
    3383     psArray *output = p_psDBFetchResult(config->dbh);
    3384     if (!output) {
    3385         psError(PS_ERR_UNKNOWN, false, "database error");
    3386         return false;
    3387     }
    3388     if (!psArrayLength(output)) {
    3389         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3390         psFree(output);
    3391         return true;
    3392     }
    3393 
    3394     // start a transaction so it's all rows or nothing
    3395     if (!psDBTransaction(config->dbh)) {
    3396         psError(PS_ERR_UNKNOWN, false, "database error");
    3397         psFree(output);
    3398         return false;
    3399     }
    3400 
    3401     // XXX why is there ever more than one result here?
    3402     for (long i = 0; i < psArrayLength(output); i++) {
    3403         psMetadata *row = output->data[i];
    3404         // convert metadata into a detResidExp object
    3405         detRunSummaryRow *runSummary = mdToDetRunSummary(config, row);
    3406         if (!runSummary) {
    3407             if (!psDBRollback(config->dbh)) {
    3408                 psError(PS_ERR_UNKNOWN, false, "database error");
    3409             }
    3410             psError(PS_ERR_UNKNOWN, false, "failed to convert metadata to detResidExp");
    3411             psFree(output);
    3412             return false;
    3413         }
    3414         // insert detResidExp object into the database
    3415         if (!detRunSummaryInsertObject(config->dbh, runSummary)) {
    3416             if (!psDBRollback(config->dbh)) {
    3417                 psError(PS_ERR_UNKNOWN, false, "database error");
    3418             }
    3419             psError(PS_ERR_UNKNOWN, false, "database error");
    3420             psFree(runSummary);
    3421             psFree(output);
    3422             return false;
    3423         }
    3424         psFree(runSummary);
    3425     }
    3426 
    3427     psFree(output);
    3428 
    3429     // XXX this logic does not deal with the case of -code being set
    3430     // XXX it should be an error for -again and -code to both be set
    3431     if (again) {
    3432         if (!startNewIteration(config, (psS64)atoll(det_id))) {
    3433             if (!psDBRollback(config->dbh)) {
    3434                 psError(PS_ERR_UNKNOWN, false, "database error");
    3435             }
    3436             psError(PS_ERR_UNKNOWN, false, "failed to start new iteration");
    3437             return false;
    3438         }
    3439     } else {
    3440         // set detRun.state to stop
    3441         if (!setDetRunState(config, (psS64)atoll(det_id), "stop")) {
    3442             if (!psDBRollback(config->dbh)) {
    3443                 psError(PS_ERR_UNKNOWN, false, "database error");
    3444             }
    3445             psError(PS_ERR_UNKNOWN, false, "failed to set detRun.state");
    3446             return false;
    3447         }
    3448     }
    3449 
    3450     if (!psDBCommit(config->dbh)) {
    3451         psError(PS_ERR_UNKNOWN, false, "database error");
    3452         return false;
    3453     }
    3454     return true;
    3455 }
    3456 
    3457 static bool detrunsummaryMode(pxConfig *config)
    3458 {
    3459     PS_ASSERT_PTR_NON_NULL(config, false);
    3460 
    3461     psMetadata *where = psMetadataAlloc();
    3462     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    3463     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3464 
    3465     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    3466     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    3467     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    3468 
    3469     psString query = pxDataGet("dettool_detrunsummary.sql");
    3470     if (!query) {
    3471         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3472         psFree(where);
    3473         return false;
    3474     }
    3475 
    3476     if (psListLength(where->list)) {
    3477         psString whereClause = psDBGenerateWhereConditionSQL(where, "NULL");
    3478         psStringAppend(&query, " AND %s", whereClause);
    3479         psFree(whereClause);
    3480     }
    3481     psFree(where);
    3482 
    3483     if (faulted) {
    3484         // list only faulted rows
    3485         psStringAppend(&query, " %s", "AND detRunSummary.fault != 0");
    3486     } else {
    3487         // don't list faulted rows
    3488         psStringAppend(&query, " %s", "AND detRunSummary.fault = 0");
    3489     }
    3490 
    3491     // treat limit == 0 as "no limit"
    3492     if (limit) {
    3493         psString limitString = psDBGenerateLimitSQL(limit);
    3494         psStringAppend(&query, " %s", limitString);
    3495         psFree(limitString);
    3496     }
    3497 
    3498     if (!p_psDBRunQuery(config->dbh, query)) {
    3499         psError(PS_ERR_UNKNOWN, false, "database error");
    3500         psFree(query);
    3501         return false;
    3502     }
    3503     psFree(query);
    3504 
    3505     psArray *output = p_psDBFetchResult(config->dbh);
    3506     if (!output) {
    3507         psError(PS_ERR_UNKNOWN, false, "database error");
    3508         return false;
    3509     }
    3510     if (!psArrayLength(output)) {
    3511         psTrace("dettool", PS_LOG_INFO, "no rows found");
    3512         psFree(output);
    3513         return true;
    3514     }
    3515 
    3516     // negative simple so the default is true
    3517     if (!ippdbPrintMetadatas(stdout, output, "rawDetrendImfile", !simple)) {
    3518         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    3519         psFree(output);
    3520         return false;
    3521     }
    3522 
    3523     psFree(output);
    3524 
    3525     return true;
    3526 }
    3527 
    3528 
    3529 static bool revertdetrunsummaryMode(pxConfig *config)
    3530 {
    3531     PS_ASSERT_PTR_NON_NULL(config, false);
    3532 
    3533     psMetadata *where = psMetadataAlloc();
    3534     PXOPT_COPY_STR(config->args, where, "-det_id",    "det_id", "==");
    3535     PXOPT_COPY_S32(config->args, where, "-iteration", "iteration", "==");
    3536     PXOPT_COPY_STR(config->args, where, "-code",      "fault", "==");
    3537 
    3538     psString query = pxDataGet("dettool_revertdetrunsummary.sql");
    3539     if (!query) {
    3540         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    3541         return false;
    3542     }
    3543 
    3544     if (psListLength(where->list)) {
    3545         psString whereClause = psDBGenerateWhereConditionSQL(where, "detRunSummary");
    3546         psStringAppend(&query, " AND %s", whereClause);
    3547         psFree(whereClause);
    3548     }
    3549     psFree(where);
    3550 
    3551     if (!p_psDBRunQuery(config->dbh, query)) {
    3552         psError(PS_ERR_UNKNOWN, false, "database error");
    3553         psFree(query);
    3554         return false;
    3555     }
    3556     psFree(query);
    3557 
    3558     if (psDBAffectedRows(config->dbh) < 1) {
    3559         psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    3560         return false;
    3561     }
    3562 
    3563     return true;
    3564 }
    3565 
    3566 
    3567 static bool updatedetrunsummaryMode(pxConfig *config)
    3568 {
    3569     PS_ASSERT_PTR_NON_NULL(config, false);
    3570    
    3571     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
    3572     PXOPT_LOOKUP_BOOL(accept, config->args, "-accept", false);
    3573     PXOPT_LOOKUP_BOOL(reject, config->args, "-reject", false);
    3574 
    3575     if (accept && reject) {
    3576         psError(PS_ERR_UNKNOWN, true, "-accept and -reject are exclusive");
    3577         return false;
    3578     }
    3579 
    3580     if (!(accept || reject)) {
    3581         psError(PS_ERR_UNKNOWN, true, "either -accept or -reject is required");
    3582         return false;
    3583     }
    3584 
    3585     char *query = "UPDATE detRunSummary SET accept = %d WHERE det_id = %"PRId64;
    3586     if (!p_psDBRunQuery(config->dbh, query, accept, (psS64)atoll(det_id))) {
    3587         psError(PS_ERR_UNKNOWN, false, "database error");
    3588         return false;
    3589     }
    3590 
    3591     return true;
    3592 }
    3593 
    3594 
    35951225static bool updatedetrunMode(pxConfig *config)
    35961226{
    35971227    PS_ASSERT_PTR_NON_NULL(config, false);
    35981228
    3599     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     1229    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    36001230    PXOPT_LOOKUP_BOOL(again, config->args, "-again", false);
    36011231    PXOPT_LOOKUP_STR(state, config->args, "-state", false, false);
    … …  
    36131243    if (state) {
    36141244        // set detRun.state to state
    3615         return setDetRunState(config, (psS64)atoll(det_id), state);
     1245        return setDetRunState(config, det_id, state);
    36161246    }
    36171247
    36181248    // else
    36191249    // -again
    3620     if (!startNewIteration(config, (psS64)atoll(det_id))) {
     1250    if (!startNewIteration(config, det_id)) {
    36211251        psError(PS_ERR_UNKNOWN, false, "failed to start new iteration");
    36221252        return false;
    … …  
    36271257
    36281258// used by updatedetrunMode
    3629 static bool startNewIteration(pxConfig *config, psS64 det_id)
     1259bool startNewIteration(pxConfig *config, psS64 det_id)
    36301260{
    36311261    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    37391369
    37401370    // det_id is required
    3741     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false);
     1371    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false);
    37421372
    37431373    // we have to support multipe exp_ids
    … …  
    37841414
    37851415    // add the det_id & iteration == 0 to the where clause
    3786     if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==",
    3787                 (psS64)atoll(det_id))) {
     1416    if (!psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", det_id)) {
    37881417        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    37891418        psFree(where);
    … …  
    38221451
    38231452    // up the detRuns iteration count
    3824     psS32 newIteration = incrementIteration(config, (psS64)atoll(det_id));
     1453    psS32 newIteration = incrementIteration(config, det_id);
    38251454    if (!newIteration) {
    38261455        // rollback
    … …  
    38461475            }
    38471476            // invalid exp_id
    3848             psError(PS_ERR_UNKNOWN, false, "exp_id %s is invalid for det_id %s",
     1477            psError(PS_ERR_UNKNOWN, false, "exp_id %s is invalid for det_id %" PRId64,
    38491478                    (char *)mItem->data.V, det_id);
    38501479            psFree(iter);
    … …  
    38531482        }
    38541483        detInputExpRow *newInputExp = detInputExpRowAlloc(
    3855             (psS64)atoll(det_id),
     1484            det_id,
    38561485            newIteration,
    38571486            inputExp->exp_id,
    … …  
    39121541    PXOPT_LOOKUP_TIME(use_begin, config->args, "-use_begin", false, false);
    39131542    PXOPT_LOOKUP_TIME(use_end, config->args, "-use_end", false, false);
    3914     PXOPT_LOOKUP_STR(parent, config->args, "-parent", false, false);
     1543    PXOPT_LOOKUP_S64(parent, config->args, "-parent", false, false);
    39151544    PXOPT_LOOKUP_STR(label, config->args, "-label", false, false);
    39161545    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    … …  
    39501579                      solang_max,
    39511580                      label,      // label
    3952                       parent ? (psS64)atoll(parent) : 0
     1581                      parent
    39531582            )) {
    39541583        psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    40011630    PS_ASSERT_PTR_NON_NULL(config, false);
    40021631   
    4003     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     1632    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    40041633    PXOPT_LOOKUP_STR(class_id, config->args, "-class_id", true, false); // required
    40051634    PXOPT_LOOKUP_STR(uri, config->args, "-uri", true, false); // required
    … …  
    40151644
    40161645    if (!detRegisteredImfileInsert(config->dbh,
    4017         (psS64)atoll(det_id),
    4018         0,  // the iteration is fixed at 0
    4019         class_id,
    4020         uri,
    4021         bg,
    4022         bg_stdev,
    4023         bg_mean_stdev,
    4024         user_1,
    4025         user_2,
    4026         user_3,
    4027         user_4,
    4028         user_5,
    4029         path_base,
    4030         0       // fault code
    4031     )) {
     1646                                   det_id,
     1647                                   0,  // the iteration is fixed at 0
     1648                                   class_id,
     1649                                   uri,
     1650                                   bg,
     1651                                   bg_stdev,
     1652                                   bg_mean_stdev,
     1653                                   user_1,
     1654                                   user_2,
     1655                                   user_3,
     1656                                   user_4,
     1657                                   user_5,
     1658                                   path_base,
     1659                                   "full",                                 
     1660                                   0       // fault code
     1661            )) {
    40321662        psError(PS_ERR_UNKNOWN, false, "database error");
    40331663        return false;
    … …  
    40751705}
    40761706
    4077 static bool setDetRunState(pxConfig *config, psS64 det_id, const char *state)
     1707bool setDetRunState(pxConfig *config, psS64 det_id, const char *state)
    40781708{
    40791709    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    41031733}
    41041734
    4105 static bool isValidMode(pxConfig *config, const char *mode)
     1735bool isValidDataState (const char *data_state) {
     1736
     1737    // check that state is a valid string value
     1738    if (!strncmp(data_state, "run", 4)) return true;
     1739    if (!strncmp(data_state, "stop", 5)) return true;
     1740    if (!strncmp(data_state, "drop", 5)) return true;
     1741    if (!strncmp(data_state, "register", 4)) return true;
     1742
     1743    psError(PS_ERR_UNKNOWN, true, "invalid data state: %s", data_state);
     1744    return false;
     1745}
     1746
     1747bool isValidMode(pxConfig *config, const char *mode)
    41061748{
    41071749    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    41221764}
    41231765
     1766
     1767bool setProcessedImfileDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *class_id, const char *data_state)
     1768{
     1769    PS_ASSERT_PTR_NON_NULL(config, false);
     1770    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1771    PS_ASSERT_PTR_NON_NULL(class_id, false);
     1772
     1773    if (!isValidDataState (data_state)) return false;
     1774
     1775    char *query = "UPDATE detProcessedImfile SET data_state = '%s'"
     1776        " WHERE det_id = %" PRId64
     1777        " AND exp_id = %" PRId64
     1778        " AND class_id = '%s'";
     1779    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, exp_id, class_id)) {
     1780        psError(PS_ERR_UNKNOWN, false,
     1781                "failed to change state for det_id %" PRId64 ", exp_id %" PRId64 ", class_id %s",
     1782                det_id, exp_id, class_id);
     1783        return false;
     1784    }
     1785
     1786    return true;
     1787}
     1788
     1789bool setProcessedExpDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *data_state)
     1790{
     1791    PS_ASSERT_PTR_NON_NULL(config, false);
     1792    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1793
     1794    if (!isValidDataState (data_state)) return false;
     1795
     1796    char *query = "UPDATE detProcessedExp SET data_state = '%s'"
     1797        " WHERE det_id = %" PRId64
     1798        " AND exp_id = %" PRId64;
     1799    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, exp_id)) {
     1800        psError(PS_ERR_UNKNOWN, false,
     1801                "failed to change state for det_id %" PRId64 ", exp_id %" PRId64,
     1802                det_id, exp_id);
     1803        return false;
     1804    }
     1805
     1806    return true;
     1807}
     1808
     1809
     1810bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
     1811{
     1812    PS_ASSERT_PTR_NON_NULL(config, false);
     1813    PS_ASSERT_PTR_NON_NULL(class_id, false);
     1814    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1815
     1816    if (!isValidDataState (data_state)) return false;
     1817
     1818    char *query = "UPDATE detStackedImfile SET data_state = '%s'"
     1819        " WHERE det_id = %" PRId64
     1820        " AND iteration = %" PRId32
     1821        " AND class_id = %s";
     1822    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration, class_id)) {
     1823        psError(PS_ERR_UNKNOWN, false,
     1824                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 "class_id %s",
     1825                det_id, iteration, class_id);
     1826        return false;
     1827    }
     1828
     1829    return true;
     1830}
     1831
     1832bool setNormStatImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
     1833{
     1834    PS_ASSERT_PTR_NON_NULL(config, false);
     1835    PS_ASSERT_PTR_NON_NULL(class_id, false);
     1836    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1837
     1838    if (!isValidDataState (data_state)) return false;
     1839
     1840    char *query = "UPDATE detNormalizedStatImfile SET data_state = '%s'"
     1841        " WHERE det_id = %" PRId64
     1842        " AND iteration = %" PRId32
     1843        " AND class_id = %s";
     1844    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration)) {
     1845        psError(PS_ERR_UNKNOWN, false,
     1846                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     1847                det_id, iteration);
     1848        return false;
     1849    }
     1850
     1851    return true;
     1852}
     1853
     1854bool setNormImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state)
     1855{
     1856    PS_ASSERT_PTR_NON_NULL(config, false);
     1857    PS_ASSERT_PTR_NON_NULL(class_id, false);
     1858    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1859
     1860    if (!isValidDataState (data_state)) return false;
     1861
     1862    char *query = "UPDATE detNormalizedImfile SET data_state = '%s'"
     1863        " WHERE det_id = %" PRId64
     1864        " AND iteration = %" PRId32
     1865        " AND class_id = %s";
     1866    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration, class_id)) {
     1867        psError(PS_ERR_UNKNOWN, false,
     1868                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 " class %s",
     1869                det_id, iteration, class_id);
     1870        return false;
     1871    }
     1872
     1873    return true;
     1874}
     1875
     1876bool setNormExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *data_state)
     1877{
     1878    PS_ASSERT_PTR_NON_NULL(config, false);
     1879    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1880
     1881    if (!isValidDataState (data_state)) return false;
     1882
     1883    char *query = "UPDATE detNormalizedExp SET data_state = '%s'"
     1884        " WHERE det_id = %" PRId64
     1885        " AND iteration = %" PRId32;
     1886    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration)) {
     1887        psError(PS_ERR_UNKNOWN, false,
     1888                "failed to change state for det_id %" PRId64 ", iteration %" PRId32,
     1889                det_id, iteration);
     1890        return false;
     1891    }
     1892
     1893    return true;
     1894}
     1895
     1896bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state)
     1897{
     1898    PS_ASSERT_PTR_NON_NULL(config, false);
     1899    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1900    PS_ASSERT_PTR_NON_NULL(class_id, false);
     1901
     1902    if (!isValidDataState (data_state)) return false;
     1903
     1904    char *query = "UPDATE detResidImfile SET data_state = '%s'"
     1905        " WHERE det_id = %" PRId64
     1906        " AND iteration = %" PRId32
     1907        " AND exp_id = %" PRId64
     1908        " AND class_id = '%s'";
     1909    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration, exp_id, class_id)) {
     1910        psError(PS_ERR_UNKNOWN, false,
     1911                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64 ", class_id %s",
     1912                det_id, iteration, exp_id, class_id);
     1913        return false;
     1914    }
     1915
     1916    return true;
     1917}
     1918
     1919bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state)
     1920{
     1921    PS_ASSERT_PTR_NON_NULL(config, false);
     1922    PS_ASSERT_PTR_NON_NULL(data_state, false);
     1923
     1924    if (!isValidDataState (data_state)) return false;
     1925
     1926    char *query = "UPDATE detResidExp SET data_state = '%s'"
     1927        " WHERE det_id = %" PRId64
     1928        " AND iteration = %" PRId32
     1929        " AND exp_id = %" PRId64;
     1930    if (!p_psDBRunQuery(config->dbh, query, data_state, det_id, iteration, exp_id)) {
     1931        psError(PS_ERR_UNKNOWN, false,
     1932                "failed to change state for det_id %" PRId64 ", iteration %" PRId32 ", exp_id %" PRId64,
     1933                det_id, iteration, exp_id);
     1934        return false;
     1935    }
     1936
     1937    return true;
     1938}
    41241939
    41251940#if 0

  • trunk/ippTools/src/dettool.h

    r18561 r19092  
    4141    DETTOOL_MODE_INPUT,
    4242    DETTOOL_MODE_RAW,
     43
    4344    DETTOOL_MODE_TOPROCESSEDIMFILE,
    4445    DETTOOL_MODE_ADDPROCESSEDIMFILE,
    4546    DETTOOL_MODE_PROCESSEDIMFILE,
    4647    DETTOOL_MODE_REVERTPROCESSEDIMFILE,
     48    DETTOOL_MODE_UPDATEPROCESSEDIMFILE,
     49    DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE,
     50    DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE,
     51
    4752    DETTOOL_MODE_TOPROCESSEDEXP,
    4853    DETTOOL_MODE_ADDPROCESSEDEXP,
    4954    DETTOOL_MODE_PROCESSEDEXP,
    5055    DETTOOL_MODE_REVERTPROCESSEDEXP,
     56    DETTOOL_MODE_UPDATEPROCESSEDEXP,
     57    DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP,
     58    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP,
     59
    5160    DETTOOL_MODE_TOSTACKED,
    5261    DETTOOL_MODE_ADDSTACKED,
    5362    DETTOOL_MODE_STACKED,
    5463    DETTOOL_MODE_REVERTSTACKED,
     64    DETTOOL_MODE_UPDATESTACKED,
     65    DETTOOL_MODE_PENDINGCLEANUP_STACKED,
     66    DETTOOL_MODE_DONECLEANUP_STACKED,
     67
    5568    DETTOOL_MODE_TONORMALIZEDSTAT,
    5669    DETTOOL_MODE_ADDNORMALIZEDSTAT,
    5770    DETTOOL_MODE_NORMALIZEDSTAT,
    5871    DETTOOL_MODE_REVERTNORMALIZEDSTAT,
     72    DETTOOL_MODE_UPDATENORMALIZEDSTAT,
     73    DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDSTAT,
     74    DETTOOL_MODE_DONECLEANUP_NORMALIZEDSTAT,
     75
    5976    DETTOOL_MODE_TONORMALIZE,
    6077    DETTOOL_MODE_ADDNORMALIZEDIMFILE,
    6178    DETTOOL_MODE_NORMALIZEDIMFILE,
    6279    DETTOOL_MODE_REVERTNORMALIZEDIMFILE,
     80    DETTOOL_MODE_UPDATENORMALIZEDIMFILE,
     81    DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDIMFILE,
     82    DETTOOL_MODE_DONECLEANUP_NORMALIZEDIMFILE,
     83
    6384    DETTOOL_MODE_TONORMALIZEDEXP,
    6485    DETTOOL_MODE_ADDNORMALIZEDEXP,
    6586    DETTOOL_MODE_NORMALIZEDEXP,
    6687    DETTOOL_MODE_REVERTNORMALIZEDEXP,
     88    DETTOOL_MODE_UPDATENORMALIZEDEXP,
     89    DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDEXP,
     90    DETTOOL_MODE_DONECLEANUP_NORMALIZEDEXP,
     91
    6792    DETTOOL_MODE_TORESIDIMFILE,
    6893    DETTOOL_MODE_ADDRESIDIMFILE,
    6994    DETTOOL_MODE_RESIDIMFILE,
    7095    DETTOOL_MODE_REVERTRESIDIMFILE,
     96    DETTOOL_MODE_UPDATERESIDIMFILE,
     97    DETTOOL_MODE_PENDINGCLEANUP_RESIDIMFILE,
     98    DETTOOL_MODE_DONECLEANUP_RESIDIMFILE,
     99
    71100    DETTOOL_MODE_TORESIDEXP,
    72101    DETTOOL_MODE_ADDRESIDEXP,
    73102    DETTOOL_MODE_RESIDEXP,
    74103    DETTOOL_MODE_REVERTRESIDEXP,
     104    DETTOOL_MODE_UPDATERESIDEXP,
     105    DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP,
     106    DETTOOL_MODE_DONECLEANUP_RESIDEXP,
     107
    75108    DETTOOL_MODE_TODETRUNSUMMARY,
    76109    DETTOOL_MODE_ADDDETRUNSUMMARY,
    77110    DETTOOL_MODE_DETRUNSUMMARY,
    78111    DETTOOL_MODE_REVERTDETRUNSUMMARY,
    79     DETTOOL_MODE_UPDATERESIDEXP,
    80112    DETTOOL_MODE_UPDATEDETRUNSUMMARY,
    81113    DETTOOL_MODE_UPDATEDETRUN,
    … …  
    92124bool tocorrectimfileMode(pxConfig *config);
    93125bool addcorrectimfileMode(pxConfig *config);
     126
    94127// register
    95128bool register_detrend_imfileMode(pxConfig *config);
    96129
     130// processedimfile
     131bool toprocessedimfileMode(pxConfig *config);
     132bool addprocessedimfileMode(pxConfig *config);
     133bool processedimfileMode(pxConfig *config);
     134bool revertprocessedimfileMode(pxConfig *config);
     135bool updateprocessedimfileMode(pxConfig *config);
     136bool pendingcleanup_processedimfileMode(pxConfig *config);
     137bool donecleanup_processedimfileMode(pxConfig *config);
     138
     139// processedexp
     140bool toprocessedexpMode(pxConfig *config);
     141bool addprocessedexpMode(pxConfig *config);
     142bool processedexpMode(pxConfig *config);
     143bool revertprocessedexpMode(pxConfig *config);
     144bool updateprocessedexpMode(pxConfig *config);
     145bool pendingcleanup_processedexpMode(pxConfig *config);
     146bool donecleanup_processedexpMode(pxConfig *config);
     147
     148// stackedimfile
     149bool tostackedMode(pxConfig *config);
     150bool addstackedMode(pxConfig *config);
     151bool stackedMode(pxConfig *config);
     152bool revertstackedMode(pxConfig *config);
     153bool updatestackedMode(pxConfig *config);
     154bool pendingcleanup_stackedMode(pxConfig *config);
     155bool donecleanup_stackedMode(pxConfig *config);
     156
     157// normalizedstat
     158bool tonormalizedstatMode(pxConfig *config);
     159bool addnormalizedstatMode(pxConfig *config);
     160bool normalizedstatMode(pxConfig *config);
     161bool revertnormalizedstatMode(pxConfig *config);
     162bool updatenormalizedstatMode(pxConfig *config);
     163bool pendingcleanup_normalizedstatMode(pxConfig *config);
     164bool donecleanup_normalizedstatMode(pxConfig *config);
     165
     166// normalizedimfile
     167bool tonormalizeMode(pxConfig *config);
     168bool addnormalizedimfileMode(pxConfig *config);
     169bool normalizedimfileMode(pxConfig *config);
     170bool revertnormalizedimfileMode(pxConfig *config);
     171bool updatenormalizedimfileMode(pxConfig *config);
     172bool pendingcleanup_normalizedimfileMode(pxConfig *config);
     173bool donecleanup_normalizedimfileMode(pxConfig *config);
     174
     175// normalizedexp
     176bool tonormalizedexpMode(pxConfig *config);
     177bool addnormalizedexpMode(pxConfig *config);
     178bool normalizedexpMode(pxConfig *config);
     179bool revertnormalizedexpMode(pxConfig *config);
     180bool updatenormalizedexpMode(pxConfig *config);
     181bool pendingcleanup_normalizedexpMode(pxConfig *config);
     182bool donecleanup_normalizedexpMode(pxConfig *config);
     183
     184// residimfile
     185bool toresidimfileMode(pxConfig *config);
     186bool addresidimfileMode(pxConfig *config);
     187bool residimfileMode(pxConfig *config);
     188bool revertresidimfileMode(pxConfig *config);
     189bool updateresidimfileMode(pxConfig *config);
     190bool pendingcleanup_residimfileMode(pxConfig *config);
     191bool donecleanup_residimfileMode(pxConfig *config);
     192
     193// residexp
     194bool toresidexpMode(pxConfig *config);
     195bool addresidexpMode(pxConfig *config);
     196bool residexpMode(pxConfig *config);
     197bool revertresidexpMode(pxConfig *config);
     198bool updateresidexpMode(pxConfig *config);
     199bool pendingcleanup_residexpMode(pxConfig *config);
     200bool donecleanup_residexpMode(pxConfig *config);
     201
     202// detrunsummary
     203bool todetrunsummaryMode(pxConfig *config);
     204bool adddetrunsummaryMode(pxConfig *config);
     205bool detrunsummaryMode(pxConfig *config);
     206bool revertdetrunsummaryMode(pxConfig *config);
     207bool updatedetrunsummaryMode(pxConfig *config);
     208
     209// other utilities
     210bool startNewIteration(pxConfig *config, psS64 det_id);
     211bool setDetRunState(pxConfig *config, psS64 det_id, const char *state);
     212bool isValidDataState (const char *data_state);
     213bool isValidMode(pxConfig *config, const char *mode);
     214
     215// functions to set the 'data_state' for stages
     216bool setProcessedImfileDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *class_id, const char *data_state);
     217bool setProcessedExpDataState(pxConfig *config, psS64 det_id, psS64 exp_id, const char *data_state);
     218bool setStackedImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
     219bool setNormStatImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
     220bool setNormImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *class_id, const char *data_state);
     221bool setNormExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, const char *data_state);
     222bool setResidImfileDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *data_state);
     223bool setResidExpDataState(pxConfig *config, psS64 det_id, psS32 iteration, psS64 exp_id, const char *data_state);
     224
    97225#endif // DETTOOL_H

  • trunk/ippTools/src/dettoolConfig.c

    r18938 r19092  
    4141    // XXX EAM : is this used?  does it make sense?
    4242    psMetadata *pendingArgs = psMetadataAlloc();
    43     psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     43    psMetadataAddS64(pendingArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    4444    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exposure type", NULL);
    4545    psMetadataAddStr(pendingArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera", NULL);
    … …  
    5151    // -definebytag
    5252    psMetadata *definebytagArgs = psMetadataAlloc();
    53     psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-exp_id",            PS_META_DUPLICATE_OK,           "include this exposure (multiple OK, required)", NULL);
     53    psMetadataAddS64(definebytagArgs, PS_LIST_TAIL, "-exp_id",            PS_META_DUPLICATE_OK,           "include this exposure (multiple OK, required)", 0);
    5454    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-det_type",  0,            "define the type of detrend run (required)", NULL);
    5555    psMetadataAddStr(definebytagArgs, PS_LIST_TAIL, "-mode",  0,            "define the mode of this detrend run", "master");
    … …  
    132132    // -definebydetrun
    133133    psMetadata *definebydetrunArgs = psMetadataAlloc();
    134     psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to base a new detRun on (required)", NULL);
     134    psMetadataAddS64(definebydetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to base a new detRun on (required)", 0);
    135135    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_det_type",  0,            "define the type of detrend run", NULL);
    136136    psMetadataAddStr(definebydetrunArgs, PS_LIST_TAIL, "-set_mode",  0,            "define the mode of this detrend run", "master");
    … …  
    163163    // -makecorrection
    164164    psMetadata *makecorrectionArgs = psMetadataAlloc();
    165     psMetadataAddStr(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to be corrected (required)", NULL);
     165    psMetadataAddS64(makecorrectionArgs, PS_LIST_TAIL, "-det_id",  0,            "det ID to be corrected (required)", 0);
    166166    psMetadataAddBool(makecorrectionArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    167167
    … …  
    173173    // -tocorrectimfile
    174174    psMetadata *tocorrectimfileArgs = psMetadataAlloc();
    175     psMetadataAddStr(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     175    psMetadataAddS64(tocorrectimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", 0);
    176176    psMetadataAddU64(tocorrectimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    177177    psMetadataAddBool(tocorrectimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    179179    // -addcorrectimfile
    180180    psMetadata *addcorrectimfileArgs = psMetadataAlloc();
    181     psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     181    psMetadataAddS64(addcorrectimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    182182    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
    183183    psMetadataAddStr(addcorrectimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI", NULL);
    … …  
    195195    psMetadata *runsArgs = psMetadataAlloc();
    196196    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_type",  0,            "search for type of detrend run", NULL);
    197     psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     197    psMetadataAddS64(runsArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", 0);
    198198    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-inst", 0,            "search for camera (instrument)", NULL);
    199199    psMetadataAddStr(runsArgs, PS_LIST_TAIL, "-telescope", 0,            "search for telescope", NULL);
    … …  
    215215    // -input
    216216    psMetadata *inputArgs = psMetadataAlloc();
    217     psMetadataAddStr(inputArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", NULL);
     217    psMetadataAddS64(inputArgs, PS_LIST_TAIL, "-det_id", 0,            "search for detrend ID", 0);
    218218    psMetadataAddS32(inputArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    219219    psMetadataAddS64(inputArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", 0);
    … …  
    226226    // -toprocessedimfile
    227227    psMetadata *toprocessedimfileArgs = psMetadataAlloc();
    228     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
    229     psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     228    psMetadataAddS64(toprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
     229    psMetadataAddS64(toprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", 0);
    230230    psMetadataAddStr(toprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
    231231    psMetadataAddU64(toprocessedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    … …  
    234234    // -addprocessedimfile
    235235    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    236     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
    237     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID (required)", NULL);
     236    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
     237    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID (required)", 0);
    238238    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    239239    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    … …  
    255255    // -processedimfile
    256256    psMetadata *processedimfileArgs = psMetadataAlloc();
    257     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
    258     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     257    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
     258    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", 0);
    259259    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
    260260    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
    … …  
    265265    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    266266
    267     // XXX these don't seem to be used anymore
    268     // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-chip",  0,            "restrict results to completed 'chip' sets", false);
    269     // psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-exp",  0,            "restrict results to complete 'exposures'", false);
    270 
    271267    // -revertprocessedimfile
    272268    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    273     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
    274     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     269    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", 0);
     270    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    275271    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    276272    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     273
     274    // -updateprocessedimfile
     275    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
     276    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     277    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     278    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     279    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     280
     281    // -pendingcleanup_processedimfile
     282    psMetadata *pendingcleanup_processedimfileArgs = psMetadataAlloc();
     283    psMetadataAddBool(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     284    psMetadataAddU64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     285    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     286    psMetadataAddS64(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
     287    psMetadataAddStr(pendingcleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     288
     289    // -donecleanup_processedimfile
     290    psMetadata *donecleanup_processedimfileArgs = psMetadataAlloc();
     291    psMetadataAddBool(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     292    psMetadataAddU64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     293    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     294    psMetadataAddS64(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
     295    psMetadataAddStr(donecleanup_processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    277296
    278297    // -toprocessedexp
    … …  
    283302    // -addproccessedexp
    284303    psMetadata *addprocessedexpArgs = psMetadataAlloc();
    285     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
    286     psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     304    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
     305    psMetadataAddS64(addprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", 0);
    287306    psMetadataAddStr(addprocessedexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    288307    psMetadataAddF64(addprocessedexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    302321    // -proccessedexp
    303322    psMetadata *processedexpArgs = psMetadataAlloc();
    304     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
    305     psMetadataAddStr(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp ID", NULL);
     323    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", 0);
     324    psMetadataAddS64(processedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp ID", 0);
    306325    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    307326    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    … …  
    310329    // -revertprocessedexp
    311330    psMetadata *revertprocessedexpArgs = psMetadataAlloc();
    312     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
    313     psMetadataAddStr(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", NULL);
     331    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", 0);
     332    psMetadataAddS64(revertprocessedexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
    314333    psMetadataAddS16(revertprocessedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     334
     335    // -updateprocessedexp
     336    psMetadata *updateprocessedexpArgs = psMetadataAlloc();
     337    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     338    psMetadataAddS64(updateprocessedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     339    psMetadataAddStr(updateprocessedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     340
     341    // -pendingcleanup_processedexp
     342    psMetadata *pendingcleanup_processedexpArgs = psMetadataAlloc();
     343    psMetadataAddBool(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     344    psMetadataAddU64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     345    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     346    psMetadataAddS64(pendingcleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     347
     348    // -donecleanup_processedexp
     349    psMetadata *donecleanup_processedexpArgs = psMetadataAlloc();
     350    psMetadataAddBool(donecleanup_processedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     351    psMetadataAddU64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     352    psMetadataAddS64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     353    psMetadataAddS64(donecleanup_processedexpArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
    315354
    316355    // -tostacked
    … …  
    321360    // -addstacked
    322361    psMetadata *addstackedArgs = psMetadataAlloc();
    323     psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     362    psMetadataAddS64(addstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    324363    psMetadataAddS32(addstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number (required)", 0);
    325364    psMetadataAddStr(addstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    … …  
    338377    // -stacked
    339378    psMetadata *stackedArgs = psMetadataAlloc();
    340     psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     379    psMetadataAddS64(stackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
    341380    psMetadataAddS32(stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
    342381    psMetadataAddStr(stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
    … …  
    348387    // -revertstacked
    349388    psMetadata *revertstackedArgs= psMetadataAlloc();
    350     psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", NULL);
     389    psMetadataAddS64(revertstackedArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID (required)", 0);
    351390    psMetadataAddS32(revertstackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    352391    psMetadataAddStr(revertstackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    353392    psMetadataAddS16(revertstackedArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     393
     394    // -updatestacked
     395    psMetadata *updatestackedArgs = psMetadataAlloc();
     396    psMetadataAddS64(updatestackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     397    psMetadataAddS32(updatestackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     398    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     399    psMetadataAddStr(updatestackedArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     400
     401    // -pendingcleanup_stacked
     402    psMetadata *pendingcleanup_stackedArgs = psMetadataAlloc();
     403    psMetadataAddBool(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     404    psMetadataAddU64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     405    psMetadataAddS64(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     406    psMetadataAddS32(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     407    psMetadataAddStr(pendingcleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     408
     409    // -donecleanup_stacked
     410    psMetadata *donecleanup_stackedArgs = psMetadataAlloc();
     411    psMetadataAddBool(donecleanup_stackedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     412    psMetadataAddU64(donecleanup_stackedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     413    psMetadataAddS64(donecleanup_stackedArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     414    psMetadataAddS32(donecleanup_stackedArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     415    psMetadataAddStr(donecleanup_stackedArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    354416
    355417    // -tonormalizedstat
    … …  
    360422    // -addnormalizedstat
    361423    psMetadata *addnormstatArgs = psMetadataAlloc();
    362     psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     424    psMetadataAddS64(addnormstatArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    363425    psMetadataAddS32(addnormstatArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    364426    psMetadataAddStr(addnormstatArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    … …  
    368430    // -normalizedstat
    369431    psMetadata *normalizedstatArgs = psMetadataAlloc();
    370     psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     432    psMetadataAddS64(normalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", 0);
    371433    psMetadataAddS32(normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    372434    psMetadataAddStr(normalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    … …  
    377439    // -revertnormalizedstat
    378440    psMetadata *revertnormalizedstatArgs= psMetadataAlloc();
    379     psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", NULL);
     441    psMetadataAddS64(revertnormalizedstatArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID (required)", 0);
    380442    psMetadataAddS32(revertnormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    381443    psMetadataAddStr(revertnormalizedstatArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
    382444    psMetadataAddS16(revertnormalizedstatArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     445
     446    // -updatenormalizedstat
     447    psMetadata *updatenormalizedstatArgs = psMetadataAlloc();
     448    psMetadataAddS64(updatenormalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     449    psMetadataAddS32(updatenormalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     450    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     451    psMetadataAddStr(updatenormalizedstatArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     452
     453    // -pendingcleanup_normalizedstat
     454    psMetadata *pendingcleanup_normalizedstatArgs = psMetadataAlloc();
     455    psMetadataAddBool(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     456    psMetadataAddU64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     457    psMetadataAddS64(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     458    psMetadataAddS32(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     459    psMetadataAddStr(pendingcleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     460
     461    // -donecleanup_normalizedstat
     462    psMetadata *donecleanup_normalizedstatArgs = psMetadataAlloc();
     463    psMetadataAddBool(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     464    psMetadataAddU64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     465    psMetadataAddS64(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     466    psMetadataAddS32(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
     467    psMetadataAddStr(donecleanup_normalizedstatArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    383468
    384469    // -tonormalize
    … …  
    389474    // -addnormalizedimfile
    390475    psMetadata *addnormalizedimfileArgs = psMetadataAlloc();
    391     psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "define detrend ID (required)", NULL);
     476    psMetadataAddS64(addnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "define detrend ID (required)", 0);
    392477    psMetadataAddS32(addnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "define iteration number", 0);
    393478    psMetadataAddStr(addnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "define class ID (required)", NULL);
    … …  
    406491    // -normalizedimfile
    407492    psMetadata *normalizedimfileArgs = psMetadataAlloc();
    408     psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     493    psMetadataAddS64(normalizedimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
    409494    psMetadataAddS32(normalizedimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
    410495    psMetadataAddStr(normalizedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
    … …  
    416501    // -revertnormalizedimfile
    417502    psMetadata *revertnormalizedimfileArgs = psMetadataAlloc();
    418     psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     503    psMetadataAddS64(revertnormalizedimfileArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    419504    psMetadataAddS32(revertnormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    420505    psMetadataAddStr(revertnormalizedimfileArgs, PS_LIST_TAIL, "-class_id", 0,            "search by class ID", NULL);
    421506    psMetadataAddS16(revertnormalizedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     507
     508    // -updatenormalizedimfile
     509    psMetadata *updatenormalizedimfileArgs = psMetadataAlloc();
     510    psMetadataAddS64(updatenormalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     511    psMetadataAddS32(updatenormalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     512    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     513    psMetadataAddStr(updatenormalizedimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     514
     515    // -pendingcleanup_normalizedimfile
     516    psMetadata *pendingcleanup_normalizedimfileArgs = psMetadataAlloc();
     517    psMetadataAddBool(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     518    psMetadataAddU64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     519    psMetadataAddS64(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     520    psMetadataAddS32(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     521    psMetadataAddStr(pendingcleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     522
     523    // -donecleanup_normalizedimfile
     524    psMetadata *donecleanup_normalizedimfileArgs = psMetadataAlloc();
     525    psMetadataAddBool(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     526    psMetadataAddU64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     527    psMetadataAddS64(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     528    psMetadataAddS32(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     529    psMetadataAddStr(donecleanup_normalizedimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    422530
    423531    // -tonormalizedexp
    … …  
    428536    // -addnormalizedexp
    429537    psMetadata *addnormalizedexpArgs = psMetadataAlloc();
    430     psMetadataAddStr(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     538    psMetadataAddS64(addnormalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    431539    psMetadataAddS32(addnormalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    432540    psMetadataAddS16(addnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    … …  
    444552    // -normalizedexp
    445553    psMetadata *normalizedexpArgs = psMetadataAlloc();
    446     psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", NULL);
     554    psMetadataAddS64(normalizedexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search by detrend ID", 0);
    447555    psMetadataAddS32(normalizedexpArgs, PS_LIST_TAIL, "-iteration",  0,            "search by iteration number", 0);
    448556    psMetadataAddStr(normalizedexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
    … …  
    453561    // -revertnormalizedexp
    454562    psMetadata *revertnormalizedexpArgs = psMetadataAlloc();
    455     psMetadataAddStr(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     563    psMetadataAddS64(revertnormalizedexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    456564    psMetadataAddS32(revertnormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    457565    psMetadataAddS16(revertnormalizedexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
     566
     567    // -updatenormalizedexp
     568    psMetadata *updatenormalizedexpArgs = psMetadataAlloc();
     569    psMetadataAddS64(updatenormalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     570    psMetadataAddS32(updatenormalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     571    psMetadataAddStr(updatenormalizedexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     572
     573    // -pendingcleanup_normalizedexp
     574    psMetadata *pendingcleanup_normalizedexpArgs = psMetadataAlloc();
     575    psMetadataAddBool(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     576    psMetadataAddU64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     577    psMetadataAddS64(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     578    psMetadataAddS32(pendingcleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     579
     580    // -donecleanup_normalizedexp
     581    psMetadata *donecleanup_normalizedexpArgs = psMetadataAlloc();
     582    psMetadataAddBool(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     583    psMetadataAddU64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     584    psMetadataAddS64(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     585    psMetadataAddS32(donecleanup_normalizedexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    458586
    459587    // -toresidimfile
    … …  
    464592    // -addresidimfile
    465593    psMetadata *addresidimfileArgs = psMetadataAlloc();
    466     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     594    psMetadataAddS64(addresidimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    467595    psMetadataAddS32(addresidimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    468     psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     596    psMetadataAddS64(addresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", 0);
    469597    psMetadataAddStr(addresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
    470598    psMetadataAddS16(addresidimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    … …  
    492620    // -residimfile
    493621    psMetadata *residimfileArgs = psMetadataAlloc();
    494     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     622    psMetadataAddS64(residimfileArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
    495623    psMetadataAddS32(residimfileArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
    496     psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     624    psMetadataAddS64(residimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
    497625    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID", NULL);
    498626    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
    … …  
    504632    // -revertresidimfile
    505633    psMetadata *revertresidimfileArgs =  psMetadataAlloc();
    506     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,          "search by detrend ID (required)", NULL);
     634    psMetadataAddS64(revertresidimfileArgs, PS_LIST_TAIL, "-det_id", 0,          "search by detrend ID (required)", 0);
    507635    psMetadataAddS32(revertresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
    508     psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,         "search by detrend ID", NULL);
     636    psMetadataAddS64(revertresidimfileArgs, PS_LIST_TAIL, "-exp_id",  0,         "search by detrend ID", 0);
    509637    psMetadataAddStr(revertresidimfileArgs, PS_LIST_TAIL, "-class_id",  0,       "search for class ID", NULL);
    510638    psMetadataAddS16(revertresidimfileArgs, PS_LIST_TAIL, "-code",  0,           "search by fault code", 0);
     639
     640    // -updateresidimfile
     641    psMetadata *updateresidimfileArgs = psMetadataAlloc();
     642    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     643    psMetadataAddS32(updateresidimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
     644    psMetadataAddS64(updateresidimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     645    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     646    psMetadataAddStr(updateresidimfileArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     647
     648    // -pendingcleanup_residimfile
     649    psMetadata *pendingcleanup_residimfileArgs = psMetadataAlloc();
     650    psMetadataAddBool(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     651    psMetadataAddU64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     652    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     653    psMetadataAddS32(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
     654    psMetadataAddS64(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     655    psMetadataAddStr(pendingcleanup_residimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
     656
     657    // -donecleanup_residimfile
     658    psMetadata *donecleanup_residimfileArgs = psMetadataAlloc();
     659    psMetadataAddBool(donecleanup_residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     660    psMetadataAddU64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     661    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-det_id",               0,            "search by chip ID", 0);
     662    psMetadataAddS32(donecleanup_residimfileArgs, PS_LIST_TAIL, "-iteration", 0,       "search by iteration number", 0);
     663    psMetadataAddS64(donecleanup_residimfileArgs, PS_LIST_TAIL, "-exp_id",               0,            "search by exp_id", 0);
     664    psMetadataAddStr(donecleanup_residimfileArgs, PS_LIST_TAIL, "-class_id",             0,            "search by exp_name", NULL);
    511665
    512666    // -toresidexp
    … …  
    517671    // -addresidexp
    518672    psMetadata *addresidexpArgs = psMetadataAlloc();
    519     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     673    psMetadataAddS64(addresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    520674    psMetadataAddS32(addresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    521     psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", NULL);
     675    psMetadataAddS64(addresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define detrend ID (required)", 0);
    522676    psMetadataAddS16(addresidexpArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    523677    psMetadataAddStr(addresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    … …  
    544698    // -residexp
    545699    psMetadata *residexpArgs = psMetadataAlloc();
    546     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     700    psMetadataAddS64(residexpArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
    547701    psMetadataAddS32(residexpArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
    548     psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", NULL);
     702    psMetadataAddS64(residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search for exp ID", 0);
    549703    psMetadataAddStr(residexpArgs, PS_LIST_TAIL, "-recip",  0,            "search for recipe", NULL);
    550704    psMetadataAddBool(residexpArgs, PS_LIST_TAIL, "-reject",  0,            "search for acceptable residuals", false);
    … …  
    555709    // -revertresidexp
    556710    psMetadata *revertresidexpArgs = psMetadataAlloc();
    557     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     711    psMetadataAddS64(revertresidexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    558712    psMetadataAddS32(revertresidexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    559     psMetadataAddStr(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", NULL);
     713    psMetadataAddS64(revertresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
    560714    psMetadataAddS16(revertresidexpArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    561715
    562716    // -updateresidexp
    563717    psMetadata *updateresidexpArgs = psMetadataAlloc();
    564     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID", NULL);
     718    psMetadataAddS64(updateresidexpArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID", 0);
    565719    psMetadataAddS32(updateresidexpArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    566     psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID", NULL);
     720    psMetadataAddS64(updateresidexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exp ID", 0);
    567721    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-recip",  0,            "define recipe", NULL);
    568722    psMetadataAddF64(updateresidexpArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    571725    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    572726    psMetadataAddBool(updateresidexpArgs, PS_LIST_TAIL, "-reject",  0,            "exposure is not to be stacked in the next iteration", false);
     727    psMetadataAddStr(updateresidexpArgs, PS_LIST_TAIL, "-data_state",           0,            "search for telescope", NULL);
     728
     729    // -pendingcleanup_residexp
     730    psMetadata *pendingcleanup_residexpArgs = psMetadataAlloc();
     731    psMetadataAddBool(pendingcleanup_residexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     732    psMetadataAddU64(pendingcleanup_residexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     733    psMetadataAddS64(pendingcleanup_residexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
     734    psMetadataAddS32(pendingcleanup_residexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     735    psMetadataAddS64(pendingcleanup_residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
     736
     737    // -donecleanup_residexp
     738    psMetadata *donecleanup_residexpArgs = psMetadataAlloc();
     739    psMetadataAddBool(donecleanup_residexpArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     740    psMetadataAddU64(donecleanup_residexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     741    psMetadataAddS64(donecleanup_residexpArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
     742    psMetadataAddS32(donecleanup_residexpArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
     743    psMetadataAddS64(donecleanup_residexpArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by detrend ID", 0);
    573744
    574745    // -todetrunsummary
    … …  
    579750    // -adddetrunsummary
    580751    psMetadata *adddetrunsummaryArgs = psMetadataAlloc();
    581     psMetadataAddStr(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     752    psMetadataAddS64(adddetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    582753    psMetadataAddS32(adddetrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "define iteration number", 0);
    583754    psMetadataAddF64(adddetrunsummaryArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);
    … …  
    590761    // -detrunsummary
    591762    psMetadata *detrunsummaryArgs = psMetadataAlloc();
    592     psMetadataAddStr(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", NULL);
     763    psMetadataAddS64(detrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend ID", 0);
    593764    psMetadataAddS32(detrunsummaryArgs, PS_LIST_TAIL, "-iteration",  0,            "search for iteration number", 0);
    594765    psMetadataAddU64(detrunsummaryArgs, PS_LIST_TAIL, "-limit",  0,                     "limit result set to N items", 0);
    … …  
    599770    // -revertdetrunsummary
    600771    psMetadata *revertdetrunsummaryArgs = psMetadataAlloc();
    601     psMetadataAddStr(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", NULL);
     772    psMetadataAddS64(revertdetrunsummaryArgs, PS_LIST_TAIL, "-det_id", 0,            "search by detrend ID (required)", 0);
    602773    psMetadataAddS32(revertdetrunsummaryArgs, PS_LIST_TAIL, "-iteration", 0,            "search by iteration number", 0);
    603774    psMetadataAddS16(revertdetrunsummaryArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    … …  
    605776    // -updatedetrunsummary
    606777    psMetadata *updatedetrunsummaryArgs = psMetadataAlloc();
    607     psMetadataAddStr(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     778    psMetadataAddS64(updatedetrunsummaryArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", 0);
    608779    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-accept",  0,            "declare that this detrun iteration is accepted as a master", false);
    609780    psMetadataAddBool(updatedetrunsummaryArgs, PS_LIST_TAIL, "-reject",  0,            "reject this detrun iteration as a master", false);
    … …  
    611782    // -updatedetrun
    612783    psMetadata *updatedetrunArgs = psMetadataAlloc();
    613     psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
     784    psMetadataAddS64(updatedetrunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", 0);
    614785    psMetadataAddBool(updatedetrunArgs, PS_LIST_TAIL, "-again",  0,            "start a new iteration of this detrend run", false);
    615786    psMetadataAddStr(updatedetrunArgs, PS_LIST_TAIL, "-state",  0,            "set the state of this detrend run", false);
    … …  
    617788    // -rerun
    618789    psMetadata *rerunArgs = psMetadataAlloc();
    619     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", NULL);
    620     psMetadataAddStr(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,            "include this exposure (multiple OK, required)", NULL);
     790    psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-det_id",  0,            "search for detrend master for detrend ID (required)", 0);
     791    psMetadataAddS64(rerunArgs, PS_LIST_TAIL, "-exp_id",  PS_META_DUPLICATE_OK,            "include this exposure (multiple OK, required)", 0);
    621792
    622793    // -register_detrend
    … …  
    644815    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_begin",  0,            "start of detrend run applicable period", NULL);
    645816    psMetadataAddTime(register_detrendArgs, PS_LIST_TAIL, "-use_end",  0,            "end of detrend run applicable period", NULL);
    646     psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,            "define parent det_id", NULL);
     817    psMetadataAddS64(register_detrendArgs, PS_LIST_TAIL, "-parent",  0,            "define parent det_id", 0);
    647818    psMetadataAddStr(register_detrendArgs, PS_LIST_TAIL, "-label",  0,            "define detrun label", NULL);
    648819    psMetadataAddBool(register_detrendArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    … …  
    650821    // -register_detrend_imfile
    651822    psMetadata *register_detrend_imfileArgs = psMetadataAlloc();
    652     psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", NULL);
     823    psMetadataAddS64(register_detrend_imfileArgs, PS_LIST_TAIL, "-det_id",  0,            "define detrend ID (required)", 0);
    653824    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search for class ID (required)", NULL);
    654825    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-uri",  0,            "define resid file URI (required)", NULL);
    … …  
    680851    PXOPT_ADD_MODE("-childlessrun",    "", DETTOOL_MODE_CHILDLESSRUN,  childlessrunArgs);
    681852    PXOPT_ADD_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
    682     PXOPT_ADD_MODE("-toprocessedimfile", "", DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
    683     PXOPT_ADD_MODE("-addprocessedimfile", "", DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
    684     PXOPT_ADD_MODE("-processedimfile", "", DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    685     PXOPT_ADD_MODE("-revertprocessedimfile", "", DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
     853
     854    PXOPT_ADD_MODE("-toprocessedimfile", "",              DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
     855    PXOPT_ADD_MODE("-addprocessedimfile", "",             DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
     856    PXOPT_ADD_MODE("-processedimfile", "",                DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     857    PXOPT_ADD_MODE("-revertprocessedimfile", "",          DETTOOL_MODE_REVERTPROCESSEDIMFILE, revertprocessedimfileArgs);
     858    PXOPT_ADD_MODE("-updateprocessedimfile", "",          DETTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     859    PXOPT_ADD_MODE("-pendingcleanup_processedimfile", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDIMFILE, pendingcleanup_processedimfileArgs);
     860    PXOPT_ADD_MODE("-donecleanup_processedimfile", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDIMFILE, donecleanup_processedimfileArgs);
     861
    686862    PXOPT_ADD_MODE("-toprocessedexp",  "", DETTOOL_MODE_TOPROCESSEDEXP,  toprocessedexpArgs);
    687863    PXOPT_ADD_MODE("-addprocessedexp", "", DETTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     864    PXOPT_ADD_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    688865    PXOPT_ADD_MODE("-revertprocessedexp", "", DETTOOL_MODE_REVERTPROCESSEDEXP, revertprocessedexpArgs);
    689     PXOPT_ADD_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     866    PXOPT_ADD_MODE("-updateprocessedexp", "", DETTOOL_MODE_UPDATEPROCESSEDEXP, updateprocessedexpArgs);
     867    PXOPT_ADD_MODE("-pendingcleanup_processedexp", "", DETTOOL_MODE_PENDINGCLEANUP_PROCESSEDEXP, pendingcleanup_processedexpArgs);
     868    PXOPT_ADD_MODE("-donecleanup_processedexp", "",    DETTOOL_MODE_DONECLEANUP_PROCESSEDEXP, donecleanup_processedexpArgs);
     869
    690870    PXOPT_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    691871    PXOPT_ADD_MODE("-addstacked",      "", DETTOOL_MODE_ADDSTACKED,    addstackedArgs);
    692872    PXOPT_ADD_MODE("-stacked",         "", DETTOOL_MODE_STACKED,       stackedArgs);
    693873    PXOPT_ADD_MODE("-revertstacked",   "", DETTOOL_MODE_REVERTSTACKED,  revertstackedArgs);
     874    PXOPT_ADD_MODE("-updatestacked",   "", DETTOOL_MODE_UPDATESTACKED,  updatestackedArgs);
     875    PXOPT_ADD_MODE("-pendingcleanup_stacked", "", DETTOOL_MODE_PENDINGCLEANUP_STACKED, pendingcleanup_stackedArgs);
     876    PXOPT_ADD_MODE("-donecleanup_stacked", "",    DETTOOL_MODE_DONECLEANUP_STACKED, donecleanup_stackedArgs);
     877
     878    PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormalizedstatArgs);
     879    PXOPT_ADD_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
     880    PXOPT_ADD_MODE("-normalizedstat",        "", DETTOOL_MODE_NORMALIZEDSTAT,   normalizedstatArgs);
     881    PXOPT_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
     882    PXOPT_ADD_MODE("-updatenormalizedstat",  "", DETTOOL_MODE_UPDATENORMALIZEDSTAT,   updatenormalizedstatArgs);
     883    PXOPT_ADD_MODE("-pendingcleanup_normalizedstat", "", DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDSTAT, pendingcleanup_normalizedstatArgs);
     884    PXOPT_ADD_MODE("-donecleanup_normalizedstat", "",    DETTOOL_MODE_DONECLEANUP_NORMALIZEDSTAT, donecleanup_normalizedstatArgs);
     885
    694886    PXOPT_ADD_MODE("-tonormalize",     "", DETTOOL_MODE_TONORMALIZE,   tonormalizeArgs);
    695     PXOPT_ADD_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
    696     PXOPT_ADD_MODE("-normalizedstat",  "", DETTOOL_MODE_NORMALIZEDSTAT,   normalizedstatArgs);
    697     PXOPT_ADD_MODE("-revertnormalizedstat",  "", DETTOOL_MODE_REVERTNORMALIZEDSTAT,   revertnormalizedstatArgs);
    698 
    699     PXOPT_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormalizedstatArgs);
    700887    PXOPT_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
    701888    PXOPT_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
    702889    PXOPT_ADD_MODE("-revertnormalizedimfile","", DETTOOL_MODE_REVERTNORMALIZEDIMFILE, revertnormalizedimfileArgs);
     890    PXOPT_ADD_MODE("-updatenormalizedimfile","", DETTOOL_MODE_UPDATENORMALIZEDIMFILE, updatenormalizedimfileArgs);
     891    PXOPT_ADD_MODE("-pendingcleanup_normalizedimfile", "", DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDIMFILE, pendingcleanup_normalizedimfileArgs);
     892    PXOPT_ADD_MODE("-donecleanup_normalizedimfile", "",    DETTOOL_MODE_DONECLEANUP_NORMALIZEDIMFILE, donecleanup_normalizedimfileArgs);
     893
    703894    PXOPT_ADD_MODE("-tonormalizedexp", "", DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpArgs);
    704895    PXOPT_ADD_MODE("-addnormalizedexp", "", DETTOOL_MODE_ADDNORMALIZEDEXP, addnormalizedexpArgs);
    705896    PXOPT_ADD_MODE("-normalizedexp",   "", DETTOOL_MODE_NORMALIZEDEXP, normalizedexpArgs);
    706897    PXOPT_ADD_MODE("-revertnormalizedexp","", DETTOOL_MODE_REVERTNORMALIZEDEXP, revertnormalizedexpArgs);
     898    PXOPT_ADD_MODE("-updatenormalizedexp","", DETTOOL_MODE_UPDATENORMALIZEDEXP, updatenormalizedexpArgs);
     899    PXOPT_ADD_MODE("-pendingcleanup_normalizedexp", "", DETTOOL_MODE_PENDINGCLEANUP_NORMALIZEDEXP, pendingcleanup_normalizedexpArgs);
     900    PXOPT_ADD_MODE("-donecleanup_normalizedexp", "",    DETTOOL_MODE_DONECLEANUP_NORMALIZEDEXP, donecleanup_normalizedexpArgs);
     901
    707902    PXOPT_ADD_MODE("-toresidimfile",   "", DETTOOL_MODE_TORESIDIMFILE, toresidimfileArgs);
    708903    PXOPT_ADD_MODE("-addresidimfile",  "", DETTOOL_MODE_ADDRESIDIMFILE, addresidimfileArgs);
    709904    PXOPT_ADD_MODE("-residimfile",     "", DETTOOL_MODE_RESIDIMFILE, residimfileArgs);
    710905    PXOPT_ADD_MODE("-revertresidimfile", "", DETTOOL_MODE_REVERTRESIDIMFILE, revertresidimfileArgs);
     906    PXOPT_ADD_MODE("-updateresidimfile", "", DETTOOL_MODE_UPDATERESIDIMFILE, updateresidimfileArgs);
     907    PXOPT_ADD_MODE("-pendingcleanup_residimfile", "", DETTOOL_MODE_PENDINGCLEANUP_RESIDIMFILE, pendingcleanup_residimfileArgs);
     908    PXOPT_ADD_MODE("-donecleanup_residimfile", "",    DETTOOL_MODE_DONECLEANUP_RESIDIMFILE, donecleanup_residimfileArgs);
     909
    711910    PXOPT_ADD_MODE("-toresidexp",      "", DETTOOL_MODE_TORESIDEXP,    toresidexpArgs);
    712911    PXOPT_ADD_MODE("-addresidexp",     "", DETTOOL_MODE_ADDRESIDEXP,  addresidexpArgs);
    713912    PXOPT_ADD_MODE("-residexp",        "", DETTOOL_MODE_RESIDEXP,     residexpArgs);
    714913    PXOPT_ADD_MODE("-revertresidexp",  "", DETTOOL_MODE_REVERTRESIDEXP, revertresidexpArgs);
     914    PXOPT_ADD_MODE("-updateresidexp",  "", DETTOOL_MODE_UPDATERESIDEXP, updateresidexpArgs);
     915    PXOPT_ADD_MODE("-pendingcleanup_residexp", "", DETTOOL_MODE_PENDINGCLEANUP_RESIDEXP, pendingcleanup_residexpArgs);
     916    PXOPT_ADD_MODE("-donecleanup_residexp", "",    DETTOOL_MODE_DONECLEANUP_RESIDEXP, donecleanup_residexpArgs);
     917
    715918    PXOPT_ADD_MODE("-todetrunsummary",  "", DETTOOL_MODE_TODETRUNSUMMARY,  todetrunsummaryArgs);
    716     PXOPT_ADD_MODE("-updateresidexp", "", DETTOOL_MODE_UPDATERESIDEXP,updateresidexpArgs);
    717919    PXOPT_ADD_MODE("-adddetrunsummary", "", DETTOOL_MODE_ADDDETRUNSUMMARY,adddetrunsummaryArgs);
    718920    PXOPT_ADD_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
    719921    PXOPT_ADD_MODE("-revertdetrunsummary", "", DETTOOL_MODE_REVERTDETRUNSUMMARY, revertdetrunsummaryArgs);
    720922    PXOPT_ADD_MODE("-updatedetrunsummary", "", DETTOOL_MODE_UPDATEDETRUNSUMMARY, updatedetrunsummaryArgs);
     923
    721924    PXOPT_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
    722925    PXOPT_ADD_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);

  • trunk/ippTools/src/dettool_correction.c

    r18561 r19092  
    2424    PS_ASSERT_PTR_NON_NULL(config, false);
    2525
    26     PXOPT_LOOKUP_STR(det_id, config->args, "-det_id", true, false); // required
     26    PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true, false); // required
    2727    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false); // optional
    2828
    2929    // build the needed where
    3030    psMetadata *where = psMetadataAlloc();
    31     psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", (psS64)atoll(det_id));
     31    psMetadataAddS64(where, PS_LIST_TAIL, "det_id", 0, "==", det_id);
    3232    psArray *runs = detRunSelectRowObjects(config->dbh, where, 1);
    3333    psFree (where);

  • trunk/ippTools/src/difftool.c

    r19038 r19092  
    4141static bool definepoprunMode(pxConfig *config);
    4242static bool definebyqueryMode(pxConfig *config);
     43static bool pendingcleanuprunMode(pxConfig *config);
     44static bool pendingcleanupskyfileMode(pxConfig *config);
     45static bool donecleanupMode(pxConfig *config);
    4346
    4447static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state);
    … …  
    6265
    6366    switch (config->mode) {
    64         MODECASE(DIFFTOOL_MODE_DEFINERUN,         definerunMode);
    65         MODECASE(DIFFTOOL_MODE_UPDATERUN,         updaterunMode);
    66         MODECASE(DIFFTOOL_MODE_ADDINPUTSKYFILE,   addinputskyfileMode);
    67         MODECASE(DIFFTOOL_MODE_INPUTSKYFILE,      inputskyfileMode);
    68         MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE,     todiffskyfileMode);
    69         MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE,    adddiffskyfileMode);
    70         MODECASE(DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileMode);
    71         MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileMode);
    72         MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunMode);
    73         MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY,             definebyqueryMode);
     67        MODECASE(DIFFTOOL_MODE_DEFINERUN,             definerunMode);
     68        MODECASE(DIFFTOOL_MODE_UPDATERUN,             updaterunMode);
     69        MODECASE(DIFFTOOL_MODE_ADDINPUTSKYFILE,       addinputskyfileMode);
     70        MODECASE(DIFFTOOL_MODE_INPUTSKYFILE,          inputskyfileMode);
     71        MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE,         todiffskyfileMode);
     72        MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE,        adddiffskyfileMode);
     73        MODECASE(DIFFTOOL_MODE_DIFFSKYFILE,           diffskyfileMode);
     74        MODECASE(DIFFTOOL_MODE_REVERTDIFFSKYFILE,     revertdiffskyfileMode);
     75        MODECASE(DIFFTOOL_MODE_DEFINEPOPRUN,          definepoprunMode);
     76        MODECASE(DIFFTOOL_MODE_DEFINEBYQUERY,         definebyqueryMode);
     77        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
     78        MODECASE(DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
     79        MODECASE(DIFFTOOL_MODE_DONECLEANUP,           donecleanupMode);
    7480        default:
    7581            psAbort("invalid option (this should not happen)");
    … …  
    259265
    260266    if (count == 2) {
    261         if (!setdiffRunState(config, diff_id, "run")) {
     267        if (!setdiffRunState(config, diff_id, "new")) {
    262268            if (!psDBRollback(config->dbh)) {
    263269                psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    496502    }
    497503
    498     if (!setdiffRunState(config, diff_id, "stop")) {
     504    if (!setdiffRunState(config, diff_id, "full")) {
    499505        if (!psDBRollback(config->dbh)) {
    500506            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    696702
    697703    // check that state is a valid string value
    698     if (!(
    699             (strncmp(state, "run", 4) == 0)
    700             || (strncmp(state, "stop", 5) == 0)
    701             || (strncmp(state, "reg", 4) == 0)
    702         )
    703     ) {
    704         psError(PS_ERR_UNKNOWN, false,
    705                 "invalid diffRun state: %s", state);
     704    if (!pxIsValidState(state)) {
     705        psError(PS_ERR_UNKNOWN, false, "invalid diffRun state: %s", state);
    706706        return false;
    707707    }
    … …  
    10081008    return true;
    10091009}
     1010
     1011static bool pendingcleanuprunMode(pxConfig *config)
     1012{
     1013    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1014
     1015    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1016    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1017
     1018    psMetadata *where = psMetadataAlloc();
     1019    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1020
     1021    psString query = pxDataGet("difftool_pendingcleanuprun.sql");
     1022    if (!query) {
     1023        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1024        return false;
     1025    }
     1026
     1027    if (where && psListLength(where->list)) {
     1028        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1029        psStringAppend(&query, " AND %s", whereClause);
     1030        psFree(whereClause);
     1031    }
     1032    psFree(where);
     1033
     1034    // treat limit == 0 as "no limit"
     1035    if (limit) {
     1036        psString limitString = psDBGenerateLimitSQL(limit);
     1037        psStringAppend(&query, " %s", limitString);
     1038        psFree(limitString);
     1039    }
     1040
     1041    if (!p_psDBRunQuery(config->dbh, query)) {
     1042        psError(PS_ERR_UNKNOWN, false, "database error");
     1043        psFree(query);
     1044        return false;
     1045    }
     1046    psFree(query);
     1047
     1048    psArray *output = p_psDBFetchResult(config->dbh);
     1049    if (!output) {
     1050        psError(PS_ERR_UNKNOWN, false, "database error");
     1051        return false;
     1052    }
     1053    if (!psArrayLength(output)) {
     1054        psTrace("difftool", PS_LOG_INFO, "no rows found");
     1055        psFree(output);
     1056        return true;
     1057    }
     1058
     1059    // negative simple so the default is true
     1060    if (!ippdbPrintMetadatas(stdout, output, "diffPendingCleanupRun", !simple)) {
     1061        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1062        psFree(output);
     1063        return false;
     1064    }
     1065
     1066    psFree(output);
     1067
     1068    return true;
     1069}
     1070
     1071
     1072static bool pendingcleanupskyfileMode(pxConfig *config)
     1073{
     1074    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1075
     1076    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", false, false);
     1077    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1078    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1079
     1080    psMetadata *where = psMetadataAlloc();
     1081    if (diff_id) {
     1082        PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
     1083    }
     1084    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1085
     1086    psString query = pxDataGet("difftool_pendingcleanupskyfile.sql");
     1087    if (!query) {
     1088        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1089        return false;
     1090    }
     1091
     1092    if (where && psListLength(where->list)) {
     1093        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1094        psStringAppend(&query, " AND %s", whereClause);
     1095        psFree(whereClause);
     1096    }
     1097    psFree(where);
     1098
     1099    // treat limit == 0 as "no limit"
     1100    if (limit) {
     1101        psString limitString = psDBGenerateLimitSQL(limit);
     1102        psStringAppend(&query, " %s", limitString);
     1103        psFree(limitString);
     1104    }
     1105
     1106    if (!p_psDBRunQuery(config->dbh, query)) {
     1107        psError(PS_ERR_UNKNOWN, false, "database error");
     1108        psFree(query);
     1109        return false;
     1110    }
     1111    psFree(query);
     1112
     1113    psArray *output = p_psDBFetchResult(config->dbh);
     1114    if (!output) {
     1115        psError(PS_ERR_UNKNOWN, false, "database error");
     1116        return false;
     1117    }
     1118    if (!psArrayLength(output)) {
     1119        psTrace("difftool", PS_LOG_INFO, "no rows found");
     1120        psFree(output);
     1121        return true;
     1122    }
     1123
     1124    // negative simple so the default is true
     1125    if (!ippdbPrintMetadatas(stdout, output, "diffPendingCleanupSkyfile", !simple)) {
     1126        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1127        psFree(output);
     1128        return false;
     1129    }
     1130
     1131    psFree(output);
     1132    return true;
     1133}
     1134
     1135
     1136static bool donecleanupMode(pxConfig *config)
     1137{
     1138    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1139
     1140    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1141    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1142
     1143    psMetadata *where = psMetadataAlloc();
     1144    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1145
     1146    psString query = pxDataGet("difftool_donecleanup.sql");
     1147    if (!query) {
     1148        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1149        return false;
     1150    }
     1151
     1152    if (where && psListLength(where->list)) {
     1153        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1154        psStringAppend(&query, " AND %s", whereClause);
     1155        psFree(whereClause);
     1156    }
     1157    psFree(where);
     1158
     1159    // treat limit == 0 as "no limit"
     1160    if (limit) {
     1161        psString limitString = psDBGenerateLimitSQL(limit);
     1162        psStringAppend(&query, " %s", limitString);
     1163        psFree(limitString);
     1164    }
     1165
     1166    if (!p_psDBRunQuery(config->dbh, query)) {
     1167        psError(PS_ERR_UNKNOWN, false, "database error");
     1168        psFree(query);
     1169        return false;
     1170    }
     1171    psFree(query);
     1172
     1173    psArray *output = p_psDBFetchResult(config->dbh);
     1174    if (!output) {
     1175        psError(PS_ERR_UNKNOWN, false, "database error");
     1176        return false;
     1177    }
     1178    if (!psArrayLength(output)) {
     1179        psTrace("difftool", PS_LOG_INFO, "no rows found");
     1180        psFree(output);
     1181        return true;
     1182    }
     1183
     1184    // negative simple so the default is true
     1185    if (!ippdbPrintMetadatas(stdout, output, "diffDoneCleanup", !simple)) {
     1186        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1187        psFree(output);
     1188        return false;
     1189    }
     1190
     1191    psFree(output);
     1192    return true;
     1193}

  • trunk/ippTools/src/difftool.h

    r18093 r19092  
    3535    DIFFTOOL_MODE_DEFINEPOPRUN,
    3636    DIFFTOOL_MODE_DEFINEBYQUERY,
     37    DIFFTOOL_MODE_PENDINGCLEANUPRUN,
     38    DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE,
     39    DIFFTOOL_MODE_DONECLEANUP,
    3740} difftoolMode;
    3841

  • trunk/ippTools/src/difftoolConfig.c

    r18976 r19092  
    140140    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    141141
     142    // -pendingcleanuprun
     143    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     144    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     145    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     146    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     147
     148    // -pendingcleanupskyfile
     149    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
     150    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     151    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,          "search by diff ID", 0);
     152    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     153    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     154
     155    // -donecleanup
     156    psMetadata *donecleanupArgs = psMetadataAlloc();
     157    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     158    psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     159    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     160
    142161    psFree(now);
    143162
    … …  
    155174    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    156175    PXOPT_ADD_MODE("-definebyquery",    "", DIFFTOOL_MODE_DEFINEBYQUERY,     definebyqueryArgs);
     176    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     177    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", DIFFTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     178    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    157179
    158180    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/faketool.c

    r18686 r19092  
    4545static bool unmaskedMode(pxConfig *config);
    4646static bool unblockMode(pxConfig *config);
     47static bool pendingcleanuprunMode(pxConfig *config);
     48static bool pendingcleanupimfileMode(pxConfig *config);
     49static bool donecleanupMode(pxConfig *config);
    4750
    4851static bool fakeProcessedCompleteExp(pxConfig *config);
    … …  
    6568
    6669    switch (config->mode) {
    67         MODECASE(FAKETOOL_MODE_DEFINEBYQUERY,                   definebyqueryMode);
     70        MODECASE(FAKETOOL_MODE_DEFINEBYQUERY,           definebyqueryMode);
    6871        MODECASE(FAKETOOL_MODE_UPDATERUN,               updaterunMode);
    6972        MODECASE(FAKETOOL_MODE_PENDINGEXP,              pendingexpMode);
    … …  
    7275        MODECASE(FAKETOOL_MODE_PROCESSEDIMFILE,         processedimfileMode);
    7376        MODECASE(FAKETOOL_MODE_REVERTPROCESSEDIMFILE,   revertprocessedimfileMode);
    74         MODECASE(FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileMode);
     77        MODECASE(FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,   updateprocessedimfileMode);
    7578        MODECASE(FAKETOOL_MODE_BLOCK,                   blockMode);
    7679        MODECASE(FAKETOOL_MODE_MASKED,                  maskedMode);
    7780        MODECASE(FAKETOOL_MODE_UNMASKED,                unmaskedMode);
    7881        MODECASE(FAKETOOL_MODE_UNBLOCK,                 unblockMode);
     82        MODECASE(FAKETOOL_MODE_PENDINGCLEANUPRUN,       pendingcleanuprunMode);
     83        MODECASE(FAKETOOL_MODE_PENDINGCLEANUPIMFILE,    pendingcleanupimfileMode);
     84        MODECASE(FAKETOOL_MODE_DONECLEANUP,             donecleanupMode);
    7985        default:
    8086            psAbort("invalid option (this should not happen)");
    … …  
    854860}
    855861
     862static bool pendingcleanuprunMode(pxConfig *config)
     863{
     864    PS_ASSERT_PTR_NON_NULL(config, NULL);
     865
     866    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     867    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     868
     869    psMetadata *where = psMetadataAlloc();
     870    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     871
     872    psString query = pxDataGet("faketool_pendingcleanuprun.sql");
     873    if (!query) {
     874        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     875        return false;
     876    }
     877
     878    if (where && psListLength(where->list)) {
     879        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     880        psStringAppend(&query, " AND %s", whereClause);
     881        psFree(whereClause);
     882    }
     883    psFree(where);
     884
     885    // treat limit == 0 as "no limit"
     886    if (limit) {
     887        psString limitString = psDBGenerateLimitSQL(limit);
     888        psStringAppend(&query, " %s", limitString);
     889        psFree(limitString);
     890    }
     891
     892    if (!p_psDBRunQuery(config->dbh, query)) {
     893        psError(PS_ERR_UNKNOWN, false, "database error");
     894        psFree(query);
     895        return false;
     896    }
     897    psFree(query);
     898
     899    psArray *output = p_psDBFetchResult(config->dbh);
     900    if (!output) {
     901        psError(PS_ERR_UNKNOWN, false, "database error");
     902        return false;
     903    }
     904    if (!psArrayLength(output)) {
     905        psTrace("faketool", PS_LOG_INFO, "no rows found");
     906        psFree(output);
     907        return true;
     908    }
     909
     910    // negative simple so the default is true
     911    if (!ippdbPrintMetadatas(stdout, output, "fakePendingCleanupRun", !simple)) {
     912        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     913        psFree(output);
     914        return false;
     915    }
     916
     917    psFree(output);
     918
     919    return true;
     920}
     921
     922
     923static bool pendingcleanupimfileMode(pxConfig *config)
     924{
     925    PS_ASSERT_PTR_NON_NULL(config, NULL);
     926
     927    PXOPT_LOOKUP_S64(fake_id, config->args, "-fake_id", false, false);
     928    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     929    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     930
     931    psMetadata *where = psMetadataAlloc();
     932    if (fake_id) {
     933        PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     934    }
     935    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     936
     937    psString query = pxDataGet("faketool_pendingcleanupimfile.sql");
     938    if (!query) {
     939        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     940        return false;
     941    }
     942
     943    if (where && psListLength(where->list)) {
     944        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     945        psStringAppend(&query, " AND %s", whereClause);
     946        psFree(whereClause);
     947    }
     948    psFree(where);
     949
     950    // treat limit == 0 as "no limit"
     951    if (limit) {
     952        psString limitString = psDBGenerateLimitSQL(limit);
     953        psStringAppend(&query, " %s", limitString);
     954        psFree(limitString);
     955    }
     956
     957    if (!p_psDBRunQuery(config->dbh, query)) {
     958        psError(PS_ERR_UNKNOWN, false, "database error");
     959        psFree(query);
     960        return false;
     961    }
     962    psFree(query);
     963
     964    psArray *output = p_psDBFetchResult(config->dbh);
     965    if (!output) {
     966        psError(PS_ERR_UNKNOWN, false, "database error");
     967        return false;
     968    }
     969    if (!psArrayLength(output)) {
     970        psTrace("faketool", PS_LOG_INFO, "no rows found");
     971        psFree(output);
     972        return true;
     973    }
     974
     975    // negative simple so the default is true
     976    if (!ippdbPrintMetadatas(stdout, output, "fakePendingCleanupImfile", !simple)) {
     977        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     978        psFree(output);
     979        return false;
     980    }
     981
     982    psFree(output);
     983
     984    return true;
     985}
     986
     987
     988static bool donecleanupMode(pxConfig *config)
     989{
     990    PS_ASSERT_PTR_NON_NULL(config, NULL);
     991
     992    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     993    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     994
     995    psMetadata *where = psMetadataAlloc();
     996    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     997
     998    psString query = pxDataGet("faketool_donecleanup.sql");
     999    if (!query) {
     1000        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1001        return false;
     1002    }
     1003
     1004    if (where && psListLength(where->list)) {
     1005        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1006        psStringAppend(&query, " AND %s", whereClause);
     1007        psFree(whereClause);
     1008    }
     1009    psFree(where);
     1010
     1011    // treat limit == 0 as "no limit"
     1012    if (limit) {
     1013        psString limitString = psDBGenerateLimitSQL(limit);
     1014        psStringAppend(&query, " %s", limitString);
     1015        psFree(limitString);
     1016    }
     1017
     1018    if (!p_psDBRunQuery(config->dbh, query)) {
     1019        psError(PS_ERR_UNKNOWN, false, "database error");
     1020        psFree(query);
     1021        return false;
     1022    }
     1023    psFree(query);
     1024
     1025    psArray *output = p_psDBFetchResult(config->dbh);
     1026    if (!output) {
     1027        psError(PS_ERR_UNKNOWN, false, "database error");
     1028        return false;
     1029    }
     1030    if (!psArrayLength(output)) {
     1031        psTrace("faketool", PS_LOG_INFO, "no rows found");
     1032        psFree(output);
     1033        return true;
     1034    }
     1035
     1036    // negative simple so the default is true
     1037    if (!ippdbPrintMetadatas(stdout, output, "fakeDoneCleanup", !simple)) {
     1038        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1039        psFree(output);
     1040        return false;
     1041    }
     1042
     1043    psFree(output);
     1044
     1045    return true;
     1046}
    8561047
    8571048static bool fakeProcessedCompleteExp(pxConfig *config)
    … …  
    8891080
    8901081        fakeRunRow *fakeRun = fakeRunObjectFromMetadata(row);
    891         // set fakeRun.state to 'stop'
    892         if (!pxfakeRunSetState(config, fakeRun->fake_id, "stop")) {
     1082        // set fakeRun.state to 'full'
     1083        if (!pxfakeRunSetState(config, fakeRun->fake_id, "full")) {
    8931084            psError(PS_ERR_UNKNOWN, false, "failed to change fakeRun.state for fake_id: %" PRId64, fakeRun->fake_id);
    8941085            psFree(fakeRun);

  • trunk/ippTools/src/faketool.h

    r18093 r19092  
    3838    FAKETOOL_MODE_UNBLOCK,
    3939    FAKETOOL_MODE_RETRYPROCESSEDIMFILE,
    40     FAKETOOL_MODE_PENDINGCLEANUP,
     40    FAKETOOL_MODE_PENDINGCLEANUPRUN,
     41    FAKETOOL_MODE_PENDINGCLEANUPIMFILE,
    4142    FAKETOOL_MODE_DONECLEANUP,
    4243} FAKETOOLMode;

  • trunk/ippTools/src/faketoolConfig.c

    r18687 r19092  
    4747    psMetadata *queueArgs = psMetadataAlloc();
    4848    // XXX need to allow multiple exp_ids
    49     psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,
    50             "search by exp_id", 0);
    51     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,
    52             "search by exp_name", NULL);
    53     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst",  0,
    54             "search for camera", NULL);
    55     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,
    56             "search for telescope", NULL);
    57     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    58             "search for exposures by time (>=)", NULL);
    59     psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    60             "search for exposures by time (<)", NULL);
    61     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,
    62             "search by exp_tag", NULL);
    63     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type",  0,
    64             "search by exp_type", "object");
    65     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel",  0,
    66             "search by filelevel", NULL);
    67     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-reduction",  0,
    68             "search by reduction class", NULL);
    69     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filter",  0,
    70             "search for filter", NULL);
    71     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min",  0,
    72             "define min airmass", NAN);
    73     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max",  0,
    74             "define max airmass", NAN);
    75     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,
    76             "define min", NAN);
    77     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,
    78             "define max", NAN);
    79     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,
    80             "define min", NAN);
    81     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,
    82             "define max", NAN);
    83     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    84             "define min", NAN);
    85     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    86             "define max", NAN);
    87     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    88             "define max fraction of saturated pixels", NAN);
    89     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    90             "define min fraction of saturated pixels", NAN);
    91     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_min",  0,
    92             "define max", NAN);
    93     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_max",  0,
    94             "define max", NAN);
    95     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    96             "define max", NAN);
    97     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    98             "define max", NAN);
    99     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    100             "define max", NAN);
    101     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    102             "define max", NAN);
    103     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_min",  0,
    104             "define min", NAN);
    105     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_max",  0,
    106             "define max", NAN);
    107     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_min",  0,
    108             "define min", NAN);
    109     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_max",  0,
    110             "define max", NAN);
    111     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    112             "define min ccd tempature", NAN);
    113     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    114             "define max ccd tempature", NAN);
    115     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_min",  0,
    116             "define min rotator position angle", NAN);
    117     psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,
    118             "define max rotator position angle", NAN);
    119     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,
    120             "search by exposure object", NULL);
    121     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,
    122             "define min solar angle", NAN);
    123     psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,
    124             "define max solar angle", NAN);
    125     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,
    126             "define workdir", NULL);
    127     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,
    128             "define label", NULL);
    129     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_reduction",  0,
    130             "define reduction class", NULL);
    131     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_expgroup",  0,
    132             "define exposure group", NULL);
    133     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb",  0,
    134             "define DVO db", NULL);
    135     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,
    136             "define tessellation identifier", NULL);
    137     psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,
    138             "define end stage", NULL);
    139     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,
    140             "do not actually modify the database", false);
    141     psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,
    142             "allow everything to be queued without search terms", false);
     49    psMetadataAddS64(queueArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     50    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     51    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     52    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     53    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     54    psMetadataAddTime(queueArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     55    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     56    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
     57    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     58    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     59    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     60    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     61    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     62    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     63    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     64    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     65    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     66    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     67    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     68    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     69    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     70    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     71    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     72    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     73    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     74    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     75    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     76    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     77    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     78    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     79    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     80    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     81    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     82    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     83    psMetadataAddF64(queueArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     84    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     85    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     86    psMetadataAddF32(queueArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     87    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_workdir",  0,            "define workdir", NULL);
     88    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_label",  0,            "define label", NULL);
     89    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_reduction",  0,            "define reduction class", NULL);
     90    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_expgroup",  0,            "define exposure group", NULL);
     91    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_dvodb",  0,            "define DVO db", NULL);
     92    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_tess_id",  0,            "define tessellation identifier", NULL);
     93    psMetadataAddStr(queueArgs, PS_LIST_TAIL, "-set_end_stage",  0,            "define end stage", NULL);
     94    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
     95    psMetadataAddBool(queueArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    14396
    14497
    14598    // -updaterun
    14699    psMetadata *updaterunArgs = psMetadataAlloc();
    147     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,
    148             "search by fake ID", 0);
    149     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,
    150             "search by exp_id", 0);
    151     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,
    152             "search by exp_name", NULL);
    153     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,
    154             "search for camera", NULL);
    155     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,
    156             "search for telescope", NULL);
    157     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    158             "search for exposures by time (>=)", NULL);
    159     psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    160             "search for exposures by time (<)", NULL);
    161     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,
    162             "search by exp_tag", NULL);
    163     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,
    164             "search by exp_type", "object");
    165     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,
    166             "search by filelevel", NULL);
    167     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,
    168             "search by reduction class", NULL);
    169     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,
    170             "search for filter", NULL);
    171     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,
    172             "define min airmass", NAN);
    173     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,
    174             "define max airmass", NAN);
    175     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,
    176             "define min", NAN);
    177     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,
    178             "define max", NAN);
    179     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,
    180             "define min", NAN);
    181     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,
    182             "define max", NAN);
    183     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    184             "define min", NAN);
    185     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    186             "define max", NAN);
    187     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    188             "define max fraction of saturated pixels", NAN);
    189     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    190             "define min fraction of saturated pixels", NAN);
    191     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,
    192             "define max", NAN);
    193     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,
    194             "define max", NAN);
    195     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    196             "define max", NAN);
    197     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    198             "define max", NAN);
    199     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    200             "define max", NAN);
    201     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    202             "define max", NAN);
    203     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,
    204             "define min", NAN);
    205     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,
    206             "define max", NAN);
    207     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,
    208             "define min", NAN);
    209     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,
    210             "define max", NAN);
    211     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,
    212             "define min ccd tempature", NAN);
    213     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,
    214             "define max ccd tempature", NAN);
    215     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,
    216             "define min rotator position angle", NAN);
    217     psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,
    218             "define max rotator position angle", NAN);
    219     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,
    220             "search by exposure object", NULL);
    221     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,
    222             "define min solar angle", NAN);
    223     psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,
    224             "define max solar angle", NAN);
    225 
    226     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    227             "set state", NULL);
    228     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,
    229             "set label", NULL);
    230     psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,
    231             "allow everything to be queued without search terms", false);
     100    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by fake ID", 0);
     101    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     102    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     103    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     104    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     105    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     106    psMetadataAddTime(updaterunArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     107    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     108    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
     109    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     110    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     111    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     112    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     113    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     114    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     115    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     116    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     117    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     118    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     119    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     120    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     121    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     122    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     123    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     124    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     125    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     126    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     127    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     128    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     129    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     130    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     131    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     132    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_min",  0,            "define min ccd tempature", NAN);
     133    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-ccd_temp_max",  0,            "define max ccd tempature", NAN);
     134    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     135    psMetadataAddF64(updaterunArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     136    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     137    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     138    psMetadataAddF32(updaterunArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     139
     140    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     141    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "set label", NULL);
     142    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    232143
    233144    // -pendingexp
    234145    psMetadata *pendingexpArgs = psMetadataAlloc();
    235     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-fake_id", 0,
    236             "search by fake ID", 0);
    237     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    238             "search by camtool ID", 0);
    239     psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,
    240             "search by chiptool ID", 0);
    241     psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,
    242             "limit result set to N items", 0);
    243     psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,
    244             "use the simple output format", false);
     146    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by fake ID", 0);
     147    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-cam_id", 0,            "search by camtool ID", 0);
     148    psMetadataAddS64(pendingexpArgs, PS_LIST_TAIL, "-chip_id", 0,            "search by chiptool ID", 0);
     149    psMetadataAddU64(pendingexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     150    psMetadataAddBool(pendingexpArgs, PS_LIST_TAIL, "-simple", 0,            "use the simple output format", false);
    245151
    246152    // -pendingimfile
    247153    psMetadata *pendingimfileArgs = psMetadataAlloc();
    248     psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    249             "search by fake ID", 0);
    250     psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    251             "search by exposure ID", 0);
    252     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    253             "search by class ID", NULL);
    254     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst",  0,
    255             "search by camera of interest", NULL);
    256     psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-filter",  0,
    257             "search by filter of interest", NULL);
    258     psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,
    259             "limit result set to N items", 0);
    260     psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,
    261             "use the simple output format", false);
     154    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake ID", 0);
     155    psMetadataAddS64(pendingimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
     156    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     157    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search by camera of interest", NULL);
     158    psMetadataAddStr(pendingimfileArgs, PS_LIST_TAIL, "-filter",  0,            "search by filter of interest", NULL);
     159    psMetadataAddU64(pendingimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     160    psMetadataAddBool(pendingimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    262161
    263162    // -addprocessedimfile
    264163    psMetadata *addprocessedimfileArgs = psMetadataAlloc();
    265     psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    266             "define fake ID (required)", 0);
    267     psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    268             "define exposure ID (required)", 0);
    269     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    270             "define class ID (required)", NULL);
    271     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,
    272             "define URL", NULL);
    273     psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-dtime_fake",  0,
    274             "define elapsed time for detrend (seconds)", NAN);
    275     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-hostname",  0,
    276             "define hostname", NULL);
    277     psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,
    278             "define base output location", NULL);
    279     psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    280             "set fault code", 0);
     164    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,            "define fake ID (required)", 0);
     165    psMetadataAddS64(addprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID (required)", 0);
     166    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID (required)", NULL);
     167    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-uri",  0,            "define URL", NULL);
     168    psMetadataAddF32(addprocessedimfileArgs, PS_LIST_TAIL, "-dtime_fake",  0,            "define elapsed time for detrend (seconds)", NAN);
     169    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-hostname",  0,            "define hostname", NULL);
     170    psMetadataAddStr(addprocessedimfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
     171    psMetadataAddS16(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code", 0);
    281172
    282173    // -processedimfile
    283174    psMetadata *processedimfileArgs = psMetadataAlloc();
    284     psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    285             "define fake ID", 0);
    286     psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    287             "define exposure ID", 0);
    288     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    289             "define class ID", NULL);
    290     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-inst",  0,
    291             "define camera of interest", NULL);
    292     psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-filter",  0,
    293             "define filter of interest", NULL);
    294     psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,
    295             "limit result set to N items", 0);
    296     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,
    297             "only return imfiles with a fault status set", false);
    298     psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,
    299             "use the simple output format", false);
     175    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,            "define fake ID", 0);
     176    psMetadataAddS64(processedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "define exposure ID", 0);
     177    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "define class ID", NULL);
     178    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "define camera of interest", NULL);
     179    psMetadataAddStr(processedimfileArgs, PS_LIST_TAIL, "-filter",  0,            "define filter of interest", NULL);
     180    psMetadataAddU64(processedimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     181    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
     182    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
    300183
    301184    // -updateprocessedimfile
    302185    psMetadata *updateprocessedimfileArgs = psMetadataAlloc();
    303     psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,
    304             "search by fake ID", 0);
    305     psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    306             "search by exposure ID", 0);
    307     psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
    308             "search by class ID", NULL);
    309     psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    310             "set fault code (required)", 0);
     186    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-fake_id",  0,            "search by fake ID", 0);
     187    psMetadataAddS64(updateprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exposure ID", 0);
     188    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,            "search by class ID", NULL);
     189    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
    311190
    312191    // -revertprocessedimfile
    313192    psMetadata *revertprocessedimfileArgs = psMetadataAlloc();
    314     psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,
    315             "search by fake ID", 0);
    316     psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,
    317             "search by exp_id", 0);
    318     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,
    319             "search by exp_name", NULL);
    320     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-inst",  0,
    321             "search for camera", NULL);
    322     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-telescope",  0,
    323             "search for telescope", NULL);
    324     psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_begin", 0,
    325             "search for exposures by time (>=)", NULL);
    326     psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_end", 0,
    327             "search for exposures by time (<)", NULL);
    328     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
    329             "search by exp_tag", NULL);
    330     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_type",  0,
    331             "search by exp_type", "object");
    332     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filelevel",  0,
    333             "search by filelevel", NULL);
    334     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-reduction",  0,
    335             "search by reduction class", NULL);
    336     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filter",  0,
    337             "search for filter", NULL);
    338     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_min",  0,
    339             "define min airmass", NAN);
    340     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_max",  0,
    341             "define max airmass", NAN);
    342     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_min",  0,
    343             "define min", NAN);
    344     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_max",  0,
    345             "define max", NAN);
    346     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_min",  0,
    347             "define min", NAN);
    348     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_max",  0,
    349             "define max", NAN);
    350     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_min",  0,
    351             "define min", NAN);
    352     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_max",  0,
    353             "define max", NAN);
    354     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,
    355             "define max fraction of saturated pixels", NAN);
    356     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,
    357             "define min fraction of saturated pixels", NAN);
    358     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_min",  0,
    359             "define max", NAN);
    360     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_max",  0,
    361             "define max", NAN);
    362     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,
    363             "define max", NAN);
    364     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,
    365             "define max", NAN);
    366     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,
    367             "define max", NAN);
    368     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,
    369             "define max", NAN);
    370     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_min",  0,
    371             "define min", NAN);
    372     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_max",  0,
    373             "define max", NAN);
    374     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_min",  0,
    375             "define min", NAN);
    376     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_max",  0,
    377             "define max", NAN);
    378     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_min",0,
    379             "define min ccd tempature", NAN);
    380     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_max",0,
    381             "define max ccd tempature", NAN);
    382     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_min",  0,
    383             "define min rotator position angle", NAN);
    384     psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max",  0,
    385             "define max rotator position angle", NAN);
    386     psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,
    387             "search by exposure object", NULL);
    388     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min",  0,
    389             "define min solar angle", NAN);
    390     psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max",  0,
    391             "define max solar angle", NAN);
    392 
    393     psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,
    394             "allow everything to be queued without search terms", false);
    395     psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    396             "search by fault code", 0);
     193    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-fake_id", 0,            "search by fake ID", 0);
     194    psMetadataAddS64(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_id",  0,            "search by exp_id", 0);
     195    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_name",  0,            "search by exp_name", NULL);
     196    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-inst",  0,            "search for camera", NULL);
     197    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-telescope",  0,            "search for telescope", NULL);
     198    psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_begin", 0,            "search for exposures by time (>=)", NULL);
     199    psMetadataAddTime(revertprocessedimfileArgs, PS_LIST_TAIL, "-dateobs_end", 0,            "search for exposures by time (<)", NULL);
     200    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,            "search by exp_tag", NULL);
     201    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_type",  0,            "search by exp_type", "object");
     202    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filelevel",  0,            "search by filelevel", NULL);
     203    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-reduction",  0,            "search by reduction class", NULL);
     204    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-filter",  0,            "search for filter", NULL);
     205    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_min",  0,            "define min airmass", NAN);
     206    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-airmass_max",  0,            "define max airmass", NAN);
     207    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_min",  0,            "define min", NAN);
     208    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ra_max",  0,            "define max", NAN);
     209    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_min",  0,            "define min", NAN);
     210    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-decl_max",  0,            "define max", NAN);
     211    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_min",  0,            "define min", NAN);
     212    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-exp_time_max",  0,            "define max", NAN);
     213    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_min",  0,            "define max fraction of saturated pixels", NAN);
     214    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-sat_pixel_frac_max",  0,            "define min fraction of saturated pixels", NAN);
     215    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_min",  0,            "define max", NAN);
     216    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_max",  0,            "define max", NAN);
     217    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_min",  0,            "define max", NAN);
     218    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_stdev_max",  0,            "define max", NAN);
     219    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_min",  0,            "define max", NAN);
     220    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-bg_mean_stdev_max",  0,            "define max", NAN);
     221    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_min",  0,            "define min", NAN);
     222    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-alt_max",  0,            "define max", NAN);
     223    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_min",  0,            "define min", NAN);
     224    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-az_max",  0,            "define max", NAN);
     225    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_min",0,            "define min ccd tempature", NAN);
     226    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-ccd_temp_max",0,            "define max ccd tempature", NAN);
     227    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_min",  0,            "define min rotator position angle", NAN);
     228    psMetadataAddF64(revertprocessedimfileArgs, PS_LIST_TAIL, "-posang_max",  0,            "define max rotator position angle", NAN);
     229    psMetadataAddStr(revertprocessedimfileArgs, PS_LIST_TAIL, "-object",  0,            "search by exposure object", NULL);
     230    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_min",  0,            "define min solar angle", NAN);
     231    psMetadataAddF32(revertprocessedimfileArgs, PS_LIST_TAIL, "-solang_max",  0,            "define max solar angle", NAN);
     232
     233    psMetadataAddBool(revertprocessedimfileArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
     234    psMetadataAddS16(revertprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    397235
    398236    // -block
    399237    psMetadata *blockArgs = psMetadataAlloc();
    400     psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,
    401             "name of a label to mask out (required)", NULL);
     238    psMetadataAddStr(blockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to mask out (required)", NULL);
    402239
    403240    // -masked
    404241    psMetadata *maskedArgs = psMetadataAlloc();
    405     psMetadataAddStr(maskedArgs, PS_LIST_TAIL, "-label",  0,
    406             "list blocks for specified label", NULL);
    407     psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,
    408             "use the simple output format", false);
    409     psMetadataAddU64(maskedArgs, PS_LIST_TAIL, "-limit",  0,
    410             "limit result set to N items", 0);
     242    psMetadataAddStr(maskedArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     243    psMetadataAddBool(maskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     244    psMetadataAddU64(maskedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    411245
    412246    // -unmasked
    413247    psMetadata *unmaskedArgs = psMetadataAlloc();
    414     psMetadataAddStr(unmaskedArgs, PS_LIST_TAIL, "-label",  0,
    415             "restrict to specified label", NULL);
    416     psMetadataAddBool(unmaskedArgs, PS_LIST_TAIL, "-simple",  0,
    417             "use the simple output format", false);
    418     psMetadataAddU64(unmaskedArgs, PS_LIST_TAIL, "-limit",  0,
    419             "limit result set to N items", 0);
     248    psMetadataAddStr(unmaskedArgs, PS_LIST_TAIL, "-label",  0,            "restrict to specified label", NULL);
     249    psMetadataAddBool(unmaskedArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     250    psMetadataAddU64(unmaskedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    420251
    421252    // -unblock
    422253    psMetadata *unblockArgs = psMetadataAlloc();
    423     psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,
    424             "name of a label to unmask (required)", NULL);
     254    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
     255
     256    // -pendingcleanuprun
     257    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     258    psMetadataAddStr(pendingcleanuprunArgs,  PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     259    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     260    psMetadataAddU64(pendingcleanuprunArgs,  PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     261
     262    // -pendingcleanupimfile
     263    psMetadata *pendingcleanupimfileArgs = psMetadataAlloc();
     264    psMetadataAddStr(pendingcleanupimfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     265    psMetadataAddS64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-fake_id", 0,          "search by chip ID", 0);
     266    psMetadataAddBool(pendingcleanupimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     267    psMetadataAddU64(pendingcleanupimfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     268
     269    // -donecleanup
     270    psMetadata *donecleanupArgs = psMetadataAlloc();
     271    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     272    psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     273    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    425274
    426275    psMetadata *argSets = psMetadataAlloc();
    427276    psMetadata *modes = psMetadataAlloc();
    428277
    429     PXOPT_ADD_MODE("-definebyquery",                 "create runs from raw exposures",
    430         FAKETOOL_MODE_DEFINEBYQUERY,                    queueArgs);
    431     PXOPT_ADD_MODE("-updaterun",             "change fake run properties",
    432         FAKETOOL_MODE_UPDATERUN,                updaterunArgs);
    433     PXOPT_ADD_MODE("-pendingexp",           "show pending exposures",
    434         FAKETOOL_MODE_PENDINGEXP,               pendingexpArgs);
    435     PXOPT_ADD_MODE("-pendingimfile",         "show pending imfiles",
    436         FAKETOOL_MODE_PENDINGIMFILE,            pendingimfileArgs);
    437     PXOPT_ADD_MODE("-addprocessedimfile",    "add a processed imfile",
    438         FAKETOOL_MODE_ADDPROCESSEDIMFILE,       addprocessedimfileArgs);
    439     PXOPT_ADD_MODE("-processedimfile",       "show processed imfiles",
    440         FAKETOOL_MODE_PROCESSEDIMFILE,          processedimfileArgs);
    441     PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",        FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
    442     PXOPT_ADD_MODE("-revertprocessedimfile", "undo a processed imfile",
    443         FAKETOOL_MODE_REVERTPROCESSEDIMFILE,    revertprocessedimfileArgs);
    444     PXOPT_ADD_MODE("-block",                 "set a label block", FAKETOOL_MODE_BLOCK,          blockArgs);
    445     PXOPT_ADD_MODE("-masked",                "show blocked labels", FAKETOOL_MODE_MASKED,         maskedArgs);
    446     PXOPT_ADD_MODE("-unmasked",              "", FAKETOOL_MODE_UNMASKED,       unmaskedArgs);
    447     PXOPT_ADD_MODE("-unblock",               "remove a label block", FAKETOOL_MODE_UNBLOCK,        unblockArgs);
     278    PXOPT_ADD_MODE("-definebyquery",         "create runs from raw exposures",       FAKETOOL_MODE_DEFINEBYQUERY,                    queueArgs);
     279    PXOPT_ADD_MODE("-updaterun",             "change fake run properties",           FAKETOOL_MODE_UPDATERUN,                updaterunArgs);
     280    PXOPT_ADD_MODE("-pendingexp",            "show pending exposures",               FAKETOOL_MODE_PENDINGEXP,               pendingexpArgs);
     281    PXOPT_ADD_MODE("-pendingimfile",         "show pending imfiles",                 FAKETOOL_MODE_PENDINGIMFILE,            pendingimfileArgs);
     282    PXOPT_ADD_MODE("-addprocessedimfile",    "add a processed imfile",               FAKETOOL_MODE_ADDPROCESSEDIMFILE,       addprocessedimfileArgs);
     283    PXOPT_ADD_MODE("-processedimfile",       "show processed imfiles",               FAKETOOL_MODE_PROCESSEDIMFILE,          processedimfileArgs);
     284    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",     FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
     285    PXOPT_ADD_MODE("-revertprocessedimfile", "undo a processed imfile",              FAKETOOL_MODE_REVERTPROCESSEDIMFILE,    revertprocessedimfileArgs);
     286    PXOPT_ADD_MODE("-block",                 "set a label block",                    FAKETOOL_MODE_BLOCK,          blockArgs);
     287    PXOPT_ADD_MODE("-masked",                "show blocked labels",                  FAKETOOL_MODE_MASKED,         maskedArgs);
     288    PXOPT_ADD_MODE("-unmasked",              "",                                     FAKETOOL_MODE_UNMASKED,       unmaskedArgs);
     289    PXOPT_ADD_MODE("-unblock",               "remove a label block",                 FAKETOOL_MODE_UNBLOCK,        unblockArgs);
     290    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", FAKETOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     291    PXOPT_ADD_MODE("-pendingcleanupimfile",  "show runs that need to be cleaned up", FAKETOOL_MODE_PENDINGCLEANUPIMFILE, pendingcleanupimfileArgs);
     292    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     FAKETOOL_MODE_DONECLEANUP,          donecleanupArgs);
    448293
    449294    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/pxcam.c

    r17171 r19092  
    3535
    3636    // check that state is a valid string value
    37     if (!(
    38             (strncmp(state, "run", 4) == 0)
    39             || (strncmp(state, "stop", 5) == 0)
    40             || (strncmp(state, "reg", 4) == 0)
    41         )
    42     ) {
     37    if (!pxIsValidState(state)) {
    4338        psError(PS_ERR_UNKNOWN, false,
    4439                "invalid camRun state: %s", state);
    … …  
    6358
    6459    // check that state is a valid string value
    65     if (!(
    66             (strncmp(state, "run", 4) == 0)
    67             || (strncmp(state, "stop", 5) == 0)
    68             || (strncmp(state, "reg", 4) == 0)
    69         )
    70     ) {
     60    if (!pxIsValidState(state)) {
    7161        psError(PS_ERR_UNKNOWN, false,
    7262                "invalid chipRun state: %s", state);
    … …  
    10898    return true;
    10999}
    110 
    111100
    112101bool pxcamRunSetLabelByQuery(pxConfig *config, psMetadata *where, const char *label)
    … …  
    162151    // different on 32/64
    163152    if (!p_psDBRunQuery(config->dbh, query,
    164                 "run", // state
     153                "new", // state
    165154                workdir  ? workdir  : "NULL",
    166155                "dirty", //workdir_state

  • trunk/ippTools/src/pxfake.c

    r17938 r19092  
    3535
    3636    // check that state is a valid string value
    37     if (!(
    38             (strncmp(state, "run", 4) == 0)
    39             || (strncmp(state, "stop", 5) == 0)
    40             || (strncmp(state, "reg", 4) == 0)
    41         )
    42     ) {
     37    if (!pxIsValidState(state)) {
    4338        psError(PS_ERR_UNKNOWN, false,
    4439                "invalid fakeRun state: %s", state);
    … …  
    6358
    6459    // check that state is a valid string value
    65     if (!(
    66             (strncmp(state, "run", 4) == 0)
    67             || (strncmp(state, "stop", 5) == 0)
    68             || (strncmp(state, "reg", 4) == 0)
    69         )
    70     ) {
     60    if (!pxIsValidState(state)) {
    7161        psError(PS_ERR_UNKNOWN, false,
    7262                "invalid fakeRun state: %s", state);
    … …  
    164154    // different on 32/64
    165155    if (!p_psDBRunQuery(config->dbh, query,
    166                 "run", // state
     156                "new", // state
    167157                workdir  ? workdir  : "NULL",
    168158                label    ? label    : "NULL",

  • trunk/ippTools/src/pxtools.c

    r18075 r19092  
    2929{
    3030    PS_ASSERT_PTR_NON_NULL(state, false);
     31   
     32    // XXX replace strncmp with strcmp
    3133
    3234    if (!((strncmp(state, "new", 4) == 0)
     35    || (strncmp(state, "reg", 3) == 0)
    3336    || (strncmp(state, "full", 5) == 0)
    3437    || (strncmp(state, "goto_cleaned", 8) == 0)

  • trunk/ippTools/src/pxwarp.c

    r18479 r19092  
    3535
    3636    // check that state is a valid string value
    37     if (!(
    38             (strncmp(state, "run", 4) == 0)
    39             || (strncmp(state, "stop", 5) == 0)
    40             || (strncmp(state, "reg", 4) == 0)
    41         )
    42     ) {
    43         psError(PS_ERR_UNKNOWN, false,
    44                 "invalid warpRun state: %s", state);
     37    if (!pxIsValidState(state)) {
     38        psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    4539        return false;
    4640    }
    … …  
    6357
    6458    // check that state is a valid string value
    65     if (!(
    66             (strncmp(state, "run", 4) == 0)
    67             || (strncmp(state, "stop", 5) == 0)
    68             || (strncmp(state, "reg", 4) == 0)
    69         )
    70     ) {
    71         psError(PS_ERR_UNKNOWN, false,
    72                 "invalid chipRun state: %s", state);
     59    if (!pxIsValidState(state)) {
     60        psError(PS_ERR_UNKNOWN, false, "invalid chipRun state: %s", state);
    7361        return false;
    7462    }
    … …  
    152140        fake_id,
    153141        "warp",     // mode
    154         "run",      // state
     142        "new",      // state
    155143        workdir,
    156144        "dirty",    // workdir_state

  • trunk/ippTools/src/stacktool.c

    r19029 r19092  
    4040static bool sumskyfileMode(pxConfig *config);
    4141static bool revertsumskyfileMode(pxConfig *config);
     42static bool pendingcleanuprunMode(pxConfig *config);
     43static bool pendingcleanupskyfileMode(pxConfig *config);
     44static bool donecleanupMode(pxConfig *config);
    4245
    4346static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    … …  
    6164
    6265    switch (config->mode) {
    63         MODECASE(STACKTOOL_MODE_DEFINEBYQUERY,              definebyqueryMode);
    64         MODECASE(STACKTOOL_MODE_DEFINERUN,          definerunMode);
    65         MODECASE(STACKTOOL_MODE_UPDATERUN,          updaterunMode);
    66         MODECASE(STACKTOOL_MODE_ADDINPUTSKYFILE,    addinputskyfileMode);
    67         MODECASE(STACKTOOL_MODE_INPUTSKYFILE,       inputskyfileMode);
    68         MODECASE(STACKTOOL_MODE_TOSUM,              tosumMode);
    69         MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,      addsumskyfileMode);
    70         MODECASE(STACKTOOL_MODE_SUMSKYFILE,         sumskyfileMode);
    71         MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,   revertsumskyfileMode);
     66        MODECASE(STACKTOOL_MODE_DEFINEBYQUERY,         definebyqueryMode);
     67        MODECASE(STACKTOOL_MODE_DEFINERUN,             definerunMode);
     68        MODECASE(STACKTOOL_MODE_UPDATERUN,             updaterunMode);
     69        MODECASE(STACKTOOL_MODE_ADDINPUTSKYFILE,       addinputskyfileMode);
     70        MODECASE(STACKTOOL_MODE_INPUTSKYFILE,          inputskyfileMode);
     71        MODECASE(STACKTOOL_MODE_TOSUM,                 tosumMode);
     72        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,         addsumskyfileMode);
     73        MODECASE(STACKTOOL_MODE_SUMSKYFILE,            sumskyfileMode);
     74        MODECASE(STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileMode);
     75        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPRUN,     pendingcleanuprunMode);
     76        MODECASE(STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileMode);
     77        MODECASE(STACKTOOL_MODE_DONECLEANUP,           donecleanupMode);
    7278        default:
    7379            psAbort("invalid option (this should not happen)");
    … …  
    288294
    289295        // create a new stackRun for this stack
    290         stackRunRow *run = stackRunRowAlloc(0, "run", workdir, NULL, registered, skycell_id, tess_id, filter);
     296        stackRunRow *run = stackRunRowAlloc(
     297            0,                          // ID
     298            "new",                      // state
     299            workdir,
     300            NULL,                       // workdir_state
     301            registered,
     302            skycell_id,
     303            tess_id,
     304            filter);
     305
    291306        if (!stackRunInsertObject(config->dbh, run)) {
    292307            if (!psDBRollback(config->dbh)) {
    … …  
    343358    if (!stackRunPrintObjects(stdout, list, !simple)) {
    344359        psError(PS_ERR_UNKNOWN, false, "failed to print object");
    345         return false;
    346     }
    347 
     360        psFree(list);
     361        return false;
     362    }
    348363    psFree(list);
    349 
    350364    return true;
    351365}
    … …  
    374388    }
    375389
    376     stackRunRow *run = stackRunRowAlloc(0, "run", workdir, NULL, registered, skycell_id, tess_id, filter);
     390    stackRunRow *run = stackRunRowAlloc(
     391        0,                              // ID
     392        "new",                          // state
     393        workdir,
     394        NULL,                           // workdir_state
     395        registered,
     396        skycell_id,
     397        tess_id,
     398        filter);
     399
    377400    if (!run) {
    378401        psError(PS_ERR_UNKNOWN, false, "failed to alloc stackRun object");
    … …  
    667690    }
    668691
    669     if (!setstackRunState(config, stack_id, "stop")) {
     692    if (!setstackRunState(config, stack_id, "full")) {
    670693        if (!psDBRollback(config->dbh)) {
    671694            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    869892
    870893    // check that state is a valid string value
    871     if (!(
    872             (strncmp(state, "run", 4) == 0)
    873             || (strncmp(state, "stop", 5) == 0)
    874             || (strncmp(state, "reg", 4) == 0)
    875         )
    876     ) {
    877         psError(PS_ERR_UNKNOWN, false,
    878                 "invalid warpRun state: %s", state);
     894    if (!pxIsValidState(state)) {
     895        psError(PS_ERR_UNKNOWN, false, "invalid stackRun state: %s", state);
    879896        return false;
    880897    }
    … …  
    889906    return true;
    890907}
     908
     909static bool pendingcleanuprunMode(pxConfig *config)
     910{
     911    PS_ASSERT_PTR_NON_NULL(config, NULL);
     912
     913    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     914    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     915
     916    psMetadata *where = psMetadataAlloc();
     917    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     918
     919    psString query = pxDataGet("stacktool_pendingcleanuprun.sql");
     920    if (!query) {
     921        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     922        return false;
     923    }
     924
     925    if (where && psListLength(where->list)) {
     926        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     927        psStringAppend(&query, " AND %s", whereClause);
     928        psFree(whereClause);
     929    }
     930    psFree(where);
     931
     932    // treat limit == 0 as "no limit"
     933    if (limit) {
     934        psString limitString = psDBGenerateLimitSQL(limit);
     935        psStringAppend(&query, " %s", limitString);
     936        psFree(limitString);
     937    }
     938
     939    if (!p_psDBRunQuery(config->dbh, query)) {
     940        psError(PS_ERR_UNKNOWN, false, "database error");
     941        psFree(query);
     942        return false;
     943    }
     944    psFree(query);
     945
     946    psArray *output = p_psDBFetchResult(config->dbh);
     947    if (!output) {
     948        psError(PS_ERR_UNKNOWN, false, "database error");
     949        return false;
     950    }
     951    if (!psArrayLength(output)) {
     952        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     953        psFree(output);
     954        return true;
     955    }
     956
     957    // negative simple so the default is true
     958    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupRun", !simple)) {
     959        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     960        psFree(output);
     961        return false;
     962    }
     963
     964    psFree(output);
     965
     966    return true;
     967}
     968
     969static bool pendingcleanupskyfileMode(pxConfig *config)
     970{
     971    PS_ASSERT_PTR_NON_NULL(config, NULL);
     972
     973    PXOPT_LOOKUP_S64(stack_id, config->args, "-stack_id", false, false);
     974    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     975    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     976
     977    psMetadata *where = psMetadataAlloc();
     978    if (stack_id) {
     979        PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     980    }
     981    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     982
     983    psString query = pxDataGet("stacktool_pendingcleanupskyfile.sql");
     984    if (!query) {
     985        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     986        return false;
     987    }
     988
     989    if (where && psListLength(where->list)) {
     990        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     991        psStringAppend(&query, " AND %s", whereClause);
     992        psFree(whereClause);
     993    }
     994    psFree(where);
     995
     996    // treat limit == 0 as "no limit"
     997    if (limit) {
     998        psString limitString = psDBGenerateLimitSQL(limit);
     999        psStringAppend(&query, " %s", limitString);
     1000        psFree(limitString);
     1001    }
     1002
     1003    if (!p_psDBRunQuery(config->dbh, query)) {
     1004        psError(PS_ERR_UNKNOWN, false, "database error");
     1005        psFree(query);
     1006        return false;
     1007    }
     1008    psFree(query);
     1009
     1010    psArray *output = p_psDBFetchResult(config->dbh);
     1011    if (!output) {
     1012        psError(PS_ERR_UNKNOWN, false, "database error");
     1013        return false;
     1014    }
     1015    if (!psArrayLength(output)) {
     1016        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1017        psFree(output);
     1018        return true;
     1019    }
     1020
     1021    // negative simple so the default is true
     1022    if (!ippdbPrintMetadatas(stdout, output, "stackPendingCleanupSkyfile", !simple)) {
     1023        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1024        psFree(output);
     1025        return false;
     1026    }
     1027
     1028    psFree(output);
     1029
     1030    return true;
     1031}
     1032
     1033
     1034static bool donecleanupMode(pxConfig *config)
     1035{
     1036    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1037
     1038    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1039    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1040
     1041    psMetadata *where = psMetadataAlloc();
     1042    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1043
     1044    psString query = pxDataGet("stacktool_donecleanup.sql");
     1045    if (!query) {
     1046        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1047        return false;
     1048    }
     1049
     1050    if (where && psListLength(where->list)) {
     1051        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1052        psStringAppend(&query, " AND %s", whereClause);
     1053        psFree(whereClause);
     1054    }
     1055    psFree(where);
     1056
     1057    // treat limit == 0 as "no limit"
     1058    if (limit) {
     1059        psString limitString = psDBGenerateLimitSQL(limit);
     1060        psStringAppend(&query, " %s", limitString);
     1061        psFree(limitString);
     1062    }
     1063
     1064    if (!p_psDBRunQuery(config->dbh, query)) {
     1065        psError(PS_ERR_UNKNOWN, false, "database error");
     1066        psFree(query);
     1067        return false;
     1068    }
     1069    psFree(query);
     1070
     1071    psArray *output = p_psDBFetchResult(config->dbh);
     1072    if (!output) {
     1073        psError(PS_ERR_UNKNOWN, false, "database error");
     1074        return false;
     1075    }
     1076    if (!psArrayLength(output)) {
     1077        psTrace("stacktool", PS_LOG_INFO, "no rows found");
     1078        psFree(output);
     1079        return true;
     1080    }
     1081
     1082    // negative simple so the default is true
     1083    if (!ippdbPrintMetadatas(stdout, output, "stackDoneCleanup", !simple)) {
     1084        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1085        psFree(output);
     1086        return false;
     1087    }
     1088
     1089    psFree(output);
     1090
     1091    return true;
     1092}

  • trunk/ippTools/src/stacktool.h

    r18093 r19092  
    3434    STACKTOOL_MODE_SUMSKYFILE,
    3535    STACKTOOL_MODE_REVERTSUMSKYFILE,
     36    STACKTOOL_MODE_PENDINGCLEANUPRUN,
     37    STACKTOOL_MODE_PENDINGCLEANUPSKYFILE,
     38    STACKTOOL_MODE_DONECLEANUP,
    3639} stacktoolMode;
    3740

  • trunk/ippTools/src/stacktoolConfig.c

    r18976 r19092  
    136136    psMetadataAddS16(revertsumskyfileArgs, PS_LIST_TAIL, "-code",  0,            "search by fault code", 0);
    137137
     138    // -pendingcleanuprun
     139    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     140    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     141    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     142    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     143
     144    // -pendingcleanupskyfile
     145    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
     146    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     147    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-stack_id", 0,          "search by stack ID", 0);
     148    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     149    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     150
     151    // -donecleanup
     152    psMetadata *donecleanupArgs = psMetadataAlloc();
     153    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     154    psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     155    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     156
    138157    psFree(now);
    139158
    … …  
    150169    PXOPT_ADD_MODE("-sumskyfile",      "list results of stackRun", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
    151170    PXOPT_ADD_MODE("-revertsumskyfile","", STACKTOOL_MODE_REVERTSUMSKYFILE,      revertsumskyfileArgs);
     171    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", STACKTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     172    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", STACKTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     173    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     STACKTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    152174
    153175    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • trunk/ippTools/src/warptool.c

    r18976 r19092  
    4646static bool maskedMode(pxConfig *config);
    4747static bool unblockMode(pxConfig *config);
     48static bool pendingcleanuprunMode(pxConfig *config);
     49static bool pendingcleanupwarpMode(pxConfig *config);
     50static bool donecleanupMode(pxConfig *config);
    4851
    4952static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    6972
    7073    switch (config->mode) {
    71         MODECASE(WARPTOOL_MODE_DEFINERUN,         definerunMode);
    72         MODECASE(WARPTOOL_MODE_UPDATERUN,         updaterunMode);
    73         MODECASE(WARPTOOL_MODE_EXP,               expMode);
    74         MODECASE(WARPTOOL_MODE_IMFILE,            imfileMode);
    75         MODECASE(WARPTOOL_MODE_TOOVERLAP,         tooverlapMode);
    76         MODECASE(WARPTOOL_MODE_ADDOVERLAP,        addoverlapMode);
    77         MODECASE(WARPTOOL_MODE_SCMAP,             scmapMode);
    78         MODECASE(WARPTOOL_MODE_TOWARPED,          towarpedMode);
    79         MODECASE(WARPTOOL_MODE_ADDWARPED,         addwarpedMode);
    80         MODECASE(WARPTOOL_MODE_WARPED,            warpedMode);
    81         MODECASE(WARPTOOL_MODE_REVERTWARPED,      revertwarpedMode);
    82         MODECASE(WARPTOOL_MODE_BLOCK,             blockMode);
    83         MODECASE(WARPTOOL_MODE_MASKED,            maskedMode);
    84         MODECASE(WARPTOOL_MODE_UNBLOCK,           unblockMode);
     74        MODECASE(WARPTOOL_MODE_DEFINERUN,          definerunMode);
     75        MODECASE(WARPTOOL_MODE_UPDATERUN,          updaterunMode);
     76        MODECASE(WARPTOOL_MODE_EXP,                expMode);
     77        MODECASE(WARPTOOL_MODE_IMFILE,             imfileMode);
     78        MODECASE(WARPTOOL_MODE_TOOVERLAP,          tooverlapMode);
     79        MODECASE(WARPTOOL_MODE_ADDOVERLAP,         addoverlapMode);
     80        MODECASE(WARPTOOL_MODE_SCMAP,              scmapMode);
     81        MODECASE(WARPTOOL_MODE_TOWARPED,           towarpedMode);
     82        MODECASE(WARPTOOL_MODE_ADDWARPED,          addwarpedMode);
     83        MODECASE(WARPTOOL_MODE_WARPED,             warpedMode);
     84        MODECASE(WARPTOOL_MODE_REVERTWARPED,       revertwarpedMode);
     85        MODECASE(WARPTOOL_MODE_BLOCK,              blockMode);
     86        MODECASE(WARPTOOL_MODE_MASKED,             maskedMode);
     87        MODECASE(WARPTOOL_MODE_UNBLOCK,            unblockMode);
     88        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPRUN,  pendingcleanuprunMode);
     89        MODECASE(WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupwarpMode);
     90        MODECASE(WARPTOOL_MODE_DONECLEANUP,        donecleanupMode);
    8591
    8692        default:
    … …  
    131137            fake_id,
    132138            mode,
    133             "run",      // state
     139            "new",      // state
    134140            workdir,
    135141            "dirty",    // workdir_state
    … …  
    11221128}
    11231129
    1124 
    11251130static bool unblockMode(pxConfig *config)
    11261131{
    … …  
    11391144}
    11401145
     1146static bool pendingcleanuprunMode(pxConfig *config)
     1147{
     1148    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1149
     1150    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1151    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1152
     1153    psMetadata *where = psMetadataAlloc();
     1154    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1155
     1156    psString query = pxDataGet("warptool_pendingcleanuprun.sql");
     1157    if (!query) {
     1158        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1159        return false;
     1160    }
     1161
     1162    if (where && psListLength(where->list)) {
     1163        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1164        psStringAppend(&query, " AND %s", whereClause);
     1165        psFree(whereClause);
     1166    }
     1167    psFree(where);
     1168
     1169    // treat limit == 0 as "no limit"
     1170    if (limit) {
     1171        psString limitString = psDBGenerateLimitSQL(limit);
     1172        psStringAppend(&query, " %s", limitString);
     1173        psFree(limitString);
     1174    }
     1175
     1176    if (!p_psDBRunQuery(config->dbh, query)) {
     1177        psError(PS_ERR_UNKNOWN, false, "database error");
     1178        psFree(query);
     1179        return false;
     1180    }
     1181    psFree(query);
     1182
     1183    psArray *output = p_psDBFetchResult(config->dbh);
     1184    if (!output) {
     1185        psError(PS_ERR_UNKNOWN, false, "database error");
     1186        return false;
     1187    }
     1188    if (!psArrayLength(output)) {
     1189        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1190        psFree(output);
     1191        return true;
     1192    }
     1193
     1194    // negative simple so the default is true
     1195    if (!ippdbPrintMetadatas(stdout, output, "warpPendingCleanupRun", !simple)) {
     1196        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1197        psFree(output);
     1198        return false;
     1199    }
     1200
     1201    psFree(output);
     1202
     1203    return true;
     1204}
     1205
     1206
     1207static bool pendingcleanupwarpMode(pxConfig *config)
     1208{
     1209    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1210
     1211    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", false, false);
     1212    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1213    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1214
     1215    psMetadata *where = psMetadataAlloc();
     1216    if (warp_id) {
     1217        PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     1218    }
     1219    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1220
     1221    psString query = pxDataGet("warptool_pendingcleanupskyfile.sql");
     1222    if (!query) {
     1223        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1224        return false;
     1225    }
     1226
     1227    if (where && psListLength(where->list)) {
     1228        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1229        psStringAppend(&query, " AND %s", whereClause);
     1230        psFree(whereClause);
     1231    }
     1232    psFree(where);
     1233
     1234    // treat limit == 0 as "no limit"
     1235    if (limit) {
     1236        psString limitString = psDBGenerateLimitSQL(limit);
     1237        psStringAppend(&query, " %s", limitString);
     1238        psFree(limitString);
     1239    }
     1240
     1241    if (!p_psDBRunQuery(config->dbh, query)) {
     1242        psError(PS_ERR_UNKNOWN, false, "database error");
     1243        psFree(query);
     1244        return false;
     1245    }
     1246    psFree(query);
     1247
     1248    psArray *output = p_psDBFetchResult(config->dbh);
     1249    if (!output) {
     1250        psError(PS_ERR_UNKNOWN, false, "database error");
     1251        return false;
     1252    }
     1253    if (!psArrayLength(output)) {
     1254        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1255        psFree(output);
     1256        return true;
     1257    }
     1258
     1259    // negative simple so the default is true
     1260    if (!ippdbPrintMetadatas(stdout, output, "warpPendingCleanupWarp", !simple)) {
     1261        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1262        psFree(output);
     1263        return false;
     1264    }
     1265
     1266    psFree(output);
     1267
     1268    return true;
     1269}
     1270
     1271
     1272static bool donecleanupMode(pxConfig *config)
     1273{
     1274    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1275
     1276    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1277    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1278
     1279    psMetadata *where = psMetadataAlloc();
     1280    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
     1281
     1282    psString query = pxDataGet("warptool_donecleanup.sql");
     1283    if (!query) {
     1284        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1285        return false;
     1286    }
     1287
     1288    if (where && psListLength(where->list)) {
     1289        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1290        psStringAppend(&query, " AND %s", whereClause);
     1291        psFree(whereClause);
     1292    }
     1293    psFree(where);
     1294
     1295    // treat limit == 0 as "no limit"
     1296    if (limit) {
     1297        psString limitString = psDBGenerateLimitSQL(limit);
     1298        psStringAppend(&query, " %s", limitString);
     1299        psFree(limitString);
     1300    }
     1301
     1302    if (!p_psDBRunQuery(config->dbh, query)) {
     1303        psError(PS_ERR_UNKNOWN, false, "database error");
     1304        psFree(query);
     1305        return false;
     1306    }
     1307    psFree(query);
     1308
     1309    psArray *output = p_psDBFetchResult(config->dbh);
     1310    if (!output) {
     1311        psError(PS_ERR_UNKNOWN, false, "database error");
     1312        return false;
     1313    }
     1314    if (!psArrayLength(output)) {
     1315        psTrace("warptool", PS_LOG_INFO, "no rows found");
     1316        psFree(output);
     1317        return true;
     1318    }
     1319
     1320    // negative simple so the default is true
     1321    if (!ippdbPrintMetadatas(stdout, output, "warpDoneCleanup", !simple)) {
     1322        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1323        psFree(output);
     1324        return false;
     1325    }
     1326
     1327    psFree(output);
     1328
     1329    return true;
     1330}
    11411331
    11421332static bool isValidMode(pxConfig *config, const char *mode)

  • trunk/ippTools/src/warptool.h

    r17145 r19092  
    4141    WARPTOOL_MODE_MASKED,
    4242    WARPTOOL_MODE_UNBLOCK,
     43    WARPTOOL_MODE_PENDINGCLEANUPRUN,
     44    WARPTOOL_MODE_PENDINGCLEANUPSKYFILE,
     45    WARPTOOL_MODE_DONECLEANUP,
    4346} warptoolMode;
    4447

  • trunk/ippTools/src/warptoolConfig.c

    r18976 r19092  
    252252    psMetadataAddStr(unblockArgs, PS_LIST_TAIL, "-label",  0,            "name of a label to unmask (required)", NULL);
    253253
     254    // -pendingcleanuprun
     255    psMetadata *pendingcleanuprunArgs = psMetadataAlloc();
     256    psMetadataAddStr(pendingcleanuprunArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     257    psMetadataAddBool(pendingcleanuprunArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     258    psMetadataAddU64(pendingcleanuprunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     259
     260    // -pendingcleanupskyfile
     261    psMetadata *pendingcleanupskyfileArgs = psMetadataAlloc();
     262    psMetadataAddStr(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     263    psMetadataAddS64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,          "search by warp ID", 0);
     264    psMetadataAddBool(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     265    psMetadataAddU64(pendingcleanupskyfileArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     266
     267    // -donecleanup
     268    psMetadata *donecleanupArgs = psMetadataAlloc();
     269    psMetadataAddStr(donecleanupArgs, PS_LIST_TAIL, "-label",  0,            "list blocks for specified label", NULL);
     270    psMetadataAddBool(donecleanupArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     271    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     272
    254273    psFree(now);
    255274    psMetadata *argSets = psMetadataAlloc();
    … …  
    267286    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    268287    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    269     PXOPT_ADD_MODE("-block",           "set a label block", WARPTOOL_MODE_BLOCK,          blockArgs);
    270     PXOPT_ADD_MODE("-masked",          "show blocked lables", WARPTOOL_MODE_MASKED,         maskedArgs);
    271     PXOPT_ADD_MODE("-unblock",         "remove a label block", WARPTOOL_MODE_UNBLOCK,        unblockArgs);
     288    PXOPT_ADD_MODE("-block",                 "set a label block",                    WARPTOOL_MODE_BLOCK,          blockArgs);
     289    PXOPT_ADD_MODE("-masked",                "show blocked lables",                  WARPTOOL_MODE_MASKED,         maskedArgs);
     290    PXOPT_ADD_MODE("-unblock",               "remove a label block",                 WARPTOOL_MODE_UNBLOCK,        unblockArgs);
     291    PXOPT_ADD_MODE("-pendingcleanuprun",     "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPRUN,    pendingcleanuprunArgs);
     292    PXOPT_ADD_MODE("-pendingcleanupskyfile", "show runs that need to be cleaned up", WARPTOOL_MODE_PENDINGCLEANUPSKYFILE, pendingcleanupskyfileArgs);
     293    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     WARPTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    272294
    273295    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.