IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 17, 2009, 12:08:50 PM (17 years ago)
Author:
beaumont
Message:

merged with head

Location:
branches/cnb_branches/cnb_branch_20090301
Files:
35 edited
3 copied

Legend:

Unmodified
Added
Removed

  • branches/cnb_branches/cnb_branch_20090301

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/camtool.c

    r21443 r23352  
    4444static bool pendingcleanupexpMode(pxConfig *config);
    4545static bool donecleanupMode(pxConfig *config);
     46static bool exportrunMode(pxConfig *config);
     47static bool importrunMode(pxConfig *config);
    4648
    4749# define MODECASE(caseName, func) \
    … …  
    7779        MODECASE(CAMTOOL_MODE_PENDINGCLEANUPEXP,    pendingcleanupexpMode);
    7880        MODECASE(CAMTOOL_MODE_DONECLEANUP,          donecleanupMode);
     81        MODECASE(CAMTOOL_MODE_EXPORTRUN,            exportrunMode);
     82        MODECASE(CAMTOOL_MODE_IMPORTRUN,            importrunMode);
    7983        default:
    8084            psAbort("invalid option (this should not happen)");
    … …  
    10811085    return true;
    10821086}
     1087
     1088bool exportrunMode(pxConfig *config)
     1089{
     1090  typedef struct ExportTable {
     1091    char tableName[80];
     1092    char sqlFilename[80];
     1093  } ExportTable;
     1094 
     1095  int numExportTables = 2;
     1096
     1097  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1098
     1099  PXOPT_LOOKUP_S64(det_id, config->args, "-cam_id", true,  false);
     1100  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1101  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1102
     1103  FILE *f = fopen (outfile, "w");
     1104  if (f == NULL) {
     1105    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1106    return false;
     1107  }
     1108
     1109  psMetadata *where = psMetadataAlloc();
     1110  PXOPT_COPY_S64(config->args, where, "-cam_id", "cam_id", "==");
     1111
     1112  ExportTable tables [] = {
     1113    {"camRun", "camtool_export_run.sql"},
     1114    {"camProcessedExp", "camtool_export_processed_exp.sql"},
     1115  };
     1116
     1117  for (int i=0; i < numExportTables; i++) {
     1118    psString query = pxDataGet(tables[i].sqlFilename);
     1119    if (!query) {
     1120      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1121      return false;
     1122    }
     1123
     1124    if (where && psListLength(where->list)) {
     1125      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1126      psStringAppend(&query, " %s", whereClause);
     1127      psFree(whereClause);
     1128    }
     1129
     1130    // treat limit == 0 as "no limit"
     1131    if (limit) {
     1132      psString limitString = psDBGenerateLimitSQL(limit);
     1133      psStringAppend(&query, " %s", limitString);
     1134      psFree(limitString);
     1135    }
     1136
     1137    if (!p_psDBRunQuery(config->dbh, query)) {
     1138      psError(PS_ERR_UNKNOWN, false, "database error");
     1139      psFree(query);
     1140      return false;
     1141    }
     1142    psFree(query);
     1143
     1144    psArray *output = p_psDBFetchResult(config->dbh);
     1145    if (!output) {
     1146      psError(PS_ERR_UNKNOWN, false, "database error");
     1147      return false;
     1148    }
     1149    if (!psArrayLength(output)) {
     1150      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1151      psFree(output);
     1152      return true;
     1153    }
     1154
     1155    // we must write the export table in non-simple (true) format
     1156    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1157      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1158      psFree(output);
     1159      return false;
     1160    }
     1161    psFree(output);
     1162  }
     1163
     1164  fclose (f);
     1165
     1166  return true;
     1167}
     1168
     1169bool importrunMode(pxConfig *config)
     1170{
     1171  unsigned int nFail;
     1172
     1173  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1174 
     1175  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1176
     1177  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1178
     1179  fprintf (stdout, "---- input ----\n");
     1180  psMetadataPrint (stderr, input, 1);
     1181
     1182  psMetadataItem *item = psMetadataLookup (input, "camRun");
     1183  psAssert (item, "entry not in input?");
     1184  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1185 
     1186  psMetadataItem *entry = psListGet (item->data.list, 0);
     1187  assert (entry);
     1188  assert (entry->type == PS_DATA_METADATA);
     1189  camRunRow *camRun = camRunObjectFromMetadata (entry->data.md);
     1190  camRunInsertObject (config->dbh, camRun);
     1191
     1192  // fprintf (stdout, "---- cam run ----\n");
     1193  // psMetadataPrint (stderr, entry->data.md, 1);
     1194 
     1195  item = psMetadataLookup (input, "camProcessedImfile");
     1196  psAssert (item, "entry not in input?");
     1197  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1198
     1199  for (int i = 0; i < item->data.list->n; i++) {
     1200    psMetadataItem *entry = psListGet (item->data.list, i);
     1201    assert (entry);
     1202    assert (entry->type == PS_DATA_METADATA);
     1203    camProcessedExpRow *camProcessedExp = camProcessedExpObjectFromMetadata (entry->data.md);
     1204    camProcessedExpInsertObject (config->dbh, camProcessedExp);
     1205
     1206    // fprintf (stdout, "---- row %d ----\n", i);
     1207    // psMetadataPrint (stderr, entry->data.md, 1);
     1208  }
     1209
     1210  return true;
     1211}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/camtool.h

    r19092 r23352  
    3939    CAMTOOL_MODE_PENDINGCLEANUPEXP,
    4040    CAMTOOL_MODE_DONECLEANUP,
     41    CAMTOOL_MODE_EXPORTRUN,
     42    CAMTOOL_MODE_IMPORTRUN
    4143} camtoolMode;
    4244

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/camtoolConfig.c

    r20276 r23352  
    228228    psMetadataAddU64(donecleanupArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    229229
     230    // -exportrun
     231    psMetadata *exportrunArgs = psMetadataAlloc();
     232    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-cam_id", 0,          "export this camera ID (required)", 0);
     233    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     234    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     235
     236    // -importrun
     237    psMetadata *importrunArgs = psMetadataAlloc();
     238    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     239
     240
    230241    psMetadata *argSets = psMetadataAlloc();
    231242    psMetadata *modes = psMetadataAlloc();
    … …  
    245256    PXOPT_ADD_MODE("-pendingcleanupexp",    "show exposures for cleanup runs",      CAMTOOL_MODE_PENDINGCLEANUPEXP, pendingcleanupexpArgs);
    246257    PXOPT_ADD_MODE("-donecleanup",          "show runs that have been cleaned",     CAMTOOL_MODE_DONECLEANUP,       donecleanupArgs);
     258   PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", CAMTOOL_MODE_EXPORTRUN, exportrunArgs);
     259    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           CAMTOOL_MODE_IMPORTRUN, importrunArgs);
    247260
    248261    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/chiptool.c

    r21521 r23352  
    4242static bool revertprocessedimfileMode(pxConfig *config);
    4343static bool updateprocessedimfileMode(pxConfig *config);
    44 static bool promoteexpMode(pxConfig *config);
     44static bool advanceexpMode(pxConfig *config);
    4545static bool blockMode(pxConfig *config);
    4646static bool maskedMode(pxConfig *config);
    … …  
    8181        MODECASE(CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,   revertprocessedimfileMode);
    8282        MODECASE(CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,   updateprocessedimfileMode);
    83         MODECASE(CHIPTOOL_MODE_PROMOTEEXP,              promoteexpMode);
     83        MODECASE(CHIPTOOL_MODE_ADVANCEEXP,              advanceexpMode);
    8484        MODECASE(CHIPTOOL_MODE_BLOCK,                   blockMode);
    8585        MODECASE(CHIPTOOL_MODE_MASKED,                  maskedMode);
    … …  
    239239    pxchipGetSearchArgs (config, where); // rawExp, chipRun
    240240    PXOPT_COPY_S64(config->args,  where, "-chip_id", "chipRun.chip_id", "==");
    241     PXOPT_COPY_STR(config->args,  where, "-label", "chipRun.label", "==");
     241    PXOPT_COPY_STR(config->args,  where, "-label",   "chipRun.label",   "==");
     242    PXOPT_COPY_STR(config->args,  where, "-state",   "chipRun.state",   "==");
    242243
    243244    if (!psListLength(where->list)
    … …  
    10781079
    10791080
    1080 static bool promoteexpMode(pxConfig *config)
     1081static bool advanceexpMode(pxConfig *config)
    10811082{
    10821083    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    12561257bool exportrunMode(pxConfig *config)
    12571258{
    1258     PS_ASSERT_PTR_NON_NULL(config, NULL);
    1259 
    1260     PXOPT_LOOKUP_S64(chip_id, config->args, "-chip_id", true,  false);
    1261     PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
    1262     PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
    1263 
    1264     FILE *f = fopen (outfile, "w");
    1265     if (f == NULL) {
    1266         psError(PS_ERR_UNKNOWN, false, "failed to open output file");
    1267         return false;
    1268     }
    1269 
    1270     psMetadata *where = psMetadataAlloc();
    1271     PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
    1272 
    1273     // *** extract the chipRun in this section ***
    1274     psString query = pxDataGet("chiptool_export_run.sql");
     1259  typedef struct ExportTable {
     1260    char tableName[80];
     1261    char sqlFilename[80];
     1262  } ExportTable;
     1263 
     1264  int numExportTables = 3;
     1265
     1266  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1267
     1268  PXOPT_LOOKUP_S64(det_id, config->args, "-chip_id", true,  false);
     1269  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1270  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1271
     1272  FILE *f = fopen (outfile, "w");
     1273  if (f == NULL) {
     1274    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1275    return false;
     1276  }
     1277
     1278  psMetadata *where = psMetadataAlloc();
     1279  PXOPT_COPY_S64(config->args, where, "-chip_id", "chip_id", "==");
     1280
     1281  ExportTable tables [] = {
     1282    {"chipRun", "chiptool_export_run.sql"},
     1283    {"chipImfile", "chiptool_export_imfile.sql"},
     1284    {"chipProcessedImfile", "chiptool_export_processed_imfile.sql"},
     1285  };
     1286
     1287
     1288  for (int i=0; i < numExportTables; i++) {
     1289    psString query = pxDataGet(tables[i].sqlFilename);
    12751290    if (!query) {
    1276         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1277         return false;
     1291      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1292      return false;
    12781293    }
    12791294
    12801295    if (where && psListLength(where->list)) {
    1281         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1282         psStringAppend(&query, " %s", whereClause);
    1283         psFree(whereClause);
     1296      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1297      psStringAppend(&query, " %s", whereClause);
     1298      psFree(whereClause);
    12841299    }
    12851300
    12861301    // treat limit == 0 as "no limit"
    12871302    if (limit) {
    1288         psString limitString = psDBGenerateLimitSQL(limit);
    1289         psStringAppend(&query, " %s", limitString);
    1290         psFree(limitString);
     1303      psString limitString = psDBGenerateLimitSQL(limit);
     1304      psStringAppend(&query, " %s", limitString);
     1305      psFree(limitString);
    12911306    }
    12921307
    12931308    if (!p_psDBRunQuery(config->dbh, query)) {
    1294         psError(PS_ERR_UNKNOWN, false, "database error");
    1295         psFree(query);
    1296         return false;
     1309      psError(PS_ERR_UNKNOWN, false, "database error");
     1310      psFree(query);
     1311      return false;
    12971312    }
    12981313    psFree(query);
    … …  
    13001315    psArray *output = p_psDBFetchResult(config->dbh);
    13011316    if (!output) {
    1302         psError(PS_ERR_UNKNOWN, false, "database error");
    1303         return false;
     1317      psError(PS_ERR_UNKNOWN, false, "database error");
     1318      return false;
    13041319    }
    13051320    if (!psArrayLength(output)) {
    1306         psTrace("chiptool", PS_LOG_INFO, "no rows found");
    1307         psFree(output);
    1308         return true;
     1321      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1322      psFree(output);
     1323      return true;
    13091324    }
    13101325
    13111326    // we must write the export table in non-simple (true) format
    1312     if (!ippdbPrintMetadatas(f, output, "chipRun", true)) {
    1313         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1314         psFree(output);
    1315         return false;
     1327    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1328      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1329      psFree(output);
     1330      return false;
    13161331    }
    13171332    psFree(output);
    1318 
    1319     // *** extract the chipProcessedImfile entries in this section ***
    1320     query = pxDataGet("chiptool_export_imfiles.sql");
    1321     if (!query) {
    1322         psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
    1323         return false;
    1324     }
    1325 
    1326     if (where && psListLength(where->list)) {
    1327         psString whereClause = psDBGenerateWhereSQL(where, NULL);
    1328         psStringAppend(&query, " %s", whereClause);
    1329         psFree(whereClause);
    1330     }
    1331     psFree(where);
    1332 
    1333     // treat limit == 0 as "no limit"
    1334     if (limit) {
    1335         psString limitString = psDBGenerateLimitSQL(limit);
    1336         psStringAppend(&query, " %s", limitString);
    1337         psFree(limitString);
    1338     }
    1339 
    1340     if (!p_psDBRunQuery(config->dbh, query)) {
    1341         psError(PS_ERR_UNKNOWN, false, "database error");
    1342         psFree(query);
    1343         return false;
    1344     }
    1345     psFree(query);
    1346 
    1347     output = p_psDBFetchResult(config->dbh);
    1348     if (!output) {
    1349         psError(PS_ERR_UNKNOWN, false, "database error");
    1350         return false;
    1351     }
    1352     if (!psArrayLength(output)) {
    1353         psTrace("chiptool", PS_LOG_INFO, "no rows found");
    1354         psFree(output);
    1355         return true;
    1356     }
    1357 
    1358     // we must write the export table in non-simple (true) format
    1359     if (!ippdbPrintMetadatas(f, output, "chipProcessedImfiles", true)) {
    1360         psError(PS_ERR_UNKNOWN, false, "failed to print array");
    1361         psFree(output);
    1362         return false;
    1363     }
    1364     psFree(output);
    1365 
    1366     fclose (f);
    1367 
    1368     return true;
    1369 }
    1370 
     1333  }
     1334
     1335  fclose (f);
     1336
     1337  return true;
     1338}
    13711339
    13721340bool importrunMode(pxConfig *config)
    13731341{
    13741342  unsigned int nFail;
     1343 
     1344  int numImportTables = 2;
     1345 
     1346  char tables[2] [80] = {"chipImfile", "chipProcessedImfile"};
    13751347
    13761348  PS_ASSERT_PTR_NON_NULL(config, NULL);
    … …  
    13831355  psMetadataPrint (stderr, input, 1);
    13841356
    1385   psMetadataItem *chipRunItem = psMetadataLookup (input, "chipRun");
    1386   psAssert (chipRunItem, "entry not in input?");
    1387   psAssert (chipRunItem->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    1388  
    1389   psMetadataItem *chipRunEntry = psListGet (chipRunItem->data.list, 0);
    1390   assert (chipRunEntry);
    1391   assert (chipRunEntry->type == PS_DATA_METADATA);
    1392   chipRunRow *chipRun = chipRunObjectFromMetadata (chipRunEntry->data.md);
    1393   chipRunInsertObject (config->dbh, chipRun);
    1394 
    1395   // fprintf (stdout, "---- chip run ----\n");
    1396   // psMetadataPrint (stderr, chipRunEntry->data.md, 1);
    1397 
    1398   psMetadataItem *item = psMetadataLookup (input, "chipProcessedImfiles");
     1357  psMetadataItem *item = psMetadataLookup (input, "chipRun");
    13991358  psAssert (item, "entry not in input?");
    14001359  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
    14011360
    1402   // XXX would be better to use the iterator?
    1403   for (int i = 0; i < item->data.list->n; i++) {
    1404     psMetadataItem *entry = psListGet (item->data.list, i);
    1405     assert (entry);
    1406     assert (entry->type == PS_DATA_METADATA);
    1407     chipProcessedImfileRow *chipProcessedImfile = chipProcessedImfileObjectFromMetadata (entry->data.md);
    1408     chipProcessedImfileInsertObject (config->dbh, chipProcessedImfile);
    1409 
    1410     // fprintf (stdout, "---- row %d ----\n", i);
    1411     // psMetadataPrint (stderr, entry->data.md, 1);
     1361  psMetadataItem *entry = psListGet (item->data.list, 0);
     1362  assert (entry);
     1363  assert (entry->type == PS_DATA_METADATA);
     1364  chipRunRow *chipRun = chipRunObjectFromMetadata (entry->data.md);
     1365  chipRunInsertObject (config->dbh, chipRun);
     1366
     1367  // fprintf (stdout, "---- chip run ----\n");
     1368  // psMetadataPrint (stderr, entry->data.md, 1);
     1369 
     1370  for (int i = 0; i < numImportTables; i++) {
     1371    psMetadataItem *item = psMetadataLookup (input, tables[i]);
     1372    psAssert (item, "entry not in input?");
     1373    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1374 
     1375    switch (i) {
     1376      case 0:
     1377        for (int i = 0; i < item->data.list->n; i++) {
     1378          psMetadataItem *entry = psListGet (item->data.list, i);
     1379          assert (entry);
     1380          assert (entry->type == PS_DATA_METADATA);
     1381          chipImfileRow *chipImfile = chipImfileObjectFromMetadata (entry->data.md);
     1382          chipImfileInsertObject (config->dbh, chipImfile);
     1383
     1384          // fprintf (stdout, "---- row %d ----\n", i);
     1385          // psMetadataPrint (stderr, entry->data.md, 1);
     1386        }
     1387        break;
     1388       
     1389      case 1:
     1390        for (int i = 0; i < item->data.list->n; i++) {
     1391          psMetadataItem *entry = psListGet (item->data.list, i);
     1392          assert (entry);
     1393          assert (entry->type == PS_DATA_METADATA);
     1394          chipProcessedImfileRow *chipProcessedImfile = chipProcessedImfileObjectFromMetadata (entry->data.md);
     1395          chipProcessedImfileInsertObject (config->dbh, chipProcessedImfile);
     1396
     1397          // fprintf (stdout, "---- row %d ----\n", i);
     1398          // psMetadataPrint (stderr, entry->data.md, 1);
     1399        }
     1400        break;
     1401    }
    14121402  }
    14131403

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/chiptool.h

    r21521 r23352  
    3232    CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,
    3333    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,
    34     CHIPTOOL_MODE_PROMOTEEXP,
     34    CHIPTOOL_MODE_ADVANCEEXP,
    3535    CHIPTOOL_MODE_BLOCK,
    3636    CHIPTOOL_MODE_MASKED,

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/chiptoolConfig.c

    r21521 r23352  
    6767    psMetadataAddS64(updaterunArgs, PS_LIST_TAIL, "-chip_id",              0,            "search by chip ID", 0);
    6868    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,            "set state", NULL);
     69    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,          "search by label", NULL);
    6970    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_state", 0,        "set state", NULL);
    7071    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-set_label", 0,        "set label", NULL);
    7172    psMetadataAddBool(updaterunArgs, PS_LIST_TAIL, "-all",  0,            "allow everything to be queued without search terms", false);
    72     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-label",  0,          "search by label", NULL);
    7373
    7474    // -pendingimfile
    … …  
    176176    psMetadataAddS16(updateprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,            "set fault code (required)", 0);
    177177
    178     // -promoteexp
    179     psMetadata *promoteexpArgs = psMetadataAlloc();
    180     psMetadataAddS64(promoteexpArgs, PS_LIST_TAIL, "-chip_id",  0,          "search by chip ID", 0);
    181     psMetadataAddStr(promoteexpArgs, PS_LIST_TAIL, "-label",  0,            "promote exposures for specified label", NULL);
    182     psMetadataAddU64(promoteexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
     178    // -advanceexp
     179    psMetadata *advanceexpArgs = psMetadataAlloc();
     180    psMetadataAddS64(advanceexpArgs, PS_LIST_TAIL, "-chip_id",  0,          "search by chip ID", 0);
     181    psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label",  0,            "advance exposures for specified label", NULL);
     182    psMetadataAddU64(advanceexpArgs, PS_LIST_TAIL, "-limit",  0,            "limit result set to N items", 0);
    183183
    184184    // -block
    … …  
    265265    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,updateprocessedimfileArgs);
    266266    PXOPT_ADD_MODE("-revertprocessedimfile","undo a processed imfile",              CHIPTOOL_MODE_REVERTPROCESSEDIMFILE,revertprocessedimfileArgs);
    267     PXOPT_ADD_MODE("-promoteexp",           "promote completed exposures",          CHIPTOOL_MODE_PROMOTEEXP,           promoteexpArgs);
     267    PXOPT_ADD_MODE("-advanceexp",           "advance completed exposures",          CHIPTOOL_MODE_ADVANCEEXP,           advanceexpArgs);
    268268    PXOPT_ADD_MODE("-block",                "set a label block",                    CHIPTOOL_MODE_BLOCK,                blockArgs);
    269269    PXOPT_ADD_MODE("-masked",               "show blocked labels",                  CHIPTOOL_MODE_MASKED,               maskedArgs);

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool.c

    r21402 r23352  
    2828static bool inputMode(pxConfig *config);
    2929static bool rawMode(pxConfig *config);
     30static bool exportrunMode(pxConfig *config);
     31static bool importrunMode(pxConfig *config);
    3032
    3133// run
    … …  
    4648    } \
    4749    break;
    48 
     50/*
     51typedef struct ExportTable {
     52    char tableName[80];
     53    char sqlFilename[80];
     54} ExportTable;
     55*/
    4956int main(int argc, char **argv)
    5057{
    … …  
    146153        MODECASE(DETTOOL_MODE_REGISTER_DETREND, register_detrendMode);
    147154        MODECASE(DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileMode);
     155        MODECASE(DETTOOL_MODE_EXPORTRUN,               exportrunMode);
     156        MODECASE(DETTOOL_MODE_IMPORTRUN,               importrunMode);
    148157        default:
    149158            psAbort("invalid option (this should not happen)");
    … …  
    578587      // generate a random-valued vector, return an index sorted by the random values
    579588      psVector *randomVector = psVectorAlloc(detrendExps->n, PS_TYPE_F32); // random values
    580       psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     589      /*
     590       * change due to PAP work on random number generator?
     591       * psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS, 0);
     592       */
     593      psRandom *rng = psRandomAlloc(PS_RANDOM_TAUS);
    581594      for (int i = 0; i < randomVector->n; i++) {
    582595        randomVector->data.F32[i] = psRandomUniform(rng);
    … …  
    19962009}
    19972010
     2011bool exportrunMode(pxConfig *config)
     2012{
     2013  typedef struct ExportTable {
     2014    char tableName[80];
     2015    char sqlFilename[80];
     2016  } ExportTable;
     2017 
     2018  int numExportTables = 12;
     2019
     2020  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2021
     2022  PXOPT_LOOKUP_S64(det_id, config->args, "-det_id", true,  false);
     2023  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     2024  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     2025
     2026  FILE *f = fopen (outfile, "w");
     2027  if (f == NULL) {
     2028    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     2029    return false;
     2030  }
     2031
     2032  psMetadata *where = psMetadataAlloc();
     2033  PXOPT_COPY_S64(config->args, where, "-det_id", "det_id", "==");
     2034
     2035  ExportTable tables [] = {
     2036    {"detInputExp", "dettool_export_input_exp.sql"},
     2037    {"detNormalizedExp", "dettool_export_normalized_exp.sql"},
     2038    {"detNormalizedImfile", "dettool_export_normalized_imfile.sql"},
     2039    {"detNormalizedStatImfile", "dettool_export_normalized_stat_imfile.sql"},
     2040    {"detProcessedExp", "dettool_export_processed_exp.sql"},
     2041    {"detProcessedImfile", "dettool_export_processed_imfile.sql"},
     2042    {"detRegisteredImfile", "dettool_export_registered_imfile.sql"},
     2043    {"detResidExp", "dettool_export_resid_exp.sql"},
     2044    {"detResidImfile", "dettool_export_resid_imfile.sql"},
     2045    {"detRun", "dettool_export_run.sql"},
     2046    {"detRunSummary", "dettool_export_run_summary.sql"},
     2047    {"detStackedImfile", "dettool_export_stacked_imfile.sql"},
     2048  };
     2049
     2050  for (int i=0; i < numExportTables; i++) {
     2051    psString query = pxDataGet(tables[i].sqlFilename);
     2052    if (!query) {
     2053      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     2054      return false;
     2055    }
     2056
     2057    if (where && psListLength(where->list)) {
     2058      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     2059      psStringAppend(&query, " %s", whereClause);
     2060      psFree(whereClause);
     2061    }
     2062
     2063    // treat limit == 0 as "no limit"
     2064    if (limit) {
     2065      psString limitString = psDBGenerateLimitSQL(limit);
     2066      psStringAppend(&query, " %s", limitString);
     2067      psFree(limitString);
     2068    }
     2069
     2070    if (!p_psDBRunQuery(config->dbh, query)) {
     2071      psError(PS_ERR_UNKNOWN, false, "database error");
     2072      psFree(query);
     2073      return false;
     2074    }
     2075    psFree(query);
     2076
     2077    psArray *output = p_psDBFetchResult(config->dbh);
     2078    if (!output) {
     2079      psError(PS_ERR_UNKNOWN, false, "database error");
     2080      return false;
     2081    }
     2082    if (!psArrayLength(output)) {
     2083      psTrace("chiptool", PS_LOG_INFO, "no rows found");
     2084      psFree(output);
     2085      return true;
     2086    }
     2087
     2088    // we must write the export table in non-simple (true) format
     2089    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     2090      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     2091      psFree(output);
     2092      return false;
     2093    }
     2094    psFree(output);
     2095 
     2096  }
     2097
     2098  fclose (f);
     2099
     2100  return true;
     2101}
     2102
     2103bool importrunMode(pxConfig *config)
     2104{
     2105  unsigned int nFail;
     2106 
     2107  int numImportTables = 11;
     2108 
     2109  char tables[11] [80] = {"detInputExp", "detNormalizedExp",
     2110    "detNormalizedStatImfile", "detProcessedExp", "detProcessedImfile",
     2111    "detRegisteredImfile", "detResidExp", "detResidImfile",
     2112    "detNormalizedImfile", "detRunSummary", "detStackedImfile"};
     2113
     2114  PS_ASSERT_PTR_NON_NULL(config, NULL);
     2115 
     2116  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     2117
     2118  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     2119
     2120  fprintf (stdout, "---- input ----\n");
     2121  psMetadataPrint (stderr, input, 1);
     2122 
     2123  psMetadataItem *item = psMetadataLookup (input, "detRun");
     2124  psAssert (item, "entry not in input?");
     2125  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     2126
     2127  psMetadataItem *entry = psListGet (item->data.list, 0);
     2128  assert (entry);
     2129  assert (entry->type == PS_DATA_METADATA);
     2130  detRunRow *detRun = detRunObjectFromMetadata (entry->data.md);
     2131  detRunInsertObject (config->dbh, detRun);
     2132 
     2133  // fprintf (stdout, "---- det run ----\n");
     2134  // psMetadataPrint (stderr, entry->data.md, 1);
     2135
     2136  for (int i = 0; i < numImportTables; i++) {
     2137    item = psMetadataLookup (input, tables[i]);
     2138    psAssert (item, "entry not in input?");
     2139    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     2140 
     2141    switch (i) {
     2142      case 0:
     2143        for (int i = 0; i < item->data.list->n; i++) {
     2144          entry = psListGet (item->data.list, i);
     2145          assert (entry);
     2146          assert (entry->type == PS_DATA_METADATA);
     2147          detInputExpRow *detInputExp = detInputExpObjectFromMetadata (entry->data.md);
     2148          detInputExpInsertObject (config->dbh, detInputExp);
     2149
     2150          // fprintf (stdout, "---- row %d ----\n", i);
     2151          // psMetadataPrint (stderr, entry->data.md, 1);
     2152        }
     2153        break;
     2154 
     2155      case 1:
     2156        for (int i = 0; i < item->data.list->n; i++) {
     2157          entry = psListGet (item->data.list, i);
     2158          assert (entry);
     2159          assert (entry->type == PS_DATA_METADATA);
     2160          detNormalizedExpRow *detNormalizedExp = detNormalizedExpObjectFromMetadata (entry->data.md);
     2161          detNormalizedExpInsertObject (config->dbh, detNormalizedExp);
     2162
     2163          // fprintf (stdout, "---- row %d ----\n", i);
     2164          // psMetadataPrint (stderr, entry->data.md, 1);
     2165        }
     2166        break;
     2167       
     2168      case 2:
     2169        for (int i = 0; i < item->data.list->n; i++) {
     2170          entry = psListGet (item->data.list, i);
     2171          assert (entry);
     2172          assert (entry->type == PS_DATA_METADATA);
     2173          detNormalizedStatImfileRow *detNormalizedStatImfile = detNormalizedStatImfileObjectFromMetadata (entry->data.md);
     2174          detNormalizedStatImfileInsertObject (config->dbh, detNormalizedStatImfile);
     2175
     2176          // fprintf (stdout, "---- row %d ----\n", i);
     2177          // psMetadataPrint (stderr, entry->data.md, 1);
     2178        }
     2179        break;
     2180 
     2181      case 3:
     2182        for (int i = 0; i < item->data.list->n; i++) {
     2183          entry = psListGet (item->data.list, i);
     2184          assert (entry);
     2185          assert (entry->type == PS_DATA_METADATA);
     2186          detProcessedExpRow *detProcessedExp =  detProcessedExpObjectFromMetadata (entry->data.md);
     2187          detProcessedExpInsertObject (config->dbh, detProcessedExp);
     2188
     2189          // fprintf (stdout, "---- row %d ----\n", i);
     2190          // psMetadataPrint (stderr, entry->data.md, 1);
     2191        }
     2192        break;
     2193       
     2194      case 4:
     2195        for (int i = 0; i < item->data.list->n; i++) {
     2196          entry = psListGet (item->data.list, i);
     2197          assert (entry);
     2198          assert (entry->type == PS_DATA_METADATA);
     2199          detProcessedImfileRow *detProcessedImfile =  detProcessedImfileObjectFromMetadata (entry->data.md);
     2200          detProcessedImfileInsertObject (config->dbh, detProcessedImfile);
     2201
     2202          // fprintf (stdout, "---- row %d ----\n", i);
     2203          // psMetadataPrint (stderr, entry->data.md, 1);
     2204        }
     2205        break;
     2206       
     2207      case 5:
     2208        for (int i = 0; i < item->data.list->n; i++) {
     2209          entry = psListGet (item->data.list, i);
     2210          assert (entry);
     2211          assert (entry->type == PS_DATA_METADATA);
     2212          detRegisteredImfileRow *detRegisteredImfile = detRegisteredImfileObjectFromMetadata (entry->data.md);
     2213          detRegisteredImfileInsertObject (config->dbh, detRegisteredImfile);
     2214
     2215          // fprintf (stdout, "---- row %d ----\n", i);
     2216          // psMetadataPrint (stderr, entry->data.md, 1);
     2217        }
     2218        break;
     2219       
     2220      case 6:
     2221        for (int i = 0; i < item->data.list->n; i++) {
     2222          entry = psListGet (item->data.list, i);
     2223          assert (entry);
     2224          assert (entry->type == PS_DATA_METADATA);
     2225          detResidExpRow *detResidExp = detResidExpObjectFromMetadata (entry->data.md);
     2226          detResidExpInsertObject (config->dbh, detResidExp);
     2227
     2228          // fprintf (stdout, "---- row %d ----\n", i);
     2229          // psMetadataPrint (stderr, entry->data.md, 1);
     2230        }
     2231        break;
     2232       
     2233      case 7:
     2234        for (int i = 0; i < item->data.list->n; i++) {
     2235          entry = psListGet (item->data.list, i);
     2236          assert (entry);
     2237          assert (entry->type == PS_DATA_METADATA);
     2238          detResidImfileRow *detResidImfile = detResidImfileObjectFromMetadata (entry->data.md);
     2239          detResidImfileInsertObject (config->dbh, detResidImfile);
     2240
     2241          // fprintf (stdout, "---- row %d ----\n", i);
     2242          // psMetadataPrint (stderr, entry->data.md, 1);
     2243        }
     2244        break;
     2245       
     2246      case 8:
     2247        for (int i = 0; i < item->data.list->n; i++) {
     2248          entry = psListGet (item->data.list, i);
     2249          assert (entry);
     2250          assert (entry->type == PS_DATA_METADATA);
     2251          detNormalizedImfileRow *detNormalizedImfile = detNormalizedImfileObjectFromMetadata (entry->data.md);
     2252          detNormalizedImfileInsertObject (config->dbh, detNormalizedImfile);
     2253
     2254          // fprintf (stdout, "---- row %d ----\n", i);
     2255          // psMetadataPrint (stderr, entry->data.md, 1);
     2256        }
     2257        break;
     2258       
     2259      case 9:
     2260        for (int i = 0; i < item->data.list->n; i++) {
     2261          entry = psListGet (item->data.list, i);
     2262          assert (entry);
     2263          assert (entry->type == PS_DATA_METADATA);
     2264          detRunSummaryRow *detRunSummary = detRunSummaryObjectFromMetadata (entry->data.md);
     2265          detRunSummaryInsertObject (config->dbh, detRunSummary);
     2266
     2267          // fprintf (stdout, "---- row %d ----\n", i);
     2268          // psMetadataPrint (stderr, entry->data.md, 1);
     2269        }
     2270        break;
     2271       
     2272      case 10:
     2273        for (int i = 0; i < item->data.list->n; i++) {
     2274          entry = psListGet (item->data.list, i);
     2275          assert (entry);
     2276          assert (entry->type == PS_DATA_METADATA);
     2277          detStackedImfileRow *detStackedImfile = detStackedImfileObjectFromMetadata (entry->data.md);
     2278          detStackedImfileInsertObject (config->dbh, detStackedImfile);
     2279
     2280          // fprintf (stdout, "---- row %d ----\n", i);
     2281          // psMetadataPrint (stderr, entry->data.md, 1);
     2282        }
     2283        break;
     2284    }
     2285  }
     2286
     2287  return true;
     2288}
     2289
    19982290#if 0
    19992291// XXX this function was left in commented as this method may be useful in the

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool.h

    r19814 r23352  
    114114    DETTOOL_MODE_RERUN,
    115115    DETTOOL_MODE_REGISTER_DETREND,
    116     DETTOOL_MODE_REGISTER_DETREND_IMFILE
     116    DETTOOL_MODE_REGISTER_DETREND_IMFILE,
     117
     118    DETTOOL_MODE_EXPORTRUN,
     119    DETTOOL_MODE_IMPORTRUN
    117120} dettoolMode;
    118121

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettoolConfig.c

    r20375 r23352  
    648648    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-faulted",  0,            "only return imfiles with a fault status set", false);
    649649    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-simple",  0,            "use the simple output format", false);
     650    psMetadataAddBool(residimfileArgs, PS_LIST_TAIL, "-included",  0,            "use only files included in ths detrun", false);
     651    // XXX is this option used?
    650652    psMetadataAddStr(residimfileArgs, PS_LIST_TAIL, "-select_state",  0,            "search for state", NULL);
    651653
    … …  
    855857    psMetadataAddStr(register_detrend_imfileArgs, PS_LIST_TAIL, "-path_base",  0,            "define base output location", NULL);
    856858
     859    // -exportrun
     860    psMetadata *exportrunArgs = psMetadataAlloc();
     861    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-det_id", 0,          "export this detrend ID (required)", 0);
     862    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     863    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     864
     865    // -importrun
     866    psMetadata *importrunArgs = psMetadataAlloc();
     867    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     868
     869
    857870    psFree(now);
    858871
    … …  
    947960    PXOPT_ADD_MODE("-register_detrend", "", DETTOOL_MODE_REGISTER_DETREND, register_detrendArgs);
    948961    PXOPT_ADD_MODE("-register_detrend_imfile", "", DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileArgs);
     962    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DETTOOL_MODE_EXPORTRUN, exportrunArgs);
     963    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DETTOOL_MODE_IMPORTRUN, importrunArgs);
    949964
    950965    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_processedimfile.c

    r19621 r23352  
    165165    PS_ASSERT_PTR_NON_NULL(config, false);
    166166
    167     bool hasWhere = false;
    168 
    169     PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
    170     PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
    171     PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    172     PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
    173 
    174167    psMetadata *where = psMetadataAlloc();
    175168    PXOPT_COPY_S64(config->args, where, "-det_id", "detProcessedImfile.det_id", "==");
    … …  
    179172    PXOPT_COPY_STR(config->args, where, "-select_mode", "detRun.mode", "==");
    180173
     174    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
     175    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     176
     177    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     178    PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
     179
    181180    psString query = pxDataGet("dettool_processedimfile.sql");
    182181    if (!query) {
    … …  
    186185    }
    187186
     187    bool hasWhere = false;
    188188    if (psListLength(where->list)) {
    189189        psString whereClause = psDBGenerateWhereSQL(where, NULL);
    … …  
    211211
    212212    if (faulted) {
     213        // list only faulted rows
    213214        psStringAppend(&query, " %s", " detProcessedImfile.fault != 0");
    214215    } else {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/dettool_residimfile.c

    r19632 r23352  
    159159    PXOPT_LOOKUP_U64(limit, config->args, "-limit", false, false);
    160160    PXOPT_LOOKUP_BOOL(simple, config->args, "-simple", false);
     161
    161162    PXOPT_LOOKUP_BOOL(faulted, config->args, "-faulted", false);
     163    PXOPT_LOOKUP_BOOL(included, config->args, "-included", false);
    162164
    163165    psString query = pxDataGet("dettool_residimfile.sql");
    … …  
    175177    }
    176178    psFree(where);
     179
     180    // restrict search to included imfiles
     181    if (included) {
     182        if (hasWhere) {
     183            psStringAppend(&query, " AND detInputExp.include = 1");
     184        } else {
     185            psStringAppend(&query, " WHERE detInputExp.include = 1");
     186        }
     187        hasWhere = true;
     188    }
    177189
    178190    if (hasWhere) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftool.c

    r21402 r23352  
    4545static bool donecleanupMode(pxConfig *config);
    4646static bool updatediffskyfileMode(pxConfig *config);
     47static bool exportrunMode(pxConfig *config);
     48static bool importrunMode(pxConfig *config);
    4749
    4850static bool setdiffRunState(pxConfig *config, psS64 diff_id, const char *state);
    … …  
    8183        MODECASE(DIFFTOOL_MODE_DONECLEANUP,           donecleanupMode);
    8284        MODECASE(DIFFTOOL_MODE_UPDATEDIFFSKYFILE,     updatediffskyfileMode);
     85        MODECASE(DIFFTOOL_MODE_EXPORTRUN,             exportrunMode);
     86        MODECASE(DIFFTOOL_MODE_IMPORTRUN,             importrunMode);
    8387        default:
    8488            psAbort("invalid option (this should not happen)");
    … …  
    14371441}
    14381442
     1443bool exportrunMode(pxConfig *config)
     1444{
     1445  typedef struct ExportTable {
     1446    char tableName[80];
     1447    char sqlFilename[80];
     1448  } ExportTable;
     1449 
     1450  int numExportFiles = 3;
     1451
     1452  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1453
     1454  PXOPT_LOOKUP_S64(det_id, config->args, "-diff_id", true,  false);
     1455  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1456  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1457
     1458  FILE *f = fopen (outfile, "w");
     1459  if (f == NULL) {
     1460    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1461    return false;
     1462  }
     1463
     1464  psMetadata *where = psMetadataAlloc();
     1465  PXOPT_COPY_S64(config->args, where, "-diff_id", "diff_id", "==");
     1466
     1467  ExportTable tables [] = {
     1468    {"diffRun", "difftool_export_run.sql"},
     1469    {"diffInputSkyfile", "difftool_export_input_skyfile.sql"},
     1470    {"diffSkyfile", "difftool_export_skyfile.sql"},
     1471  };
     1472
     1473  for (int i=0; i < numExportFiles; i++) {
     1474    psString query = pxDataGet(tables[i].sqlFilename);
     1475    if (!query) {
     1476      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1477      return false;
     1478    }
     1479
     1480    if (where && psListLength(where->list)) {
     1481      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1482      psStringAppend(&query, " %s", whereClause);
     1483      psFree(whereClause);
     1484    }
     1485
     1486    // treat limit == 0 as "no limit"
     1487    if (limit) {
     1488      psString limitString = psDBGenerateLimitSQL(limit);
     1489      psStringAppend(&query, " %s", limitString);
     1490      psFree(limitString);
     1491    }
     1492
     1493    if (!p_psDBRunQuery(config->dbh, query)) {
     1494      psError(PS_ERR_UNKNOWN, false, "database error");
     1495      psFree(query);
     1496      return false;
     1497    }
     1498    psFree(query);
     1499
     1500    psArray *output = p_psDBFetchResult(config->dbh);
     1501    if (!output) {
     1502      psError(PS_ERR_UNKNOWN, false, "database error");
     1503      return false;
     1504    }
     1505    if (!psArrayLength(output)) {
     1506      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1507      psFree(output);
     1508      return true;
     1509    }
     1510
     1511    // we must write the export table in non-simple (true) format
     1512    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1513      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1514      psFree(output);
     1515      return false;
     1516    }
     1517    psFree(output);
     1518  }
     1519
     1520  fclose (f);
     1521
     1522  return true;
     1523}
     1524
     1525bool importrunMode(pxConfig *config)
     1526{
     1527  unsigned int nFail;
     1528 
     1529  int numImportTables = 2;
     1530 
     1531  char tables[2] [80] = {"diffInputSkyfile", "diffSkyfile"};
     1532
     1533  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1534 
     1535  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1536
     1537  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1538
     1539  fprintf (stdout, "---- input ----\n");
     1540  psMetadataPrint (stderr, input, 1);
     1541
     1542  psMetadataItem *item = psMetadataLookup (input, "diffRun");
     1543  psAssert (item, "entry not in input?");
     1544  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1545
     1546  psMetadataItem *entry = psListGet (item->data.list, 0);
     1547  assert (entry);
     1548  assert (entry->type == PS_DATA_METADATA);
     1549  diffRunRow *diffRun = diffRunObjectFromMetadata (entry->data.md);
     1550  diffRunInsertObject (config->dbh, diffRun);
     1551
     1552  // fprintf (stdout, "---- diff run ----\n");
     1553  // psMetadataPrint (stderr, entry->data.md, 1);
     1554
     1555  for (int i = 0; i < numImportTables; i++) {
     1556    item = psMetadataLookup (input, tables[i]);
     1557    psAssert (item, "entry not in input?");
     1558    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1559 
     1560    switch (i) {
     1561      case 0:
     1562        for (int i = 0; i < item->data.list->n; i++) {
     1563          entry = psListGet (item->data.list, i);
     1564          assert (entry);
     1565          assert (entry->type == PS_DATA_METADATA);
     1566          diffInputSkyfileRow *diffInputSkyfile = diffInputSkyfileObjectFromMetadata (entry->data.md);
     1567          diffInputSkyfileInsertObject (config->dbh, diffInputSkyfile);
     1568
     1569          // fprintf (stdout, "---- row %d ----\n", i);
     1570          // psMetadataPrint (stderr, entry->data.md, 1);
     1571        }
     1572        break;
     1573       
     1574      case 1:
     1575        for (int i = 0; i < item->data.list->n; i++) {
     1576          entry = psListGet (item->data.list, i);
     1577          assert (entry);
     1578          assert (entry->type == PS_DATA_METADATA);
     1579          diffSkyfileRow *diffSkyfile = diffSkyfileObjectFromMetadata (entry->data.md);
     1580          diffSkyfileInsertObject (config->dbh, diffSkyfile);
     1581
     1582          // fprintf (stdout, "---- row %d ----\n", i);
     1583          // psMetadataPrint (stderr, entry->data.md, 1);
     1584        }
     1585        break;
     1586    }
     1587  }
     1588
     1589  return true;
     1590}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftool.h

    r19677 r23352  
    3939    DIFFTOOL_MODE_DONECLEANUP,
    4040    DIFFTOOL_MODE_UPDATEDIFFSKYFILE,
     41    DIFFTOOL_MODE_EXPORTRUN,
     42    DIFFTOOL_MODE_IMPORTRUN
    4143} difftoolMode;
    4244

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/difftoolConfig.c

    r21308 r23352  
    187187    psMetadataAddS16(updatediffskyfileArgs, PS_LIST_TAIL, "-code", 0,         "set fault code (required)", 0);
    188188
     189    // -exportrun
     190    psMetadata *exportrunArgs = psMetadataAlloc();
     191    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-diff_id", 0,          "export this diff ID (required)", 0);
     192    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     193    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     194
     195    // -importrun
     196    psMetadata *importrunArgs = psMetadataAlloc();
     197    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     198
     199
    189200
    190201    psFree(now);
    … …  
    207218    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     DIFFTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    208219    PXOPT_ADD_MODE("-updatediffskyfile",     "update fault code for a diffskyfile",  DIFFTOOL_MODE_UPDATEDIFFSKYFILE,          updatediffskyfileArgs);
     220    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", DIFFTOOL_MODE_EXPORTRUN, exportrunArgs);
     221    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           DIFFTOOL_MODE_IMPORTRUN, importrunArgs);
    209222
    210223    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/faketool.c

    r21463 r23352  
    4141static bool revertprocessedimfileMode(pxConfig *config);
    4242static bool updateprocessedimfileMode(pxConfig *config);
    43 static bool promoteexpMode(pxConfig *config);
     43static bool advanceexpMode(pxConfig *config);
    4444static bool blockMode(pxConfig *config);
    4545static bool maskedMode(pxConfig *config);
    … …  
    5252static bool tofullimfileMode(pxConfig *config);
    5353static bool topurgedimfileMode(pxConfig *config);
     54static bool exportrunMode(pxConfig *config);
     55static bool importrunMode(pxConfig *config);
    5456
    5557# define MODECASE(caseName, func) \
    … …  
    7880        MODECASE(FAKETOOL_MODE_REVERTPROCESSEDIMFILE,   revertprocessedimfileMode);
    7981        MODECASE(FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,   updateprocessedimfileMode);
    80         MODECASE(FAKETOOL_MODE_PROMOTEEXP,              promoteexpMode);
     82        MODECASE(FAKETOOL_MODE_ADVANCEEXP,              advanceexpMode);
    8183        MODECASE(FAKETOOL_MODE_BLOCK,                   blockMode);
    8284        MODECASE(FAKETOOL_MODE_MASKED,                  maskedMode);
    … …  
    8991        MODECASE(FAKETOOL_MODE_TOFULLIMFILE,            tofullimfileMode);
    9092        MODECASE(FAKETOOL_MODE_TOPURGEDIMFILE,          topurgedimfileMode);
     93        MODECASE(FAKETOOL_MODE_EXPORTRUN,               exportrunMode);
     94        MODECASE(FAKETOOL_MODE_IMPORTRUN,               importrunMode);
    9195
    9296        default:
    … …  
    10481052}
    10491053
    1050 static bool promoteexpMode(pxConfig *config)
     1054static bool advanceexpMode(pxConfig *config)
    10511055{
    10521056    PS_ASSERT_PTR_NON_NULL(config, false);
    … …  
    12251229    return change_imfile_data_state(config, "purged", "goto_purged");
    12261230}
     1231
     1232bool exportrunMode(pxConfig *config)
     1233{
     1234  typedef struct ExportTable {
     1235    char tableName[80];
     1236    char sqlFilename[80];
     1237  } ExportTable;
     1238
     1239  int numExportTables = 2;
     1240 
     1241  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1242
     1243  PXOPT_LOOKUP_S64(det_id, config->args, "-fake_id", true,  false);
     1244  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1245  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1246
     1247  FILE *f = fopen (outfile, "w");
     1248  if (f == NULL) {
     1249    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1250    return false;
     1251  }
     1252
     1253  psMetadata *where = psMetadataAlloc();
     1254  PXOPT_COPY_S64(config->args, where, "-fake_id", "fake_id", "==");
     1255
     1256  ExportTable tables [] = {
     1257    {"fakeRun", "faketool_export_run.sql"},
     1258    {"fakeProcessedImfile", "faketool_export_processed_imfile.sql"},
     1259  };
     1260
     1261  for (int i=0; i < numExportTables; i++) {
     1262    psString query = pxDataGet(tables[i].sqlFilename);
     1263    if (!query) {
     1264      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1265      return false;
     1266    }
     1267
     1268    if (where && psListLength(where->list)) {
     1269      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1270      psStringAppend(&query, " %s", whereClause);
     1271      psFree(whereClause);
     1272    }
     1273
     1274    // treat limit == 0 as "no limit"
     1275    if (limit) {
     1276      psString limitString = psDBGenerateLimitSQL(limit);
     1277      psStringAppend(&query, " %s", limitString);
     1278      psFree(limitString);
     1279    }
     1280
     1281    if (!p_psDBRunQuery(config->dbh, query)) {
     1282      psError(PS_ERR_UNKNOWN, false, "database error");
     1283      psFree(query);
     1284      return false;
     1285    }
     1286    psFree(query);
     1287
     1288    psArray *output = p_psDBFetchResult(config->dbh);
     1289    if (!output) {
     1290      psError(PS_ERR_UNKNOWN, false, "database error");
     1291      return false;
     1292    }
     1293    if (!psArrayLength(output)) {
     1294      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1295      psFree(output);
     1296      return true;
     1297    }
     1298
     1299    // we must write the export table in non-simple (true) format
     1300    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1301      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1302      psFree(output);
     1303      return false;
     1304    }
     1305    psFree(output);
     1306  }
     1307
     1308    fclose (f);
     1309
     1310    return true;
     1311}
     1312
     1313bool importrunMode(pxConfig *config)
     1314{
     1315  unsigned int nFail;
     1316
     1317  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1318 
     1319  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1320
     1321  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1322
     1323  fprintf (stdout, "---- input ----\n");
     1324  psMetadataPrint (stderr, input, 1);
     1325
     1326  psMetadataItem *item = psMetadataLookup (input, "fakeRun");
     1327  psAssert (item, "entry not in input?");
     1328  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1329
     1330  psMetadataItem *entry = psListGet (item->data.list, 0);
     1331  assert (entry);
     1332  assert (entry->type == PS_DATA_METADATA);
     1333  fakeRunRow *fakeRun = fakeRunObjectFromMetadata (entry->data.md);
     1334  fakeRunInsertObject (config->dbh, fakeRun);
     1335
     1336  // fprintf (stdout, "---- fake run ----\n");
     1337  // psMetadataPrint (stderr, entry->data.md, 1);
     1338
     1339  item = psMetadataLookup (input, "fakeProcessedImfile");
     1340  psAssert (item, "entry not in input?");
     1341  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1342
     1343  for (int i = 0; i < item->data.list->n; i++) {
     1344    psMetadataItem *entry = psListGet (item->data.list, i);
     1345    assert (entry);
     1346    assert (entry->type == PS_DATA_METADATA);
     1347    fakeProcessedImfileRow *fakeProcessedImfile = fakeProcessedImfileObjectFromMetadata (entry->data.md);
     1348    fakeProcessedImfileInsertObject (config->dbh, fakeProcessedImfile);
     1349
     1350    // fprintf (stdout, "---- row %d ----\n", i);
     1351    // psMetadataPrint (stderr, entry->data.md, 1);
     1352  }
     1353
     1354  return true;
     1355}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/faketool.h

    r21463 r23352  
    3333    FAKETOOL_MODE_REVERTPROCESSEDIMFILE,
    3434    FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,
    35     FAKETOOL_MODE_PROMOTEEXP,
     35    FAKETOOL_MODE_ADVANCEEXP,
    3636    FAKETOOL_MODE_BLOCK,
    3737    FAKETOOL_MODE_MASKED,
    … …  
    4545    FAKETOOL_MODE_TOFULLIMFILE,
    4646    FAKETOOL_MODE_TOPURGEDIMFILE,
     47    FAKETOOL_MODE_EXPORTRUN,
     48    FAKETOOL_MODE_IMPORTRUN
    4749} FAKETOOLMode;
    4850

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/faketoolConfig.c

    r21463 r23352  
    242242
    243243
    244     // -promoteexp
    245     psMetadata *promoteexpArgs = psMetadataAlloc();
    246     psMetadataAddS64(promoteexpArgs, PS_LIST_TAIL, "-fake_id", 0,      "search by fake ID", 0);
    247     psMetadataAddStr(promoteexpArgs, PS_LIST_TAIL, "-label",  0,       "search by label ", NULL);
    248     psMetadataAddU64(promoteexpArgs, PS_LIST_TAIL, "-limit",  0,       "limit exposures to promote to N items", 0);
     244    // -advanceexp
     245    psMetadata *advanceexpArgs = psMetadataAlloc();
     246    psMetadataAddS64(advanceexpArgs, PS_LIST_TAIL, "-fake_id", 0,      "search by fake ID", 0);
     247    psMetadataAddStr(advanceexpArgs, PS_LIST_TAIL, "-label",  0,       "search by label ", NULL);
     248    psMetadataAddU64(advanceexpArgs, PS_LIST_TAIL, "-limit",  0,       "limit exposures to advance to N items", 0);
    249249
    250250    // -block
    … …  
    301301    psMetadataAddStr(topurgedimfileArgs, PS_LIST_TAIL, "-class_id",  0,        "class ID to update", NULL);
    302302
     303    // -exportrun
     304    psMetadata *exportrunArgs = psMetadataAlloc();
     305    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-fake_id", 0,          "export this fake ID (required)", 0);
     306    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     307    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     308
     309    // -importrun
     310    psMetadata *importrunArgs = psMetadataAlloc();
     311    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     312
     313
    303314
    304315
    … …  
    314325    PXOPT_ADD_MODE("-updateprocessedimfile","change procesed imfile properties",     FAKETOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
    315326    PXOPT_ADD_MODE("-revertprocessedimfile", "undo a processed imfile",              FAKETOOL_MODE_REVERTPROCESSEDIMFILE,    revertprocessedimfileArgs);
    316     PXOPT_ADD_MODE("-promoteexp",            "promote completed exposoures",         FAKETOOL_MODE_PROMOTEEXP,          promoteexpArgs);
     327    PXOPT_ADD_MODE("-advanceexp",            "advance completed exposoures",         FAKETOOL_MODE_ADVANCEEXP,          advanceexpArgs);
    317328    PXOPT_ADD_MODE("-block",                 "set a label block",                    FAKETOOL_MODE_BLOCK,          blockArgs);
    318329    PXOPT_ADD_MODE("-masked",                "show blocked labels",                  FAKETOOL_MODE_MASKED,         maskedArgs);
    … …  
    325336    PXOPT_ADD_MODE("-tofullimfile",        "set imfile state to full",               FAKETOOL_MODE_TOFULLIMFILE,         tofullimfileArgs);
    326337    PXOPT_ADD_MODE("-topurgedimfile",      "set imfile state to purged",             FAKETOOL_MODE_TOPURGEDIMFILE,       topurgedimfileArgs);
     338    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", FAKETOOL_MODE_EXPORTRUN, exportrunArgs);
     339    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           FAKETOOL_MODE_IMPORTRUN, importrunArgs);
    327340
    328341

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/flatcorr.c

    r21402 r23352  
    4646static bool inputexpMode(pxConfig *config);
    4747static bool inputimfileMode(pxConfig *config);
     48static bool exportrunMode(pxConfig *config);
     49static bool importrunMode(pxConfig *config);
    4850
    4951static bool setflatcorrRunState(pxConfig *config, psS64 corr_id, const char *state);
    … …  
    7880        MODECASE(FLATCORR_MODE_INPUTEXP,       inputexpMode);
    7981        MODECASE(FLATCORR_MODE_INPUTIMFILE,    inputimfileMode);
     82        MODECASE(FLATCORR_MODE_EXPORTRUN,      exportrunMode);
     83        MODECASE(FLATCORR_MODE_IMPORTRUN,      importrunMode);
    8084        default:
    8185            psAbort("invalid option (this should not happen)");
    … …  
    734738    return true;
    735739}
     740
     741bool exportrunMode(pxConfig *config)
     742{
     743  typedef struct ExportTable {
     744    char tableName[80];
     745    char sqlFilename[80];
     746  } ExportTable;
     747 
     748  int numExportTables = 3;
     749
     750  PS_ASSERT_PTR_NON_NULL(config, NULL);
     751
     752  PXOPT_LOOKUP_S64(det_id, config->args, "-corr_id", true,  false);
     753  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     754  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     755
     756  FILE *f = fopen (outfile, "w");
     757  if (f == NULL) {
     758    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     759    return false;
     760  }
     761
     762  psMetadata *where = psMetadataAlloc();
     763  PXOPT_COPY_S64(config->args, where, "-coor_id", "corr_id", "==");
     764
     765  ExportTable tables [] = {
     766    {"flatcorrRun", "flatcorrtool_export_run.sql"},
     767    {"flatcorrCamLink", "flatcorrtool_export_cam_link.sql"},
     768    {"flatcorrChipLink", "flatcorr_export_chip_link.sql"},
     769  };
     770
     771  for (int i=0; i < numExportTables; i++) {
     772    psString query = pxDataGet(tables[i].sqlFilename);
     773    if (!query) {
     774      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     775      return false;
     776    }
     777
     778    if (where && psListLength(where->list)) {
     779      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     780      psStringAppend(&query, " %s", whereClause);
     781      psFree(whereClause);
     782    }
     783
     784    // treat limit == 0 as "no limit"
     785    if (limit) {
     786      psString limitString = psDBGenerateLimitSQL(limit);
     787      psStringAppend(&query, " %s", limitString);
     788      psFree(limitString);
     789    }
     790
     791    if (!p_psDBRunQuery(config->dbh, query)) {
     792      psError(PS_ERR_UNKNOWN, false, "database error");
     793      psFree(query);
     794      return false;
     795    }
     796    psFree(query);
     797
     798    psArray *output = p_psDBFetchResult(config->dbh);
     799    if (!output) {
     800      psError(PS_ERR_UNKNOWN, false, "database error");
     801      return false;
     802    }
     803    if (!psArrayLength(output)) {
     804      psTrace("regtool", PS_LOG_INFO, "no rows found");
     805      psFree(output);
     806      return true;
     807    }
     808
     809    // we must write the export table in non-simple (true) format
     810    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     811      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     812      psFree(output);
     813      return false;
     814    }
     815    psFree(output);
     816  }
     817
     818    fclose (f);
     819
     820    return true;
     821}
     822
     823bool importrunMode(pxConfig *config)
     824{
     825  unsigned int nFail;
     826  psMetadataItem *item, *entry;
     827 
     828  int numImportTables = 3;
     829 
     830  char tables[3] [80] = {"flatcorrRun", "flatcorrCamLink", "flatcorrChipLink"};
     831
     832  PS_ASSERT_PTR_NON_NULL(config, NULL);
     833 
     834  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     835
     836  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     837
     838  fprintf (stdout, "---- input ----\n");
     839  psMetadataPrint (stderr, input, 1);
     840
     841  for (int i = 0; i < numImportTables; i++) {
     842    item = psMetadataLookup (input, tables[i]);
     843    psAssert (item, "entry not in input?");
     844    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     845   
     846    entry = psListGet (item->data.list, 0);
     847    assert (entry);
     848    assert (entry->type == PS_DATA_METADATA);
     849 
     850    switch (i) {
     851      case 0:
     852      {
     853        flatcorrRunRow *flatcorrRun = flatcorrRunObjectFromMetadata (entry->data.md);
     854        flatcorrRunInsertObject (config->dbh, flatcorrRun);
     855
     856        // fprintf (stdout, "---- flatcorr run ----\n");
     857        // psMetadataPrint (stderr, entry->data.md, 1);
     858        break;
     859      }
     860      case 1:
     861      {
     862        flatcorrCamLinkRow *flatcorrCamLink = flatcorrCamLinkObjectFromMetadata (entry->data.md);
     863        flatcorrCamLinkInsertObject (config->dbh, flatcorrCamLink);
     864
     865        // fprintf (stdout, "---- flatcorr cam link ----\n");
     866        // psMetadataPrint (stderr, entry->data.md, 1);
     867        break;
     868      }
     869      case 2:
     870      {
     871        flatcorrChipLinkRow *flatcorrChipLink = flatcorrChipLinkObjectFromMetadata (entry->data.md);
     872        flatcorrChipLinkInsertObject (config->dbh, flatcorrChipLink);
     873
     874        // fprintf (stdout, "---- flatcorr chip link ----\n");
     875        // psMetadataPrint (stderr, entry->data.md, 1);
     876        break;
     877      }
     878    }
     879  }
     880  return true;
     881}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/flatcorr.h

    r20397 r23352  
    3535    FLATCORR_MODE_UPDATERUN,
    3636    FLATCORR_MODE_INPUTEXP,
    37     FLATCORR_MODE_INPUTIMFILE
     37    FLATCORR_MODE_INPUTIMFILE,
     38    FLATCORR_MODE_EXPORTRUN,
     39    FLATCORR_MODE_IMPORTRUN
    3840} flatcorrMode;
    3941

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/flatcorrConfig.c

    r20397 r23352  
    125125    psMetadataAddU64(inputimfileArgs, PS_LIST_TAIL, "-limit",   0, "limit result set to N items", 0);
    126126
     127    // -exportrun
     128    psMetadata *exportrunArgs = psMetadataAlloc();
     129    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-corr_id", 0,          "export this correction ID (required)", 0);
     130    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     131    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     132
     133    // -importrun
     134    psMetadata *importrunArgs = psMetadataAlloc();
     135    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     136
     137
    127138    psFree(now);
    128139
    … …  
    141152    PXOPT_ADD_MODE("-inputexp",       "list exposures for a correction run",               FLATCORR_MODE_INPUTEXP,       inputexpArgs);
    142153    PXOPT_ADD_MODE("-inputimfile",    "list imfiles for a chip run",                       FLATCORR_MODE_INPUTIMFILE,    inputimfileArgs);
     154    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", FLATCORR_MODE_EXPORTRUN, exportrunArgs);
     155    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           FLATCORR_MODE_IMPORTRUN, importrunArgs);
    143156
    144157    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxadmin.c

    r18927 r23352  
    2929
    3030bool createMode(pxConfig *config);
     31bool createMirrorMode(pxConfig *config);
    3132bool deleteMode(pxConfig *config);
    3233static bool runMultipleStatments(pxConfig *config, const char *query);
    … …  
    5354            }
    5455            break;
     56        case PXADMIN_MODE_CREATE_MIRROR:
     57            if (!createMirrorMode(config)) {
     58                goto FAIL;
     59            }
     60            break;
    5561        case PXADMIN_MODE_DELETE:
    5662            if (!deleteMode(config)) {
    … …  
    8692
    8793    psString query = pxDataGet("pxadmin_create_tables.sql");
     94    if (!query) {
     95        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     96        return false;
     97    }
     98
     99    // BEGIN
     100    if (!psDBTransaction(config->dbh)) {
     101        psError(PS_ERR_UNKNOWN, false, "database error");
     102        return false;
     103    }
     104
     105    if (!runMultipleStatments(config, query)) {
     106        if (!psDBRollback(config->dbh)) {
     107                psError(PS_ERR_UNKNOWN, false, "database error");
     108        }
     109        psError(PS_ERR_UNKNOWN, false, "database error");
     110        psFree(query);
     111        return false;
     112    }
     113    psFree(query);
     114
     115    // COMMIT
     116    if (!psDBCommit(config->dbh)) {
     117        psError(PS_ERR_UNKNOWN, false, "database error");
     118        return false;
     119    }
     120
     121    return true;
     122}
     123
     124
     125bool createMirrorMode(pxConfig *config)
     126{
     127    PS_ASSERT_PTR_NON_NULL(config, false);
     128
     129    psString query = pxDataGet("pxadmin_create_mirror_tables.sql");
    88130    if (!query) {
    89131        psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxadmin.h

    r9392 r23352  
    2626    PXADMIN_MODE_NONE      = 0x0,
    2727    PXADMIN_MODE_CREATE,
     28    PXADMIN_MODE_CREATE_MIRROR,
    2829    PXADMIN_MODE_DELETE,
    2930    PXADMIN_MODE_RECREATE

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxadminConfig.c

    r19062 r23352  
    3131    fprintf (stderr, "\nPan-STARRS DataBase Admin Tool\n\n");
    3232    fprintf (stderr, "Usage: %s [mode]\n", program);
    33     fprintf (stderr, " [mode] : -create | -delete\n\n");
     33    fprintf (stderr, " [mode] : -create | -create-mirror | -delete\n\n");
    3434
    3535    psMetadataItem *server = pmConfigUserSite(config->modules, "DBSERVER",   PS_DATA_STRING);
    … …  
    8787        config->mode = PXADMIN_MODE_CREATE;
    8888    }
     89    if ((N = psArgumentGet(argc, argv, "-create-mirror"))) {
     90        psArgumentRemove(N, &argc, argv);
     91        if (config->mode) {
     92            psAbort("only one mode selection is allowed");
     93        }
     94        config->mode = PXADMIN_MODE_CREATE_MIRROR;
     95    }
    8996    if ((N = psArgumentGet(argc, argv, "-delete"))) {
    9097        psArgumentRemove(N, &argc, argv);
    … …  
    105112    psMetadataAddStr(arguments, PS_LIST_TAIL, "-create", 0,
    106113            "create all IPP tables", "");
     114    psMetadataAddStr(arguments, PS_LIST_TAIL, "-create-mirror", 0,
     115            "mirror all IPP tables", "");
    107116    psMetadataAddStr(arguments, PS_LIST_TAIL, "-delete", 0,
    108117            "delete all IPP tables", "");

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxtools.c

    r20413 r23352  
    3030    PS_ASSERT_PTR_NON_NULL(state, false);
    3131   
    32     // XXX replace strncmp with strcmp
    33 
    3432    if (!strcmp(state, "new")) return true;
    3533    if (!strcmp(state, "reg")) return true;
    … …  
    3836    if (!strcmp(state, "wait")) return true;
    3937    if (!strcmp(state, "goto_cleaned")) return true;
     38    if (!strcmp(state, "error_cleaned")) return true;
     39    if (!strcmp(state, "goto_scrubbed")) return true;
     40    if (!strcmp(state, "error_scrubbed")) return true;
    4041    if (!strcmp(state, "cleaned")) return true;
    4142    if (!strcmp(state, "update")) return true;
    4243    if (!strcmp(state, "purged")) return true;
    4344    if (!strcmp(state, "goto_purged")) return true;
     45    if (!strcmp(state, "error_purged")) return true;
    4446
    4547    return false;
    4648}
     49
     50// 'scrubbed' is a virtual state equivalent to cleaned, but allows files to be removed
     51// even if the config files is missing

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/pxwarp.c

    r21402 r23352  
    5858    // check that state is a valid string value
    5959    if (!pxIsValidState(state)) {
    60         psError(PS_ERR_UNKNOWN, false, "invalid chipRun state: %s", state);
     60        psError(PS_ERR_UNKNOWN, false, "invalid warpRun state: %s", state);
    6161        return false;
    6262    }

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/regtool.c

    r21402 r23352  
    4444static bool updateprocessedexpMode(pxConfig *config);
    4545static bool cleardupexpMode(pxConfig *config);
     46static bool exportrunMode(pxConfig *config);
     47static bool importrunMode(pxConfig *config);
    4648
    4749# define MODECASE(caseName, func) \
    … …  
    7678        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
    7779        MODECASE(REGTOOL_MODE_CLEARDUPEXP,           cleardupexpMode);
     80        MODECASE(CHIPTOOL_MODE_EXPORTRUN,            exportrunMode);
     81        MODECASE(CHIPTOOL_MODE_IMPORTRUN,            importrunMode);
    7882        default:
    7983            psAbort("invalid option (this should not happen)");
    … …  
    11071111    return true;
    11081112}
     1113
     1114bool exportrunMode(pxConfig *config)
     1115{
     1116  typedef struct ExportTable {
     1117    char tableName[80];
     1118    char sqlFilename[80];
     1119  } ExportTable;
     1120 
     1121  int numExportTables = 2;
     1122
     1123  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1124
     1125  PXOPT_LOOKUP_S64(det_id, config->args, "-exp_id", true,  false);
     1126  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1127  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1128
     1129  FILE *f = fopen (outfile, "w");
     1130  if (f == NULL) {
     1131    psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1132    return false;
     1133  }
     1134
     1135  psMetadata *where = psMetadataAlloc();
     1136  PXOPT_COPY_S64(config->args, where, "-exp_id", "exp_id", "==");
     1137
     1138  ExportTable tables [] = {
     1139    {"rawExp", "regtool_export_raw__exp.sql"},
     1140    {"rawImfile", "regtool_export_raw_imfile.sql"},
     1141  };
     1142
     1143  for (int i=0; i < numExportTables; i++) {
     1144    psString query = pxDataGet(tables[i].sqlFilename);
     1145    if (!query) {
     1146      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1147      return false;
     1148    }
     1149
     1150    if (where && psListLength(where->list)) {
     1151      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1152      psStringAppend(&query, " %s", whereClause);
     1153      psFree(whereClause);
     1154    }
     1155
     1156    // treat limit == 0 as "no limit"
     1157    if (limit) {
     1158      psString limitString = psDBGenerateLimitSQL(limit);
     1159      psStringAppend(&query, " %s", limitString);
     1160      psFree(limitString);
     1161    }
     1162
     1163    if (!p_psDBRunQuery(config->dbh, query)) {
     1164      psError(PS_ERR_UNKNOWN, false, "database error");
     1165      psFree(query);
     1166      return false;
     1167    }
     1168    psFree(query);
     1169
     1170    psArray *output = p_psDBFetchResult(config->dbh);
     1171    if (!output) {
     1172      psError(PS_ERR_UNKNOWN, false, "database error");
     1173      return false;
     1174    }
     1175    if (!psArrayLength(output)) {
     1176      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1177      psFree(output);
     1178      return true;
     1179    }
     1180
     1181    // we must write the export table in non-simple (true) format
     1182    if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1183      psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1184      psFree(output);
     1185      return false;
     1186    }
     1187    psFree(output);
     1188  }
     1189
     1190  fclose (f);
     1191
     1192  return true;
     1193}
     1194
     1195bool importrunMode(pxConfig *config)
     1196{
     1197  unsigned int nFail;
     1198
     1199  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1200 
     1201  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1202
     1203  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1204
     1205  fprintf (stdout, "---- input ----\n");
     1206  psMetadataPrint (stderr, input, 1);
     1207
     1208  psMetadataItem *item = psMetadataLookup (input, "rawExp");
     1209  psAssert (item, "entry not in input?");
     1210  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1211 
     1212  psMetadataItem *entry = psListGet (item->data.list, 0);
     1213  assert (entry);
     1214  assert (entry->type == PS_DATA_METADATA);
     1215  rawExpRow *rawExp = rawExpObjectFromMetadata (entry->data.md);
     1216  rawExpInsertObject (config->dbh, rawExp);
     1217
     1218  // fprintf (stdout, "---- raw exp ----\n");
     1219  // psMetadataPrint (stderr, entry->data.md, 1);
     1220
     1221  item = psMetadataLookup (input, "rawImfile");
     1222  psAssert (item, "entry not in input?");
     1223  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1224
     1225  for (int i = 0; i < item->data.list->n; i++) {
     1226    psMetadataItem *entry = psListGet (item->data.list, i);
     1227    assert (entry);
     1228    assert (entry->type == PS_DATA_METADATA);
     1229    rawImfileRow *rawImfile = rawImfileObjectFromMetadata (entry->data.md);
     1230    rawImfileInsertObject (config->dbh, rawImfile);
     1231
     1232    // fprintf (stdout, "---- row %d ----\n", i);
     1233    // psMetadataPrint (stderr, entry->data.md, 1);
     1234  }
     1235
     1236  return true;
     1237}
     1238

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/regtool.h

    r18328 r23352  
    3636    REGTOOL_MODE_UPDATEPROCESSEDEXP,
    3737    REGTOOL_MODE_CLEARDUPEXP,
     38    REGTOOL_MODE_EXPORTRUN,
     39    REGTOOL_MODE_IMPORTRUN
    3840} regtoolMode;
    3941

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/regtoolConfig.c

    r20608 r23352  
    278278    psMetadataAddS16(updatedprocessedexpArgs, PS_LIST_TAIL, "-code",    0,            "set fault code (required)", INT16_MAX);
    279279
     280    // -exportrun
     281    psMetadata *exportrunArgs = psMetadataAlloc();
     282    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-exp_id", 0,          "export this exposure ID (required)", 0);
     283    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     284    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     285
     286    // -importrun
     287    psMetadata *importrunArgs = psMetadataAlloc();
     288    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     289
     290
    280291    // -cleardupexp
    281292    psMetadata *cleardupexpArgs = psMetadataAlloc();
    … …  
    295306    PXOPT_ADD_MODE("-updateprocessedexp",      "", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    296307    PXOPT_ADD_MODE("-cleardupexp",             "", REGTOOL_MODE_CLEARDUPEXP,      cleardupexpArgs);
     308    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", REGTOOL_MODE_EXPORTRUN, exportrunArgs);
     309    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           REGTOOL_MODE_IMPORTRUN, importrunArgs);
    297310
    298311    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/stacktool.c

    r21402 r23352  
    4444static bool donecleanupMode(pxConfig *config);
    4545static bool updatesumskyfileMode(pxConfig *config);
     46static bool exportrunMode(pxConfig *config);
     47static bool importrunMode(pxConfig *config);
    4648
    4749static bool setstackRunState(pxConfig *config, psS64 stack_id, const char *state);
    … …  
    7880        MODECASE(STACKTOOL_MODE_DONECLEANUP,           donecleanupMode);
    7981        MODECASE(STACKTOOL_MODE_UPDATESUMSKYFILE,      updatesumskyfileMode);
     82        MODECASE(STACKTOOL_MODE_EXPORTRUN,             exportrunMode);
     83        MODECASE(STACKTOOL_MODE_IMPORTRUN,             importrunMode);
    8084        default:
    8185            psAbort("invalid option (this should not happen)");
    … …  
    11801184}
    11811185
     1186bool exportrunMode(pxConfig *config)
     1187{
     1188  typedef struct ExportTable {
     1189    char tableName[80];
     1190    char sqlFilename[80];
     1191  } ExportTable;
     1192
     1193  int numExportTables = 3;
     1194 
     1195  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1196
     1197  PXOPT_LOOKUP_S64(det_id, config->args, "-stack_id", true,  false);
     1198  PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1199  PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1200
     1201  FILE *f = fopen (outfile, "w");
     1202  if (f == NULL) {
     1203      psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1204      return false;
     1205  }
     1206
     1207  psMetadata *where = psMetadataAlloc();
     1208  PXOPT_COPY_S64(config->args, where, "-stack_id", "stack_id", "==");
     1209
     1210  ExportTable tables [] = {
     1211    {"stackRun", "stacktool_export_run.sql"},
     1212    {"stackInputSkyfile", "stacktool_export_input_skyfile.sql"},
     1213    {"stackSumSkyfile", "stacktool_export_sum_skyfile.sql"},
     1214  };
     1215
     1216  for (int i=0; i < numExportTables; i++) {
     1217    psString query = pxDataGet(tables[i].sqlFilename);
     1218    if (!query) {
     1219      psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1220      return false;
     1221    }
     1222
     1223    if (where && psListLength(where->list)) {
     1224      psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1225      psStringAppend(&query, " %s", whereClause);
     1226      psFree(whereClause);
     1227    }
     1228
     1229    // treat limit == 0 as "no limit"
     1230    if (limit) {
     1231      psString limitString = psDBGenerateLimitSQL(limit);
     1232      psStringAppend(&query, " %s", limitString);
     1233      psFree(limitString);
     1234    }
     1235
     1236    if (!p_psDBRunQuery(config->dbh, query)) {
     1237      psError(PS_ERR_UNKNOWN, false, "database error");
     1238      psFree(query);
     1239      return false;
     1240    }
     1241    psFree(query);
     1242
     1243    psArray *output = p_psDBFetchResult(config->dbh);
     1244    if (!output) {
     1245      psError(PS_ERR_UNKNOWN, false, "database error");
     1246      return false;
     1247    }
     1248    if (!psArrayLength(output)) {
     1249      psTrace("regtool", PS_LOG_INFO, "no rows found");
     1250      psFree(output);
     1251      return true;
     1252    }
     1253    psFree(output);
     1254  }
     1255
     1256    fclose (f);
     1257
     1258    return true;
     1259}
     1260
     1261bool importrunMode(pxConfig *config)
     1262{
     1263  unsigned int nFail;
     1264 
     1265  int numImportTables = 2;
     1266 
     1267  char tables[2] [80] = {"stackInputSkyfile", "stackSumSkyfile"};
     1268
     1269  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1270 
     1271  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1272
     1273  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1274
     1275  fprintf (stdout, "---- input ----\n");
     1276  psMetadataPrint (stderr, input, 1);
     1277
     1278  psMetadataItem *item = psMetadataLookup (input, "stackRun");
     1279  psAssert (item, "entry not in input?");
     1280  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1281
     1282  psMetadataItem *entry = psListGet (item->data.list, 0);
     1283  assert (entry);
     1284  assert (entry->type == PS_DATA_METADATA);
     1285  stackRunRow *stackRun = stackRunObjectFromMetadata (entry->data.md);
     1286  stackRunInsertObject (config->dbh, stackRun);
     1287
     1288  // fprintf (stdout, "---- stack run ----\n");
     1289  // psMetadataPrint (stderr, entry->data.md, 1);
     1290
     1291  for (int i = 0; i < numImportTables; i++) {
     1292    psMetadataItem *item = psMetadataLookup (input, tables[i]);
     1293    psAssert (item, "entry not in input?");
     1294    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1295 
     1296    switch (i) {
     1297      case 0:
     1298        for (int i = 0; i < item->data.list->n; i++) {
     1299          entry = psListGet (item->data.list, i);
     1300          assert (entry);
     1301          assert (entry->type == PS_DATA_METADATA);
     1302          stackInputSkyfileRow *stackInputSkyfile = stackInputSkyfileObjectFromMetadata (entry->data.md);
     1303          stackInputSkyfileInsertObject (config->dbh, stackInputSkyfile);
     1304
     1305          // fprintf (stdout, "---- row %d ----\n", i);
     1306          // psMetadataPrint (stderr, entry->data.md, 1);
     1307        }
     1308        break;
     1309       
     1310      case 1:
     1311        for (int i = 0; i < item->data.list->n; i++) {
     1312          entry = psListGet (item->data.list, i);
     1313          assert (entry);
     1314          assert (entry->type == PS_DATA_METADATA);
     1315          stackSumSkyfileRow *stackSumSkyfile = stackSumSkyfileObjectFromMetadata (entry->data.md);
     1316          stackSumSkyfileInsertObject (config->dbh, stackSumSkyfile);
     1317
     1318          // fprintf (stdout, "---- row %d ----\n", i);
     1319          // psMetadataPrint (stderr, entry->data.md, 1);
     1320        }
     1321        break;
     1322    }
     1323  }
     1324 
     1325  return true;
     1326}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/stacktool.h

    r19676 r23352  
    3838    STACKTOOL_MODE_DONECLEANUP,
    3939    STACKTOOL_MODE_UPDATESUMSKYFILE,
     40    STACKTOOL_MODE_EXPORTRUN,
     41    STACKTOOL_MODE_IMPORTRUN
    4042} stacktoolMode;
    4143

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/stacktoolConfig.c

    r19931 r23352  
    187187    psMetadataAddS16(updatesumskyfileArgs, PS_LIST_TAIL, "-code", 0,            "set fault code (required)", 0);
    188188
     189    // -exportrun
     190    psMetadata *exportrunArgs = psMetadataAlloc();
     191    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-stack_id", 0,          "export this stack ID (required)", 0);
     192    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     193    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     194
     195    // -importrun
     196    psMetadata *importrunArgs = psMetadataAlloc();
     197    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     198
     199
    189200    psFree(now);
    190201
    … …  
    205216    PXOPT_ADD_MODE("-donecleanup",           "show runs that have been cleaned",     STACKTOOL_MODE_DONECLEANUP,          donecleanupArgs);
    206217    PXOPT_ADD_MODE("-updatesumskyfile",      "update fault code for sumskyfile",     STACKTOOL_MODE_UPDATESUMSKYFILE,          updatesumskyfileArgs);
     218    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", STACKTOOL_MODE_EXPORTRUN, exportrunArgs);
     219    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           STACKTOOL_MODE_IMPORTRUN, importrunArgs);
    207220
    208221    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptool.c

    r21402 r23352  
    5454static bool tofullskyfileMode(pxConfig *config);
    5555static bool updateskyfileMode(pxConfig *config);
     56static bool exportrunMode(pxConfig *config);
     57static bool importrunMode(pxConfig *config);
    5658
    5759static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    … …  
    99101        MODECASE(WARPTOOL_MODE_TOFULLSKYFILE,      tofullskyfileMode);
    100102        MODECASE(WARPTOOL_MODE_UPDATESKYFILE,      updateskyfileMode);
     103        MODECASE(WARPTOOL_MODE_EXPORTRUN,          exportrunMode);
     104        MODECASE(WARPTOOL_MODE_IMPORTRUN,          importrunMode);
    101105
    102106        default:
    … …  
    16801684    return true;
    16811685}
     1686
     1687bool exportrunMode(pxConfig *config)
     1688{
     1689  typedef struct ExportTable {
     1690    char tableName[80];
     1691    char sqlFilename[80];
     1692  } ExportTable;
     1693
     1694    PS_ASSERT_PTR_NON_NULL(config, NULL);
     1695
     1696    PXOPT_LOOKUP_S64(det_id, config->args, "-warp_id", true,  false);
     1697    PXOPT_LOOKUP_STR(outfile, config->args, "-outfile", true,  false);
     1698    PXOPT_LOOKUP_U64(limit,   config->args, "-limit",   false, false);
     1699
     1700    FILE *f = fopen (outfile, "w");
     1701    if (f == NULL) {
     1702        psError(PS_ERR_UNKNOWN, false, "failed to open output file");
     1703        return false;
     1704    }
     1705
     1706    psMetadata *where = psMetadataAlloc();
     1707    PXOPT_COPY_S64(config->args, where, "-warp_id", "warp_id", "==");
     1708
     1709    ExportTable tables [] = {
     1710      {"warpRun", "warptool_export_run.sql"},
     1711      {"warpImfile", "warptool_export_imfile.sql"},
     1712      {"warpSkyfile", "warptool_export_skyfile.sql"},
     1713      {"warpSkyCellMap", "warptool_export_sky_cell_map.sql"},
     1714    };
     1715
     1716
     1717    for (int i=0; i < sizeof(tables); i++) {
     1718      psString query = pxDataGet(tables[i].sqlFilename);
     1719      if (!query) {
     1720          psError(PXTOOLS_ERR_DATA, false, "failed to retreive SQL statement");
     1721          return false;
     1722      }
     1723
     1724      if (where && psListLength(where->list)) {
     1725          psString whereClause = psDBGenerateWhereSQL(where, NULL);
     1726          psStringAppend(&query, " %s", whereClause);
     1727          psFree(whereClause);
     1728      }
     1729
     1730      // treat limit == 0 as "no limit"
     1731      if (limit) {
     1732        psString limitString = psDBGenerateLimitSQL(limit);
     1733        psStringAppend(&query, " %s", limitString);
     1734        psFree(limitString);
     1735      }
     1736
     1737      if (!p_psDBRunQuery(config->dbh, query)) {
     1738        psError(PS_ERR_UNKNOWN, false, "database error");
     1739        psFree(query);
     1740        return false;
     1741      }
     1742      psFree(query);
     1743
     1744      psArray *output = p_psDBFetchResult(config->dbh);
     1745      if (!output) {
     1746          psError(PS_ERR_UNKNOWN, false, "database error");
     1747          return false;
     1748      }
     1749      if (!psArrayLength(output)) {
     1750        psTrace("regtool", PS_LOG_INFO, "no rows found");
     1751        psFree(output);
     1752        return true;
     1753      }
     1754
     1755      // we must write the export table in non-simple (true) format
     1756      if (!ippdbPrintMetadatas(f, output, tables[i].tableName, true)) {
     1757        psError(PS_ERR_UNKNOWN, false, "failed to print array");
     1758        psFree(output);
     1759        return false;
     1760      }
     1761      psFree(output);
     1762    }
     1763
     1764    fclose (f);
     1765
     1766    return true;
     1767}
     1768
     1769bool importrunMode(pxConfig *config)
     1770{
     1771  unsigned int nFail;
     1772
     1773  int numImportTables = 3;
     1774 
     1775  char tables[3] [80] = {"warpImfile", "warpSkyfile", "warpSkyCellMap"};
     1776
     1777  PS_ASSERT_PTR_NON_NULL(config, NULL);
     1778 
     1779  PXOPT_LOOKUP_STR(infile, config->args, "-infile", true,  false);
     1780
     1781  psMetadata *input = psMetadataConfigRead (NULL, &nFail, infile, false);
     1782
     1783  fprintf (stdout, "---- input ----\n");
     1784  psMetadataPrint (stderr, input, 1);
     1785
     1786  psMetadataItem *item = psMetadataLookup (input, "warpRun");
     1787  psAssert (item, "entry not in input?");
     1788  psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1789 
     1790  psMetadataItem *entry = psListGet (item->data.list, 0);
     1791  assert (entry);
     1792  assert (entry->type == PS_DATA_METADATA);
     1793  warpRunRow *warpRun = warpRunObjectFromMetadata (entry->data.md);
     1794  warpRunInsertObject (config->dbh, warpRun);
     1795
     1796  // fprintf (stdout, "---- warp run ----\n");
     1797  // psMetadataPrint (stderr, entry->data.md, 1);
     1798
     1799  for (int i = 0; i < numImportTables; i++) {
     1800    item = psMetadataLookup (input, tables[i]);
     1801    psAssert (item, "entry not in input?");
     1802    psAssert (item->type == PS_DATA_METADATA_MULTI, "entry not multi?");
     1803   
     1804    switch (i) {
     1805      case 0: 
     1806        for (int i = 0; i < item->data.list->n; i++) {
     1807          entry = psListGet (item->data.list, i);
     1808          assert (entry);
     1809          assert (entry->type == PS_DATA_METADATA);
     1810          warpImfileRow *warpImfile = warpImfileObjectFromMetadata (entry->data.md);
     1811          warpImfileInsertObject (config->dbh, warpImfile);
     1812
     1813          // fprintf (stdout, "---- row %d ----\n", i);
     1814          // psMetadataPrint (stderr, entry->data.md, 1);
     1815        }
     1816        break;
     1817       
     1818      case 1: 
     1819        for (int i = 0; i < item->data.list->n; i++) {
     1820          entry = psListGet (item->data.list, i);
     1821          assert (entry);
     1822          assert (entry->type == PS_DATA_METADATA);
     1823          warpSkyfileRow *warpSkyfile = warpSkyfileObjectFromMetadata (entry->data.md);
     1824          warpSkyfileInsertObject (config->dbh, warpSkyfile);
     1825
     1826          // fprintf (stdout, "---- row %d ----\n", i);
     1827          // psMetadataPrint (stderr, entry->data.md, 1);
     1828        }
     1829        break;
     1830       
     1831      case 2: 
     1832        for (int i = 0; i < item->data.list->n; i++) {
     1833          entry = psListGet (item->data.list, i);
     1834          assert (entry);
     1835          assert (entry->type == PS_DATA_METADATA);
     1836          warpSkyCellMapRow *warpSkyCellMap = warpSkyCellMapObjectFromMetadata (entry->data.md);
     1837          warpSkyCellMapInsertObject (config->dbh, warpSkyCellMap);
     1838
     1839          // fprintf (stdout, "---- row %d ----\n", i);
     1840          // psMetadataPrint (stderr, entry->data.md, 1);
     1841        }
     1842        break;
     1843    }
     1844  }
     1845  return true;
     1846}

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptool.h

    r19522 r23352  
    4949    WARPTOOL_MODE_TOFULLSKYFILE,
    5050    WARPTOOL_MODE_UPDATESKYFILE,
     51    WARPTOOL_MODE_EXPORTRUN,
     52    WARPTOOL_MODE_IMPORTRUN
    5153} warptoolMode;
    5254

  • branches/cnb_branches/cnb_branch_20090301/ippTools/src/warptoolConfig.c

    r20973 r23352  
    354354    psMetadataAddS16(updateskyfileArgs, PS_LIST_TAIL, "-code",  0,      "new fault code", 0);
    355355
     356    // -exportrun
     357    psMetadata *exportrunArgs = psMetadataAlloc();
     358    psMetadataAddS64(exportrunArgs, PS_LIST_TAIL, "-warp_id", 0,          "export this warp ID (required)", 0);
     359    psMetadataAddStr(exportrunArgs, PS_LIST_TAIL, "-outfile", 0,          "export to this file (required)", NULL);
     360    psMetadataAddU64(exportrunArgs, PS_LIST_TAIL, "-limit",   0,          "limit result set to N items", 0);
     361
     362    // -importrun
     363    psMetadata *importrunArgs = psMetadataAlloc();
     364    psMetadataAddStr(importrunArgs, PS_LIST_TAIL, "-infile",  0,          "import from this file (required)", NULL);
     365
     366
    356367    psFree(now);
    357368    psMetadata *argSets = psMetadataAlloc();
    … …  
    380391    PXOPT_ADD_MODE("-tofullskyfile", "set skyfile as full (updated)", WARPTOOL_MODE_TOFULLSKYFILE, tofullskyfileArgs);
    381392    PXOPT_ADD_MODE("-updateskyfile", "update fault code for skyfile", WARPTOOL_MODE_UPDATESKYFILE, updateskyfileArgs);
     393    PXOPT_ADD_MODE("-exportrun",            "export run for import on other database", WARPTOOL_MODE_EXPORTRUN, exportrunArgs);
     394    PXOPT_ADD_MODE("-importrun",            "import run from metadata file",           WARPTOOL_MODE_IMPORTRUN, importrunArgs);
    382395
    383396    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.