IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 24149


Ignore:
Timestamp:
May 12, 2009, 4:07:48 PM (17 years ago)
Author:
Paul Price
Message:

Reworking magic (and some diff) to be ready for performing magic on warp-warp diffs. Several database changes to diff and magic tables because we can no longer assume that a diff is associated with a single exposure. Ready for testing.

Location:
branches/pap_magic
Files:
1 added
1 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • branches/pap_magic/dbconfig/changes.txt

    r24136 r24149  
    11131113
    11141114ALTER TABLE magicRun ADD COLUMN inverse TINYINT NOT NULL DEFAULT 0 AFTER diff_id;
     1115ALTER TABLE diffSkyfile DROP COLUMN uri;
     1116
     1117DROP TABLE IF EXISTS magicSkyfileMask;
     1118ALTER TABLE magicInputSkyfile DROP FOREIGN KEY magicInputSkyfile_ibfk_2;
     1119ALTER TABLE magicInputSkyfile DROP KEY diff_id;
     1120ALTER TABLE magicInputSkyfile DROP PRIMARY KEY, ADD PRIMARY KEY(magic_id,node);
     1121ALTER TABLE magicInputSkyfile DROP COLUMN diff_id;
     1122ALTER TABLE magicNodeResult CHANGE COLUMN uri path_base VARCHAR(255);

  • branches/pap_magic/dbconfig/diff.md

    r24120 r24149  
    3333    diff_id      S64        0       # Primary Key fkey(diff_id) ref diffRun(diff_id)
    3434    skycell_id   STR        64      #
    35     uri          STR        255
    3635    path_base    STR        255
    3736    data_state   STR        64

  • branches/pap_magic/dbconfig/magic.md

    r24136 r24149  
    1616END
    1717
     18### This is left over from when diffs were composed of a single skycell
     19### When we're not too busy, it should be deleted in favour of:
     20### magicRun JOIN diffSkyfile USING(diff_id) WHERE diffSkyfile.fault = 0 AND diffSkyfile.quality = 0
    1821magicInputSkyfile METADATA
    1922    magic_id    S64         0       # Primary Key fkey(magic_id) ref magicRun(magic_id)
    20     diff_id     S64         0       # Primary Key fkey(diff_id) ref diffRun(diff_id)
    2123    node        STR         64      #
    2224END
    … …  
    3133    magic_id    S64         0       # Primary Key fkey(magic_id) ref magicRun(magic_id)
    3234    node        STR         64      # Primary Key fkey(magic_id, node) ref magicTree(magic_id, node)
    33     uri         STR         255
     35    path_base   STR         255
    3436    fault       S16         0       # Key
    3537END

  • branches/pap_magic/ippScripts/Build.PL

    r24038 r24149  
    7373        scripts/ipp_serial_stack.pl
    7474        scripts/ipp_serial_mops.pl
     75        scripts/ipp_serial_magic.pl
    7576        scripts/ipp_mops_translate.pl
    7677        scripts/ipp_simulation_data.pl

  • branches/pap_magic/ippScripts/scripts/magic_definerun.pl

    r23186 r24149  
    164164&my_die("failed to retrieve new magic run information", $PS_EXIT_CONFIG_ERROR) if !$magic_id;
    165165
     166### This is left over from when diffs were composed of a single skycell
     167### When we're not too busy, it should be deleted in favour of:
     168### magicRun JOIN diffSkyfile USING(diff_id) WHERE diffSkyfile.fault = 0 AND diffSkyfile.quality = 0
    166169foreach my $diff_skyfile (@$inputs) {
    167170    my $skycell_id = $diff_skyfile->{skycell_id};
    … …  
    171174    }
    172175    my $diff_id = $diff_skyfile->{diff_id};
    173     my $command = "$magictool -addinputskyfile -magic_id $magic_id -diff_id $diff_id";
    174     $command .= "  -node $skycell_id";
     176    my $command = "$magictool -addinputskyfile";
     177    $command .= " -magic_id $magic_id";
     178    $command .= " -node $skycell_id";
    175179    $command .= " -dbname $dbname" if $dbname;
    176180

  • branches/pap_magic/ippScripts/scripts/magic_process.pl

    r23966 r24149  
    3737
    3838# Parse the command-line arguments
    39 my ($magic_id, $node, $camera, $dbname, $outroot, $template_uri, $save_temps, $verbose, $no_update, $no_op, $logfile);
     39my ($magic_id, $node, $camera, $dbname, $outroot, $save_temps, $verbose, $no_update, $no_op, $logfile);
    4040
    4141GetOptions(
    … …  
    4545           'dbname=s'        => \$dbname,     # Database name
    4646           'outroot=s'       => \$outroot,    # Output root name
    47            'template_uri=s'  => \$template_uri,# uri of diff template
    4847           'save-temps'      => \$save_temps, # Save temporary files?
    4948           'verbose'         => \$verbose,    # Print stuff?
    … …  
    5958    defined $node and
    6059    defined $camera and
    61     defined $outroot and
    62     defined $template_uri;
     60    defined $outroot;
    6361
    6462my $ipprc = PS::IPP::Config->new( $camera ) or my_die( "Unable to set up", $magic_id, $node, $PS_EXIT_CONFIG_ERROR ); # IPP configuration
    … …  
    138136        }
    139137
    140         my $template = $ipprc->file_resolve($template_uri);
    141         &my_die("failed to resolve template_uri: $template_uri", $magic_id, $node, $PS_EXIT_DATA_ERROR)
    142             if !($template);
     138        my $template = resolve_template($innode);
     139        &my_die("failed to resolve template", $magic_id, $node, $PS_EXIT_DATA_ERROR)
     140            unless defined $template;
    143141
    144142        $command .= " --detect --image $image --mask $mask --weight $weight -k $template";
    … …  
    189187            foreach my $innode (@$inputs) {
    190188                # root for inputs from previous stage
    191                 my $in_uri = $innode->{uri};
    192                 print $sfh "$in_uri\n";
    193 
    194                 cat_list_to_list($in_fh, $in_uri, "input.list");
     189                my $in_path_base = $innode->{magic_path_base};
     190                print $sfh "$in_path_base\n";
     191
     192                cat_list_to_list($in_fh, $in_path_base, "input.list");
    195193                # build input lists by combining the lists from
    196194                # previous stages
    197                 cat_list_to_list($ifh, $in_uri, "image.list");
    198                 cat_list_to_list($mfh, $in_uri, "mask.list");
    199                 cat_list_to_list($wfh, $in_uri, "weight.list");
     195                cat_list_to_list($ifh, $in_path_base, "image.list");
     196                cat_list_to_list($mfh, $in_path_base, "mask.list");
     197                cat_list_to_list($wfh, $in_path_base, "weight.list");
    200198            }
    201199            close $in_fh;
    … …  
    241239    $command   .= " -magic_id $magic_id";
    242240    $command   .= " -node $node";
    243     $command   .= " -uri $outroot";
     241    $command   .= " -path_base $outroot";
    244242    $command   .= " -dbname $dbname" if defined $dbname;
    245243
    … …  
    307305sub cat_list_to_list   {
    308306    my $out = shift;        # output file handle
    309     my $uri = shift;        # uri to append ...
     307    my $path_base = shift;  # path_base to append ...
    310308    my $extension = shift;  # ... the extension to
    311309
    312     my $filename = "$uri.$extension";
     310    my $filename = "$path_base.$extension";
    313311
    314312    my $in;
    … …  
    319317}
    320318
    321 sub resolve_inputs {
    322 
     319sub resolve_inputs
     320{
    323321    my $node = shift;
    324     my $input_base = $node->{path_base};
    325 
    326     my $image = $ipprc->file_resolve($ipprc->filename("PPSUB.OUTPUT", $input_base));
    327     my $mask = $ipprc->file_resolve($ipprc->filename("PPSUB.OUTPUT.MASK", $input_base));
    328     my $weight= $ipprc->file_resolve($ipprc->filename("PPSUB.OUTPUT.VARIANCE", $input_base));
    329 
    330     return ($image, $mask, $weight);
     322    my $input_base = $node->{diff_path_base};
     323
     324    my ($image, $mask, $variance); # Names to return
     325    if ($node->{inverse}) {
     326        $image = "PPSUB.INVERSE";
     327        $mask = "PPSUB.INVERSE.MASK";
     328        $variance = "PPSUB.INVERSE.VARIANCE";
     329    } else {
     330        $image = "PPSUB.OUTPUT";
     331        $mask = "PPSUB.OUTPUT.MASK";
     332        $variance = "PPSUB.OUTPUT.VARIANCE";
     333    }
     334
     335    $image = $ipprc->file_resolve($ipprc->filename($image, $input_base));
     336    $mask = $ipprc->file_resolve($ipprc->filename($mask, $input_base));
     337    $variance= $ipprc->file_resolve($ipprc->filename($variance, $input_base));
     338
     339    return ($image, $mask, $variance);
     340}
     341
     342sub resolve_template
     343{
     344    my $node = shift;
     345
     346    my $image;                  # Name of template to return
     347    my $path_base;              # Base name for name
     348    if (defined $node->{warp_path_base} and $node->{warp_path_base} ne "NULL") {
     349        $path_base = $node->{warp_path_base};
     350        $image = "PSWARP.OUTPUT";
     351    } elsif (defined $node->{stack_path_base} and $node->{stack_path_base} ne "NULL") {
     352        $path_base = $node->{stack_path_base};
     353        $image = "PPSTACK.OUTPUT";
     354    } else {
     355        return undef;
     356    }
     357
     358    $image = $ipprc->file_resolve($ipprc->filename($image, $path_base));
     359
     360    return $image
    331361}
    332362

  • branches/pap_magic/ippTasks/magic.pro

    r24098 r24149  
    280280    book getword magicToProcess $pageName camera -var CAMERA
    281281    book getword magicToProcess $pageName workdir -var WORKDIR_TEMPLATE
    282     book getword magicToProcess $pageName template_uri -var TEMPLATE_URI
    283282    book getword magicToProcess $pageName dbname -var DBNAME
    284283
    … …  
    302301    mkdir $outpath
    303302
    304     $run = magic_process.pl --magic_id $MAGIC_ID --camera $CAMERA --node $NODE --outroot $outroot --template_uri $TEMPLATE_URI --logfile $logfile
     303    $run = magic_process.pl --magic_id $MAGIC_ID --camera $CAMERA --node $NODE --outroot $outroot --logfile $logfile
    305304    add_standard_args run
    306305

  • branches/pap_magic/ippTools/share/magictool_inputs.sql

    r23886 r24149  
    1 SELECT *
    2 FROM (
    3 -- Single skycells
     1-- Get input details for a magic node
    42SELECT
    53    magicRun.magic_id,
    6     magicRun.state,
    7     magicInputSkyfile.node,
    8     diffSkyfile.diff_id,
    9     diffSkyfile.uri,
    10     diffSkyfile.path_base,
    11     diffSkyfile.fault,
    12     diffSkyfile.quality
     4    magicRun.inverse, -- Using the inverse subtraction?
     5    magicRun.diff_id,
     6    magicInputs.node,
     7    -- Only one of diff_path_base and magic_path_base should be non-NULL
     8    -- If diff_path_base is non-NULL, then only one of warp_path_base and stack_path_base should be non-NULL
     9    magicInputs.diff_path_base, -- path_base for the diff (if any)
     10    magicInputs.warp_path_base, -- path_base for the template warp (if any)
     11    magicInputs.stack_path_base, -- path_base for the template stack (if any)
     12    magicInputs.magic_path_base -- path_base for child nodes (if any)
    1313FROM magicRun
    14 JOIN magicInputSkyfile
    15 USING(magic_id)
    16 JOIN diffSkyfile
    17     ON magicInputSkyfile.diff_id = diffSkyfile.diff_id
    18     AND magicInputSkyfile.node = diffSkyfile.skycell_id
    19 UNION
    20 -- Merged skycells
    21 SELECT
    22     magicRun.magic_id,
    23     magicRun.state,
    24     magicTree.node,
    25     0,   -- no diff_id
    26     magicNodeResult.uri,
    27     NULL, -- magicNodeResult doesn't have a path_base
    28     magicNodeResult.fault,
    29     0 as quality
    30 FROM magicTree
    31 JOIN magicRun
    32     USING(magic_id)
    33 JOIN magicNodeResult
    34     ON magicTree.magic_id = magicNodeResult.magic_id
    35     AND magicTree.dep = magicNodeResult.node
    36 ) as Foo
    37 WHERE
    38     fault = 0
    39     AND quality = 0
     14JOIN (
     15    -- Single skycells: have uri=NULL
     16    SELECT
     17        magic_id,
     18        magicRun.diff_id,
     19        skycell_id AS node,
     20        diffSkyfile.path_base AS diff_path_base,
     21        warpSkyfile.path_base AS warp_path_base,
     22        stackSumSkyfile.path_base AS stack_path_base,
     23        NULL AS magic_path_base
     24    FROM magicRun
     25    JOIN magicTree USING(magic_id)
     26    JOIN magicInputSkyfile USING(magic_id, node)
     27    JOIN diffRun USING(diff_id)
     28    JOIN diffSkyfile
     29        ON diffSkyfile.diff_id = magicRun.diff_id
     30        AND diffSkyfile.skycell_id = magicInputSkyfile.node
     31    JOIN magicNodeResult USING(magic_id, node)
     32    JOIN (
     33        -- Template for non-inverse
     34        SELECT
     35            magic_id,
     36            skycell_id,
     37            warp1 AS warp_id,
     38            stack1 AS stack_id
     39        FROM magicRun
     40        JOIN diffInputSkyfile USING(diff_id)
     41        WHERE magicRun.inverse = 0
     42            -- WHERE hook (magicRun.magic_id, diffInputSkyfile.skycell_id) %s
     43        UNION
     44        -- Template for inverse
     45        SELECT
     46            magic_id,
     47            skycell_id,
     48            warp2 AS warp_id,
     49            stack2 AS stack_id
     50        FROM magicRun
     51        JOIN diffInputSkyfile USING(diff_id)
     52        WHERE magicRun.inverse = 1
     53            -- WHERE hook (magicRun.magic_id, diffInputSkyfile.skycell_id) %s
     54        ) AS diffTemplates USING(magic_id, skycell_id)
     55    LEFT JOIN warpSkyfile USING(warp_id, skycell_id)
     56    LEFT JOIN stackSumSkyfile USING(stack_id)
     57    -- WHERE hook (magicRun.magic_id, magicTree.node) %s
     58    UNION
     59    -- Merged skycells: have diff_id=0, various_path_base=NULL
     60    SELECT
     61        magicTree.magic_id,
     62        0 AS diff_id,
     63        magicTree.dep,
     64        NULL AS diff_path_base,
     65        NULL AS warp_path_base,
     66        NULL AS stack_path_base,
     67        magicNodeResult.path_base
     68    FROM magicTree
     69    JOIN magicRun USING(magic_id)
     70    JOIN magicNodeResult
     71        ON magicTree.magic_id = magicNodeResult.magic_id
     72        AND magicTree.dep = magicNodeResult.node
     73    -- WHERE hook (magicRun.magic_id, magicTree.node) %s
     74    ) AS magicInputs USING(magic_id)

  • branches/pap_magic/ippTools/share/magictool_inputskyfile.sql

    r23389 r24149  
    11SELECT
    22    magicInputSkyfile.*,
    3     diffSkyfile.uri
     3    magicRun.inverse,
     4    diffSkyfile.path_base
    45FROM magicRun
    5 JOIN magicInputSkyfile
    6     USING(magic_id)
     6JOIN magicInputSkyfile USING(magic_id)
    77JOIN diffSkyfile
    88    ON magicInputSkyfile.diff_id = diffSkyfile.diff_id

  • branches/pap_magic/ippTools/share/magictool_toprocess_inputs.sql

    r23971 r24149  
    1 SELECT * FROM
    2 (SELECT
     1SELECT
    32    magicTree.*,
     3    magicRun.workdir,
    44    rawExp.exp_id,
    55    rawExp.camera,
    6 --    diffSkyfile.path_base,
    7     magicRun.workdir,
    86    -- convert magic_id into a boolean value (1 or 0)
    97    -- note that the type stays a 64 bit int
    10     magicNodeResult.magic_id IS TRUE as done,
    11     magicNodeResult.fault IS TRUE as bad,
    12     warpSkyfile.uri as template_uri
     8    magicNodeResult.magic_id IS TRUE AS done,
     9    magicNodeResult.fault IS TRUE AS bad
    1310FROM magicTree
    1411JOIN magicRun USING(magic_id)
    15 JOIN magicInputSkyfile USING(magic_id, node)
    16 JOIN diffSkyfile
    17     ON magicInputSkyfile.diff_id = diffSkyfile.diff_id
    18     AND magicInputSkyfile.node = diffSkyfile.skycell_id
    19 JOIN diffInputSkyfile
    20     ON diffSkyfile.diff_id = diffInputSkyfile.diff_id
    21     AND diffSkyfile.skycell_id = diffInputSkyfile.skycell_id
    22 JOIN warpSkyfile
    23     ON diffInputSkyfile.warp2 = warpSkyfile.warp_id
    24     AND diffInputSkyfile.skycell_id = warpSkyfile.skycell_id
    2512JOIN rawExp USING(exp_id)
    2613LEFT JOIN magicNodeResult
    … …  
    3118    AND magicNodeResult.magic_id IS NULL
    3219    AND magicNodeResult.node IS NULL
    33     -- where hook 1 %s
    34 UNION
    35 SELECT
    36     magicTree.*,
    37     rawExp.exp_id,
    38     rawExp.camera,
    39 --    diffSkyfile.path_base,
    40     magicRun.workdir,
    41     -- convert magic_id into a boolean value (1 or 0)
    42     -- note that the type stays a 64 bit int
    43     magicNodeResult.magic_id IS TRUE as done,
    44     magicNodeResult.fault IS TRUE as bad,
    45     stackSumSkyfile.uri as template_uri
    46 FROM magicTree
    47 JOIN magicRun USING(magic_id)
    48 JOIN magicInputSkyfile USING(magic_id, node)
    49 JOIN diffSkyfile
    50     ON magicInputSkyfile.diff_id = diffSkyfile.diff_id
    51     AND magicInputSkyfile.node = diffSkyfile.skycell_id
    52 JOIN diffInputSkyfile
    53     ON diffSkyfile.diff_id = diffInputSkyfile.diff_id
    54     AND diffSkyfile.skycell_id = diffInputSkyfile.skycell_id
    55 JOIN stackSumSkyfile
    56     ON diffInputSkyfile.stack2 = stackSumSkyfile.stack_id
    57 JOIN rawExp USING(exp_id)
    58 LEFT JOIN magicNodeResult
    59     ON magicTree.magic_id = magicNodeResult.magic_id
    60     AND magicTree.node = magicNodeResult.node
    61 WHERE
    62     magicRun.state = 'new'
    63     AND magicNodeResult.magic_id IS NULL
    64     AND magicNodeResult.node IS NULL
    65     -- where hook 2 %s
    66 ) as foo
     20-- WHERE hook %s

  • branches/pap_magic/ippTools/share/magictool_toprocess_tree.sql

    r23971 r24149  
    11SELECT
    22    magicTree.*,
    3     exp_id,
    4     camera,
    53    magicRun.workdir,
     4    rawExp.exp_id,
     5    rawExp.camera,
    66    -- convert magic_id into a boolean value (1 or 0)
    77    -- note that the type stays a 64 bit int
    8     magicNodeResult.magic_id IS TRUE as done,
    9     magicNodeResult.fault IS TRUE as bad,
    10     'notused' as template_uri
     8    magicNodeResult.magic_id IS TRUE AS done,
     9    magicNodeResult.fault IS TRUE AS bad,
    1110FROM magicTree
    1211JOIN magicRun USING(magic_id)
    … …  
    1716WHERE
    1817    magicRun.state = 'new'
    19     -- where hook %s
     18-- WHERE hook %s
    2019ORDER BY
    2120    magicRun.magic_id

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

    r24136 r24149  
    972972        diff_id BIGINT,
    973973        skycell_id VARCHAR(64),
    974         uri VARCHAR(255),
    975974        path_base VARCHAR(255),
    976975        data_state VARCHAR(64),
    … …  
    10501049        magic_id BIGINT,
    10511050        node VARCHAR(64),
    1052         uri VARCHAR(255),
     1051        path_base VARCHAR(255),
    10531052        fault SMALLINT,
    10541053        PRIMARY KEY(magic_id, node),

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

    r24135 r24149  
    489489    PXOPT_LOOKUP_S16(fault, config->args, "-fault", false, false);
    490490    PXOPT_LOOKUP_S16(quality, config->args, "-quality", false, false);
    491     PXOPT_LOOKUP_STR(uri, config->args, "-uri", (fault == 0), false);
    492491    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", (fault == 0), false);
    493492
    … …  
    523522                           diff_id,
    524523                           skycell_id,
    525                            uri,
    526524                           path_base,
    527525                           "full",

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

    r24135 r24149  
    9292    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-fault",  0,            "set fault code", 0);
    9393    psMetadataAddS16(adddiffskyfileArgs, PS_LIST_TAIL, "-quality",  0,            "set quality", 0);
    94     psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-uri", 0,            "define URI of file", 0);
    9594    psMetadataAddStr(adddiffskyfileArgs, PS_LIST_TAIL, "-path_base", 0,            "define base output location", 0);
    9695    psMetadataAddF64(adddiffskyfileArgs, PS_LIST_TAIL, "-bg",  0,            "define exposure background", NAN);

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

    r24136 r24149  
    131131    psMetadata *diffWhere = psMetadataAlloc(); // WHERE conditions for diffRuns
    132132    PXOPT_COPY_STR(config->args, diffWhere, "-diff_label", "diffRun.label", "==");
     133    PXOPT_COPY_S64(config->args, diffWhere, "-diff_id", "diff_id", "==");
    133134
    134135    psMetadata *queryWhere = psMetadataAlloc(); // WHERE conditions for everything else
    … …  
    391392    // required
    392393    PXOPT_LOOKUP_S64(magic_id, config->args, "-magic_id", true, false);
    393     PXOPT_LOOKUP_S64(diff_id, config->args, "-diff_id", true, false);
    394394    PXOPT_LOOKUP_STR(node, config->args, "-node", true, false);
    395395
    … …  
    397397            config->dbh,
    398398            magic_id,
    399             diff_id,
    400399            node
    401400    );
    … …  
    612611    PS_ASSERT_PTR_NON_NULL(config, false);
    613612
    614     psMetadata *where = psMetadataAlloc();
    615     PXOPT_COPY_S64(config->args, where, "-magic_id", "magic_id", "==");
    616     PXOPT_COPY_STR(config->args, where, "-node", "node", "==");
     613    // Regrettably, there are multiple WHERE hooks which call the same things different names
     614    psMetadata *templatesWhere = psMetadataAlloc(); // WHERE for selecting template
     615    psMetadata *magicWhere = psMetadataAlloc();     // WHERE for selecting magic runs
     616    psMetadata *finalWhere = psMetadataAlloc();     // WHERE at end
     617
     618    PXOPT_COPY_S64(config->args, templatesWhere, "-magic_id", "magicRun.magic_id", "==");
     619    PXOPT_COPY_STR(config->args, templatesWhere, "-node", "diffInputSkyfile.skycell_id", "==");
     620
     621    PXOPT_COPY_S64(config->args, magicWhere, "-magic_id", "magicRun.magic_id", "==");
     622    PXOPT_COPY_STR(config->args, magicWhere, "-node", "magicTree.node", "==");
     623
     624    PXOPT_COPY_S64(config->args, finalWhere, "-magic_id", "magicRun.magic_id", "==");
     625    PXOPT_COPY_STR(config->args, finalWhere, "-node", "magicInputs.node", "==");
    617626
    618627    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    … …  
    625634    }
    626635
    627     if (psListLength(where->list)) {
    628         psString whereClause = psDBGenerateWhereConditionSQL(where, NULL);
    629         psStringAppend(&query, " AND %s", whereClause);
     636    psString templatesWhereStr = psStringCopy(""); // WHERE for selecting template
     637    psString magicWhereStr = psStringCopy("");     // WHERE for selecting magic runs
     638
     639    if (psListLength(templatesWhere->list)) {
     640        psString whereClause = psDBGenerateWhereConditionSQL(templatesWhere, NULL);
     641        psStringAppend(&templatesWhereStr, "\nAND %s", whereClause);
    630642        psFree(whereClause);
    631643    }
    632     psFree(where);
     644    psFree(templatesWhere);
     645
     646    if (psListLength(magicWhere->list)) {
     647        psString whereClause = psDBGenerateWhereConditionSQL(magicWhere, NULL);
     648        psStringAppend(&magicWhereStr, "\nWHERE %s", whereClause);
     649        psFree(whereClause);
     650    }
     651    psFree(magicWhere);
     652
     653    if (psListLength(finalWhere->list)) {
     654        psString whereClause = psDBGenerateWhereConditionSQL(finalWhere, NULL);
     655        psStringAppend(&query, "\nWHERE %s", whereClause);
     656        psFree(whereClause);
     657    }
     658    psFree(finalWhere);
    633659
    634660    // treat limit == 0 as "no limit"
    … …  
    639665    }
    640666
    641     if (!p_psDBRunQuery(config->dbh, query)) {
    642         psError(PS_ERR_UNKNOWN, false, "database error");
     667    if (!p_psDBRunQueryF(config->dbh, query,
     668                         templatesWhereStr, templatesWhereStr,
     669                         magicWhereStr, magicWhereStr)) {
     670        psError(PS_ERR_UNKNOWN, false, "database error");
     671        psFree(templatesWhereStr);
     672        psFree(magicWhereStr);
    643673        psFree(query);
    644674        return false;
    645675    }
     676    psFree(templatesWhereStr);
     677    psFree(magicWhereStr);
    646678    psFree(query);
    647679
    … …  
    964996
    965997    // optional
    966     PXOPT_LOOKUP_STR(uri, config->args, "-uri", false, false);
     998    PXOPT_LOOKUP_STR(path_base, config->args, "-path_base", false, false);
    967999
    9681000    // default values
    … …  
    9721004                               magic_id,
    9731005                               node,
    974                                uri,
     1006                               path_base,
    9751007                               fault
    9761008        )) {

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

    r24136 r24149  
    5353    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-dvodb",       0, "define dvodb", NULL);
    5454    psMetadataAddTime(definebyqueryArgs, PS_LIST_TAIL, "-registered", 0, "time detrend run was registered", now);
     55    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-diff_id", 0, "search diff_id", 0);
    5556    psMetadataAddS64(definebyqueryArgs, PS_LIST_TAIL, "-exp_id", 0, "search exp_id", 0);
    5657    psMetadataAddStr(definebyqueryArgs, PS_LIST_TAIL, "-diff_label", 0, "select diff label", NULL);
    … …  
    8081    psMetadata *addinputskyfileArgs = psMetadataAlloc();
    8182    psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    82     psMetadataAddS64(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0, "define difftool ID (required)", 0);
    8383    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    8484
    … …  
    127127    psMetadataAddS64(addresultArgs, PS_LIST_TAIL, "-magic_id", 0, "define magictool ID (required)", 0);
    128128    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node", 0, "define symbolic node name (required)", NULL);
    129     psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri", 0, "define URI", NULL);
     129    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-path_base", 0, "define path_base", NULL);
    130130    psMetadataAddS16(addresultArgs, PS_LIST_TAIL, "-fault", 0, "set fault code", 0);
    131131
Note: See TracChangeset for help on using the changeset viewer.