IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 18523


Ignore:
Timestamp:
Jul 14, 2008, 4:05:33 PM (18 years ago)
Author:
Paul Price
Message:

Adding magictool -totree

Location:
trunk/ippTools
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/share/Makefile.am

    r18366 r18523  
    6565        magictool_find_complete_warpruns.sql \
    6666        magictool_inputskyfile.sql \
     67        magictool_totree.sql \
    6768        magictool_tomask.sql \
    6869        magictool_toprocess_inputs.sql \

  • trunk/ippTools/src/magictool.c

    r18522 r18523  
    3636static bool addinputskyfileMode(pxConfig *config);
    3737static bool inputskyfileMode(pxConfig *config);
     38static bool totreeMode(pxConfig *config);
    3839static bool inputtreeMode(pxConfig *config);
    3940static bool toprocessMode(pxConfig *config);
    … …  
    6364
    6465    switch (config->mode) {
    65         MODECASE(MAGICTOOL_MODE_DEFINEBYQUERY,          definebyqueryMode);
     66        MODECASE(MAGICTOOL_MODE_DEFINEBYQUERY,  definebyqueryMode);
    6667        MODECASE(MAGICTOOL_MODE_DEFINERUN,      definerunMode);
    6768        MODECASE(MAGICTOOL_MODE_UPDATERUN,      updaterunMode);
    6869        MODECASE(MAGICTOOL_MODE_ADDINPUTSKYFILE,addinputskyfileMode);
    6970        MODECASE(MAGICTOOL_MODE_INPUTSKYFILE,   inputskyfileMode);
     71        MODECASE(MAGICTOOL_MODE_TOTREE,         totreeMode);
    7072        MODECASE(MAGICTOOL_MODE_INPUTTREE,      inputtreeMode);
    7173        MODECASE(MAGICTOOL_MODE_TOPROCESS,      toprocessMode);
    … …  
    411413
    412414
    413 static bool inputtreeMode(pxConfig *config)
    414 {
    415     PS_ASSERT_PTR_NON_NULL(config, false);
    416 
    417     // required
    418     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
    419     PXOPT_LOOKUP_STR(dep_file, config->args, "-dep_file", true, false);
    420 
    421     if (!parseAndInsertNodeDeps(config, (psS64)atoll(magic_id), dep_file)) {
    422         psError(PS_ERR_UNKNOWN, false, "failed to parse file");
    423         return false;
    424     }
    425 
    426     return true;
    427 }
    428 
    429 
    430 bool findBaseNodes(void *arg, pxNode *node)
    431 {
    432     bool status = false;
    433     psS64 done = psMetadataLookupS64(&status, node->data, "done");
    434     if (!status) {
    435         psAbort("failed to lookup value for done column");
    436     }
    437 
    438     if ((!pxNodeHasChildren(node)) && (!done)) {
    439         // if this node has no child and it's not 'done', then push it's data
    440         // onto the void *array
    441         psArrayAdd((psArray *)arg, 0, node->data);
    442         return false;
    443     }
    444 
    445     return true;
    446 }
    447 
    448 
    449 bool findReadyNodes(void *arg, pxNode *node)
    450 {
    451 
    452     if (pxNodeHasChildren(node)) {
    453         psListIterator *iter = psListIteratorAlloc(node->children, 0, false);
    454         psMetadata *work = psMetadataCopy(NULL, node->data);
    455         psMetadataRemoveKey(work, "dep");
    456         psMetadataRemoveKey(work, "done");
    457         psMetadataRemoveKey(work, "uri");
    458         pxNode *child = NULL;
    459         while ((child = psListGetAndIncrement(iter))) {
    460             psMetadata *data = child->data;
    461 
    462             bool status = false;
    463             psS32 done = psMetadataLookupS32(&status, data, "done");
    464             if (!status) {
    465                 psAbort("failed to lookup value for done column");
    466             }
    467 
    468             if (!done) {
    469                 // if a child isn't "done", give up on this node and continue
    470                 // to crawl the tree
    471                 psFree(iter);
    472                 psFree(work);
    473                 return true;
    474             }
    475 
    476             char *uri = psMetadataLookupStr(&status, data, "uri");
    477             if (!status) {
    478                 psAbort("failed to lookup value for uri column");
    479             }
    480 
    481             psMetadataAddStr(work, PS_LIST_TAIL, "uri", PS_META_DUPLICATE_OK, NULL, uri);
    482 
    483         }
    484         psFree(iter);
    485         // if all this nodes children are done, then push it's data onto the
    486         // void *array
    487         psArrayAdd((psArray *)arg, 0, work);
    488         psFree(work);
    489         return false;
    490     }
    491 
    492     return true;
    493 }
    494 
    495 
    496 static bool toprocessMode(pxConfig *config)
    497 {
    498     PS_ASSERT_PTR_NON_NULL(config, false);
    499 
    500     PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", false, false);
     415static bool totreeMode(pxConfig *config)
     416{
     417    PS_ASSERT_PTR_NON_NULL(config, false);
     418
     419    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    501420    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    502421
    503422    // look for "inputs" that need to processed
    504     psString query = pxDataGet("magictool_toprocess_inputs.sql");
     423    psString query = pxDataGet("magictool_totree.sql");
    505424    if (!query) {
    506425        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    … …  
    508427    }
    509428
    510     if (magic_id) {
    511         psMetadata *where = psMetadataAlloc();
    512         psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
    513         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    514         psFree(where);
    515         psStringAppend(&query, " %s", whereClause);
    516         psFree(whereClause);
     429    // treat limit == 0 as "no limit"
     430    if (limit) {
     431        psString limitString = psDBGenerateLimitSQL(limit);
     432        psStringAppend(&query, " %s", limitString);
     433        psFree(limitString);
    517434    }
    518435
    … …  
    540457    if (!psArrayLength(output)) {
    541458        psTrace("magictool", PS_LOG_INFO, "no rows found");
     459        psFree(output);
     460        return true;
     461    }
     462
     463    if (psArrayLength(output)) {
     464        // negative simple so the default is true
     465        if (!ippdbPrintMetadatas(stdout, output, "totree", !simple)) {
     466            psError(PS_ERR_UNKNOWN, false, "failed to print array");
     467            psFree(output);
     468            return false;
     469        }
     470    }
     471
     472    psFree(output);
     473
     474    return true;
     475}
     476
     477
     478static bool inputtreeMode(pxConfig *config)
     479{
     480    PS_ASSERT_PTR_NON_NULL(config, false);
     481
     482    // required
     483    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", true, false);
     484    PXOPT_LOOKUP_STR(dep_file, config->args, "-dep_file", true, false);
     485
     486    if (!parseAndInsertNodeDeps(config, (psS64)atoll(magic_id), dep_file)) {
     487        psError(PS_ERR_UNKNOWN, false, "failed to parse file");
     488        return false;
     489    }
     490
     491    return true;
     492}
     493
     494
     495bool findBaseNodes(void *arg, pxNode *node)
     496{
     497    bool status = false;
     498    psS64 done = psMetadataLookupS64(&status, node->data, "done");
     499    if (!status) {
     500        psAbort("failed to lookup value for done column");
     501    }
     502
     503    if ((!pxNodeHasChildren(node)) && (!done)) {
     504        // if this node has no child and it's not 'done', then push it's data
     505        // onto the void *array
     506        psArrayAdd((psArray *)arg, 0, node->data);
     507        return false;
     508    }
     509
     510    return true;
     511}
     512
     513
     514bool findReadyNodes(void *arg, pxNode *node)
     515{
     516
     517    if (pxNodeHasChildren(node)) {
     518        psListIterator *iter = psListIteratorAlloc(node->children, 0, false);
     519        psMetadata *work = psMetadataCopy(NULL, node->data);
     520        psMetadataRemoveKey(work, "dep");
     521        psMetadataRemoveKey(work, "done");
     522        psMetadataRemoveKey(work, "uri");
     523        pxNode *child = NULL;
     524        while ((child = psListGetAndIncrement(iter))) {
     525            psMetadata *data = child->data;
     526
     527            bool status = false;
     528            psS32 done = psMetadataLookupS32(&status, data, "done");
     529            if (!status) {
     530                psAbort("failed to lookup value for done column");
     531            }
     532
     533            if (!done) {
     534                // if a child isn't "done", give up on this node and continue
     535                // to crawl the tree
     536                psFree(iter);
     537                psFree(work);
     538                return true;
     539            }
     540
     541            char *uri = psMetadataLookupStr(&status, data, "uri");
     542            if (!status) {
     543                psAbort("failed to lookup value for uri column");
     544            }
     545
     546            psMetadataAddStr(work, PS_LIST_TAIL, "uri", PS_META_DUPLICATE_OK, NULL, uri);
     547
     548        }
     549        psFree(iter);
     550        // if all this nodes children are done, then push it's data onto the
     551        // void *array
     552        psArrayAdd((psArray *)arg, 0, work);
     553        psFree(work);
     554        return false;
     555    }
     556
     557    return true;
     558}
     559
     560
     561static bool toprocessMode(pxConfig *config)
     562{
     563    PS_ASSERT_PTR_NON_NULL(config, false);
     564
     565    PXOPT_LOOKUP_STR(magic_id, config->args, "-magic_id", false, false);
     566    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     567
     568    // look for "inputs" that need to processed
     569    psString query = pxDataGet("magictool_toprocess_inputs.sql");
     570    if (!query) {
     571        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     572        return false;
     573    }
     574
     575    if (magic_id) {
     576        psMetadata *where = psMetadataAlloc();
     577        psMetadataAddS64(where, PS_LIST_TAIL, "magic_id", 0, "==", (psS64)atoll(magic_id));
     578        psString whereClause = psDBGenerateWhereSQL(where, NULL);
     579        psFree(where);
     580        psStringAppend(&query, " %s", whereClause);
     581        psFree(whereClause);
     582    }
     583
     584    if (!p_psDBRunQuery(config->dbh, query)) {
     585        psError(PS_ERR_UNKNOWN, false, "database error");
     586        psFree(query);
     587        return false;
     588    }
     589    psFree(query);
     590
     591    psArray *output = p_psDBFetchResult(config->dbh);
     592    if (!output) {
     593        psErrorCode err = psErrorCodeLast();
     594        switch (err) {
     595            case PS_ERR_DB_CLIENT:
     596                psError(PXTOOLS_ERR_SYS, false, "database error");
     597            case PS_ERR_DB_SERVER:
     598                psError(PXTOOLS_ERR_PROG, false, "database error");
     599            default:
     600                psError(PXTOOLS_ERR_PROG, false, "unknown error");
     601        }
     602
     603        return false;
     604    }
     605    if (!psArrayLength(output)) {
     606        psTrace("magictool", PS_LOG_INFO, "no rows found");
    542607//        psFree(output);
    543608//        return true;

  • trunk/ippTools/src/magictool.h

    r18520 r18523  
    3030    MAGICTOOL_MODE_ADDINPUTSKYFILE,
    3131    MAGICTOOL_MODE_INPUTSKYFILE,
     32    MAGICTOOL_MODE_TOTREE,
    3233    MAGICTOOL_MODE_INPUTTREE,
    3334    MAGICTOOL_MODE_TOPROCESS,

  • trunk/ippTools/src/magictoolConfig.c

    r18521 r18523  
    9898            "use the simple output format", false);
    9999
     100    // -totree
     101    psMetadata *totreeArgs = psMetadataAlloc();
     102    psMetadataAddStr(totreeArgs, PS_LIST_TAIL, "-magic_id", 0, "search by magic ID", NULL);
     103    psMetadataAddU64(totreeArgs, PS_LIST_TAIL, "-limit", 0, "limit result set to N items", 0);
     104    psMetadataAddBool(totreeArgs, PS_LIST_TAIL, "-simple", 0, "use the simple output format", false);
     105
    100106    // -inputtree
    101107    psMetadata *inputtreeArgs = psMetadataAlloc();
    … …  
    144150    psMetadata *modes   = psMetadataAlloc();
    145151
    146     PXOPT_ADD_MODE("-definebyquery",           "", MAGICTOOL_MODE_DEFINEBYQUERY,           queueArgs);
     152    PXOPT_ADD_MODE("-definebyquery",   "", MAGICTOOL_MODE_DEFINEBYQUERY,   queueArgs);
    147153    PXOPT_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
    148154    PXOPT_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);
    149155    PXOPT_ADD_MODE("-addinputskyfile", "", MAGICTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    150156    PXOPT_ADD_MODE("-inputskyfile",    "", MAGICTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
     157    PXOPT_ADD_MODE("-totree",          "", MAGICTOOL_MODE_TOTREE,          totreeArgs);
    151158    PXOPT_ADD_MODE("-inputtree",       "", MAGICTOOL_MODE_INPUTTREE,       inputtreeArgs);
    152159    PXOPT_ADD_MODE("-toprocess",       "", MAGICTOOL_MODE_TOPROCESS,       toprocessArgs);
Note: See TracChangeset for help on using the changeset viewer.