IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 18, 2010, 12:49:05 PM (16 years ago)
Author:
eugene
Message:

merging changes from trunk into branches/pap

Location:
branches/pap
Files:
63 edited
13 copied

Legend:

Unmodified
Added
Removed

  • branches/pap

  • branches/pap/ippTools/share/Makefile.am

    r27391 r28003  
    3131     chiptool_donecleanup.sql \
    3232     chiptool_find_rawexp.sql \
     33     chiptool_listrun.sql \
    3334     chiptool_pendingcleanupimfile.sql \
    3435     chiptool_pendingcleanuprun.sql \
    … …  
    3637     chiptool_processedimfile.sql \
    3738     chiptool_revertprocessedimfile.sql \
     39     chiptool_revertupdatedimfile.sql \
    3840     chiptool_run.sql \
    3941     chiptool_runstate.sql \
    4042     chiptool_setimfiletoupdate.sql \
     43     chiptool_export_run.sql \
    4144     chiptool_export_imfile.sql \
    4245     chiptool_export_processed_imfile.sql \
    43      chiptool_export_run.sql \
    4446     chiptool_unmasked.sql \
    4547     detselect_search.sql \
    … …  
    109111     difftool_export_skyfile.sql \
    110112     difftool_inputskyfile.sql \
     113     difftool_listrun.sql \
    111114     difftool_pendingcleanuprun.sql \
    112115     difftool_pendingcleanupskyfile.sql \
    113116     difftool_revertdiffskyfile_delete.sql \
    114      difftool_revertdiffskyfile_update.sql \
     117     difftool_revertdiffskyfile_updated.sql \
     118     difftool_setskyfiletoupdate.sql \
    115119     difftool_skyfile.sql \
    116120     difftool_todiffskyfile.sql \
    … …  
    194198     magictool_rawimfile.sql \
    195199     magictool_revertnode.sql \
     200     magictool_exposure.sql \
    196201     magicdstool_clearstatefaults.sql \
    197202     magicdstool_completed_runs.sql \
    … …  
    221226     pstamptool_completedreq.sql \
    222227     pstamptool_datastore.sql \
     228     pstamptool_getdependent.sql \
    223229     pstamptool_listjob.sql \
     230     pstamptool_pendingcleanup.sql \
    224231     pstamptool_pendingdependent.sql \
    225232     pstamptool_pendingjob.sql \
    226233     pstamptool_pendingreq.sql \
    227234     pstamptool_project.sql \
     235     pstamptool_revertdependent.sql \
    228236     pstamptool_revertjob.sql \
    229237     pstamptool_revertreq.sql \
    230238     pstamptool_revertreq_deletejobs.sql \
     239     pstamptool_updatejob.sql \
    231240     pxadmin_create_tables.sql \
    232241     pxadmin_create_mirror_tables.sql \
    … …  
    290299     warptool_finish_run.sql \
    291300     warptool_imfile.sql \
     301     warptool_listrun.sql \
    292302     warptool_pendingcleanuprun.sql \
    293303     warptool_pendingcleanupskyfile.sql \
    294304     warptool_revertoverlap.sql \
    295305     warptool_revertwarped_delete.sql \
     306     warptool_revertwarped_updated.sql \
    296307     warptool_runstate.sql \
    297308     warptool_scmap.sql \
     309     warptool_setskyfiletoupdate.sql \
    298310     warptool_tooverlap.sql \
    299311     warptool_towarped.sql \

  • branches/pap/ippTools/share/camtool_find_pendingexp.sql

    r26567 r28003  
    1010    rawExp.telescope,
    1111    rawExp.filelevel,
    12     chipRun.magicked AS chip_magicked
     12    chipRun.magicked AS chip_magicked,
     13    camProcessedExp.path_base
    1314FROM camRun
    1415JOIN chipRun

  • branches/pap/ippTools/share/camtool_find_processedexp.sql

    r27133 r28003  
    33    camRun.workdir,
    44    camRun.label,
     5    camRun.state,
    56    camRun.magicked,
    67    chipRun.chip_id,
     8    chipRun.state as chip_state,
    79    chipRun.magicked as chip_magicked,
    810    rawExp.exp_tag,

  • branches/pap/ippTools/share/chiptool_change_imfile_data_state.sql

    r23384 r28003  
    33-- chip_id and class_id
    44UPDATE chipProcessedImfile
     5JOIN chipRun USING(chip_id, exp_id)
    56JOIN rawImfile USING(exp_id, class_id)
    67    SET

  • branches/pap/ippTools/share/chiptool_pendingcleanupimfile.sql

    r22751 r28003  
    1313    USING(chip_id)
    1414WHERE
    15     ((chipRun.state = 'goto_cleaned' AND chipProcessedImfile.data_state = 'full')
     15    ((chipRun.state = 'goto_cleaned' AND (chipProcessedImfile.data_state = 'full'
     16                                       OR chipProcessedImfile.data_state = 'update'))
    1617OR
    17     (chipRun.state = 'goto_scrubbed' AND chipProcessedImfile.data_state = 'full')
     18    (chipRun.state = 'goto_scrubbed' AND chipProcessedImfile.data_state != 'scrubbed')
    1819OR
    1920    (chipRun.state = 'goto_purged' AND chipProcessedImfile.data_state != 'purged'))

  • branches/pap/ippTools/share/chiptool_pendingimfile.sql

    r27391 r28003  
    1010    rawExp.camera,
    1111    rawExp.telescope,
    12     rawExp.filelevel
     12    rawExp.filelevel,
     13    IFNULL(Label.priority, 10000) AS priority,
     14    chipProcessedImfile.path_base
    1315FROM chipRun
    1416JOIN rawExp
    … …  
    2527LEFT JOIN chipMask
    2628    ON chipRun.label = chipMask.label
     29LEFT JOIN Label ON chipRun.label = Label.label
    2730WHERE
    2831    ((chipRun.state = 'new'
    … …  
    3336    OR
    3437    (chipRun.state = 'update'
    35     AND chipProcessedImfile.data_state = 'update'))
    36 -- // Restriction to prevent the processing of bad chips. Not needed now.
    37 --     AND
    38 --     (rawImfile.class_id != 'XY15' AND
    39 --     rawImfile.class_id != 'XY32' AND
    40 --     rawImfile.class_id != 'XY45')
    41 
     38    AND chipProcessedImfile.data_state = 'update'
     39    AND chipProcessedImfile.fault = 0))
     40    AND (Label.active OR Label.active IS NULL)

  • branches/pap/ippTools/share/chiptool_processedimfile.sql

    r26907 r28003  
    2222    rawExp.camera,
    2323    rawExp.telescope,
    24     rawExp.filelevel
     24    rawExp.filelevel,
     25    rawExp.dateobs,
     26    rawExp.ra,
     27    rawExp.decl,
     28    rawExp.exp_time,
     29    rawImfile.magicked AS raw_magicked,
     30    rawImfile.burntool_state,
     31    magicDSRun.state AS dsRun_state
    2532FROM chipRun
    2633JOIN chipImfile
    … …  
    3037JOIN rawExp
    3138    ON chipProcessedImfile.exp_id = rawExp.exp_id
     39JOIN rawImfile
     40    ON rawExp.exp_id = rawImfile.exp_id
     41    AND chipProcessedImfile.class_id = rawImfile.class_id
     42LEFT JOIN magicDSRun
     43    ON stage_id = chip_id AND stage = 'chip' AND magicDSRun.re_place

  • branches/pap/ippTools/share/detselect_search.sql

    r16514 r28003  
    2727    ) as Foo
    2828WHERE
    29     (state = 'stop' OR state = 'register')
     29    (state = 'stop')

  • branches/pap/ippTools/share/difftool_definewarpstack_part1.sql

    r26144 r28003  
    55    warpRun.label,
    66    warpRun.tess_id,
     7    warpRun.data_group,
    78    COUNT(skycell_id) as skycell_count
    89FROM warpRun

  • branches/pap/ippTools/share/difftool_definewarpwarp_select.sql

    r27576 r28003  
    33    inputWarpRun.tess_id AS tess_id,
    44    inputRawExp.exp_id AS input_exp_id,
     5    inputWarpRun.data_group AS input_data_group,
    56    -- The following trick pulls out the warp_id that has the smallest distance
    67    SUBSTRING_INDEX(GROUP_CONCAT(templateWarpRun.warp_id ORDER BY ABS(ASIN(SQRT(POW(SIN(0.5*(inputRawExp.decl - templateRawExp.decl)),2) + COS(inputRawExp.decl) * COS(templateRawExp.decl) * POW(SIN(0.5*(inputRawExp.ra - templateRawExp.ra)),2))))), ',', 1) AS template_warp_id

  • branches/pap/ippTools/share/difftool_skyfile.sql

    r26986 r28003  
    77    diffRun.label,
    88    diffRun.bothways,
     9    diffRun.diff_mode,
    910    warp1,
    1011    stack1,

  • branches/pap/ippTools/share/difftool_todiffskyfile.sql

    r27391 r28003  
    1212    diffRun.reduction,
    1313    diffRun.bothways,
    14     diffRun.diff_mode
     14    diffRun.diff_mode,
     15    diffSkyfile.path_base
    1516FROM diffRun
    1617JOIN diffInputSkyfile USING(diff_id)

  • branches/pap/ippTools/share/magicdstool_todestreak_camera.sql

    r27301 r28003  
    33    magicDSRun.magic_id,
    44    chipRun.exp_id,
     5    camRun.magicked,
    56    magicDSRun.label,
    67    camera,

  • branches/pap/ippTools/share/magicdstool_todestreak_chip.sql

    r27358 r28003  
    33    magicDSRun.magic_id,
    44    chipRun.exp_id,
     5    chipRun.magicked,
    56    magicDSRun.label,
    67    camera,
    … …  
    3334    magicDSRun.state = 'new'
    3435    AND magicDSRun.stage = 'chip'
    35     AND chipRun.state = 'full'
     36    AND (chipRun.state = 'full' OR (chipRun.state = 'update' and chipProcessedImfile.data_state = 'full'))
    3637    AND chipProcessedImfile.fault = 0
    3738    AND chipProcessedImfile.quality = 0

  • branches/pap/ippTools/share/magicdstool_todestreak_diff.sql

    r27476 r28003  
    1010    stage,
    1111    magicRun.diff_id AS stage_id,
     12    diffRun.magicked,
    1213    diffSkyfile.skycell_id AS component,
    1314    CAST(NULL AS CHAR(255)) AS uri,
    … …  
    4748    magicDSRun.label,
    4849    rawExp.camera,
    49     magicMask.uri as streaks_uri,
     50    magicMask.uri AS streaks_uri,
    5051    (SELECT uri from magicMask where magic_id = inv_magic_id) AS inv_streaks_uri,
    5152    stage,
    52     magicRun.diff_id as stage_id,
    53     diffSkyfile.skycell_id as component,
     53    magicRun.diff_id AS stage_id,
     54    diffRun.magicked,
     55    diffSkyfile.skycell_id AS component,
    5456    CAST(NULL AS CHAR(255)) AS uri,
    5557    diffSkyfile.path_base,
    5658    magicRun.inverse,
    57     CAST(NULL AS CHAR(255)) as cam_path_base,
     59    CAST(NULL AS CHAR(255)) AS cam_path_base,
    5860    CAST(NULL AS CHAR(255)) AS cam_reduction,
    5961    outroot,
    … …  
    8082    AND diffSkyfile.quality = 0
    8183    AND magicDSFile.component IS NULL
    82 ) as magicDSRun
     84) AS magicDSRun
    8385-- we need the following so this query is compatible with the other stages
    8486WHERE magic_ds_id IS NOT NULL

  • branches/pap/ippTools/share/magicdstool_todestreak_raw.sql

    r27454 r28003  
    44    magicRun.exp_id,
    55    magicDSRun.label,
    6     camera,
     6    rawExp.camera,
    77    magicMask.uri as streaks_uri,
    88    CAST(NULL AS CHAR(255)) AS inv_streaks_uri,
    99    stage,
    1010    stage_id,
     11    rawExp.magicked,
    1112    class_id as component,
    1213    rawImfile.uri AS uri,
    … …  
    2526JOIN camRun USING(cam_id)
    2627JOIN camProcessedExp USING(cam_id)
    27 JOIN rawImfile ON magicRun.exp_id = rawImfile.exp_id
     28JOIN rawExp ON magicRun.exp_id = rawExp.exp_id
     29JOIN rawImfile ON rawExp.exp_id = rawImfile.exp_id
    2830LEFT JOIN magicDSFile
    2931    ON magicDSRun.magic_ds_id = magicDSFile.magic_ds_id

  • branches/pap/ippTools/share/magicdstool_todestreak_warp.sql

    r27301 r28003  
    99    stage,
    1010    stage_id,
     11    warpRun.magicked,
    1112    warpSkyfile.skycell_id as component,
    1213    warpSkyfile.uri,

  • branches/pap/ippTools/share/magicdstool_torevert_camera.sql

    r27015 r28003  
    1313    0 AS bothways,
    1414    0 AS bytes,
    15     0 AS md5sum
     15    0 AS md5sum,
     16    camRun.magicked
    1617FROM magicDSRun
    1718    JOIN magicDSFile using(magic_ds_id)

  • branches/pap/ippTools/share/magicdstool_torevert_chip.sql

    r27015 r28003  
    1313    0 AS bothways,
    1414    0 AS bytes,
    15     0 AS md5sum
     15    0 AS md5sum,
     16    chipRun.magicked
    1617FROM magicDSRun
    1718    JOIN magicDSFile using(magic_ds_id)
    1819    JOIN camProcessedExp using(cam_id)
    19     JOIN chipProcessedImfile ON (stage_id = chipProcessedImfile.chip_id AND component = class_id)
     20    JOIN chipRun ON (stage_id = chipRun.chip_id)
     21    -- JOIN chipProcessedImfile ON (stage_id = chipProcessedImfile.chip_id AND component = class_id)
     22    JOIN chipProcessedImfile USING(chip_id, exp_id)
    2023    JOIN rawExp using(exp_id)
    2124WHERE magicDSRun.stage = 'chip'

  • branches/pap/ippTools/share/magicdstool_torevert_diff.sql

    r27015 r28003  
    1313    CAST(diffRun.bothways AS SIGNED) AS bothways,
    1414    0 AS bytes,
    15     0 AS md5sum
     15    0 AS md5sum,
     16    diffRun.magicked
    1617FROM magicDSRun
    1718    JOIN magicRun using(magic_id)

  • branches/pap/ippTools/share/magicdstool_torevert_raw.sql

    r27015 r28003  
    1010    outroot,
    1111    rawImfile.uri AS path_base,
    12     NULL AS cam_path_base,
     12    CAST(NULL AS CHAR(255)) AS cam_path_base,
    1313    0 AS bothways,
    1414    bytes,
    15     md5sum
     15    md5sum,
     16    0 AS magicked
    1617FROM magicDSRun
    1718    JOIN magicDSFile using(magic_ds_id)

  • branches/pap/ippTools/share/magicdstool_torevert_warp.sql

    r27015 r28003  
    1313    0 AS bothways,
    1414    0 AS bytes,
    15     0 AS md5sum
     15    0 AS md5sum,
     16    warpRun.magicked
    1617FROM magicDSRun
    1718    JOIN magicDSFile USING(magic_ds_id)

  • branches/pap/ippTools/share/pstamptool_completedreq.sql

    r25281 r28003  
    1 SELECT *
     1SELECT pstampRequest.* ,
     2    IFNULL(Label.priority, 0) AS priority
    23FROM pstampRequest
     4    LEFT JOIN Label USING(label)
    35WHERE state = 'run'
    46    AND (

  • branches/pap/ippTools/share/pstamptool_pendingdependent.sql

    r25793 r28003  
    1 SELECT *
     1SELECT DISTINCT
     2    pstampDependent.*,
     3    IFNULL(Label.priority, 10000) AS priority
    24FROM pstampDependent
    3 WHERE state = 'new'
     5JOIN pstampJob USING(dep_id)
     6JOIN pstampRequest USING(req_id)
     7LEFT JOIN Label ON pstampRequest.label = Label.label
     8WHERE pstampDependent.state = 'new'
     9    AND pstampDependent.fault = 0
     10    AND pstampJob.state = 'run'
     11    AND (pstampRequest.state = 'run' OR pstampRequest.state = 'new')
     12    AND (Label.active OR Label.active IS NULL)

  • branches/pap/ippTools/share/pstamptool_pendingjob.sql

    r25793 r28003  
    1 SELECT pstampJob.*
     1SELECT pstampJob.*,
     2    IFNULL(Label.priority, 10000) AS priority
    23FROM pstampJob
    34    JOIN pstampRequest USING(req_id)
    45    LEFT JOIN pstampDependent USING(dep_id)
     6    LEFT JOIN Label ON pstampRequest.label = Label.label
    57WHERE pstampRequest.state = 'run'
    68    AND pstampRequest.fault = 0
    … …  
    810    AND pstampJob.fault = 0
    911    AND (dep_id = 0 OR pstampDependent.state = 'full')
     12    AND (Label.active OR Label.active IS NULL)

  • branches/pap/ippTools/share/pstamptool_pendingreq.sql

    r25199 r28003  
    11-- postage stamp requests ready for download and parsing
    22SELECT
    3  pstampRequest.*,
    4  pstampDataStore.outProduct as ds_outProduct
    5  FROM pstampRequest
    6  LEFT JOIN pstampDataStore
    7     USING(ds_id)
    8  WHERE pstampRequest.state = 'new'
     3    pstampRequest.*,
     4    pstampDataStore.outProduct AS ds_outProduct,
     5    IFNULL(Label.priority, 10000) AS priority
     6FROM pstampRequest
     7    LEFT JOIN pstampDataStore USING(ds_id)
     8    LEFT JOIN Label ON pstampRequest.label = Label.label
     9WHERE pstampRequest.state = 'new'
    910    AND pstampRequest.fault = 0
     11    AND (Label.active OR Label.active IS NULL)

  • branches/pap/ippTools/share/pxadmin_create_tables.sql

    r27546 r28003  
    11751175        KEY(label),
    11761176        KEY(fault),
     1177        KEY(stage),
     1178        KEY(stage_id),
    11771179        FOREIGN KEY(magic_id) REFERENCES magicRun(magic_id),
    11781180        FOREIGN KEY(inv_magic_id) REFERENCES magicRun(magic_id)
    … …  
    13011303        outProduct VARCHAR(64),
    13021304        uri VARCHAR(255),
     1305        outdir     VARCHAR(255),
    13031306        fault SMALLINT,
    13041307        PRIMARY KEY(req_id),
    … …  
    13271330        stage      VARCHAR(64),
    13281331        stage_id   BIGINT,
     1332        component  VARCHAR(64),
    13291333        imagedb    VARCHAR(64),
    13301334        rlabel     VARCHAR(64),
    1331         no_magic   TINYINT,
    1332         PRIMARY KEY(dep_id)
     1335        outdir     VARCHAR(255),
     1336        need_magic TINYINT,
     1337        PRIMARY KEY(dep_id),
     1338        KEY(state),
     1339        KEY(stage),
     1340        KEY(stage_id)
    13331341) ENGINE=innodb DEFAULT CHARSET=latin1;
    13341342
    … …  
    13421350    comment     VARCHAR(255),
    13431351    PRIMARY KEY(target_id),
     1352    KEY(stage),
     1353    KEY(dist_group),
     1354    KEY(filter),
     1355    KEY(state),
    13441356    CONSTRAINT UNIQUE (dist_group, filter, stage, clean)
    13451357)  ENGINE=innodb DEFAULT CHARSET=latin1;
    … …  
    13651377    KEY(state),
    13661378    KEY(label),
     1379    KEY(stage),
     1380    KEY(stage_id),
     1381    KEY(magic_ds_id),
     1382    KEY(fault),
     1383    KEY(data_group),
    13671384    FOREIGN KEY(target_id) REFERENCES distTarget(target_id)
    13681385)  ENGINE=innodb DEFAULT CHARSET=latin1;
    … …  
    15491566      note VARCHAR(255),             -- note
    15501567      registered TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- time run was registered
    1551       PRIMARY KEY(dqstats_id),
     1568      PRIMARY KEY(ss_id),
    15521569      KEY(state),
    15531570      KEY(label),
    … …  
    15811598      KEY(fault),
    15821599      KEY(quality),
    1583       FOREIGN KEY(ss_id) REFERENCES staticskyRun(ss_id),
     1600      FOREIGN KEY(ss_id) REFERENCES staticskyRun(ss_id)
     1601) ENGINE=innodb DEFAULT CHARSET=latin1;
     1602
     1603CREATE TABLE Label (
     1604    label       VARCHAR(64),
     1605    priority    INT,
     1606    active      TINYINT,
     1607    comment     VARCHAR(80),
     1608    PRIMARY KEY(label),
     1609    KEY(priority),
     1610    KEY(active)
    15841611) ENGINE=innodb DEFAULT CHARSET=latin1;
    15851612

  • branches/pap/ippTools/share/pxadmin_drop_tables.sql

    r25851 r28003  
    8181DROP TABLE IF EXISTS publishDone;
    8282DROP TABLE IF EXISTS pstampDependent;
     83DROP TABLE IF EXISTS staticskyInput;
     84DROP TABLE IF EXISTS staticskyResult;
     85DROP TABLE IF EXISTS staticskyRun;
     86DROP TABLE IF EXISTS Label;
    8387
    8488SET FOREIGN_KEY_CHECKS=1

  • branches/pap/ippTools/share/stacktool_tosum.sql

    r27679 r28003  
    66    stackRun.reduction,
    77    stackRun.label,
    8     stackRun.state
     8    stackRun.state,
     9    stackSumSkyfile.path_base
    910FROM stackRun
    1011JOIN stackInputSkyfile USING(stack_id)
    … …  
    1617    -- WHERE hook %s
    1718GROUP BY stack_id
    18 HAVING COUNT(warpRun.state = 'full') = COUNT(stackInputSkyfile.warp_id)
     19HAVING SUM(IF(warpRun.state = 'full', 1, 0)) = COUNT(stackInputSkyfile.warp_id)

  • branches/pap/ippTools/share/warptool_pendingcleanupskyfile.sql

    r24186 r28003  
    1010    USING(warp_id)
    1111WHERE
    12    ((warpRun.state = 'goto_cleaned'  AND warpSkyfile.data_state = 'full')
     12   ((warpRun.state = 'goto_cleaned'  AND (warpSkyfile.data_state = 'full'
     13                                      OR  warpSkyfile.data_state = 'update'))
    1314    OR
    1415    (warpRun.state = 'goto_scrubbed' AND warpSkyfile.data_state != 'scrubbed')

  • branches/pap/ippTools/share/warptool_scmap.sql

    r19092 r28003  
    33    chipProcessedImfile.uri,
    44    chipProcessedImfile.path_base as chip_path_base,
    5     camProcessedExp.path_base as cam_path_base
     5    camProcessedExp.path_base as cam_path_base,
     6    chipProcessedImfile.chip_id,
     7    chipRun.state,
     8    chipProcessedImfile.data_state,
     9    chipProcessedImfile.magicked,
     10    rawImfile.magicked AS raw_magicked
    611FROM warpRun
    712JOIN warpSkyCellMap
    … …  
    1823    ON chipRun.chip_id = chipProcessedImfile.chip_id
    1924    AND warpSkyCellMap.class_id = chipProcessedImfile.class_id
     25JOIN rawImfile
     26    ON chipRun.exp_id = rawImfile.exp_id
     27    AND chipProcessedImfile.class_id = rawImfile.class_id
    2028WHERE
    21 --    warpRun.state = 'new'
    22     fakeRun.state = 'full'
    23     AND camRun.state = 'full'
    24     AND chipRun.state = 'full'
     29    1

  • branches/pap/ippTools/share/warptool_towarped.sql

    r27503 r28003  
     1SELECT
     2    warp_id,
     3    warp_skyfile_id,
     4    skycell_id,
     5    tess_id,
     6    fake_id,
     7    state,
     8    reduction,
     9    cam_id,
     10    camera,
     11    exp_tag,
     12    workdir,
     13    magicked,
     14    path_base
     15FROM (
    116    SELECT DISTINCT
    217        warpSkyCellMap.warp_id,
    … …  
    1126        rawExp.exp_tag,
    1227        warpRun.workdir,
    13         chipRun.magicked
     28        chipRun.magicked,
     29        CAST(NULL AS CHAR(255)) AS path_base
    1430    FROM warpRun
    1531    JOIN warpSkyCellMap
    … …  
    4561        AND warpSkyCellMap.fault = 0
    4662        -- where hook 1 %s
     63        -- limit hook 1 %s
     64UNION
     65    SELECT
     66        warpSkyCellMap.warp_id,
     67        warpImfile.warp_skyfile_id,
     68        warpSkyCellMap.skycell_id,
     69        warpSkyCellMap.tess_id,
     70        warpRun.fake_id,
     71        warpRun.state,
     72        warpRun.reduction,
     73        camRun.cam_id,
     74        rawExp.camera,
     75        rawExp.exp_tag,
     76        warpRun.workdir,
     77        MIN(chipProcessedImfile.magicked) AS magicked,
     78        warpSkyfile.path_base
     79    FROM warpRun
     80    JOIN warpImfile USING(warp_id)
     81    JOIN warpSkyCellMap USING(warp_id, skycell_id)
     82    JOIN warpSkyfile USING(warp_id, skycell_id)
     83    JOIN fakeRun USING(fake_id)
     84    JOIN camRun USING(cam_id)
     85    JOIN chipRun USING(chip_id)
     86    JOIN rawExp USING(exp_id)
     87    LEFT JOIN chipProcessedImfile USING(chip_id, class_id)
     88    WHERE warpRun.state = 'update'
     89        AND warpSkyfile.data_state = 'update'
     90        AND warpSkyfile.fault = 0
     91        AND camRun.state = 'full'
     92        AND chipProcessedImfile.data_state = 'full'
     93        -- if warpSkyfile was magicked previously require inputs to be magicked
     94        -- this blocks processing until all the chip inputs have been destreaked
     95        AND (warpSkyfile.magicked = 0 OR chipProcessedImfile.magicked >= 0)
     96        -- where hook 2 %s
     97    GROUP BY warp_id, skycell_id
     98    HAVING COUNT(warpSkyCellMap.class_id) = COUNT(chipProcessedImfile.class_id)
     99    -- limit hook 2 %s
     100) as towarped
     101

  • branches/pap/ippTools/share/warptool_warped.sql

    r25791 r28003  
    77    rawExp.exp_id,
    88    rawExp.exp_name,
    9     rawExp.camera
     9    rawExp.camera,
     10    rawExp.filter,
     11    rawExp.dateobs,
     12    rawExp.ra,
     13    rawExp.decl,
     14    rawExp.exp_time
    1015FROM warpRun
    1116JOIN warpSkyfile
    … …  
    2126JOIN rawExp
    2227    ON chipRun.exp_id  = rawExp.exp_id
    23 WHERE
    24 -- bogus test; just here so there there is a 'WHERE' stmt to append conditionals too
    25 -- XXX EAM : not needed: fix warptool.c
    26     warpRun.warp_id is NOT NULL

  • branches/pap/ippTools/src/addtool.c

    r27391 r28003  
    280280    PXOPT_COPY_STR(config->args, where, "-state",     "addRun.state", "==");
    281281    PXOPT_COPY_STR(config->args, where, "-reduction", "addRun.reduction", "==");
     282    PXOPT_COPY_STR(config->args, where, "-dvodb", "addRun.dvodb", "==");
    282283
    283284    if (!psListLength(where->list)) {

  • branches/pap/ippTools/src/addtoolConfig.c

    r27082 r28003  
    7676    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state",                  0, "search by addRun state", NULL);
    7777    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-reduction",              0, "search by addRun reduction class", NULL);
     78    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-dvodb",                  0, "search by dvodb", NULL);
    7879    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",                   0, "allow everything to be queued without search terms", false);
    7980    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state",              0, "set state", NULL);
    8081    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label",              0, "set label", NULL);
     82    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dvodb",              0, "set dvodb", NULL);
    8183    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_data_group", 0,   "define new data_group", NULL);
    8284    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_dist_group", 0,   "define new dist_group", NULL);

  • branches/pap/ippTools/src/camtool.c

    r27391 r28003  
    681681    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    682682    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     683    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    683684
    684685    // generate restrictions
    … …  
    741742    }
    742743
    743     // order by cam_id so that the postage stamp parser can easliy find the 'latest' astrometry
    744     psStringAppend(&query, " ORDER BY exp_id, cam_id");
     744
     745    if (pstamp_order) {
     746        // put runs in order of exposure id with newest chip Runs first
     747        // The postage stamp parser depends on this behavior
     748        psStringAppend(&query, " ORDER BY exp_id, cam_id DESC");
     749    }
    745750
    746751    // treat limit == 0 as "no limit"

  • branches/pap/ippTools/src/camtoolConfig.c

    r27300 r28003  
    184184    pxmagicAddArguments(processedexpArgs);
    185185
     186    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-pstamp_order",  0,      "order the results for the postage stamp server", false);
     187
    186188    psMetadataAddU64(processedexpArgs, PS_LIST_TAIL, "-limit",    0,            "limit result set to N items", 0);
    187189    psMetadataAddBool(processedexpArgs, PS_LIST_TAIL, "-all",     0,            "list everything without restriction", false);

  • branches/pap/ippTools/src/chiptool.c

    r27391 r28003  
    6060static bool runstateMode(pxConfig *config);
    6161static bool setimfiletoupdateMode(pxConfig *config);
     62static bool listrunMode(pxConfig *config);
    6263
    6364# define MODECASE(caseName, func) \
    … …  
    103104        MODECASE(CHIPTOOL_MODE_RUNSTATE,                runstateMode);
    104105        MODECASE(CHIPTOOL_MODE_SETIMFILETOUPDATE,       setimfiletoupdateMode);
     106        MODECASE(CHIPTOOL_MODE_LISTRUN,                 listrunMode);
    105107        default:
    106108            psAbort("invalid option (this should not happen)");
    … …  
    420422    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chipRun.chip_id", "==");
    421423    // we only allow a single label to match (do not use pxAddLabelSearchArgs here)
    422     PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
     424    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "LIKE");
    423425    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    424     PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "==");
    425     PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "==");
     426    PXOPT_COPY_STR(config->args,  where, "-data_group", "chipRun.data_group",   "LIKE");
     427    PXOPT_COPY_STR(config->args,  where, "-dist_group", "chipRun.dist_group",   "LIKE");
    426428
    427429    if (!psListLength(where->list)) {
    … …  
    469471    }
    470472    psFree(where);
     473
     474    psStringAppend(&query, "\nORDER BY priority DESC, chip_id");
    471475
    472476    // treat limit == 0 as "no limit"
    … …  
    699703    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    700704    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     705    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     706    if (allfiles) {
     707        faulted = false;
     708    }
    701709
    702710    psMetadata *where = psMetadataAlloc();
    … …  
    740748        // list only faulted rows
    741749        psStringAppend(&query, " %s", "AND chipProcessedImfile.fault != 0");
    742     } else {
     750    } else if (!allfiles) {
    743751        // don't list faulted rows
    744752        psStringAppend(&query, " %s", "AND chipProcessedImfile.fault = 0");
    … …  
    807815        return false;
    808816    }
     817    psString query_update = pxDataGet("chiptool_revertupdatedimfile.sql");
     818    if (!query) {
     819        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     820        psFree(where);
     821        return false;
     822    }
    809823
    810824    if (where && psListLength(where->list)) {
    811825        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    812826        psStringAppend(&query, " AND %s", whereClause);
     827        psStringAppend(&query_update, " AND %s", whereClause);
    813828        psFree(whereClause);
    814829    }
    … …  
    822837    }
    823838    psFree(query);
     839    if (!p_psDBRunQuery(config->dbh, query_update)) {
     840        psError(PS_ERR_UNKNOWN, false, "database error");
     841        psFree(query_update);
     842        return false;
     843    }
     844    psFree(query_update);
    824845
    825846    return true;
    … …  
    14141435    }
    14151436
    1416     char *set_magicked_imfile = "";
    1417     char *set_magicked_run = "";
     1437    psString set_magicked_imfile = psStringCopy("");
     1438    psString set_magicked_run = psStringCopy("");
    14181439    if (!strcmp(data_state, "full")) {
    14191440        // if (chipProcessedImfile.magicked < 0 and rawImfile.magicked = 0) leave magicked unchanged. This will
    … …  
    14211442        // otherwise copy magicked from the rawImfile
    14221443        // Same thing for chipRun/rawExp
    1423         set_magicked_imfile = "\n , chipProcessedImfile.magicked = IF((chipProcessedImfile.magicked < 0 AND rawImfile.magicked = 0), chipProcessedImfile.magicked, rawImfile.magicked)";
    1424         set_magicked_run = "\n , chipRun.magicked = IF((chipRun.magicked < 0 AND rawExp.magicked = 0), chipRun.magicked, rawExp.magicked)";
     1444        psStringAppend(&set_magicked_imfile, "\n , chipProcessedImfile.magicked = IF((chipProcessedImfile.magicked < 0"
     1445                                      " AND rawImfile.magicked = 0), chipProcessedImfile.magicked, rawImfile.magicked)");
     1446        psStringAppend(&set_magicked_run, "\n , chipRun.magicked = IF((chipRun.magicked < 0 AND rawExp.magicked = 0), "
     1447                                      " chipRun.magicked, rawExp.magicked)");
     1448
    14251449    } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
    14261450        // if magicked is non-zero set it to -1
    1427         set_magicked_imfile = "\n, chipProcessedImfile.magicked = IF(chipProcessedImfile.magicked = 0, 0, -1)";
    1428         set_magicked_run = "\n, chipRun.magicked = IF(chipRun.magicked = 0, 0, -1)";
     1451        // Once one imfile has been cleaned, the chipRun is no longer 'magicked'
     1452        psStringAppend(&set_magicked_imfile, "\n, chipProcessedImfile.magicked = IF(chipProcessedImfile.magicked = 0, 0, -1),"
     1453                                             " chipRun.magicked = IF(chipRun.magicked = 0, 0, -1)");
    14291454    }
    14301455
    … …  
    14401465    }
    14411466    psFree(query);
     1467    psFree(set_magicked_imfile);
     1468    psFree(set_magicked_run);
    14421469    if (psDBAffectedRows(config->dbh) < 1) {
    14431470        psError(PS_ERR_UNKNOWN, false, "should have affected atleast 1 row");
    … …  
    17571784    return true;
    17581785}
     1786
     1787static bool listrunMode(pxConfig *config)
     1788{
     1789    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1790
     1791    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     1792    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1793    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     1794
     1795    psMetadata *where = psMetadataAlloc();
     1796    pxchipGetSearchArgs (config, where); // chipRun, chipProcessedImfile, rawExp
     1797    PXOPT_COPY_S64(config->args, where, "-chip_id", "chipRun.chip_id", "==");
     1798    PXOPT_COPY_STR(config->args, where, "-reduction", "chipRun.reduction", "==");
     1799    PXOPT_COPY_STR(config->args, where, "-state", "chipRun.state", "==");
     1800    pxAddLabelSearchArgs (config, where, "-label", "chipRun.label", "LIKE");
     1801    pxAddLabelSearchArgs (config, where, "-data_group", "chipRun.data_group", "LIKE");
     1802    pxAddLabelSearchArgs (config, where, "-dist_group", "chipRun.dist_group", "LIKE");
     1803    PXOPT_COPY_S64(config->args, where, "-magicked", "chipRun.magicked", "==");
     1804
     1805    psString where2 = NULL;
     1806    pxmagicAddWhere(config, &where2, "chipRun");
     1807    // add cuts on ra and decl if supplied
     1808    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     1809        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     1810        return false;
     1811    }
     1812
     1813    psString query = pxDataGet("chiptool_listrun.sql");
     1814    if (!query) {
     1815        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1816        return false;
     1817    }
     1818
     1819    if (psListLength(where->list)) {
     1820        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1821        psStringAppend(&query, " WHERE %s %s", whereClause, where2 ? where2 : "");
     1822        psFree(whereClause);
     1823    } else if (psMetadataLookupBool(NULL, config->args, "-all") || where2) {
     1824        psStringAppend(&query, " WHERE chipRun.chip_id IS NOT NULL %s", where2 ? where2 : "");
     1825    } else {
     1826        psFree(where);
     1827        psError(PXTOOLS_ERR_CONFIG, false, "search parameters (or -all) are required");
     1828        return false;
     1829    }
     1830    psFree(where);
     1831
     1832    if (pstamp_order) {
     1833        // put runs in order of exposure id with newest chip Runs first
     1834        // The postage stamp parser depends on this behavior
     1835        psStringAppend(&query, "\nORDER by exp_id, chip_id DESC");
     1836    }
     1837
     1838    // treat limit == 0 as "no limit"
     1839    if (limit) {
     1840        psString limitString = psDBGenerateLimitSQL(limit);
     1841        psStringAppend(&query, " %s", limitString);
     1842        psFree(limitString);
     1843    }
     1844
     1845    if (!p_psDBRunQuery(config->dbh, query)) {
     1846        psError(PS_ERR_UNKNOWN, false, "database error");
     1847        psFree(query);
     1848        return false;
     1849    }
     1850    psFree(query);
     1851
     1852    psArray *output = p_psDBFetchResult(config->dbh);
     1853    if (!output) {
     1854        psError(PS_ERR_UNKNOWN, false, "database error");
     1855        return false;
     1856    }
     1857    if (!psArrayLength(output)) {
     1858        psTrace("chiptool", PS_LOG_INFO, "no rows found");
     1859        psFree(output);
     1860        return true;
     1861    }
     1862
     1863    // negative simple so the default is true
     1864    if (!ippdbPrintMetadatas(stdout, output, "chipRun", !simple)) {
     1865        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1866        psFree(output);
     1867        return false;
     1868    }
     1869
     1870    psFree(output);
     1871
     1872    return true;
     1873}

  • branches/pap/ippTools/src/chiptool.h

    r27391 r28003  
    5050    CHIPTOOL_MODE_EXPORTRUN,
    5151    CHIPTOOL_MODE_IMPORTRUN,
    52     CHIPTOOL_MODE_RUNSTATE
     52    CHIPTOOL_MODE_RUNSTATE,
     53    CHIPTOOL_MODE_LISTRUN
    5354} chiptoolMode;
    5455

  • branches/pap/ippTools/src/chiptoolConfig.c

    r27391 r28003  
    196196    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
    197197    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-faulted",  0,        "only return imfiles with a fault status set", false);
     198    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-allfiles",  0,       "only all matching imfiles regardless of fault status", false);
    198199    psMetadataAddBool(processedimfileArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
    199200
    … …  
    216217    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code (required)", 0);
    217218    psMetadataAddStr(updateprocessedimfileArgs, PS_LIST_TAIL, "-set_state", 0,         "set state", NULL);
     219
     220    // -processedExp
     221    psMetadata *listrunArgs = psMetadataAlloc();
     222    pxchipSetSearchArgs(listrunArgs);
     223    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-chip_id",  0,         "search by  chip ID", 0);
     224    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-reduction",          0, "search by reduction class", NULL);
     225    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by chipRun label (LIKE comparison)", NULL);
     226    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-state",              0, "search by chipRun state", NULL);
     227    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by chipRun data_group (LIKE comparison)", NULL);
     228    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by chipRun dist_group (LIKE comparison)", NULL);
     229    pxmagicAddArguments(listrunArgs);
     230
     231    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     232    psMetadataAddU64(listrunArgs,  PS_LIST_TAIL, "-limit",  0,           "limit result set to N items", 0);
     233    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,            "list everything without search terms", false);
     234    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,         "use the simple output format", false);
     235    pxspaceAddArguments(listrunArgs);
     236
    218237    // -block
    219238    psMetadata *blockArgs = psMetadataAlloc();
    … …  
    328347    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
    329348    PXOPT_ADD_MODE("-runstate",             "list the states of chip run",          CHIPTOOL_MODE_RUNSTATE,             runstateArgs);
     349    PXOPT_ADD_MODE("-listrun",              "list chipRuns",                        CHIPTOOL_MODE_LISTRUN,              listrunArgs);
    330350    PXOPT_ADD_MODE("-advanceexp",           "advance completed exposures",          CHIPTOOL_MODE_ADVANCEEXP,           advanceexpArgs);
    331351    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);

  • branches/pap/ippTools/src/difftool.c

    r27445 r28003  
    5757static bool toscrubbedskyfileMode(pxConfig *config);
    5858static bool tofullskyfileMode(pxConfig *config);
     59static bool listrunMode(pxConfig *config);
     60static bool setskyfiletoupdateMode(pxConfig *config);
    5961
    6062
    … …  
    101103        MODECASE(DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,     toscrubbedskyfileMode);
    102104        MODECASE(DIFFTOOL_MODE_TOFULLSKYFILE,         tofullskyfileMode);
     105        MODECASE(DIFFTOOL_MODE_LISTRUN,               listrunMode);
     106        MODECASE(DIFFTOOL_MODE_SETSKYFILETOUPDATE,    setskyfiletoupdateMode);
    103107
    104108        default:
    … …  
    194198    PXOPT_COPY_S64(config->args, where, "-diff_id",  "diff_id",   "==");
    195199    PXOPT_COPY_STR(config->args, where, "-label",     "label",     "==");
     200    PXOPT_COPY_STR(config->args, where, "-data_group","data_group",     "==");
    196201    PXOPT_COPY_STR(config->args, where, "-state",     "state",     "==");
    197202    if (!psListLength(where->list)) {
    … …  
    702707    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
    703708
     709    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
    704710    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
    705711    if (!template) {
    … …  
    745751    psFree(where);
    746752
     753    if (pstamp_order) {
     754        if (template) {
     755            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     756        } else {
     757            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     758        }
     759    }
     760           
    747761    // treat limit == 0 as "no limit"
    748762    if (limit) {
    … …  
    810824    }
    811825
    812     if (!psDBTransaction(config->dbh)) {
    813         psError(PS_ERR_UNKNOWN, false, "database error");
    814         psFree(where);
    815         return false;
    816     }
    817 
    818     // Update state to 'new'
    819     {
    820         psString query = pxDataGet("difftool_revertdiffskyfile_update.sql");
    821         if (!query) {
    822             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    823             if (!psDBRollback(config->dbh)) {
    824                 psError(PS_ERR_UNKNOWN, false, "database error");
    825             }
    826             return false;
    827         }
    828 
    829         if (psListLength(where->list)) {
    830             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    831             psStringAppend(&query, " AND %s", whereClause);
    832             psFree(whereClause);
    833         }
    834 
    835         if (!p_psDBRunQuery(config->dbh, query)) {
    836             psError(PS_ERR_UNKNOWN, false, "database error");
    837             psFree(query);
    838             if (!psDBRollback(config->dbh)) {
    839                 psError(PS_ERR_UNKNOWN, false, "database error");
    840             }
    841             return false;
    842         }
    843         psFree(query);
    844 
    845         psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    846     }
    847 
    848     // Delete product
    849826    {
    850827        psString query = pxDataGet("difftool_revertdiffskyfile_delete.sql");
    851828        if (!query) {
    852829            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    853             if (!psDBRollback(config->dbh)) {
    854                 psError(PS_ERR_UNKNOWN, false, "database error");
    855             }
     830            return false;
     831        }
     832        psString query_updated = pxDataGet("difftool_revertdiffskyfile_updated.sql");
     833        if (!query_updated) {
     834            psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    856835            return false;
    857836        }
    … …  
    860839            psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    861840            psStringAppend(&query, " AND %s", whereClause);
     841            psStringAppend(&query_updated, " AND %s", whereClause);
    862842            psFree(whereClause);
    863843        }
    … …  
    866846            psError(PS_ERR_UNKNOWN, false, "database error");
    867847            psFree(query);
    868             if (!psDBRollback(config->dbh)) {
    869                 psError(PS_ERR_UNKNOWN, false, "database error");
    870             }
    871848            return false;
    872849        }
    873850        psFree(query);
    874 
    875851        psLogMsg("difftool", PS_LOG_INFO, "Deleted %" PRIu64 " rows", psDBAffectedRows(config->dbh));
     852
     853        if (!p_psDBRunQuery(config->dbh, query_updated)) {
     854            psError(PS_ERR_UNKNOWN, false, "database error");
     855            psFree(query_updated);
     856            return false;
     857        }
     858        psFree(query_updated);
     859
     860        psLogMsg("difftool", PS_LOG_INFO, "Updated %" PRIu64 " rows", psDBAffectedRows(config->dbh));
    876861    }
    877862
    878863    psFree(where);
    879864
    880     if (!psDBCommit(config->dbh)) {
    881         psError(PS_ERR_UNKNOWN, false, "database error");
    882         return false;
    883     }
    884865
    885866    return true;
    … …  
    971952        return false;
    972953    }
    973     psS16 diff_mode = 0;
     954    psS16 diff_mode = IPP_DIFF_MODE_UNDEFINED;
    974955    if ((input_warp_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
    975       diff_mode = 1;
     956      diff_mode = IPP_DIFF_MODE_WARP_WARP;
    976957    }
    977958    else if ((input_warp_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
    978       diff_mode = 2;
     959      diff_mode = IPP_DIFF_MODE_WARP_STACK;
    979960    }
    980961    else if ((input_stack_id != PS_MAX_S64) && (template_warp_id != PS_MAX_S64)) {
    981       diff_mode = 3;
     962      diff_mode = IPP_DIFF_MODE_STACK_WARP;
    982963    }
    983964    else if ((input_stack_id != PS_MAX_S64) && (template_stack_id != PS_MAX_S64)) {
    984       diff_mode = 4;
     965      diff_mode = IPP_DIFF_MODE_STACK_STACK;
    985966    }
    986967
    … …  
    13661347        }
    13671348
    1368 
    13691349        psString filter = psMetadataLookupStr(&mdok, row, "filter");
    13701350        if (!mdok) {
    … …  
    13781358            return false;
    13791359        }
     1360
     1361        psString warp_data_group = psMetadataLookupStr(&mdok, row, "data_group");
     1362        if (!mdok) {
     1363          psError(PXTOOLS_ERR_PROG, false, "warp data_group not found");
     1364          psFree(warp2Query);
     1365          psFree(stackQuery);
     1366          psFree(skycell_query);
     1367          if (!psDBRollback(config->dbh)) {
     1368            psError(PS_ERR_UNKNOWN, false, "database error");
     1369          }
     1370          return false;
     1371        }
     1372        if (warp_data_group) {
     1373          data_group = warp_data_group;
     1374        }
     1375       
    13801376        if (!p_psDBRunQueryF(config->dbh, skycell_query, stackQuery, warp_id, filter, warp2Query)) {
    13811377            psError(PS_ERR_UNKNOWN, false, "database error");
    … …  
    14161412                true,                   // exposure
    14171413                0,       // magicked
    1418                 2,       // diff_mode for warp-stack difference
     1414                IPP_DIFF_MODE_WARP_STACK,
    14191415                note
    14201416        );
    … …  
    17391735        const char *template = psMetadataLookupStr(NULL, row, "template_warp_id");
    17401736        const char *tess_id = psMetadataLookupStr(NULL, row, "tess_id");
     1737        psString input_data_group = psMetadataLookupStr(NULL, row, "input_data_group");
     1738        if (input_data_group) {
     1739          data_group = input_data_group;
     1740        }
     1741
    17411742        if (!input_id || !template || !tess_id) {
    17421743            psError(PXTOOLS_ERR_PROG, false, "Identifiers not found");
    … …  
    17491750            return false;
    17501751        }
    1751 
     1752       
    17521753        diffRunRow *run = diffRunRowAlloc(0,
    17531754                                          "reg",
    … …  
    17631764                                          true,  // exposure
    17641765                                          false, // magicked
    1765                                           1,     // diff_mode for warp-warp diff
     1766                                          IPP_DIFF_MODE_WARP_WARP,
    17661767                                          note); // Run to insert
    17671768        if (!diffRunInsertObject(config->dbh, run)) {
    … …  
    20452046                                      false,                 // exposure
    20462047                                      0,       // magicked
    2047                                       4,      // diff_mode
     2048                                      IPP_DIFF_MODE_STACK_STACK, // diff_mode
    20482049                                      note
    20492050                                      );
    … …  
    23382339    psMetadata *where = psMetadataAlloc();
    23392340    PXOPT_COPY_S64(config->args, where, "-diff_id",   "diff_id",   "==");
     2341    PXOPT_COPY_STR(config->args, where, "-skycell_id", "skycell_id",   "==");
    23402342
    23412343    if (!pxSetFaultCode(config->dbh, "diffSkyfile", where, fault)) {
    … …  
    26062608  return true;
    26072609}
     2610
     2611static bool listrunMode(pxConfig *config)
     2612{
     2613    PS_ASSERT_PTR_NON_NULL(config, false);
     2614
     2615    psMetadata *where = psMetadataAlloc();
     2616    PXOPT_COPY_S64(config->args, where,  "-diff_id", "diffRun.diff_id", "==");
     2617    PXOPT_COPY_STR(config->args, where, "-tess_id", "diffRun.tess_id", "==");
     2618    PXOPT_COPY_S64(config->args, where,  "-magicked", "diffRun.magicked", "==");
     2619    pxAddLabelSearchArgs (config, where, "-label", "diffRun.label", "LIKE");
     2620    pxAddLabelSearchArgs (config, where, "-data_group", "diffRun.data_group", "LIKE");
     2621    pxAddLabelSearchArgs (config, where, "-dist_group", "diffRun.dist_group", "LIKE");
     2622
     2623    PXOPT_LOOKUP_BOOL(template, config->args, "-template", false);
     2624    if (!template) {
     2625        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawInput.exp_id", "==");
     2626        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawInput.exp_name", "==");
     2627        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpInput.warp_id", "==");
     2628        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawInput.dateobs",  ">=");
     2629        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawInput.dateobs",  "<=");
     2630        PXOPT_COPY_STR(config->args, where, "-filter",     "rawInput.filter", "LIKE");
     2631    } else {
     2632        PXOPT_COPY_S64(config->args, where, "-exp_id", "rawTemplate.exp_id", "==");
     2633        PXOPT_COPY_STR(config->args, where, "-exp_name", "rawTemplate.exp_name", "==");
     2634        PXOPT_COPY_STR(config->args, where, "-warp_id", "warpTemplate.warp_id", "==");
     2635        PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawTemplate.dateobs",  ">=");
     2636        PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawTemplate.dateobs",  "<=");
     2637        PXOPT_COPY_STR(config->args, where, "-filter",     "rawTemplate.filter", "LIKE");
     2638    }
     2639
     2640    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2641    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2642    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2643    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     2644
     2645
     2646    psString where2 = NULL;
     2647    pxmagicAddWhere(config, &where2, "diffRun");
     2648    pxspaceAddWhere(config, &where2, template ? "rawTemplate" : "rawInput");
     2649    psString query = pxDataGet("difftool_listrun.sql");
     2650    if (!query) {
     2651        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2652        return false;
     2653    }
     2654
     2655    if (psListLength(where->list)) {
     2656        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2657        psStringAppend(&query, " WHERE %s", whereClause);
     2658        psFree(whereClause);
     2659    } else if (where2) {
     2660        psStringAppend(&query, " WHERE diffRun.diff_id is not null %s", where2);
     2661    } else if (!all) {
     2662        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2663        return false;
     2664    }
     2665    psFree(where);
     2666
     2667    if (pstamp_order) {
     2668        if (template) {
     2669            psStringAppend(&query, " ORDER BY rawTemplate.exp_id, diff_id DESC");
     2670        } else {
     2671            psStringAppend(&query, " ORDER BY rawInput.exp_id, diff_id DESC");
     2672        }
     2673    }
     2674           
     2675    // treat limit == 0 as "no limit"
     2676    if (limit) {
     2677        psString limitString = psDBGenerateLimitSQL(limit);
     2678        psStringAppend(&query, " %s", limitString);
     2679        psFree(limitString);
     2680    }
     2681
     2682    if (!p_psDBRunQuery(config->dbh, query)) {
     2683        psError(PS_ERR_UNKNOWN, false, "database error");
     2684        psFree(query);
     2685        return false;
     2686    }
     2687    psFree(query);
     2688
     2689    psArray *output = p_psDBFetchResult(config->dbh);
     2690    if (!output) {
     2691        psErrorCode err = psErrorCodeLast();
     2692        switch (err) {
     2693            case PS_ERR_DB_CLIENT:
     2694                psError(PXTOOLS_ERR_SYS, false, "database error");
     2695            case PS_ERR_DB_SERVER:
     2696                psError(PXTOOLS_ERR_PROG, false, "database error");
     2697            default:
     2698                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2699        }
     2700
     2701        return false;
     2702    }
     2703    if (!psArrayLength(output)) {
     2704        psTrace("difftool", PS_LOG_INFO, "no rows found");
     2705        psFree(output);
     2706        return true;
     2707    }
     2708
     2709    if (psArrayLength(output)) {
     2710        // negative simple so the default is true
     2711        if (!ippdbPrintMetadatas(stdout, output, "diffRun", !simple)) {
     2712            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2713            psFree(output);
     2714            return false;
     2715        }
     2716    }
     2717
     2718    psFree(output);
     2719
     2720    return true;
     2721}
     2722// a very specfic function to queue a cleaned warpSkyfile to be updated
     2723static bool setskyfiletoupdateMode(pxConfig *config)
     2724{
     2725    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2726
     2727    PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
     2728    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2729    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2730
     2731    psString query = pxDataGet("difftool_setskyfiletoupdate.sql");
     2732    if (!query) {
     2733        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2734        return false;
     2735    }
     2736
     2737    psString setHook = psStringCopy("");
     2738    if (label) {
     2739        psStringAppend(&setHook, "\n , diffRun.label = '%s'", label);
     2740    }
     2741
     2742    if (skycell_id) {
     2743        psStringAppend(&query, " AND (diffSkyfile.skycell_id = '%s')", skycell_id);
     2744    }
     2745
     2746    if (!p_psDBRunQueryF(config->dbh, query, setHook, diff_id)) {
     2747        psError(PS_ERR_UNKNOWN, false, "database error");
     2748        return false;
     2749    }
     2750
     2751    psFree(setHook);
     2752    psFree(query);
     2753
     2754    return true;
     2755}

  • branches/pap/ippTools/src/difftool.h

    r26927 r28003  
    4747    DIFFTOOL_MODE_TOPURGEDSKYFILE,
    4848    DIFFTOOL_MODE_TOSCRUBBEDSKYFILE,
    49     DIFFTOOL_MODE_TOFULLSKYFILE
    50    
     49    DIFFTOOL_MODE_TOFULLSKYFILE,
     50    DIFFTOOL_MODE_LISTRUN,
     51    DIFFTOOL_MODE_SETSKYFILETOUPDATE,
    5152} difftoolMode;
    5253

  • branches/pap/ippTools/src/difftoolConfig.c

    r27444 r28003  
    6565    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
    6666    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0,            "define by label instead of diff ID", 0);
     67    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-data_group", 0,       "define by data_group instead of diff ID", 0);
    6768    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "define new value for label", 0);
    6869    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "define new state", NULL);
    … …  
    147148    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
    148149    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     150    psMetadataAddStr(diffskyfileArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
    149151    psMetadataAddS16(diffskyfileArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
    150152    pxmagicAddArguments(diffskyfileArgs);
    151153    pxspaceAddArguments(diffskyfileArgs);
    152154
     155    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
    153156    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
    154157    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
    155158    psMetadataAddBool(diffskyfileArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     159
     160    // -listrun
     161    psMetadata *listrunArgs = psMetadataAlloc();
     162    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-diff_id", 0,           "search by diff ID", 0);
     163    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-tess_id",  0,          "search by tessellation ID", NULL);
     164    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-warp_id",  0,         "search by warp_id", NULL);
     165    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-template",  0,        "apply exposure args to template of bothways diff", false);
     166    psMetadataAddS64(listrunArgs, PS_LIST_TAIL,  "-exp_id",  0,           "search by exposure ID", 0);
     167    psMetadataAddStr(listrunArgs , PS_LIST_TAIL, "-exp_name",  0,        "search by exposure name", NULL);
     168    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     169    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     170    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search for filter", NULL);
     171    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-label",  PS_META_DUPLICATE_OK, "search by diffRun label (LIKE comparison)", NULL);
     172    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-data_group",  PS_META_DUPLICATE_OK, "search by diffRun data_group (LIKE comparison)", NULL);
     173    psMetadataAddStr(listrunArgs,  PS_LIST_TAIL, "-dist_group",  PS_META_DUPLICATE_OK, "search by diffRun dist_group (LIKE comparison)", NULL);
     174    pxmagicAddArguments(listrunArgs);
     175    pxspaceAddArguments(listrunArgs);
     176
     177    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     178
     179    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     180    psMetadataAddU64(listrunArgs, PS_LIST_TAIL,  "-limit",  0,            "limit result set to N items", 0);
     181    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     182
    156183
    157184    // -revertdiffskyfile
    … …  
    299326    psMetadata *updatediffskyfileArgs = psMetadataAlloc();
    300327    psMetadataAddS64(updatediffskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,      "define diff ID (required)", 0);
    301     psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,         "set fault code (required)", 0);
     328    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-fault", 0,        "set fault code (required)", 0);
     329    psMetadataAddStr(updatediffskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,   "search by skycell ID", NULL);
    302330
    303331    // -tocleanedskyfile
    … …  
    321349    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
    322350    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-magicked",  0, "define magicked state", 0);
     351
     352    // -setskyfiletoupdate
     353    psMetadata *setskyfiletoupdateArgs = psMetadataAlloc();
     354    psMetadataAddS64(setskyfiletoupdateArgs, PS_LIST_TAIL, "-diff_id", 0,           "search by difftool ID (required)", 0);
     355    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by tessellation ID", NULL);
     356    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,        "new value for diffRun.label", NULL);
     357
     358
    323359
    324360    // -exportrun
    … …  
    348384    PXOPT_ADD_MODE("-advance",          "", DIFFTOOL_MODE_ADVANCE,           advanceArgs);
    349385    PXOPT_ADD_MODE("-diffskyfile",      "", DIFFTOOL_MODE_DIFFSKYFILE,       diffskyfileArgs);
     386    PXOPT_ADD_MODE("-listrun",          "", DIFFTOOL_MODE_LISTRUN,           listrunArgs);
    350387    PXOPT_ADD_MODE("-revertdiffskyfile","", DIFFTOOL_MODE_REVERTDIFFSKYFILE, revertdiffskyfileArgs);
    351388    PXOPT_ADD_MODE("-definepoprun",     "", DIFFTOOL_MODE_DEFINEPOPRUN,      definepoprunArgs);
    … …  
    357394    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    358395    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);
     396    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", DIFFTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
     397
    359398    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
    360399    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);

  • branches/pap/ippTools/src/magicdstool.c

    r27519 r28003  
    572572    // we can transition by query as well
    573573
    574 
    575574    psMetadata *where = psMetadataAlloc();
    576575    PXOPT_COPY_STR(config->args, where, "-label", "label", "==");
    … …  
    12341233        psFree(whereClause);
    12351234    } else {
    1236         psError(PS_ERR_UNKNOWN, true, "search arugments are required");
    1237         return false;
     1235        psError(PS_ERR_UNKNOWN, true, "search arguments are required");
     1236        return false;
     1237    }
     1238
     1239    if (!strcmp(state, "goto_cleaned")) {
     1240        // Don't set state back to goto_cleaned if it is already cleaned
     1241        psStringAppend(&query, " AND (magicDSRun.state != 'cleaned')");
     1242
     1243        // don't clean up magicDSRun's where stage is camera
     1244        psStringAppend(&query, " AND (magicDSRun.stage != 'camera')");
    12381245    }
    12391246

  • branches/pap/ippTools/src/magictool.c

    r27274 r28003  
    4848static bool maskMode(pxConfig *config);
    4949static bool censorrunMode(pxConfig *config);
     50static bool exposureMode(pxConfig *config);
    5051
    5152static bool setmagicRunState(pxConfig *config, psS64 magic_id, const char *state);
    … …  
    8788        MODECASE(MAGICTOOL_MODE_MASK,                maskMode);
    8889        MODECASE(MAGICTOOL_MODE_CENSORRUN,           censorrunMode);
     90        MODECASE(MAGICTOOL_MODE_EXPOSURE,            exposureMode);
    8991        default:
    9092            psAbort("invalid option (this should not happen)");
    … …  
    15141516    return true;
    15151517}
     1518
     1519
     1520static bool exposureMode(pxConfig *config)
     1521{
     1522    PS_ASSERT_PTR_NON_NULL(config, false);
     1523
     1524    psMetadata *where = psMetadataAlloc();
     1525    PXOPT_COPY_S64(config->args, where, "-magic_id", "magicRun.magic_id", "==");
     1526    PXOPT_COPY_BOOL(config->args, where, "-inverse", "magicRun.inverse", "==");
     1527
     1528    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     1529
     1530    psString query = pxDataGet("magictool_exposure.sql");
     1531    if (!query) {
     1532        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1533        return false;
     1534    }
     1535
     1536    psString whereClause = psStringCopy(""); // WHERE restrictions
     1537    if (psListLength(where->list)) {
     1538        psString clause = psDBGenerateWhereConditionSQL(where, NULL);
     1539        psStringAppend(&whereClause, "\nWHERE %s", clause);
     1540        psFree(clause);
     1541    }
     1542    psFree(where);
     1543
     1544    if (!p_psDBRunQueryF(config->dbh, query, whereClause, whereClause)) {
     1545        psError(PS_ERR_UNKNOWN, false, "database error");
     1546        psFree(query);
     1547        return false;
     1548    }
     1549    psFree(query);
     1550
     1551    psArray *output = p_psDBFetchResult(config->dbh);
     1552    if (!output) {
     1553        psErrorCode err = psErrorCodeLast();
     1554        switch (err) {
     1555            case PS_ERR_DB_CLIENT:
     1556                psError(PXTOOLS_ERR_SYS, false, "database error");
     1557                break;
     1558            case PS_ERR_DB_SERVER:
     1559                psError(PXTOOLS_ERR_PROG, false, "database error");
     1560                break;
     1561            default:
     1562                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     1563                break;
     1564        }
     1565        return false;
     1566    }
     1567    if (!psArrayLength(output)) {
     1568        psTrace("magictool", PS_LOG_INFO, "no rows found");
     1569        psFree(output);
     1570        return true;
     1571    }
     1572
     1573    if (!ippdbPrintMetadatas(stdout, output, "magicMask", !simple)) {
     1574        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1575        psFree(output);
     1576        return false;
     1577    }
     1578    psFree(output);
     1579
     1580    return true;
     1581}

  • branches/pap/ippTools/src/magictool.h

    r24883 r28003  
    4242    MAGICTOOL_MODE_MASK,
    4343    MAGICTOOL_MODE_CENSORRUN,
     44    MAGICTOOL_MODE_EXPOSURE,
    4445} MAGICtoolMode;
    4546

  • branches/pap/ippTools/src/magictoolConfig.c

    r27274 r28003  
    168168    psMetadataAddS64(censorrunArgs, PS_LIST_TAIL, "-exp_id", 0, "define exposure ID", 0);
    169169    psMetadataAddStr(censorrunArgs, PS_LIST_TAIL, "-label",       0, "define label", NULL);
     170
     171    // -exposure
     172    psMetadata *exposureArgs = psMetadataAlloc();
     173    psMetadataAddS64(exposureArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID", 0);
     174    psMetadataAddBool(exposureArgs, PS_LIST_TAIL, "-inverse", 0, "select the inverse subtraction?", false);
     175    psMetadataAddBool(exposureArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    170176
    171177    psFree(now);
    … …  
    191197    PXOPT_ADD_MODE("-mask",                "", MAGICTOOL_MODE_MASK,                maskArgs);
    192198    PXOPT_ADD_MODE("-censorrun",           "", MAGICTOOL_MODE_CENSORRUN,           censorrunArgs);
     199    PXOPT_ADD_MODE("-exposure",            "", MAGICTOOL_MODE_EXPOSURE,            exposureArgs);
    193200
    194201    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/pap/ippTools/src/pstamptool.c

    r27282 r28003  
    4040static bool updatereqMode(pxConfig *config);
    4141static bool revertreqMode(pxConfig *config);
     42static bool pendingcleanupMode(pxConfig *config);
    4243static bool addjobMode(pxConfig *config);
    4344static bool listjobMode(pxConfig *config);
    … …  
    5152static bool pendingdependentMode(pxConfig *config);
    5253static bool updatedependentMode(pxConfig *config);
     54static bool revertdependentMode(pxConfig *config);
    5355
    5456# define MODECASE(caseName, func) \
    … …  
    8082        MODECASE(PSTAMPTOOL_MODE_UPDATEREQ, updatereqMode);
    8183        MODECASE(PSTAMPTOOL_MODE_REVERTREQ, revertreqMode);
     84        MODECASE(PSTAMPTOOL_MODE_PENDINGCLEANUP, pendingcleanupMode);
    8285        MODECASE(PSTAMPTOOL_MODE_ADDJOB, addjobMode);
    8386        MODECASE(PSTAMPTOOL_MODE_LISTJOB, listjobMode);
    … …  
    9194        MODECASE(PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentMode);
    9295        MODECASE(PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentMode);
     96        MODECASE(PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentMode);
    9397        default:
    9498            psAbort("invalid option (this should not happen)");
    … …  
    263267        NULL,   // outProduct
    264268        uri,
     269        NULL,   // outdir
    265270        0       // fault
    266271        )) {
    … …  
    299304    }
    300305    psFree(where);
     306
     307    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    301308
    302309    // treat limit == 0 as "no limit"
    … …  
    337344}
    338345
    339 static bool listreqMode(pxConfig *config)
     346static bool pendingcleanupMode(pxConfig *config)
    340347{
    341348    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    343350    psMetadata *where = psMetadataAlloc();
    344351    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    345     PXOPT_COPY_S64(config->args, where, "-not_req_id", "req_id", "!=");
    346     PXOPT_COPY_STR(config->args, where, "-name", "name", "==");
    347 
    348     PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
     352    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     353
     354    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    349355    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    350356
    351     if (!psListLength(where->list)) {
    352         psError(PS_ERR_UNKNOWN, true, "-req_id or -name must be supplied");
    353         return false;
    354     }
    355 
    356     psString query = psStringCopy("SELECT * from pstampRequest");
    357 
    358     psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    359     psStringAppend(&query, " WHERE %s", whereClause);
    360     psFree(whereClause);
    361     psFree(where);
     357    psString query = pxDataGet("pstamptool_pendingcleanup.sql");
     358    if (!query) {
     359        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     360        return false;
     361    }
     362
     363    if (psListLength(where->list)) {
     364        psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampRequest");
     365        psStringAppend(&query, " AND %s", whereClause);
     366        psFree(whereClause);
     367    }
     368    psFree(where);
     369
     370    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    362371
    363372    // treat limit == 0 as "no limit"
    … …  
    381390    }
    382391    if (!psArrayLength(output)) {
    383         psTrace("pstamptool", PS_LOG_INFO, "request not found");
    384         // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
    385         psError(PXTOOLS_ERR_CONFIG, true, "request not found");
    386         psFree(output);
    387         // we return false so that the caller can determine that a request does not exist
    388         return false;
     392        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     393        psFree(output);
     394        return true;
    389395    }
    390396
    … …  
    401407}
    402408
    403 static bool completedreqMode(pxConfig *config)
    404 {
    405     PS_ASSERT_PTR_NON_NULL(config, false);
    406 
    407     psMetadata *where = psMetadataAlloc();
    408     pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
    409 
    410     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     409static bool listreqMode(pxConfig *config)
     410{
     411    PS_ASSERT_PTR_NON_NULL(config, false);
     412
     413    psMetadata *where = psMetadataAlloc();
     414    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
     415    PXOPT_COPY_S64(config->args, where, "-not_req_id", "req_id", "!=");
     416    PXOPT_COPY_STR(config->args, where, "-name", "name", "==");
     417
     418    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",  false, false);
    411419    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    412420
    413     psString query = pxDataGet("pstamptool_completedreq.sql");
    414 
    415     if (psListLength(where->list)) {
    416         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    417         psStringAppend(&query, " AND %s", whereClause);
    418         psFree(whereClause);
    419     }
     421    if (!psListLength(where->list)) {
     422        psError(PS_ERR_UNKNOWN, true, "-req_id or -name must be supplied");
     423        return false;
     424    }
     425
     426    psString query = psStringCopy("SELECT * from pstampRequest");
     427
     428    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     429    psStringAppend(&query, " WHERE %s", whereClause);
     430    psFree(whereClause);
    420431    psFree(where);
    421432
    … …  
    432443        return false;
    433444    }
     445    psFree(query);
    434446
    435447    psArray *output = p_psDBFetchResult(config->dbh);
    … …  
    438450        return false;
    439451    }
    440 
    441452    if (!psArrayLength(output)) {
    442         psTrace("pstamptool", PS_LOG_INFO, "no rows found");
    443         psFree(output);
    444         return true;
     453        psTrace("pstamptool", PS_LOG_INFO, "request not found");
     454        // This causes main to exit with PS_EXIT_DATA_ERROR which the script is looking for
     455        psError(PXTOOLS_ERR_CONFIG, true, "request not found");
     456        psFree(output);
     457        // we return false so that the caller can determine that a request does not exist
     458        return false;
    445459    }
    446460
    … …  
    457471}
    458472
     473static bool completedreqMode(pxConfig *config)
     474{
     475    PS_ASSERT_PTR_NON_NULL(config, false);
     476
     477    psMetadata *where = psMetadataAlloc();
     478    pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     479
     480    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     481    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     482
     483    psString query = pxDataGet("pstamptool_completedreq.sql");
     484
     485    if (psListLength(where->list)) {
     486        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     487        psStringAppend(&query, " AND %s", whereClause);
     488        psFree(whereClause);
     489    }
     490    psFree(where);
     491
     492    psStringAppend(&query, " ORDER BY priority DESC, req_id");
     493
     494    // treat limit == 0 as "no limit"
     495    if (limit) {
     496        psString limitString = psDBGenerateLimitSQL(limit);
     497        psStringAppend(&query, " %s", limitString);
     498        psFree(limitString);
     499    }
     500
     501    if (!p_psDBRunQuery(config->dbh, query)) {
     502        psError(PS_ERR_UNKNOWN, false, "database error");
     503        psFree(query);
     504        return false;
     505    }
     506
     507    psArray *output = p_psDBFetchResult(config->dbh);
     508    if (!output) {
     509        psError(PS_ERR_UNKNOWN, false, "database error");
     510        return false;
     511    }
     512
     513    if (!psArrayLength(output)) {
     514        psTrace("pstamptool", PS_LOG_INFO, "no rows found");
     515        psFree(output);
     516        return true;
     517    }
     518
     519    // negative simple so the default is true
     520    if (!ippdbPrintMetadatas(stdout, output, "pstampRequest", !simple)) {
     521        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     522        psFree(output);
     523        return false;
     524    }
     525
     526    psFree(output);
     527
     528    return true;
     529}
     530
    459531static bool updatereqMode(pxConfig *config)
    460532{
    461533    PS_ASSERT_PTR_NON_NULL(config, false);
    462534
    463     PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",     true, false);
    464     PXOPT_LOOKUP_STR(state,      config->args, "-state",      false, false);
    465     PXOPT_LOOKUP_STR(outProduct, config->args, "-outProduct", false, false);
    466     PXOPT_LOOKUP_STR(fault,      config->args, "-fault",      false, false);
    467     PXOPT_LOOKUP_STR(uri,        config->args, "-uri",        false, false);
    468     PXOPT_LOOKUP_STR(name,       config->args, "-name",       false, false);
    469     PXOPT_LOOKUP_STR(reqType,    config->args, "-reqType",    false, false);
    470 
    471     psString query = NULL;
    472     psStringAppend(&query, "UPDATE pstampRequest SET");
    473 
     535    // PXOPT_LOOKUP_S64(req_id,     config->args, "-req_id",   true, false);
     536    PXOPT_LOOKUP_STR(state,      config->args, "-set_state",      false, false);
     537    PXOPT_LOOKUP_STR(label,      config->args, "-set_label",      false, false);
     538    PXOPT_LOOKUP_STR(outProduct, config->args, "-set_outProduct", false, false);
     539    PXOPT_LOOKUP_S16(fault,      config->args, "-set_fault",          false, false);
     540    PXOPT_LOOKUP_STR(uri,        config->args, "-set_uri",        false, false);
     541    PXOPT_LOOKUP_STR(outdir,     config->args, "-set_outdir",        false, false);
     542    PXOPT_LOOKUP_STR(name,       config->args, "-set_name",       false, false);
     543    PXOPT_LOOKUP_STR(reqType,    config->args, "-set_reqType",    false, false);
     544    PXOPT_LOOKUP_BOOL(clearfault,config->args, "-clearfault",    false);
     545
     546    psMetadata *where = psMetadataAlloc();
     547    PXOPT_COPY_S64(config->args, where, "-req_id",     "req_id", "==");
     548    PXOPT_COPY_S64(config->args, where, "-req_id_max", "req_id", "<=");
     549    PXOPT_COPY_S32(config->args, where, "-fault",      "fault", "==");
     550    PXOPT_COPY_STR(config->args, where, "-state",      "state", "==");
     551    pxAddLabelSearchArgs(config, where, "-label",      "pstampRequest.label", "LIKE");
     552    if (!psListLength(where->list)) {
     553        psFree(where);
     554        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     555        return false;
     556    }
     557
     558    psString query = psStringCopy("UPDATE pstampRequest SET");
     559
     560    psString stateCheck = NULL;
    474561    char c = ' ';
    475562    if (state) {
    476563        psStringAppend(&query, "%c state = '%s'", c, state);
    477564        c = ',';
     565        if (!strcmp(state, "goto_cleaned")) {
     566            psStringAppend(&stateCheck, " AND state != 'cleaned'");
     567        }
     568    }
     569    if (label) {
     570        psStringAppend(&query, "%c label = '%s'", c, label);
     571        c = ',';
    478572    }
    479573    if (outProduct) {
    … …  
    481575        c = ',';
    482576    }
    483     if (fault) {
    484         psStringAppend(&query, "%c fault = %s", c, fault);
     577    if (outdir) {
     578        psStringAppend(&query, "%c outdir = '%s'", c, outdir);
     579        c = ',';
     580    }
     581    if (clearfault) {
     582        if (fault) {
     583            psError(PXTOOLS_ERR_CONFIG, true, "only one of -fault and -clearfault is allowed");
     584            return false;
     585        }
     586        psStringAppend(&query, "%c fault = 0", c);
     587        c = ',';
     588    } else if (fault) {
     589        psStringAppend(&query, "%c fault = %d", c, fault);
    485590        c = ',';
    486591    }
    … …  
    497602        c = ',';
    498603    }
    499     if (!state && !outProduct && !fault && !uri && !name && !reqType) {
    500         psError(PS_ERR_UNKNOWN, true, "at least one of state, outProduct, fault, uri, name, and reqType must be specified");
    501         return false;
    502     }
    503 
    504     psStringAppend(&query, " WHERE req_id = %" PRId64, req_id);
     604    if (c != ',') {
     605        psError(PS_ERR_UNKNOWN, true, "at least one set option is required");
     606        return false;
     607    }
     608
     609    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     610    psStringAppend(&query, "\nWHERE %s", whereClause);
     611    psFree(whereClause);
     612    psFree(where);
     613
     614    if (stateCheck) {
     615        psStringAppend(&query, "%s", stateCheck);
     616    }
    505617
    506618    if (!p_psDBRunQuery(config->dbh, query)) {
    … …  
    510622    }
    511623
    512     psU64 affected = psDBAffectedRows(config->dbh);
    513     // note zero is not an error
    514     if (affected > 1) {
    515         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    516                                         PRIu64 " rows were modified", affected);
    517         return false;
    518     }
     624    // psU64 affected = psDBAffectedRows(config->dbh);
     625    // psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampRequests", affected);
    519626
    520627    return true;
    … …  
    528635
    529636    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    530     PXOPT_COPY_S64(config->args, where, "-fault", "req_id", "==");
     637    PXOPT_COPY_S64(config->args, where, "-fault", "fault", "==");
    531638    PXOPT_COPY_STR(config->args, where, "-state", "pstampRequest.state", "==");
    532639    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    … …  
    703810    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
    704811    PXOPT_COPY_S64(config->args, where, "-req_id", "req_id", "==");
    705     pxAddLabelSearchArgs(config, where, "-label", "label", "LIKE");
     812    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "LIKE");
    706813
    707814    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    722829    psFree(where);
    723830
     831    psStringAppend(&query, " ORDER BY priority DESC, req_id");
     832
    724833    // treat limit == 0 as "no limit"
    725834    if (limit) {
    … …  
    763872    PS_ASSERT_PTR_NON_NULL(config, false);
    764873
    765     PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", true, false);
    766     PXOPT_LOOKUP_STR(state,     config->args, "-state",  true, false);
    767     PXOPT_LOOKUP_STR(fault,     config->args, "-fault",  false, false);
    768 
    769     psString faultStr = NULL;
    770     if (!fault) {
    771         faultStr = psStringCopy("");
    772     } else {
    773         psStringAppend(&faultStr, ", fault = '%s'", fault);
    774     }
    775 
    776     char *query ="UPDATE pstampJob"
    777         " SET state = '%s' %s"
    778         " WHERE job_id = %" PRId64;
    779 
    780     if (!p_psDBRunQueryF(config->dbh, query, state, faultStr, job_id)) {
     874    PXOPT_LOOKUP_S64(job_id,    config->args, "-job_id", false, false);
     875    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", false, false);
     876
     877    if (!job_id && !dep_id) {
     878        psError(PS_ERR_UNKNOWN, true, "at least -job_id or -dep_id is required");
     879        return false;
     880    }
     881
     882    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  false, false);
     883    PXOPT_LOOKUP_S32(fault,     config->args, "-set_fault",  false, false);
     884   
     885    if (!state && !fault) {
     886        psError(PS_ERR_UNKNOWN, true, "at least one of -set_state and -set_fault is required");
     887        return false;
     888    }
     889
     890    psMetadata *where = psMetadataAlloc();
     891
     892    PXOPT_COPY_S64(config->args, where, "-job_id", "job_id", "==");
     893    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     894
     895    psString query = pxDataGet("pstamptool_updatejob.sql");
     896
     897    char c = ' ';
     898    if (state) {
     899        psStringAppend(&query, "\n %c pstampJob.state = '%s'", c, state);
     900        c = ',';
     901    }
     902    if (fault) {
     903        psStringAppend(&query, "\n %c pstampJob.fault = %d", c, fault);
     904        c = ',';
     905    }
     906   
     907    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     908    psStringAppend(&query, " WHERE %s", whereClause);
     909    psFree(whereClause);
     910    psFree(where);
     911
     912    if (!p_psDBRunQuery(config->dbh, query)) {
    781913        psError(PS_ERR_UNKNOWN, false, "database error");
    782914        psFree(query);
    783915        return false;
    784916    }
    785     psFree(faultStr);
     917    psFree(query);
    786918
    787919    psU64 affected = psDBAffectedRows(config->dbh);
    788     if (affected != 1) {
    789         psError(PS_ERR_UNKNOWN, false, "should have affected one row but %"
    790                                         PRIu64 " rows were modified", affected);
    791         return false;
    792     }
     920    psLogMsg("pstamptool", PS_LOG_INFO, "Updated %" PRIu64 " pstampJobs", affected);
    793921
    794922    return true;
    … …  
    9521080    PXOPT_LOOKUP_STR(stage,       config->args, "-stage",   true, false);
    9531081    PXOPT_LOOKUP_S64(stage_id,    config->args, "-stage_id", true, false);
     1082    PXOPT_LOOKUP_STR(component,   config->args, "-component",  true, false);
    9541083    PXOPT_LOOKUP_STR(imagedb,     config->args, "-imagedb",  true, false);
    955     PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  false, false);
    956     PXOPT_LOOKUP_BOOL(no_magic,   config->args, "-no_magic", false);
     1084    PXOPT_LOOKUP_STR(rlabel,      config->args, "-rlabel",  true, false);
     1085    PXOPT_LOOKUP_STR(outdir,      config->args, "-outdir",  true, false);
     1086    PXOPT_LOOKUP_BOOL(need_magic, config->args, "-need_magic", false);
    9571087    PXOPT_LOOKUP_BOOL(no_create,  config->args, "-no_create", false);
    9581088
    … …  
    9611091    PXOPT_COPY_STR(config->args, where, "-imagedb", "imagedb", "==");
    9621092    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     1093    PXOPT_COPY_STR(config->args, where, "-component", "component", "==");
    9631094
    9641095    // start a transaction eraly so it will contain any row level locks
    … …  
    9681099    }
    9691100
    970     psString query = pxDataGet("pstamptool_pendingdependent.sql");
     1101    psString query = pxDataGet("pstamptool_getdependent.sql");
    9711102    if (!query) {
    9721103        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    9731104        return false;
    9741105    }
    975     psString whereClause = psDBGenerateWhereSQL(where, "WHERE");
     1106    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    9761107    if (!no_create) {
    9771108        // This will lock the row until the transaction is committed
    978         psStringAppend(&query, " %s FOR UPDATE", whereClause);
     1109        psStringAppend(&query, " AND %s FOR UPDATE", whereClause);
    9791110    } else {
    980         psStringAppend(&query, " %s", whereClause);
     1111        psStringAppend(&query, " AND %s", whereClause);
    9811112    }
    9821113    psFree(whereClause);
    … …  
    10271158        stage,
    10281159        stage_id,
     1160        component,
    10291161        imagedb,
    10301162        rlabel,
    1031         no_magic
     1163        need_magic,
     1164        outdir,
     1165        0               // fault
    10321166        )) {
    10331167        if (!psDBRollback(config->dbh)) {
    … …  
    10381172    }
    10391173
     1174    // if we try and get this after commit zero is returned
     1175    psS64 dep_id = psDBLastInsertID(config->dbh);
     1176    if (!dep_id) {
     1177        psError(PS_ERR_UNKNOWN, false, "psDBLastInsertID returned NULL");
     1178        if (!psDBRollback(config->dbh)) {
     1179            psError(PS_ERR_UNKNOWN, false, "database error");
     1180        }
     1181        return false;
     1182    }
     1183
    10401184    if (!psDBCommit(config->dbh)) {
    10411185        // rollback
    … …  
    10471191    }
    10481192
    1049     psS64 dep_id = psDBLastInsertID(config->dbh);
    10501193    printf("%" PRId64 "\n", dep_id);
    10511194
    … …  
    10581201
    10591202    psMetadata *where = psMetadataAlloc();
     1203    PXOPT_COPY_STR(config->args, where, "-stage", "stage", "==");
     1204    PXOPT_COPY_STR(config->args, where, "-imagedb", "imagedb", "==");
     1205    PXOPT_COPY_S64(config->args, where, "-stage_id", "stage_id", "==");
     1206    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1207    PXOPT_COPY_STR(config->args, where, "-rlabel", "rlabel", "==");
     1208    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
    10601209
    10611210    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    10691218
    10701219    if (psListLength(where->list)) {
    1071         psString whereClause = psDBGenerateWhereConditionSQL(where, "pstampDependent");
     1220        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    10721221        psStringAppend(&query, " AND %s", whereClause);
    10731222        psFree(whereClause);
    10741223    }
    10751224    psFree(where);
     1225
     1226    psStringAppend(&query, " ORDER BY priority DESC, req_id");
    10761227
    10771228    // treat limit == 0 as "no limit"
    … …  
    11161267
    11171268    PXOPT_LOOKUP_S64(dep_id,    config->args, "-dep_id", true, false);
    1118     PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  true, false);
    1119 
    1120     char *query ="UPDATE pstampDependent"
    1121         " SET state = '%s'"
    1122         " WHERE dep_id = %" PRId64;
    1123 
    1124     if (!p_psDBRunQueryF(config->dbh, query, state, dep_id)) {
     1269    PXOPT_LOOKUP_STR(state,     config->args, "-set_state",  false, false);
     1270    PXOPT_LOOKUP_S16(fault,     config->args, "-set_fault",  false, false);
     1271
     1272    if (!fault && !state) {
     1273        psError(PS_ERR_UNKNOWN, true, "at least one of -set_state or fault is required");
     1274        return false;
     1275    }
     1276    psString query = psStringCopy("UPDATE pstampDependent SET");
     1277    bool needComma = false;
     1278    if (state) {
     1279        psStringAppend(&query, " state = '%s'", state);
     1280        needComma = true;
     1281    }
     1282    if (fault) {
     1283        psStringAppend(&query, "%s fault = %d", needComma ? ", " : "", fault);
     1284        needComma = true;
     1285    }
     1286    psStringAppend(&query, " WHERE dep_id = %" PRId64, dep_id);
     1287
     1288    if (!p_psDBRunQuery(config->dbh, query)) {
    11251289        psError(PS_ERR_UNKNOWN, false, "database error");
    11261290        psFree(query);
    … …  
    11371301    return true;
    11381302}
     1303static bool revertdependentMode(pxConfig *config)
     1304{
     1305    PS_ASSERT_PTR_NON_NULL(config, false);
     1306
     1307    psMetadata *where = psMetadataAlloc();
     1308    PXOPT_COPY_S64(config->args, where, "-fault", "pstampDependent.fault", "==");
     1309    PXOPT_COPY_S64(config->args, where, "-dep_id", "dep_id", "==");
     1310    pxAddLabelSearchArgs(config, where, "-label", "pstampRequest.label", "==");
     1311
     1312    if (!psListLength(where->list)) {
     1313        psFree(where);
     1314        psError(PXTOOLS_ERR_CONFIG, false, "search parameters are required");
     1315        return false;
     1316    }
     1317    psString query = pxDataGet("pstamptool_revertdependent.sql");
     1318    if (!query) {
     1319        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1320        return false;
     1321    }
     1322
     1323    psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1324    psStringAppend(&query, " AND %s", whereClause);
     1325    psFree(whereClause);
     1326    psFree(where);
     1327
     1328    if (!p_psDBRunQuery(config->dbh, query)) {
     1329        psError(PS_ERR_UNKNOWN, false, "database error");
     1330        psFree(query);
     1331        return false;
     1332    }
     1333
     1334    return true;
     1335}

  • branches/pap/ippTools/src/pstamptool.h

    r25793 r28003  
    3434    PSTAMPTOOL_MODE_UPDATEREQ,
    3535    PSTAMPTOOL_MODE_REVERTREQ,
     36    PSTAMPTOOL_MODE_PENDINGCLEANUP,
    3637    PSTAMPTOOL_MODE_ADDJOB,
    3738    PSTAMPTOOL_MODE_LISTJOB,
    … …  
    4647    PSTAMPTOOL_MODE_PENDINGDEPENDENT,
    4748    PSTAMPTOOL_MODE_UPDATEDEPENDENT,
     49    PSTAMPTOOL_MODE_REVERTDEPENDENT,
    4850} pstamptoolMode;
    4951

  • branches/pap/ippTools/src/pstamptoolConfig.c

    r27282 r28003  
    9898    // -updatereq
    9999    psMetadata *updatereqArgs = psMetadataAlloc();
    100     psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,            "req_id for which to change state", 0);
    101     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    102     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-outProduct", 0,            "define request outProduct", NULL);
    103     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-fault", 0,            "define request fault code", NULL);
    104     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-uri", 0,            "define the uri", NULL);
    105     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-name", 0,            "define the name", NULL);
    106     psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-reqType", 0,            "define the reqType", NULL);
     100    psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id", 0,       "req_id for which to update", 0);
     101    psMetadataAddS64(updatereqArgs, PS_LIST_TAIL, "-req_id_max", 0,   "maximum req_id for which to update", 0);
     102    psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-fault", 0,        "search by fault code", 0);
     103    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-state", 0,        "search by state", NULL);
     104    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampJob label (LIKE comparision)", NULL);
     105    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_state", 0,        "new state", NULL);
     106    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_label", 0,        "new label", NULL);
     107    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_outProduct", 0,   "new outProduct", NULL);
     108    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_outdir", 0,   "new outdir", NULL);
     109    psMetadataAddS16(updatereqArgs, PS_LIST_TAIL, "-set_fault", 0,        "new fault code", 0);
     110    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_uri", 0,          "new uri", NULL);
     111    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_name", 0,         "new name", NULL);
     112    psMetadataAddStr(updatereqArgs, PS_LIST_TAIL, "-set_reqType", 0,      "new reqType", NULL);
     113    psMetadataAddBool(updatereqArgs, PS_LIST_TAIL, "-clearfault", 0,      "set fault to zero", false);
    107114
    108115    // -revertreq
    … …  
    112119    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-state", 0,      "state to revert", NULL);
    113120    psMetadataAddStr(revertreqArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     121
     122    // -pendingcleanup
     123    psMetadata *pendingcleanupArgs = psMetadataAlloc();
     124    psMetadataAddS64(pendingcleanupArgs, PS_LIST_TAIL, "-req_id", 0,   "define req_id", 0);
     125    psMetadataAddS64(pendingcleanupArgs, PS_LIST_TAIL, "-ds_id", 0,    "define ds_id", 0);
     126    psMetadataAddStr(pendingcleanupArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by pstampRequest label (LIKE comparision)", NULL);
     127    psMetadataAddU64(pendingcleanupArgs, PS_LIST_TAIL, "-limit",  0,   "limit result set to N items", 0);
     128    psMetadataAddBool(pendingcleanupArgs, PS_LIST_TAIL, "-simple", 0,  "use the simple output format", false);
    114129
    115130    // -addjob
    … …  
    144159    psMetadata *updatejobArgs = psMetadataAlloc();
    145160    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-job_id", 0,            "req_id for which to change state", 0);
    146     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-state", 0,            "new state", NULL);
    147     psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-fault", 0,            "new result", NULL);
     161    psMetadataAddS64(updatejobArgs, PS_LIST_TAIL, "-dep_id", 0,            "dep_id for which to change state", 0);
     162    psMetadataAddStr(updatejobArgs, PS_LIST_TAIL, "-set_state", 0,            "new state", NULL);
     163    psMetadataAddS16(updatejobArgs, PS_LIST_TAIL, "-set_fault", 0,            "new result", 0);
    148164
    149165    // -revertjob
    … …  
    159175    // -getdependent
    160176    psMetadata *getdependentArgs = psMetadataAlloc();
    161     psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run (required)", 0);
    162     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run (required)", NULL);
    163     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run (required)", NULL);
    164     psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
    165     psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
    166     psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     177    // arguabely all of these could be -set_ arguments, but since this mode is both a query and
     178    // a create if doesn't exist I like it this way
     179    psMetadataAddS64(getdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define stage id for dependent (required)", 0);
     180    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent (required)", NULL);
     181    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-component", 0, "define component for depenent (required)", NULL);
     182    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent (required)", NULL);
     183    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent ", NULL);
     184    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-need_magic", 0, "define need_magic", false);
     185    psMetadataAddStr(getdependentArgs, PS_LIST_TAIL, "-outdir", 0,    "define output directory for dependent (required)", NULL);
     186    psMetadataAddBool(getdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no matching dependent do not create one", false);
    167187
    168188    // -updatedependent
    169189    psMetadata *updatedependentArgs = psMetadataAlloc();
    170     psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent run (required)", 0);
    171     psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state (required)", NULL);
     190    psMetadataAddS64(updatedependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent (required)", 0);
     191    psMetadataAddStr(updatedependentArgs, PS_LIST_TAIL, "-set_state", 0, "new value for state", NULL);
     192    psMetadataAddS16(updatedependentArgs, PS_LIST_TAIL, "-set_fault",  0,   "new value for fault", 0);
     193
     194    // -revertdependent
     195    psMetadata *revertdependentArgs = psMetadataAlloc();
     196    psMetadataAddS64(revertdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define id for dependent", 0);
     197    psMetadataAddStr(revertdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for dependent ", NULL);
     198    psMetadataAddS16(revertdependentArgs, PS_LIST_TAIL, "-fault",  0,   "define fault", 0);
    172199
    173200    // -pendingdependent
    174201    psMetadata *pendingdependentArgs = psMetadataAlloc();
    175     psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent run", 0);
    176     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent run", NULL);
    177     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent run", NULL);
    178     psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent run", NULL);
    179     psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_magic", 0, "define no_magic", false);
    180     psMetadataAddBool(pendingdependentArgs,PS_LIST_TAIL, "-no_create", 0, "if no run exists do not create one", false);
     202    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-stage_id", 0, "define id for dependent", 0);
     203    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-stage", 0,    "define stage for dependent", NULL);
     204    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-component", 0,    "define component for dependent", NULL);
     205    psMetadataAddS64(pendingdependentArgs, PS_LIST_TAIL, "-dep_id", 0, "define dep_id for dependent", 0);
     206    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK,   "define label for pstampRequest", NULL);
     207    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-rlabel", 0,   "define label for dependent", NULL);
     208    psMetadataAddStr(pendingdependentArgs, PS_LIST_TAIL, "-imagedb", 0,  "define imagedb for depenent", NULL);
    181209    psMetadataAddU64(pendingdependentArgs, PS_LIST_TAIL, "-limit",  0,    "limit result set to N items", 0);
    182210    psMetadataAddBool(pendingdependentArgs, PS_LIST_TAIL, "-simple", 0,   "use the simple output format", false);
    … …  
    216244    PXOPT_ADD_MODE("-completedreq",    "", PSTAMPTOOL_MODE_COMPLETEDREQ, completedreqArgs);
    217245    PXOPT_ADD_MODE("-revertreq",       "", PSTAMPTOOL_MODE_REVERTREQ,    revertreqArgs);
     246    PXOPT_ADD_MODE("-pendingcleanup",  "", PSTAMPTOOL_MODE_PENDINGCLEANUP, pendingcleanupArgs);
    218247
    219248    PXOPT_ADD_MODE("-addjob",          "", PSTAMPTOOL_MODE_ADDJOB,       addjobArgs);
    … …  
    230259    PXOPT_ADD_MODE("-updatedependent", "", PSTAMPTOOL_MODE_UPDATEDEPENDENT, updatedependentArgs);
    231260    PXOPT_ADD_MODE("-pendingdependent","", PSTAMPTOOL_MODE_PENDINGDEPENDENT, pendingdependentArgs);
     261    PXOPT_ADD_MODE("-revertdependent","", PSTAMPTOOL_MODE_REVERTDEPENDENT, revertdependentArgs);
    232262
    233263    PXOPT_ADD_MODE("-addproject",      "", PSTAMPTOOL_MODE_ADDPROJECT, addprojectArgs);

  • branches/pap/ippTools/src/pxchip.c

    r27246 r28003  
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    71     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    72     psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     71    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     72    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
    7373    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    7474    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
    75     psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode", 0, "search by observation mode", NULL);
     75    psMetadataAddStr(md,  PS_LIST_TAIL, "-obs_mode",           0, "search by observation mode", NULL);
    7676    return true;
    7777}
    … …  
    121121    PXOPT_COPY_F64(config->args, where, "-posang_min", "rawExp.posang", ">=");
    122122    PXOPT_COPY_F64(config->args, where, "-posang_max", "rawExp.posang", "<");
    123     PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "==");
     123    PXOPT_COPY_STR(config->args, where, "-object", "rawExp.object", "LIKE");
    124124    PXOPT_COPY_F32(config->args, where, "-sun_angle_min", "rawExp.sun_angle", ">=");
    125125    PXOPT_COPY_F32(config->args, where, "-sun_angle_max", "rawExp.sun_angle", "<");

  • branches/pap/ippTools/src/pxmagic.c

    r26981 r28003  
    8585    }
    8686    if (destreaked) {
    87         psStringAppend(out, " AND %s.magicked > 0", table);
     87        psStringAppend(out, " AND %s.magicked != 0", table);
    8888    }
     89    // Note -magicked is  handled by the caller. XXX: Why?
    8990    return true;
    9091}

  • branches/pap/ippTools/src/pxtools.h

    r27391 r28003  
    286286  PXOPT_COPY_PRIMITIVE(from, to, psU64, U64, oldname, newname, comment)
    287287
     288#define PXOPT_COPY_BOOL(from, to, oldname, newname, comment) \
     289  PXOPT_COPY_V(from, to, psBool, Bool, oldname, newname, comment)
    288290
    289291/*** these PXOPT_ADD_WHERE macros are used to construct the default sql elements ***/

  • branches/pap/ippTools/src/regtool.c

    r27536 r28003  
    350350    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    351351    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     352    PXOPT_LOOKUP_BOOL(allfiles, config->args, "-allfiles", false);
     353    if (allfiles) {
     354        faulted = false;
     355    }
    352356    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    353357    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
    … …  
    389393        // list only faulted rows
    390394        psStringAppend(&query, " %s", "AND rawImfile.fault != 0");
    391     } else {
     395    } else if (!allfiles) {
    392396        // don't list faulted rows
    393397        psStringAppend(&query, " %s", "AND rawImfile.fault = 0");

  • branches/pap/ippTools/src/regtoolConfig.c

    r27315 r28003  
    144144    ADD_OPT(U64,  processedimfileArgs, "-limit",     "limit result set to N items",           0);
    145145    ADD_OPT(Bool, processedimfileArgs, "-faulted",   "only return imfiles with a fault status set", false);
     146    ADD_OPT(Bool, processedimfileArgs, "-allfiles",   "return imfiles regardless of fault status", false);
    146147    ADD_OPT(Bool, processedimfileArgs, "-all",   "list without search arguments", false);
    147148    ADD_OPT(Bool, processedimfileArgs, "-simple",    "use the simple output format",          false);

  • branches/pap/ippTools/src/stacktool.c

    r27679 r28003  
    155155    PXOPT_COPY_F32(config->args,  where, "-select_good_frac_min",      "warpSkyfile.good_frac", ">=");
    156156    PXOPT_COPY_STR(config->args,  where, "-select_skycell_id",         "warpSkyfile.skycell_id", "==");
     157    PXOPT_COPY_STR(config->args,  where, "-select_data_group",         "warpRun.data_group", "==");
    157158    pxAddLabelSearchArgs (config, where, "-select_label",              "warpRun.label", "LIKE"); // define using warp label
    158159

  • branches/pap/ippTools/src/stacktoolConfig.c

    r27121 r28003  
    5959    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_exp_type", 0, "search for exp_type", "object");
    6060    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by warpRun label (LIKE comparison, multiple OK)", NULL);
     61    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_data_group", 0 , "search by warpRun data_group", NULL);
    6162    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_comment", 0, "search for comment (LIKE)", NULL);
    6263    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_inst", 0, "search for camera", NULL);

  • branches/pap/ippTools/src/staticskytool.c

    r27546 r28003  
    107107
    108108    // optional
    109     PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
    110     PXOPT_LOOKUP_STR(data_group, config->args, "-set_data_group", false, false);
    111     PXOPT_LOOKUP_STR(dist_group, config->args, "-set_dist_group", false, false);
    112     PXOPT_LOOKUP_STR(reduction, config->args, "-set_reduction", false, false);
    113     PXOPT_LOOKUP_STR(note, config->args, "-set_note", false, false);
     109    PXOPT_LOOKUP_STR(label,       config->args, "-set_label", false, false);
     110    PXOPT_LOOKUP_STR(data_group,  config->args, "-set_data_group", false, false);
     111    PXOPT_LOOKUP_STR(dist_group,  config->args, "-set_dist_group", false, false);
     112    PXOPT_LOOKUP_STR(reduction,   config->args, "-set_reduction", false, false);
     113    PXOPT_LOOKUP_STR(note,        config->args, "-set_note", false, false);
    114114    PXOPT_LOOKUP_TIME(registered, config->args, "-set_registered", false, false);
    115115
    … …  
    118118
    119119    PXOPT_COPY_F32(config->args, where, "-select_good_frac_min", "stackSumSkyfile.good_frac", ">=");
    120     PXOPT_COPY_STR(config->args, where, "-select_skycell_id", "stackRun.skycell_id", "==");
    121     pxAddLabelSearchArgs(config, where, "-select_label", "stackRun.label", "LIKE");
    122     pxAddLabelSearchArgs(config, where, "-select_filter", "stackRun.filter", "LIKE");
     120    PXOPT_COPY_STR(config->args, where, "-select_skycell_id",    "stackRun.skycell_id",      "==");
     121    pxAddLabelSearchArgs(config, where, "-select_label",         "stackRun.label",            "LIKE");
     122    pxAddLabelSearchArgs(config, where, "-select_filter",        "stackRun.filter",          "LIKE");
    123123
    124124    // these are used to build the HAVING restriction
    125     PXOPT_COPY_S32(config->args, having, "-min_num", "num", ">=");
     125    PXOPT_COPY_S32(config->args, having, "-min_num",    "num",        ">=");
    126126    PXOPT_COPY_S32(config->args, having, "-min_filter", "num_filter", ">=");
    127127

  • branches/pap/ippTools/src/staticskytoolConfig.c

    r27546 r28003  
    4646
    4747    // -definebyquery
     48    // XXX need a 'ra_min,max', 'dec_min,max' : to do this, we need a table of skycell boundaries
    4849    psMetadata *definebyqueryArgs = psMetadataAlloc();
    49     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
    50     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
    51     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
    52     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
    53     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
    54     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
     50    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
     51    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
     52    psMetadataAddF32(definebyqueryArgs,  PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
     53    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
     54    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
     55    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_workdir", 0, "define workdir (required)", NULL);
     56    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_label", 0, "define label", NULL);
     57    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_data_group", 0, "define data group", NULL);
     58    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_dist_group", 0, "define dist group", NULL);
     59    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_note", 0, "define note", NULL);
     60    psMetadataAddStr(definebyqueryArgs,  PS_LIST_TAIL, "-set_reduction", 0, "define reduction", NULL);
    5561    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-set_registered", 0, "time detrend run was registered", now);
    56     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_skycell_id", 0, "search for skycell_id", NULL);
    57     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_tess_id", 0, "search for tess_id", NULL);
    58     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-select_good_frac_min", 0, "define min good_frac", 0.0);
    59     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_label", PS_META_DUPLICATE_OK, "search by stackRun label (LIKE comparison, multiple OK)", NULL);
    60     psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-select_filter", PS_META_DUPLICATE_OK, "search by filter (LIKE comparison, multiple OK)", NULL);
    6162    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0, "do not actually modify the database", false);
    6263    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    6465    // -updaterun
    6566    psMetadata *updaterunArgs = psMetadataAlloc();
    66     psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-ss_id", 0, "search by stack ID", 0);
     67    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-sky_id", 0, "search by stack ID", 0);
    6768    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0, "search by state", NULL);
    6869    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label", 0, "search by label", 0);
    … …  
    7576    // -inputs
    7677    psMetadata *inputsArgs = psMetadataAlloc();
    77     psMetadataAddS64(inputsArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     78    psMetadataAddS64(inputsArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    7879    psMetadataAddU64(inputsArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    7980    psMetadataAddBool(inputsArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
    … …  
    8182    // -todo
    8283    psMetadata *todoArgs = psMetadataAlloc();
    83     psMetadataAddS64(todoArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     84    psMetadataAddS64(todoArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    8485    psMetadataAddStr(todoArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", NULL);
    8586    psMetadataAddU64(todoArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
    … …  
    8889    // -addresult
    8990    psMetadata *addresultArgs = psMetadataAlloc();
    90     psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-ss_id", 0, "define stack ID (required)", 0);
     91    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define stack ID (required)", 0);
    9192    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define base output location", 0);
    9293    psMetadataAddF32(addresultArgs, PS_LIST_TAIL, "-dtime_phot", 0, "define photometry time", NAN);
    … …  
    100101    // -result
    101102    psMetadata *resultArgs= psMetadataAlloc();
    102     psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     103    psMetadataAddS64(resultArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    103104    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-tess_id", 0, "search by tess ID", 0);
    104105    psMetadataAddStr(resultArgs, PS_LIST_TAIL, "-skycell_id", 0, "search by skycell ID", 0);
    … …  
    111112    // -revert
    112113    psMetadata *revertArgs= psMetadataAlloc();
    113     psMetadataAddS64(revertArgs, PS_LIST_TAIL, "-ss_id", 0, "search by staticsky ID", 0);
     114    psMetadataAddS64(revertArgs, PS_LIST_TAIL, "-sky_id", 0, "search by staticsky ID", 0);
    114115    psMetadataAddStr(revertArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search by label", 0);
    115116    psMetadataAddS16(revertArgs, PS_LIST_TAIL, "-fault", 0, "search by fault code", 0);
    … …  
    118119    // -updateresult
    119120    psMetadata *updateresultArgs = psMetadataAlloc();
    120     psMetadataAddS64(updateresultArgs, PS_LIST_TAIL, "-ss_id", 0, "define staticksky ID (required)", 0);
     121    psMetadataAddS64(updateresultArgs, PS_LIST_TAIL, "-sky_id", 0, "define staticksky ID (required)", 0);
    121122    psMetadataAddS16(updateresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code (required)", 0);
    122123
    123124    // -exportrun
    124125    psMetadata *exportrunArgs = psMetadataAlloc();
    125     psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-ss_id", 0, "export this staticsky ID (required)", 0);
     126    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-sky_id", 0, "export this staticsky ID (required)", 0);
    126127    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0, "export to this file (required)", NULL);
    127128    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);

  • branches/pap/ippTools/src/warptool.c

    r27503 r28003  
    5959static bool importrunMode(pxConfig *config);
    6060static bool runstateMode(pxConfig *config);
     61static bool listrunMode(pxConfig *config);
     62static bool setskyfiletoupdateMode(pxConfig *config);
    6163
    6264static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    110112        MODECASE(WARPTOOL_MODE_IMPORTRUN,          importrunMode);
    111113        MODECASE(WARPTOOL_MODE_RUNSTATE,           runstateMode);
     114        MODECASE(WARPTOOL_MODE_LISTRUN,            listrunMode);
     115        MODECASE(WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateMode);
    112116
    113117        default:
    … …  
    244248    PXOPT_COPY_F64(config->args,   where, "-posang_max",         "rawExp.posang",         "<");
    245249    PXOPT_COPY_STR(config->args,   where, "-object",             "rawExp.object",         "==");
     250    PXOPT_COPY_STR(config->args,   where, "-comment",            "rawExp.comment",        "LIKE");
     251    PXOPT_COPY_STR(config->args,   where, "-obs_mode",           "rawExp.obs_mode",       "LIKE");
    246252    PXOPT_COPY_F32(config->args,   where, "-sun_angle_min",      "rawExp.sun_angle",      ">=");
    247253    PXOPT_COPY_F32(config->args,   where, "-sun_angle_max",      "rawExp.sun_angle",      "<");
    … …  
    269275    PXOPT_LOOKUP_TIME(registered, config->args, "-registered", false, false);
    270276    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     277    PXOPT_LOOKUP_BOOL(pretend, config->args, "-pretend", false);
    271278
    272279    // check mode
    … …  
    306313    if (!psArrayLength(output)) {
    307314        psTrace("warptool", PS_LOG_INFO, "no rows found");
     315        psFree(output);
     316        return true;
     317    }
     318
     319    if (pretend) {
     320        // negative simple so the default is true
     321        if (!ippdbPrintMetadatas(stdout, output, "rawExp", !simple)) {
     322            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     323            psFree(output);
     324            return false;
     325        }
    308326        psFree(output);
    309327        return true;
    … …  
    916934
    917935    // treat limit == 0 as "no limit"
     936    psString limitString = psStringCopy("\n");
    918937    if (limit) {
    919         psString limitString = psDBGenerateLimitSQL(limit);
     938        // We apply the limit to both sides of the UNION
     939        // to avoid slow queries and to the query itself
     940        // to satisfy the user's requested limit
     941        psStringAppend(&limitString, "%s", psDBGenerateLimitSQL(limit));
    920942        psStringAppend(&query, " %s", limitString);
    921         psFree(limitString);
    922     }
    923 
     943    }
     944
     945#define TWO_WHERES
    924946#ifdef TWO_WHERES
    925     if (!p_psDBRunQueryF(config->dbh, query, whereStr, whereStr)) {
     947    if (!p_psDBRunQueryF(config->dbh, query, whereStr, limitString, whereStr,  limitString)) {
    926948        psError(PS_ERR_UNKNOWN, false, "database error");
    927949        psFree(query);
    … …  
    935957    }
    936958#endif
     959    psFree(limitString);
    937960    psFree(whereStr);
    938961    psFree(query);
    … …  
    9941017    PXOPT_LOOKUP_STR(hostname, config->args, "-hostname", false, false);
    9951018    PXOPT_LOOKUP_F32(good_frac, config->args, "-good_frac", false, false);
    996     PXOPT_LOOKUP_S64(magicked, config->args, "-magicked", false, false);
     1019    PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
    9971020
    9981021    // default values
    … …  
    12421265    if (psListLength(where->list)) {
    12431266        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1244         psStringAppend(&query, " AND %s", whereClause);
     1267        psStringAppend(&query, " WHERE %s", whereClause);
    12451268        psFree(whereClause);
    12461269    } else if (!all && !where2) {
    … …  
    12481271        return false;
    12491272    }
     1273
     1274    if (where2) {
     1275        if (psListLength(where->list)) {
     1276            psStringAppend(&query, " %s", where2);
     1277        } else {
     1278            psStringAppend(&query, " WHERE 1 %s", where2);
     1279        }
     1280    }
    12501281    psFree(where);
    1251 
    1252     if (where2) {
    1253         psStringAppend(&query, " %s", where2);
    1254     }
    12551282
    12561283    // treat limit == 0 as "no limit"
    … …  
    13221349    }
    13231350
    1324     if (!psDBTransaction(config->dbh)) {
    1325         psError(PS_ERR_UNKNOWN, false, "database error");
    1326         psFree(where);
    1327         return false;
    1328     }
    1329 
    1330     // Delete product
    1331     int numDeleted;                     // Number deleted
    1332     {
    1333         psString query = pxDataGet("warptool_revertwarped_delete.sql");
    1334         if (!query) {
    1335             psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
    1336             if (!psDBRollback(config->dbh)) {
    1337                 psError(PS_ERR_UNKNOWN, false, "database error");
    1338             }
    1339             return false;
    1340         }
    1341 
    1342         if (psListLength(where->list)) {
    1343             psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    1344             psStringAppend(&query, " AND %s", whereClause);
    1345             psFree(whereClause);
    1346         }
    1347 
    1348         if (!p_psDBRunQuery(config->dbh, query)) {
    1349             psError(PS_ERR_UNKNOWN, false, "database error");
    1350             psFree(query);
    1351             if (!psDBRollback(config->dbh)) {
    1352                 psError(PS_ERR_UNKNOWN, false, "database error");
    1353             }
    1354             return false;
    1355         }
     1351    psString query = pxDataGet("warptool_revertwarped_delete.sql");
     1352    if (!query) {
     1353        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1354        return false;
     1355    }
     1356    psString query_updated = pxDataGet("warptool_revertwarped_updated.sql");
     1357    if (!query_updated) {
     1358        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     1359        return false;
     1360    }
     1361
     1362    if (psListLength(where->list)) {
     1363        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     1364        psStringAppend(&query, " AND %s", whereClause);
     1365        psStringAppend(&query_updated, " AND %s", whereClause);
     1366        psFree(whereClause);
     1367    }
     1368    psFree(where);
     1369
     1370    if (!p_psDBRunQuery(config->dbh, query)) {
     1371        psError(PS_ERR_UNKNOWN, false, "database error");
    13561372        psFree(query);
    1357 
    1358         numDeleted = psDBAffectedRows(config->dbh);
    1359     }
     1373        return false;
     1374    }
     1375    psFree(query);
     1376
     1377    int numDeleted = psDBAffectedRows(config->dbh);
    13601378
    13611379    psLogMsg("warptool", PS_LOG_INFO, "Deleted %d warpSkyfiles", numDeleted);
    13621380
    1363     psFree(where);
    1364 
    1365     if (!psDBCommit(config->dbh)) {
    1366         psError(PS_ERR_UNKNOWN, false, "database error");
    1367         return false;
    1368     }
     1381    // fix any faulted warpSkyfiles in data_state 'update'
     1382
     1383    if (!p_psDBRunQuery(config->dbh, query_updated)) {
     1384        psError(PS_ERR_UNKNOWN, false, "database error");
     1385        psFree(query_updated);
     1386        return false;
     1387    }
     1388    psFree(query_updated);
     1389
     1390    int numUpdated = psDBAffectedRows(config->dbh);
     1391
     1392    psLogMsg("warptool", PS_LOG_INFO, "Updated %d warpSkyfiles", numUpdated);
    13691393
    13701394    return true;
    … …  
    16651689    }
    16661690
    1667     char *set_magicked_skyfile = "";
    1668     char *set_magicked_run = "";
     1691    psString set_magicked_skyfile = psStringCopy("");
     1692    psString set_magicked_run = psStringCopy("");
    16691693    if (!strcmp(data_state, "full")) {
    1670         set_magicked_skyfile = "\n , warpSkyfile.magicked = IF((warpSkyfile.magicked < 0 AND chipRun.magicked = 0), warpSkyfile.magicked, chipRun.magicked)";
    1671         set_magicked_run = "\n,  warpRun.magicked = IF((warpRun.magicked < 0 AND chipRun.magicked = 0), warpRun.magicked, chipRun.magicked)";
    1672 
     1694        // magicked is only an argument for for -tofullskyfile
     1695        PXOPT_LOOKUP_S64(magicked, config->args, "-set_magicked", false, false);
     1696        if (magicked) {
     1697            psStringAppend(&set_magicked_skyfile, "\n , warpSkyfile.magicked = %" PRId64, magicked);
     1698            psStringAppend(&set_magicked_run, "\n,  warpRun.magicked = %" PRId64, magicked);
     1699        }
    16731700    } else if (!strcmp(data_state, "cleaned") || !strcmp(data_state, "purged")) {
    1674         set_magicked_skyfile = "\n, warpSkyfile.magicked = IF(warpSkyfile.magicked = 0, 0, -1)";
    1675         set_magicked_run = "\n, warpRun.magicked = IF(warpRun.magicked = 0, 0, -1)";
     1701        // if magicked is currently nonzero set it to -1
     1702        // Set warpRun.magicked when the first skyfile is cleaned
     1703        psStringAppend(&set_magicked_skyfile, "\n, warpSkyfile.magicked = IF(warpSkyfile.magicked = 0, 0, -1), warpRun.magicked = IF(warpRun.magicked = 0, 0, -1)");
    16761704    }
    16771705
    … …  
    16861714    }
    16871715    psFree(query);
     1716    psFree(set_magicked_skyfile);
    16881717
    16891718    query = pxDataGet("warptool_change_run_state.sql");
    … …  
    16961725        return false;
    16971726    }
     1727    psFree(set_magicked_run);
    16981728
    16991729    if (!psDBCommit(config->dbh)) {
    … …  
    20262056    return true;
    20272057}
     2058
     2059static bool listrunMode(pxConfig *config)
     2060{
     2061    PS_ASSERT_PTR_NON_NULL(config, false);
     2062
     2063    psMetadata *where = psMetadataAlloc();
     2064    PXOPT_COPY_S64(config->args, where, "-warp_id",    "warpRun.warp_id", "==");
     2065    PXOPT_COPY_STR(config->args, where, "-tess_id",    "warpRun.tess_id", "==");
     2066    PXOPT_COPY_STR(config->args, where, "-state",      "warpRun.state", "==");
     2067    PXOPT_COPY_S64(config->args, where, "-exp_id",     "rawExp.exp_id", "==");
     2068    PXOPT_COPY_STR(config->args, where, "-exp_name",   "rawExp.exp_name", "==");
     2069    PXOPT_COPY_S64(config->args, where, "-fake_id",    "fakeRun.fake_id", "==");
     2070    PXOPT_COPY_TIME(config->args, where, "-dateobs_begin", "rawExp.dateobs",  ">=");
     2071    PXOPT_COPY_TIME(config->args, where, "-dateobs_end",   "rawExp.dateobs",  "<=");
     2072    PXOPT_COPY_STR(config->args, where, "-filter",    "rawExp.filter", "LIKE");
     2073    PXOPT_COPY_S64(config->args, where, "-magicked", "warpRun.magicked", "==");
     2074    pxAddLabelSearchArgs (config, where, "-label",   "warpRun.label", "LIKE");
     2075    pxAddLabelSearchArgs (config, where, "-data_group",   "warpRun.data_group", "LIKE");
     2076    pxAddLabelSearchArgs (config, where, "-dist_group",   "warpRun.dist_group", "LIKE");
     2077
     2078    PXOPT_LOOKUP_BOOL(all, config->args, "-all", false);
     2079
     2080    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     2081    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     2082    PXOPT_LOOKUP_BOOL(pstamp_order, config->args, "-pstamp_order", false);
     2083
     2084    // find all rawImfiles matching the default query
     2085    psString query = pxDataGet("warptool_listrun.sql");
     2086    if (!query) {
     2087        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2088        return false;
     2089    }
     2090
     2091    // generate where strings for arguments that require extra processing
     2092    // beyond PXOPT_COPY*
     2093    psString where2 = NULL;
     2094    if (!pxmagicAddWhere(config, &where2, "warpRun")) {
     2095        psError(psErrorCodeLast(), false, "pxMagicAddWhere failed");
     2096        return false;
     2097    }
     2098    if (!pxspaceAddWhere(config, &where2, "rawExp")) {
     2099        psError(psErrorCodeLast(), false, "pxSpaceAddWhere failed");
     2100        return false;
     2101    }
     2102
     2103    if (psListLength(where->list)) {
     2104        psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
     2105        psStringAppend(&query, " WHERE %s", whereClause);
     2106        psFree(whereClause);
     2107    } else if (!all && !where2) {
     2108        psError(PXTOOLS_ERR_CONFIG, true, "search parameters or -all are required");
     2109        return false;
     2110    }
     2111
     2112    if (where2) {
     2113        if (psListLength(where->list)) {
     2114            psStringAppend(&query, " %s", where2);
     2115        } else {
     2116            psStringAppend(&query, " WHERE 1 %s", where2);
     2117        }
     2118    }
     2119    psFree(where);
     2120
     2121    if (pstamp_order) {
     2122        // put runs in order of exposure id with newest chip Runs first
     2123        // The postage stamp parser depends on this behavior
     2124        psStringAppend(&query, "\nORDER by exp_id, warp_id DESC");
     2125    }
     2126
     2127
     2128    // treat limit == 0 as "no limit"
     2129    if (limit) {
     2130        psString limitString = psDBGenerateLimitSQL(limit);
     2131        psStringAppend(&query, " %s", limitString);
     2132        psFree(limitString);
     2133    }
     2134
     2135    if (!p_psDBRunQuery(config->dbh, query)) {
     2136        psError(PS_ERR_UNKNOWN, false, "database error");
     2137        psFree(query);
     2138        return false;
     2139    }
     2140    psFree(query);
     2141
     2142    psArray *output = p_psDBFetchResult(config->dbh);
     2143    if (!output) {
     2144        psErrorCode err = psErrorCodeLast();
     2145        switch (err) {
     2146            case PS_ERR_DB_CLIENT:
     2147                psError(PXTOOLS_ERR_SYS, false, "database error");
     2148            case PS_ERR_DB_SERVER:
     2149                psError(PXTOOLS_ERR_PROG, false, "database error");
     2150            default:
     2151                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     2152        }
     2153
     2154        return false;
     2155    }
     2156    if (!psArrayLength(output)) {
     2157        psTrace("warptool", PS_LOG_INFO, "no rows found");
     2158        psFree(output);
     2159        return true;
     2160    }
     2161
     2162    if (psArrayLength(output)) {
     2163        // negative simple so the default is true
     2164        if (!ippdbPrintMetadatas(stdout, output, "warpRun", !simple)) {
     2165            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2166            psFree(output);
     2167            return false;
     2168        }
     2169    }
     2170
     2171    psFree(output);
     2172
     2173    return true;
     2174}
     2175
     2176// a very specfic function to queue a cleaned warpSkyfile to be updated
     2177static bool setskyfiletoupdateMode(pxConfig *config)
     2178{
     2179    PS_ASSERT_PTR_NON_NULL(config, NULL);
     2180
     2181    PXOPT_LOOKUP_S64(warp_id, config->args, "-warp_id", true, false);
     2182    PXOPT_LOOKUP_STR(skycell_id, config->args, "-skycell_id", false, false);
     2183    PXOPT_LOOKUP_STR(label, config->args, "-set_label", false, false);
     2184
     2185    psString query = pxDataGet("warptool_setskyfiletoupdate.sql");
     2186    if (!query) {
     2187        psError(PXTOOLS_ERR_SYS, false, "failed to retreive SQL statement");
     2188        return false;
     2189    }
     2190
     2191    psString setHook = psStringCopy("");
     2192    if (label) {
     2193        psStringAppend(&setHook, "\n , warpRun.label = '%s'", label);
     2194    }
     2195
     2196    if (skycell_id) {
     2197        psStringAppend(&query, " AND (warpSkyfile.skycell_id = '%s')", skycell_id);
     2198    }
     2199
     2200    if (!p_psDBRunQueryF(config->dbh, query, setHook, warp_id)) {
     2201        psError(PS_ERR_UNKNOWN, false, "database error");
     2202        return false;
     2203    }
     2204
     2205    psFree(setHook);
     2206    psFree(query);
     2207
     2208    return true;
     2209}

  • branches/pap/ippTools/src/warptool.h

    r25822 r28003  
    5555    WARPTOOL_MODE_IMPORTRUN,
    5656    WARPTOOL_MODE_RUNSTATE,
     57    WARPTOOL_MODE_LISTRUN,
     58    WARPTOOL_MODE_SETSKYFILETOUPDATE,
    5759} warptoolMode;
    5860

  • branches/pap/ippTools/src/warptoolConfig.c

    r27389 r28003  
    8989    psMetadataAddF64(definebyqueryArgs, PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    9090    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    91     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    92     psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
     91    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);
     92    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-obs_mode",           0, "search by observation mode", NULL);
     93    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_min",      0, "search by min solar angle", NAN);
     94    psMetadataAddF32(definebyqueryArgs, PS_LIST_TAIL, "-sun_angle_max",      0, "search by max solar angle", NAN);
    9395    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-reduction",          0, "search by fakeRun reduction class", NULL);
    9496    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-label", PS_META_DUPLICATE_OK, "search on fakeRun label", NULL);
    … …  
    106108    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered",  0,            "time detrend run was registered", now);
    107109    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     110    psMetadataAddBool(definebyqueryArgs, PS_LIST_TAIL, "-pretend",  0,            "do not actually modify the database", false);
    108111
    109112    // -definerun
    … …  
    217220    psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-hostname", 0,            "define hostname", 0);
    218221    psMetadataAddF32(addwarpedArgs, PS_LIST_TAIL, "-good_frac",  0,            "define %% of good pixels", NAN);
    219     psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-magicked",  0, "define if this skycell has been magicked", 0);
     222    psMetadataAddS64(addwarpedArgs, PS_LIST_TAIL, "-set_magicked",  0, "define if this skycell has been magicked", 0);
    220223    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    221224    psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    … …  
    236239    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
    237240    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     241    psMetadataAddStr(warpedArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
    238242    // add magic related arguments
    239243    pxmagicAddArguments(warpedArgs);
    … …  
    244248    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    245249    psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     250
     251    // -listrun
     252    psMetadata *listrunArgs = psMetadataAlloc();
     253    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID", 0);
     254    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-tess_id",  0,          "search by tessellation ID", NULL);
     255    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-state",  0,            "search by state", NULL);
     256    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-exp_id", 0,            "search by exposure tag", 0);
     257    psMetadataAddStr(listrunArgs, PS_LIST_TAIL, "-exp_name", 0,          "search by exposure tag", 0);
     258    psMetadataAddS64(listrunArgs, PS_LIST_TAIL, "-fake_id", 0,           "search by phase 3 version of exposure tag", 0);
     259    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_begin", 0,    "search for exposures by time (>=)", NULL);
     260    psMetadataAddTime(listrunArgs, PS_LIST_TAIL, "-dateobs_end", 0,      "search for exposures by time (<=)", NULL);
     261    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-filter", 0,           "search for exposures by filter", NULL);
     262    psMetadataAddS16(listrunArgs, PS_LIST_TAIL,  "-fault",  0,           "search by fault code", 0);
     263    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-label",  PS_META_DUPLICATE_OK, "search by warpRun label", NULL);
     264    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-data_group",  PS_META_DUPLICATE_OK, "search by warpRun data_group", NULL);
     265    psMetadataAddStr(listrunArgs, PS_LIST_TAIL,  "-dist_group",  PS_META_DUPLICATE_OK, "search by warpRun dist_group", NULL);
     266    // add magic related arguments
     267    pxmagicAddArguments(listrunArgs);
     268    // add arguments for spatial search
     269    pxspaceAddArguments(listrunArgs);
     270
     271    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-pstamp_order",  0,    "order results for postage stamp server", false);
     272
     273    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-all",  0,             "search without arguments", false);
     274    psMetadataAddU64(listrunArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     275    psMetadataAddBool(listrunArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
    246276
    247277    // -revertwarped
    … …  
    315345    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,    "warptool ID to update", 0);
    316346    psMetadataAddStr(tofullskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0, "skycell ID to update", NULL);
     347    psMetadataAddS64(tofullskyfileArgs, PS_LIST_TAIL, "-set_magicked",  0, "new value for magicked", 0);
    317348
    318349    // -updateskyfile
    … …  
    345376    psMetadataAddU64(runstateArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    346377    psMetadataAddBool(runstateArgs, PS_LIST_TAIL, "-simple",  0,          "use the simple output format", false);
     378
     379    // -setskyfiletoupdate
     380    psMetadata *setskyfiletoupdateArgs = psMetadataAlloc();
     381    psMetadataAddS64(setskyfiletoupdateArgs, PS_LIST_TAIL, "-warp_id", 0,           "search by warptool ID (required)", 0);
     382    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-skycell_id",  0,       "search by tessellation ID", NULL);
     383    psMetadataAddStr(setskyfiletoupdateArgs, PS_LIST_TAIL, "-set_label",  0,        "new value for warpRun.label", NULL);
    347384
    348385
    … …  
    364401    PXOPT_ADD_MODE("-advancerun",      "", WARPTOOL_MODE_ADVANCERUN,     advancerunArgs);
    365402    PXOPT_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
     403    PXOPT_ADD_MODE("-listrun",         "", WARPTOOL_MODE_LISTRUN,        listrunArgs);
    366404    PXOPT_ADD_MODE("-runstate",        "", WARPTOOL_MODE_RUNSTATE,       runstateArgs);
    367405    PXOPT_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
    … …  
    377415    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full (updated)", WARPTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    378416    PXOPT_ADD_MODE("-updateskyfile", "update fault code for skyfile", WARPTOOL_MODE_UPDATESKYFILE, updateskyfileArgs);
     417    PXOPT_ADD_MODE("-setskyfiletoupdate", "set cleaned skyfile to be updated", WARPTOOL_MODE_SETSKYFILETOUPDATE, setskyfiletoupdateArgs);
    379418    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
    380419    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
Note: See TracChangeset for help on using the changeset viewer.