IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Feb 6, 2007, 3:46:45 PM (19 years ago)
Author:
jhoblitt
Message:

VERSION 1.1.1

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/src/ippdb.c

    r11635 r11679  
    2020/*
    2121 *
    22  * This file was generated by glueforge 1.00
     22 * This file was generated by glueforge 0.36
    2323 *
    2424 * Do NOT directly edit this file.
    … …  
    6262#define DETRESIDEXP_TABLE_NAME "detResidExp"
    6363#define DETRUNSUMMARY_TABLE_NAME "detRunSummary"
    64 #define P4RUN_TABLE_NAME "p4Run"
    65 #define P4INPUTIMFILE_TABLE_NAME "p4InputImfile"
    66 #define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile"
    67 #define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile"
    68 #define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile"
     64#define P4ARUN_TABLE_NAME "p4aRun"
     65#define P4AINPUTEXP_TABLE_NAME "p4aInputExp"
     66#define P4ASCFILE_TABLE_NAME "p4aScfile"
     67#define P4BRUN_TABLE_NAME "p4bRun"
     68#define P4BINPUTSCFILE_TABLE_NAME "p4bInputScfile"
     69#define P4BDIFFSCFILE_TABLE_NAME "p4bDiffScfile"
     70#define P4CRUN_TABLE_NAME "p4cRun"
     71#define P4CINPUTEXP_TABLE_NAME "p4cInputExp"
    6972#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
     73#define SKYCELL_TABLE_NAME "skyCell"
     74#define SKYCELLMAP_TABLE_NAME "skyCellMap"
    7075#define MAX_STRING_LENGTH 1024
    7176
    … …  
    438443    psMetadata *where = expTagCounterMetadataFromObject(object);
    439444    long long count = psDBDeleteRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, 0);
    440     psFree(where)
     445    psFree(where);
    441446    if (count < 0) {
    442447        psError(PS_ERR_UNKNOWN, true, "failed to delete row from expTagCounter");
    … …  
    460465        psMetadata *where = expTagCounterMetadataFromObject(object);
    461466        long long count = psDBDeleteRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, limit);
    462         psFree(where)
     467        psFree(where);
    463468        if (count < 0) {
    464469            psError(PS_ERR_UNKNOWN, true, "failed to delete row from expTagCounter");
    … …  
    843848    psMetadata *where = summitExpMetadataFromObject(object);
    844849    long long count = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, where, 0);
    845     psFree(where)
     850    psFree(where);
    846851    if (count < 0) {
    847852        psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitExp");
    … …  
    865870        psMetadata *where = summitExpMetadataFromObject(object);
    866871        long long count = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, where, limit);
    867         psFree(where)
     872        psFree(where);
    868873        if (count < 0) {
    869874            psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitExp");
    … …  
    12921297    psMetadata *where = summitImfileMetadataFromObject(object);
    12931298    long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, 0);
    1294     psFree(where)
     1299    psFree(where);
    12951300    if (count < 0) {
    12961301        psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile");
    … …  
    13141319        psMetadata *where = summitImfileMetadataFromObject(object);
    13151320        long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit);
    1316         psFree(where)
     1321        psFree(where);
    13171322        if (count < 0) {
    13181323            psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile");
    … …  
    16101615    psMetadata *where = pzPendingExpMetadataFromObject(object);
    16111616    long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, 0);
    1612     psFree(where)
     1617    psFree(where);
    16131618    if (count < 0) {
    16141619        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp");
    … …  
    16321637        psMetadata *where = pzPendingExpMetadataFromObject(object);
    16331638        long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit);
    1634         psFree(where)
     1639        psFree(where);
    16351640        if (count < 0) {
    16361641            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp");
    … …  
    19941999    psMetadata *where = pzPendingImfileMetadataFromObject(object);
    19952000    long long count = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, 0);
    1996     psFree(where)
     2001    psFree(where);
    19972002    if (count < 0) {
    19982003        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingImfile");
    … …  
    20162021        psMetadata *where = pzPendingImfileMetadataFromObject(object);
    20172022        long long count = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit);
    2018         psFree(where)
     2023        psFree(where);
    20192024        if (count < 0) {
    20202025            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingImfile");
    … …  
    23122317    psMetadata *where = pzDoneExpMetadataFromObject(object);
    23132318    long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, 0);
    2314     psFree(where)
     2319    psFree(where);
    23152320    if (count < 0) {
    23162321        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp");
    … …  
    23342339        psMetadata *where = pzDoneExpMetadataFromObject(object);
    23352340        long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, limit);
    2336         psFree(where)
     2341        psFree(where);
    23372342        if (count < 0) {
    23382343            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp");
    … …  
    27182723    psMetadata *where = pzDoneImfileMetadataFromObject(object);
    27192724    long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, 0);
    2720     psFree(where)
     2725    psFree(where);
    27212726    if (count < 0) {
    27222727        psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile");
    … …  
    27402745        psMetadata *where = pzDoneImfileMetadataFromObject(object);
    27412746        long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit);
    2742         psFree(where)
     2747        psFree(where);
    27432748        if (count < 0) {
    27442749            psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile");
    … …  
    31013106    psMetadata *where = newExpMetadataFromObject(object);
    31023107    long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, 0);
    3103     psFree(where)
     3108    psFree(where);
    31043109    if (count < 0) {
    31053110        psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp");
    … …  
    31233128        psMetadata *where = newExpMetadataFromObject(object);
    31243129        long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, limit);
    3125         psFree(where)
     3130        psFree(where);
    31263131        if (count < 0) {
    31273132            psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp");
    … …  
    34413446    psMetadata *where = newImfileMetadataFromObject(object);
    34423447    long long count = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, where, 0);
    3443     psFree(where)
     3448    psFree(where);
    34443449    if (count < 0) {
    34453450        psError(PS_ERR_UNKNOWN, true, "failed to delete row from newImfile");
    … …  
    34633468        psMetadata *where = newImfileMetadataFromObject(object);
    34643469        long long count = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, where, limit);
    3465         psFree(where)
     3470        psFree(where);
    34663471        if (count < 0) {
    34673472            psError(PS_ERR_UNKNOWN, true, "failed to delete row from newImfile");
    … …  
    41644169    psMetadata *where = rawExpMetadataFromObject(object);
    41654170    long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, 0);
    4166     psFree(where)
     4171    psFree(where);
    41674172    if (count < 0) {
    41684173        psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp");
    … …  
    41864191        psMetadata *where = rawExpMetadataFromObject(object);
    41874192        long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, limit);
    4188         psFree(where)
     4193        psFree(where);
    41894194        if (count < 0) {
    41904195            psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp");
    … …  
    48444849    psMetadata *where = rawImfileMetadataFromObject(object);
    48454850    long long count = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, where, 0);
    4846     psFree(where)
     4851    psFree(where);
    48474852    if (count < 0) {
    48484853        psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawImfile");
    … …  
    48664871        psMetadata *where = rawImfileMetadataFromObject(object);
    48674872        long long count = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, where, limit);
    4868         psFree(where)
     4873        psFree(where);
    48694874        if (count < 0) {
    48704875            psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawImfile");
    … …  
    51615166    psMetadata *where = p1PendingExpMetadataFromObject(object);
    51625167    long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, 0);
    5163     psFree(where)
     5168    psFree(where);
    51645169    if (count < 0) {
    51655170        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp");
    … …  
    51835188        psMetadata *where = p1PendingExpMetadataFromObject(object);
    51845189        long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
    5185         psFree(where)
     5190        psFree(where);
    51865191        if (count < 0) {
    51875192            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp");
    … …  
    55215526    psMetadata *where = p2PendingExpMetadataFromObject(object);
    55225527    long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, 0);
    5523     psFree(where)
     5528    psFree(where);
    55245529    if (count < 0) {
    55255530        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp");
    … …  
    55435548        psMetadata *where = p2PendingExpMetadataFromObject(object);
    55445549        long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
    5545         psFree(where)
     5550        psFree(where);
    55465551        if (count < 0) {
    55475552            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp");
    … …  
    59035908    psMetadata *where = p2PendingImfileMetadataFromObject(object);
    59045909    long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, 0);
    5905     psFree(where)
     5910    psFree(where);
    59065911    if (count < 0) {
    59075912        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile");
    … …  
    59255930        psMetadata *where = p2PendingImfileMetadataFromObject(object);
    59265931        long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
    5927         psFree(where)
     5932        psFree(where);
    59285933        if (count < 0) {
    59295934            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile");
    … …  
    62416246    psMetadata *where = p2ProcessedExpMetadataFromObject(object);
    62426247    long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, 0);
    6243     psFree(where)
     6248    psFree(where);
    62446249    if (count < 0) {
    62456250        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp");
    … …  
    62636268        psMetadata *where = p2ProcessedExpMetadataFromObject(object);
    62646269        long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
    6265         psFree(where)
     6270        psFree(where);
    62666271        if (count < 0) {
    62676272            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp");
    … …  
    65156520    psMetadata *where = p2MaskMetadataFromObject(object);
    65166521    long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, 0);
    6517     psFree(where)
     6522    psFree(where);
    65186523    if (count < 0) {
    65196524        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask");
    … …  
    65376542        psMetadata *where = p2MaskMetadataFromObject(object);
    65386543        long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, limit);
    6539         psFree(where)
     6544        psFree(where);
    65406545        if (count < 0) {
    65416546            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask");
    … …  
    70257030    psMetadata *where = p2ProcessedImfileMetadataFromObject(object);
    70267031    long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, 0);
    7027     psFree(where)
     7032    psFree(where);
    70287033    if (count < 0) {
    70297034        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile");
    … …  
    70477052        psMetadata *where = p2ProcessedImfileMetadataFromObject(object);
    70487053        long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
    7049         psFree(where)
     7054        psFree(where);
    70507055        if (count < 0) {
    70517056            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile");
    … …  
    73637368    psMetadata *where = p3PendingExpMetadataFromObject(object);
    73647369    long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, 0);
    7365     psFree(where)
     7370    psFree(where);
    73667371    if (count < 0) {
    73677372        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp");
    … …  
    73857390        psMetadata *where = p3PendingExpMetadataFromObject(object);
    73867391        long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
    7387         psFree(where)
     7392        psFree(where);
    73887393        if (count < 0) {
    73897394            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp");
    … …  
    79787983    psMetadata *where = p3ProcessedExpMetadataFromObject(object);
    79797984    long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, 0);
    7980     psFree(where)
     7985    psFree(where);
    79817986    if (count < 0) {
    79827987        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
    … …  
    80008005        psMetadata *where = p3ProcessedExpMetadataFromObject(object);
    80018006        long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
    8002         psFree(where)
     8007        psFree(where);
    80038008        if (count < 0) {
    80048009            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp");
    … …  
    82528257    psMetadata *where = p3MaskMetadataFromObject(object);
    82538258    long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, 0);
    8254     psFree(where)
     8259    psFree(where);
    82558260    if (count < 0) {
    82568261        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask");
    … …  
    82748279        psMetadata *where = p3MaskMetadataFromObject(object);
    82758280        long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, limit);
    8276         psFree(where)
     8281        psFree(where);
    82778282        if (count < 0) {
    82788283            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask");
    … …  
    90009005    psMetadata *where = detRunMetadataFromObject(object);
    90019006    long long count = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, where, 0);
    9002     psFree(where)
     9007    psFree(where);
    90039008    if (count < 0) {
    90049009        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRun");
    … …  
    90229027        psMetadata *where = detRunMetadataFromObject(object);
    90239028        long long count = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, where, limit);
    9024         psFree(where)
     9029        psFree(where);
    90259030        if (count < 0) {
    90269031            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRun");
    … …  
    93379342    psMetadata *where = detInputExpMetadataFromObject(object);
    93389343    long long count = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, where, 0);
    9339     psFree(where)
     9344    psFree(where);
    93409345    if (count < 0) {
    93419346        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detInputExp");
    … …  
    93599364        psMetadata *where = detInputExpMetadataFromObject(object);
    93609365        long long count = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit);
    9361         psFree(where)
     9366        psFree(where);
    93629367        if (count < 0) {
    93639368            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detInputExp");
    … …  
    98269831    psMetadata *where = detProcessedImfileMetadataFromObject(object);
    98279832    long long count = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, 0);
    9828     psFree(where)
     9833    psFree(where);
    98299834    if (count < 0) {
    98309835        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedImfile");
    … …  
    98489853        psMetadata *where = detProcessedImfileMetadataFromObject(object);
    98499854        long long count = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit);
    9850         psFree(where)
     9855        psFree(where);
    98519856        if (count < 0) {
    98529857            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedImfile");
    … …  
    1027110276    psMetadata *where = detProcessedExpMetadataFromObject(object);
    1027210277    long long count = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, 0);
    10273     psFree(where)
     10278    psFree(where);
    1027410279    if (count < 0) {
    1027510280        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedExp");
    … …  
    1029310298        psMetadata *where = detProcessedExpMetadataFromObject(object);
    1029410299        long long count = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit);
    10295         psFree(where)
     10300        psFree(where);
    1029610301        if (count < 0) {
    1029710302            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedExp");
    … …  
    1071510720    psMetadata *where = detStackedImfileMetadataFromObject(object);
    1071610721    long long count = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, 0);
    10717     psFree(where)
     10722    psFree(where);
    1071810723    if (count < 0) {
    1071910724        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detStackedImfile");
    … …  
    1073710742        psMetadata *where = detStackedImfileMetadataFromObject(object);
    1073810743        long long count = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit);
    10739         psFree(where)
     10744        psFree(where);
    1074010745        if (count < 0) {
    1074110746            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detStackedImfile");
    … …  
    1107311078    psMetadata *where = detNormalizedStatImfileMetadataFromObject(object);
    1107411079    long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, 0);
    11075     psFree(where)
     11080    psFree(where);
    1107611081    if (count < 0) {
    1107711082        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile");
    … …  
    1109511100        psMetadata *where = detNormalizedStatImfileMetadataFromObject(object);
    1109611101        long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit);
    11097         psFree(where)
     11102        psFree(where);
    1109811103        if (count < 0) {
    1109911104            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile");
    … …  
    1153911544    psMetadata *where = detNormalizedImfileMetadataFromObject(object);
    1154011545    long long count = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, 0);
    11541     psFree(where)
     11546    psFree(where);
    1154211547    if (count < 0) {
    1154311548        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedImfile");
    … …  
    1156111566        psMetadata *where = detNormalizedImfileMetadataFromObject(object);
    1156211567        long long count = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit);
    11563         psFree(where)
     11568        psFree(where);
    1156411569        if (count < 0) {
    1156511570            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedImfile");
    … …  
    1198311988    psMetadata *where = detNormalizedExpMetadataFromObject(object);
    1198411989    long long count = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, 0);
    11985     psFree(where)
     11990    psFree(where);
    1198611991    if (count < 0) {
    1198711992        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedExp");
    … …  
    1200512010        psMetadata *where = detNormalizedExpMetadataFromObject(object);
    1200612011        long long count = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit);
    12007         psFree(where)
     12012        psFree(where);
    1200812013        if (count < 0) {
    1200912014            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedExp");
    … …  
    1249312498    psMetadata *where = detResidImfileMetadataFromObject(object);
    1249412499    long long count = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, 0);
    12495     psFree(where)
     12500    psFree(where);
    1249612501    if (count < 0) {
    1249712502        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidImfile");
    … …  
    1251512520        psMetadata *where = detResidImfileMetadataFromObject(object);
    1251612521        long long count = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit);
    12517         psFree(where)
     12522        psFree(where);
    1251812523        if (count < 0) {
    1251912524            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidImfile");
    … …  
    1298012985    psMetadata *where = detResidExpMetadataFromObject(object);
    1298112986    long long count = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, where, 0);
    12982     psFree(where)
     12987    psFree(where);
    1298312988    if (count < 0) {
    1298412989        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidExp");
    … …  
    1300213007        psMetadata *where = detResidExpMetadataFromObject(object);
    1300313008        long long count = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit);
    13004         psFree(where)
     13009        psFree(where);
    1300513010        if (count < 0) {
    1300613011            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidExp");
    … …  
    1337913384    psMetadata *where = detRunSummaryMetadataFromObject(object);
    1338013385    long long count = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, 0);
    13381     psFree(where)
     13386    psFree(where);
    1338213387    if (count < 0) {
    1338313388        psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRunSummary");
    … …  
    1340113406        psMetadata *where = detRunSummaryMetadataFromObject(object);
    1340213407        long long count = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit);
    13403         psFree(where)
     13408        psFree(where);
    1340413409        if (count < 0) {
    1340513410            psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRunSummary");
    … …  
    1345813463    return true;
    1345913464}
    13460 static void p4RunRowFree(p4RunRow *object);
    13461 
    13462 p4RunRow *p4RunRowAlloc(psS32 p4_id, const char *survey_mode, const char *state, const char *workdir, const char *filter, const char *skycell_id, const char *tess_id, psF64 ra, psF64 decl, const char *input_ss, const char *output_ss)
    13463 {
    13464     p4RunRow        *_object;
    13465 
    13466     _object = psAlloc(sizeof(p4RunRow));
    13467     psMemSetDeallocator(_object, (psFreeFunc)p4RunRowFree);
    13468 
    13469     _object->p4_id = p4_id;
    13470     _object->survey_mode = psStringCopy(survey_mode);
     13465static void p4aRunRowFree(p4aRunRow *object);
     13466
     13467p4aRunRow *p4aRunRowAlloc(psS32 p4a_id, const char *state, const char *workdir, bool magic)
     13468{
     13469    p4aRunRow       *_object;
     13470
     13471    _object = psAlloc(sizeof(p4aRunRow));
     13472    psMemSetDeallocator(_object, (psFreeFunc)p4aRunRowFree);
     13473
     13474    _object->p4a_id = p4a_id;
    1347113475    _object->state = psStringCopy(state);
    1347213476    _object->workdir = psStringCopy(workdir);
    13473     _object->filter = psStringCopy(filter);
    13474     _object->skycell_id = psStringCopy(skycell_id);
    13475     _object->tess_id = psStringCopy(tess_id);
    13476     _object->ra = ra;
    13477     _object->decl = decl;
    13478     _object->input_ss = psStringCopy(input_ss);
    13479     _object->output_ss = psStringCopy(output_ss);
     13477    _object->magic = magic;
    1348013478
    1348113479    return _object;
    1348213480}
    1348313481
    13484 static void p4RunRowFree(p4RunRow *object)
    13485 {
    13486     psFree(object->survey_mode);
     13482static void p4aRunRowFree(p4aRunRow *object)
     13483{
    1348713484    psFree(object->state);
    1348813485    psFree(object->workdir);
    13489     psFree(object->filter);
    13490     psFree(object->skycell_id);
    13491     psFree(object->tess_id);
    13492     psFree(object->input_ss);
    13493     psFree(object->output_ss);
    13494 }
    13495 
    13496 bool p4RunCreateTable(psDB *dbh)
     13486}
     13487
     13488bool p4aRunCreateTable(psDB *dbh)
    1349713489{
    1349813490    psMetadata *md = psMetadataAlloc();
    13499     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
    13500         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    13501         psFree(md);
    13502         return false;
    13503     }
    13504     if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, "Key", "64")) {
    13505         psError(PS_ERR_UNKNOWN, false, "failed to add item survey_mode");
     13491    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     13492        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1350613493        psFree(md);
    1350713494        return false;
    … …  
    1351713504        return false;
    1351813505    }
    13519     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) {
    13520         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    13521         psFree(md);
    13522         return false;
    13523     }
    13524     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, "64")) {
    13525         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    13526         psFree(md);
    13527         return false;
    13528     }
    13529     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, "64")) {
    13530         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    13531         psFree(md);
    13532         return false;
    13533     }
    13534     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, 0.0)) {
    13535         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    13536         psFree(md);
    13537         return false;
    13538     }
    13539     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, 0.0)) {
    13540         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    13541         psFree(md);
    13542         return false;
    13543     }
    13544     if (!psMetadataAdd(md, PS_LIST_TAIL, "input_ss", PS_DATA_STRING, NULL, "64")) {
    13545         psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss");
    13546         psFree(md);
    13547         return false;
    13548     }
    13549     if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, "64")) {
    13550         psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss");
    13551         psFree(md);
    13552         return false;
    13553     }
    13554 
    13555     bool status = psDBCreateTable(dbh, P4RUN_TABLE_NAME, md);
     13506    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
     13507        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     13508        psFree(md);
     13509        return false;
     13510    }
     13511
     13512    bool status = psDBCreateTable(dbh, P4ARUN_TABLE_NAME, md);
    1355613513
    1355713514    psFree(md);
    … …  
    1356013517}
    1356113518
    13562 bool p4RunDropTable(psDB *dbh)
    13563 {
    13564     return psDBDropTable(dbh, P4RUN_TABLE_NAME);
    13565 }
    13566 
    13567 bool p4RunInsert(psDB * dbh, psS32 p4_id, const char *survey_mode, const char *state, const char *workdir, const char *filter, const char *skycell_id, const char *tess_id, psF64 ra, psF64 decl, const char *input_ss, const char *output_ss)
     13519bool p4aRunDropTable(psDB *dbh)
     13520{
     13521    return psDBDropTable(dbh, P4ARUN_TABLE_NAME);
     13522}
     13523
     13524bool p4aRunInsert(psDB * dbh, psS32 p4a_id, const char *state, const char *workdir, bool magic)
    1356813525{
    1356913526    psMetadata *md = psMetadataAlloc();
    13570     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    13571         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    13572         psFree(md);
    13573         return false;
    13574     }
    13575     if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, NULL, survey_mode)) {
    13576         psError(PS_ERR_UNKNOWN, false, "failed to add item survey_mode");
     13527    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, p4a_id)) {
     13528        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1357713529        psFree(md);
    1357813530        return false;
    … …  
    1358813540        return false;
    1358913541    }
    13590     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, filter)) {
    13591         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    13592         psFree(md);
    13593         return false;
    13594     }
    13595     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
    13596         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    13597         psFree(md);
    13598         return false;
    13599     }
    13600     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
    13601         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    13602         psFree(md);
    13603         return false;
    13604     }
    13605     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, ra)) {
    13606         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    13607         psFree(md);
    13608         return false;
    13609     }
    13610     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, decl)) {
    13611         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    13612         psFree(md);
    13613         return false;
    13614     }
    13615     if (!psMetadataAdd(md, PS_LIST_TAIL, "input_ss", PS_DATA_STRING, NULL, input_ss)) {
    13616         psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss");
    13617         psFree(md);
    13618         return false;
    13619     }
    13620     if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, output_ss)) {
    13621         psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss");
    13622         psFree(md);
    13623         return false;
    13624     }
    13625 
    13626     bool status = psDBInsertOneRow(dbh, P4RUN_TABLE_NAME, md);
     13542    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
     13543        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     13544        psFree(md);
     13545        return false;
     13546    }
     13547
     13548    bool status = psDBInsertOneRow(dbh, P4ARUN_TABLE_NAME, md);
    1362713549    psFree(md);
    1362813550
    … …  
    1363013552}
    1363113553
    13632 long long p4RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13554long long p4aRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1363313555{
    1363413556    long long       deleted = 0;
    1363513557
    13636     long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
     13558    long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
    1363713559    if (count < 0) {
    13638         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     13560        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
    1363913561        return count;
    1364013562
    … …  
    1364413566    return deleted;
    1364513567}
    13646 bool p4RunInsertObject(psDB *dbh, p4RunRow *object)
    13647 {
    13648     return p4RunInsert(dbh, object->p4_id, object->survey_mode, object->state, object->workdir, object->filter, object->skycell_id, object->tess_id, object->ra, object->decl, object->input_ss, object->output_ss);
    13649 }
    13650 
    13651 bool p4RunInsertObjects(psDB *dbh, psArray *objects)
     13568bool p4aRunInsertObject(psDB *dbh, p4aRunRow *object)
     13569{
     13570    return p4aRunInsert(dbh, object->p4a_id, object->state, object->workdir, object->magic);
     13571}
     13572
     13573bool p4aRunInsertObjects(psDB *dbh, psArray *objects)
    1365213574{
    1365313575    for (long i = 0; i < psArrayLength(objects); i++) {
    13654         if (!p4RunInsertObject(dbh, objects->data[i])) {
     13576        if (!p4aRunInsertObject(dbh, objects->data[i])) {
    1365513577            return false;
    1365613578        }
    … …  
    1366013582}
    1366113583
    13662 bool p4RunInsertFits(psDB *dbh, const psFits *fits)
     13584bool p4aRunInsertFits(psDB *dbh, const psFits *fits)
    1366313585{
    1366413586    psArray         *rowSet;
    1366513587
    13666     // move to (the first?) extension named  P4RUN_TABLE_NAME
    13667     if (!psFitsMoveExtName(fits, P4RUN_TABLE_NAME)) {
    13668         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4RUN_TABLE_NAME);
     13588    // move to (the first?) extension named  P4ARUN_TABLE_NAME
     13589    if (!psFitsMoveExtName(fits, P4ARUN_TABLE_NAME)) {
     13590        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ARUN_TABLE_NAME);
    1366913591        return false;
    1367013592    }
    … …  
    1368413606    }
    1368513607
    13686     if (!psDBInsertRows(dbh, P4RUN_TABLE_NAME, rowSet)) {
     13608    if (!psDBInsertRows(dbh, P4ARUN_TABLE_NAME, rowSet)) {
    1368713609        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1368813610        psFree(rowSet);
    … …  
    1369513617}
    1369613618
    13697 bool p4RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13619bool p4aRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1369813620{
    1369913621    psArray         *rowSet;
    1370013622
    13701     rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     13623    rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
    1370213624    if (!rowSet) {
    1370313625        return false;
    … …  
    1370513627
    1370613628    // output to fits
    13707     if (!psFitsWriteTable(fits, NULL, rowSet, P4RUN_TABLE_NAME)) {
     13629    if (!psFitsWriteTable(fits, NULL, rowSet, P4ARUN_TABLE_NAME)) {
    1370813630        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1370913631        psFree(rowSet);
    … …  
    1371613638}
    1371713639
    13718 psMetadata *p4RunMetadataFromObject(const p4RunRow *object)
     13640psMetadata *p4aRunMetadataFromObject(const p4aRunRow *object)
    1371913641{
    1372013642    psMetadata *md = psMetadataAlloc();
    13721     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    13722         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    13723         psFree(md);
    13724         return false;
    13725     }
    13726     if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, NULL, object->survey_mode)) {
    13727         psError(PS_ERR_UNKNOWN, false, "failed to add item survey_mode");
     13643    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, object->p4a_id)) {
     13644        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1372813645        psFree(md);
    1372913646        return false;
    … …  
    1373913656        return false;
    1374013657    }
    13741     if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) {
    13742         psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    13743         psFree(md);
    13744         return false;
    13745     }
    13746     if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
    13747         psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
    13748         psFree(md);
    13749         return false;
    13750     }
    13751     if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
    13752         psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    13753         psFree(md);
    13754         return false;
    13755     }
    13756     if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, object->ra)) {
    13757         psError(PS_ERR_UNKNOWN, false, "failed to add item ra");
    13758         psFree(md);
    13759         return false;
    13760     }
    13761     if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, object->decl)) {
    13762         psError(PS_ERR_UNKNOWN, false, "failed to add item decl");
    13763         psFree(md);
    13764         return false;
    13765     }
    13766     if (!psMetadataAdd(md, PS_LIST_TAIL, "input_ss", PS_DATA_STRING, NULL, object->input_ss)) {
    13767         psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss");
    13768         psFree(md);
    13769         return false;
    13770     }
    13771     if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, object->output_ss)) {
    13772         psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss");
     13658    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
     13659        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    1377313660        psFree(md);
    1377413661        return false;
    … …  
    1377913666}
    1378013667
    13781 p4RunRow *p4RunObjectFromMetadata(psMetadata *md)
     13668p4aRunRow *p4aRunObjectFromMetadata(psMetadata *md)
    1378213669{
    1378313670
    1378413671bool status = false;
    13785     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    13786     if (!status) {
    13787         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
    13788         return false;
    13789     }
    13790     char* survey_mode = psMetadataLookupPtr(&status, md, "survey_mode");
    13791     if (!status) {
    13792         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item survey_mode");
     13672    psS32 p4a_id = psMetadataLookupS32(&status, md, "p4a_id");
     13673    if (!status) {
     13674        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4a_id");
    1379313675        return false;
    1379413676    }
    … …  
    1380313685        return false;
    1380413686    }
    13805     char* filter = psMetadataLookupPtr(&status, md, "filter");
    13806     if (!status) {
    13807         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    13808         return false;
    13809     }
    13810     char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
    13811     if (!status) {
    13812         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
    13813         return false;
    13814     }
    13815     char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
    13816     if (!status) {
    13817         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    13818         return false;
    13819     }
    13820     psF64 ra = psMetadataLookupF64(&status, md, "ra");
    13821     if (!status) {
    13822         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    13823         return false;
    13824     }
    13825     psF64 decl = psMetadataLookupF64(&status, md, "decl");
    13826     if (!status) {
    13827         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    13828         return false;
    13829     }
    13830     char* input_ss = psMetadataLookupPtr(&status, md, "input_ss");
    13831     if (!status) {
    13832         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item input_ss");
    13833         return false;
    13834     }
    13835     char* output_ss = psMetadataLookupPtr(&status, md, "output_ss");
    13836     if (!status) {
    13837         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item output_ss");
    13838         return false;
    13839     }
    13840 
    13841     return p4RunRowAlloc(p4_id, survey_mode, state, workdir, filter, skycell_id, tess_id, ra, decl, input_ss, output_ss);
    13842 }
    13843 psArray *p4RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13687    bool magic = psMetadataLookupBool(&status, md, "magic");
     13688    if (!status) {
     13689        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
     13690        return false;
     13691    }
     13692
     13693    return p4aRunRowAlloc(p4a_id, state, workdir, magic);
     13694}
     13695psArray *p4aRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1384413696{
    1384513697    psArray         *rowSet;
    … …  
    1384713699    psU64           i;
    1384813700
    13849     rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     13701    rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
    1385013702    if (!rowSet) {
    1385113703        return NULL;
    … …  
    1385713709
    1385813710    for (i = 0; i < rowSet->n; i++) {
    13859         p4RunRow *object = p4RunObjectFromMetadata(rowSet->data[i]);
     13711        p4aRunRow *object = p4aRunObjectFromMetadata(rowSet->data[i]);
    1386013712        psArrayAdd(returnSet, 0, object);
    1386113713        psFree(object);
    … …  
    1386613718    return returnSet;
    1386713719}
    13868 bool p4RunDeleteObject(psDB *dbh, const p4RunRow *object)
    13869 {
    13870     psMetadata *where = p4RunMetadataFromObject(object);
    13871     long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, 0);
    13872     psFree(where)
     13720bool p4aRunDeleteObject(psDB *dbh, const p4aRunRow *object)
     13721{
     13722    psMetadata *where = p4aRunMetadataFromObject(object);
     13723    long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, 0);
     13724    psFree(where);
    1387313725    if (count < 0) {
    13874         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     13726        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
    1387513727        return false;
    1387613728    }
    … …  
    1387813730        // XXX should this be a psAbort() instead?  It is possible that
    1387913731        // having an object match multiple rows was by design.
    13880         psError(PS_ERR_UNKNOWN, true, "p4RunRow object matched more then one row.  Check your database schema");
    13881         return false;
    13882     }
    13883 
    13884     return true;
    13885 }
    13886 long long p4RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     13732        psError(PS_ERR_UNKNOWN, true, "p4aRunRow object matched more then one row.  Check your database schema");
     13733        return false;
     13734    }
     13735
     13736    return true;
     13737}
     13738long long p4aRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1388713739{
    1388813740    long long       deleted = 0;
    1388913741
    1389013742    for (long long i = 0; i < objects->n; i++) {
    13891         p4RunRow *object = objects->data[i];
    13892         psMetadata *where = p4RunMetadataFromObject(object);
    13893         long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
    13894         psFree(where)
     13743        p4aRunRow *object = objects->data[i];
     13744        psMetadata *where = p4aRunMetadataFromObject(object);
     13745        long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
     13746        psFree(where);
    1389513747        if (count < 0) {
    13896             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
     13748            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
    1389713749            return count;
    1389813750        }
    … …  
    1390313755    return deleted;
    1390413756}
    13905 bool p4RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     13757bool p4aRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1390613758{
    1390713759    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1390913761    psMetadata *output = psMetadataAlloc();
    1391013762    for (long i = 0; i < psArrayLength(objects); i++) {
    13911         psMetadata *md = p4RunMetadataFromObject(objects->data[i]);
     13763        psMetadata *md = p4aRunMetadataFromObject(objects->data[i]);
    1391213764        if (!psMetadataAddMetadata(
    1391313765            output,
    1391413766            PS_LIST_TAIL,
    13915             P4RUN_TABLE_NAME,
     13767            P4ARUN_TABLE_NAME,
    1391613768            PS_META_DUPLICATE_OK,
    1391713769            NULL,
    … …  
    1393413786    return true;
    1393513787}
    13936 bool p4RunPrintObject(FILE *stream, p4RunRow *object, bool mdcf)
     13788bool p4aRunPrintObject(FILE *stream, p4aRunRow *object, bool mdcf)
    1393713789{
    1393813790    PS_ASSERT_PTR_NON_NULL(object, false);
    1393913791
    13940     psMetadata *md = p4RunMetadataFromObject(object);
     13792    psMetadata *md = p4aRunMetadataFromObject(object);
    1394113793
    1394213794    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1394913801    return true;
    1395013802}
    13951 static void p4InputImfileRowFree(p4InputImfileRow *object);
    13952 
    13953 p4InputImfileRow *p4InputImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id)
    13954 {
    13955     p4InputImfileRow *_object;
    13956 
    13957     _object = psAlloc(sizeof(p4InputImfileRow));
    13958     psMemSetDeallocator(_object, (psFreeFunc)p4InputImfileRowFree);
    13959 
    13960     _object->p4_id = p4_id;
     13803static void p4aInputExpRowFree(p4aInputExpRow *object);
     13804
     13805p4aInputExpRow *p4aInputExpRowAlloc(psS32 p4a_id, const char *exp_tag, psS32 p3_version)
     13806{
     13807    p4aInputExpRow *_object;
     13808
     13809    _object = psAlloc(sizeof(p4aInputExpRow));
     13810    psMemSetDeallocator(_object, (psFreeFunc)p4aInputExpRowFree);
     13811
     13812    _object->p4a_id = p4a_id;
    1396113813    _object->exp_tag = psStringCopy(exp_tag);
    1396213814    _object->p3_version = p3_version;
    13963     _object->class_id = psStringCopy(class_id);
    1396413815
    1396513816    return _object;
    1396613817}
    1396713818
    13968 static void p4InputImfileRowFree(p4InputImfileRow *object)
     13819static void p4aInputExpRowFree(p4aInputExpRow *object)
    1396913820{
    1397013821    psFree(object->exp_tag);
    13971     psFree(object->class_id);
    13972 }
    13973 
    13974 bool p4InputImfileCreateTable(psDB *dbh)
     13822}
     13823
     13824bool p4aInputExpCreateTable(psDB *dbh)
    1397513825{
    1397613826    psMetadata *md = psMetadataAlloc();
    13977     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    13978         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13827    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, "Primary Key", 0)) {
     13828        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1397913829        psFree(md);
    1398013830        return false;
    … …  
    1399013840        return false;
    1399113841    }
    13992     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    13993         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    13994         psFree(md);
    13995         return false;
    13996     }
    13997 
    13998     bool status = psDBCreateTable(dbh, P4INPUTIMFILE_TABLE_NAME, md);
     13842
     13843    bool status = psDBCreateTable(dbh, P4AINPUTEXP_TABLE_NAME, md);
    1399913844
    1400013845    psFree(md);
    … …  
    1400313848}
    1400413849
    14005 bool p4InputImfileDropTable(psDB *dbh)
    14006 {
    14007     return psDBDropTable(dbh, P4INPUTIMFILE_TABLE_NAME);
    14008 }
    14009 
    14010 bool p4InputImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id)
     13850bool p4aInputExpDropTable(psDB *dbh)
     13851{
     13852    return psDBDropTable(dbh, P4AINPUTEXP_TABLE_NAME);
     13853}
     13854
     13855bool p4aInputExpInsert(psDB * dbh, psS32 p4a_id, const char *exp_tag, psS32 p3_version)
    1401113856{
    1401213857    psMetadata *md = psMetadataAlloc();
    14013     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14014         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13858    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, p4a_id)) {
     13859        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1401513860        psFree(md);
    1401613861        return false;
    … …  
    1402613871        return false;
    1402713872    }
    14028     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    14029         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14030         psFree(md);
    14031         return false;
    14032     }
    14033 
    14034     bool status = psDBInsertOneRow(dbh, P4INPUTIMFILE_TABLE_NAME, md);
     13873
     13874    bool status = psDBInsertOneRow(dbh, P4AINPUTEXP_TABLE_NAME, md);
    1403513875    psFree(md);
    1403613876
    … …  
    1403813878}
    1403913879
    14040 long long p4InputImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     13880long long p4aInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1404113881{
    1404213882    long long       deleted = 0;
    1404313883
    14044     long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit);
     13884    long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
    1404513885    if (count < 0) {
    14046         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile");
     13886        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
    1404713887        return count;
    1404813888
    … …  
    1405213892    return deleted;
    1405313893}
    14054 bool p4InputImfileInsertObject(psDB *dbh, p4InputImfileRow *object)
    14055 {
    14056     return p4InputImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id);
    14057 }
    14058 
    14059 bool p4InputImfileInsertObjects(psDB *dbh, psArray *objects)
     13894bool p4aInputExpInsertObject(psDB *dbh, p4aInputExpRow *object)
     13895{
     13896    return p4aInputExpInsert(dbh, object->p4a_id, object->exp_tag, object->p3_version);
     13897}
     13898
     13899bool p4aInputExpInsertObjects(psDB *dbh, psArray *objects)
    1406013900{
    1406113901    for (long i = 0; i < psArrayLength(objects); i++) {
    14062         if (!p4InputImfileInsertObject(dbh, objects->data[i])) {
     13902        if (!p4aInputExpInsertObject(dbh, objects->data[i])) {
    1406313903            return false;
    1406413904        }
    … …  
    1406813908}
    1406913909
    14070 bool p4InputImfileInsertFits(psDB *dbh, const psFits *fits)
     13910bool p4aInputExpInsertFits(psDB *dbh, const psFits *fits)
    1407113911{
    1407213912    psArray         *rowSet;
    1407313913
    14074     // move to (the first?) extension named  P4INPUTIMFILE_TABLE_NAME
    14075     if (!psFitsMoveExtName(fits, P4INPUTIMFILE_TABLE_NAME)) {
    14076         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTIMFILE_TABLE_NAME);
     13914    // move to (the first?) extension named  P4AINPUTEXP_TABLE_NAME
     13915    if (!psFitsMoveExtName(fits, P4AINPUTEXP_TABLE_NAME)) {
     13916        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4AINPUTEXP_TABLE_NAME);
    1407713917        return false;
    1407813918    }
    … …  
    1409213932    }
    1409313933
    14094     if (!psDBInsertRows(dbh, P4INPUTIMFILE_TABLE_NAME, rowSet)) {
     13934    if (!psDBInsertRows(dbh, P4AINPUTEXP_TABLE_NAME, rowSet)) {
    1409513935        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1409613936        psFree(rowSet);
    … …  
    1410313943}
    1410413944
    14105 bool p4InputImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     13945bool p4aInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1410613946{
    1410713947    psArray         *rowSet;
    1410813948
    14109     rowSet = psDBSelectRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit);
     13949    rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
    1411013950    if (!rowSet) {
    1411113951        return false;
    … …  
    1411313953
    1411413954    // output to fits
    14115     if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTIMFILE_TABLE_NAME)) {
     13955    if (!psFitsWriteTable(fits, NULL, rowSet, P4AINPUTEXP_TABLE_NAME)) {
    1411613956        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1411713957        psFree(rowSet);
    … …  
    1412413964}
    1412513965
    14126 psMetadata *p4InputImfileMetadataFromObject(const p4InputImfileRow *object)
     13966psMetadata *p4aInputExpMetadataFromObject(const p4aInputExpRow *object)
    1412713967{
    1412813968    psMetadata *md = psMetadataAlloc();
    14129     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    14130         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     13969    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, object->p4a_id)) {
     13970        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
    1413113971        psFree(md);
    1413213972        return false;
    … …  
    1414213982        return false;
    1414313983    }
    14144     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    14145         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14146         psFree(md);
    14147         return false;
    14148     }
    1414913984
    1415013985
    … …  
    1415213987}
    1415313988
    14154 p4InputImfileRow *p4InputImfileObjectFromMetadata(psMetadata *md)
     13989p4aInputExpRow *p4aInputExpObjectFromMetadata(psMetadata *md)
    1415513990{
    1415613991
    1415713992bool status = false;
    14158     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    14159     if (!status) {
    14160         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     13993    psS32 p4a_id = psMetadataLookupS32(&status, md, "p4a_id");
     13994    if (!status) {
     13995        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4a_id");
    1416113996        return false;
    1416213997    }
    … …  
    1417114006        return false;
    1417214007    }
    14173     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    14174     if (!status) {
    14175         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    14176         return false;
    14177     }
    14178 
    14179     return p4InputImfileRowAlloc(p4_id, exp_tag, p3_version, class_id);
    14180 }
    14181 psArray *p4InputImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14008
     14009    return p4aInputExpRowAlloc(p4a_id, exp_tag, p3_version);
     14010}
     14011psArray *p4aInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1418214012{
    1418314013    psArray         *rowSet;
    … …  
    1418514015    psU64           i;
    1418614016
    14187     rowSet = psDBSelectRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit);
     14017    rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
    1418814018    if (!rowSet) {
    1418914019        return NULL;
    … …  
    1419514025
    1419614026    for (i = 0; i < rowSet->n; i++) {
    14197         p4InputImfileRow *object = p4InputImfileObjectFromMetadata(rowSet->data[i]);
     14027        p4aInputExpRow *object = p4aInputExpObjectFromMetadata(rowSet->data[i]);
    1419814028        psArrayAdd(returnSet, 0, object);
    1419914029        psFree(object);
    … …  
    1420414034    return returnSet;
    1420514035}
    14206 bool p4InputImfileDeleteObject(psDB *dbh, const p4InputImfileRow *object)
    14207 {
    14208     psMetadata *where = p4InputImfileMetadataFromObject(object);
    14209     long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, 0);
    14210     psFree(where)
     14036bool p4aInputExpDeleteObject(psDB *dbh, const p4aInputExpRow *object)
     14037{
     14038    psMetadata *where = p4aInputExpMetadataFromObject(object);
     14039    long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, 0);
     14040    psFree(where);
    1421114041    if (count < 0) {
    14212         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile");
     14042        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
    1421314043        return false;
    1421414044    }
    … …  
    1421614046        // XXX should this be a psAbort() instead?  It is possible that
    1421714047        // having an object match multiple rows was by design.
    14218         psError(PS_ERR_UNKNOWN, true, "p4InputImfileRow object matched more then one row.  Check your database schema");
    14219         return false;
    14220     }
    14221 
    14222     return true;
    14223 }
    14224 long long p4InputImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14048        psError(PS_ERR_UNKNOWN, true, "p4aInputExpRow object matched more then one row.  Check your database schema");
     14049        return false;
     14050    }
     14051
     14052    return true;
     14053}
     14054long long p4aInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1422514055{
    1422614056    long long       deleted = 0;
    1422714057
    1422814058    for (long long i = 0; i < objects->n; i++) {
    14229         p4InputImfileRow *object = objects->data[i];
    14230         psMetadata *where = p4InputImfileMetadataFromObject(object);
    14231         long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit);
    14232         psFree(where)
     14059        p4aInputExpRow *object = objects->data[i];
     14060        psMetadata *where = p4aInputExpMetadataFromObject(object);
     14061        long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
     14062        psFree(where);
    1423314063        if (count < 0) {
    14234             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile");
     14064            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
    1423514065            return count;
    1423614066        }
    … …  
    1424114071    return deleted;
    1424214072}
    14243 bool p4InputImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14073bool p4aInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1424414074{
    1424514075    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1424714077    psMetadata *output = psMetadataAlloc();
    1424814078    for (long i = 0; i < psArrayLength(objects); i++) {
    14249         psMetadata *md = p4InputImfileMetadataFromObject(objects->data[i]);
     14079        psMetadata *md = p4aInputExpMetadataFromObject(objects->data[i]);
    1425014080        if (!psMetadataAddMetadata(
    1425114081            output,
    1425214082            PS_LIST_TAIL,
    14253             P4INPUTIMFILE_TABLE_NAME,
     14083            P4AINPUTEXP_TABLE_NAME,
    1425414084            PS_META_DUPLICATE_OK,
    1425514085            NULL,
    … …  
    1427214102    return true;
    1427314103}
    14274 bool p4InputImfilePrintObject(FILE *stream, p4InputImfileRow *object, bool mdcf)
     14104bool p4aInputExpPrintObject(FILE *stream, p4aInputExpRow *object, bool mdcf)
    1427514105{
    1427614106    PS_ASSERT_PTR_NON_NULL(object, false);
    1427714107
    14278     psMetadata *md = p4InputImfileMetadataFromObject(object);
     14108    psMetadata *md = p4aInputExpMetadataFromObject(object);
    1427914109
    1428014110    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1428714117    return true;
    1428814118}
    14289 static void p4WarpedImfileRowFree(p4WarpedImfileRow *object);
    14290 
    14291 p4WarpedImfileRow *p4WarpedImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    14292 {
    14293     p4WarpedImfileRow *_object;
    14294 
    14295     _object = psAlloc(sizeof(p4WarpedImfileRow));
    14296     psMemSetDeallocator(_object, (psFreeFunc)p4WarpedImfileRowFree);
    14297 
    14298     _object->p4_id = p4_id;
     14119static void p4aScfileRowFree(p4aScfileRow *object);
     14120
     14121p4aScfileRow *p4aScfileRowAlloc(psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     14122{
     14123    p4aScfileRow    *_object;
     14124
     14125    _object = psAlloc(sizeof(p4aScfileRow));
     14126    psMemSetDeallocator(_object, (psFreeFunc)p4aScfileRowFree);
     14127
     14128    _object->p4a_id = p4a_id;
     14129    _object->skycell_id = psStringCopy(skycell_id);
     14130    _object->tess_id = psStringCopy(tess_id);
    1429914131    _object->exp_tag = psStringCopy(exp_tag);
    1430014132    _object->p3_version = p3_version;
    14301     _object->class_id = psStringCopy(class_id);
    1430214133    _object->uri = psStringCopy(uri);
    14303     _object->b1_uri = psStringCopy(b1_uri);
    14304     _object->b2_uri = psStringCopy(b2_uri);
     14134    _object->bg = bg;
     14135    _object->bg_mean_stdev = bg_mean_stdev;
    1430514136
    1430614137    return _object;
    1430714138}
    1430814139
    14309 static void p4WarpedImfileRowFree(p4WarpedImfileRow *object)
    14310 {
     14140static void p4aScfileRowFree(p4aScfileRow *object)
     14141{
     14142    psFree(object->skycell_id);
     14143    psFree(object->tess_id);
    1431114144    psFree(object->exp_tag);
    14312     psFree(object->class_id);
    1431314145    psFree(object->uri);
    14314     psFree(object->b1_uri);
    14315     psFree(object->b2_uri);
    14316 }
    14317 
    14318 bool p4WarpedImfileCreateTable(psDB *dbh)
     14146}
     14147
     14148bool p4aScfileCreateTable(psDB *dbh)
    1431914149{
    1432014150    psMetadata *md = psMetadataAlloc();
    14321     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    14322         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14151    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, "Primary Key", 0)) {
     14152        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
     14153        psFree(md);
     14154        return false;
     14155    }
     14156    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     14157        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14158        psFree(md);
     14159        return false;
     14160    }
     14161    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     14162        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1432314163        psFree(md);
    1432414164        return false;
    … …  
    1433414174        return false;
    1433514175    }
    14336     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    14337         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14338         psFree(md);
    14339         return false;
    14340     }
    1434114176    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1434214177        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1434414179        return false;
    1434514180    }
    14346     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, "255")) {
    14347         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14348         psFree(md);
    14349         return false;
    14350     }
    14351     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) {
    14352         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    14353         psFree(md);
    14354         return false;
    14355     }
    14356 
    14357     bool status = psDBCreateTable(dbh, P4WARPEDIMFILE_TABLE_NAME, md);
     14181    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
     14182        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     14183        psFree(md);
     14184        return false;
     14185    }
     14186    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
     14187        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     14188        psFree(md);
     14189        return false;
     14190    }
     14191
     14192    bool status = psDBCreateTable(dbh, P4ASCFILE_TABLE_NAME, md);
    1435814193
    1435914194    psFree(md);
    … …  
    1436214197}
    1436314198
    14364 bool p4WarpedImfileDropTable(psDB *dbh)
    14365 {
    14366     return psDBDropTable(dbh, P4WARPEDIMFILE_TABLE_NAME);
    14367 }
    14368 
    14369 bool p4WarpedImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     14199bool p4aScfileDropTable(psDB *dbh)
     14200{
     14201    return psDBDropTable(dbh, P4ASCFILE_TABLE_NAME);
     14202}
     14203
     14204bool p4aScfileInsert(psDB * dbh, psS32 p4a_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1437014205{
    1437114206    psMetadata *md = psMetadataAlloc();
    14372     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14373         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14207    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, p4a_id)) {
     14208        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
     14209        psFree(md);
     14210        return false;
     14211    }
     14212    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     14213        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14214        psFree(md);
     14215        return false;
     14216    }
     14217    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     14218        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1437414219        psFree(md);
    1437514220        return false;
    … …  
    1438514230        return false;
    1438614231    }
    14387     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    14388         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14389         psFree(md);
    14390         return false;
    14391     }
    1439214232    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1439314233        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1439514235        return false;
    1439614236    }
    14397     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) {
    14398         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14399         psFree(md);
    14400         return false;
    14401     }
    14402     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) {
    14403         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    14404         psFree(md);
    14405         return false;
    14406     }
    14407 
    14408     bool status = psDBInsertOneRow(dbh, P4WARPEDIMFILE_TABLE_NAME, md);
     14237    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
     14238        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     14239        psFree(md);
     14240        return false;
     14241    }
     14242    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
     14243        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     14244        psFree(md);
     14245        return false;
     14246    }
     14247
     14248    bool status = psDBInsertOneRow(dbh, P4ASCFILE_TABLE_NAME, md);
    1440914249    psFree(md);
    1441014250
    … …  
    1441214252}
    1441314253
    14414 long long p4WarpedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14254long long p4aScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1441514255{
    1441614256    long long       deleted = 0;
    1441714257
    14418     long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit);
     14258    long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
    1441914259    if (count < 0) {
    14420         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile");
     14260        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
    1442114261        return count;
    1442214262
    … …  
    1442614266    return deleted;
    1442714267}
    14428 bool p4WarpedImfileInsertObject(psDB *dbh, p4WarpedImfileRow *object)
    14429 {
    14430     return p4WarpedImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
    14431 }
    14432 
    14433 bool p4WarpedImfileInsertObjects(psDB *dbh, psArray *objects)
     14268bool p4aScfileInsertObject(psDB *dbh, p4aScfileRow *object)
     14269{
     14270    return p4aScfileInsert(dbh, object->p4a_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
     14271}
     14272
     14273bool p4aScfileInsertObjects(psDB *dbh, psArray *objects)
    1443414274{
    1443514275    for (long i = 0; i < psArrayLength(objects); i++) {
    14436         if (!p4WarpedImfileInsertObject(dbh, objects->data[i])) {
     14276        if (!p4aScfileInsertObject(dbh, objects->data[i])) {
    1443714277            return false;
    1443814278        }
    … …  
    1444214282}
    1444314283
    14444 bool p4WarpedImfileInsertFits(psDB *dbh, const psFits *fits)
     14284bool p4aScfileInsertFits(psDB *dbh, const psFits *fits)
    1444514285{
    1444614286    psArray         *rowSet;
    1444714287
    14448     // move to (the first?) extension named  P4WARPEDIMFILE_TABLE_NAME
    14449     if (!psFitsMoveExtName(fits, P4WARPEDIMFILE_TABLE_NAME)) {
    14450         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4WARPEDIMFILE_TABLE_NAME);
     14288    // move to (the first?) extension named  P4ASCFILE_TABLE_NAME
     14289    if (!psFitsMoveExtName(fits, P4ASCFILE_TABLE_NAME)) {
     14290        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ASCFILE_TABLE_NAME);
    1445114291        return false;
    1445214292    }
    … …  
    1446614306    }
    1446714307
    14468     if (!psDBInsertRows(dbh, P4WARPEDIMFILE_TABLE_NAME, rowSet)) {
     14308    if (!psDBInsertRows(dbh, P4ASCFILE_TABLE_NAME, rowSet)) {
    1446914309        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1447014310        psFree(rowSet);
    … …  
    1447714317}
    1447814318
    14479 bool p4WarpedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14319bool p4aScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1448014320{
    1448114321    psArray         *rowSet;
    1448214322
    14483     rowSet = psDBSelectRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit);
     14323    rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
    1448414324    if (!rowSet) {
    1448514325        return false;
    … …  
    1448714327
    1448814328    // output to fits
    14489     if (!psFitsWriteTable(fits, NULL, rowSet, P4WARPEDIMFILE_TABLE_NAME)) {
     14329    if (!psFitsWriteTable(fits, NULL, rowSet, P4ASCFILE_TABLE_NAME)) {
    1449014330        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1449114331        psFree(rowSet);
    … …  
    1449814338}
    1449914339
    14500 psMetadata *p4WarpedImfileMetadataFromObject(const p4WarpedImfileRow *object)
     14340psMetadata *p4aScfileMetadataFromObject(const p4aScfileRow *object)
    1450114341{
    1450214342    psMetadata *md = psMetadataAlloc();
    14503     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    14504         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14343    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4a_id", PS_DATA_S32, NULL, object->p4a_id)) {
     14344        psError(PS_ERR_UNKNOWN, false, "failed to add item p4a_id");
     14345        psFree(md);
     14346        return false;
     14347    }
     14348    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     14349        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14350        psFree(md);
     14351        return false;
     14352    }
     14353    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     14354        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1450514355        psFree(md);
    1450614356        return false;
    … …  
    1451614366        return false;
    1451714367    }
    14518     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    14519         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14520         psFree(md);
    14521         return false;
    14522     }
    1452314368    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    1452414369        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1452614371        return false;
    1452714372    }
    14528     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) {
    14529         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14530         psFree(md);
    14531         return false;
    14532     }
    14533     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) {
    14534         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     14373    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
     14374        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     14375        psFree(md);
     14376        return false;
     14377    }
     14378    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
     14379        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
    1453514380        psFree(md);
    1453614381        return false;
    … …  
    1454114386}
    1454214387
    14543 p4WarpedImfileRow *p4WarpedImfileObjectFromMetadata(psMetadata *md)
     14388p4aScfileRow *p4aScfileObjectFromMetadata(psMetadata *md)
    1454414389{
    1454514390
    1454614391bool status = false;
    14547     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    14548     if (!status) {
    14549         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     14392    psS32 p4a_id = psMetadataLookupS32(&status, md, "p4a_id");
     14393    if (!status) {
     14394        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4a_id");
     14395        return false;
     14396    }
     14397    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     14398    if (!status) {
     14399        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     14400        return false;
     14401    }
     14402    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     14403    if (!status) {
     14404        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    1455014405        return false;
    1455114406    }
    … …  
    1456014415        return false;
    1456114416    }
    14562     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    14563     if (!status) {
    14564         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    14565         return false;
    14566     }
    1456714417    char* uri = psMetadataLookupPtr(&status, md, "uri");
    1456814418    if (!status) {
    … …  
    1457014420        return false;
    1457114421    }
    14572     char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri");
    14573     if (!status) {
    14574         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    14575         return false;
    14576     }
    14577     char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri");
    14578     if (!status) {
    14579         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    14580         return false;
    14581     }
    14582 
    14583     return p4WarpedImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
    14584 }
    14585 psArray *p4WarpedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14422    psF64 bg = psMetadataLookupF64(&status, md, "bg");
     14423    if (!status) {
     14424        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
     14425        return false;
     14426    }
     14427    psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     14428    if (!status) {
     14429        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
     14430        return false;
     14431    }
     14432
     14433    return p4aScfileRowAlloc(p4a_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
     14434}
     14435psArray *p4aScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1458614436{
    1458714437    psArray         *rowSet;
    … …  
    1458914439    psU64           i;
    1459014440
    14591     rowSet = psDBSelectRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit);
     14441    rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
    1459214442    if (!rowSet) {
    1459314443        return NULL;
    … …  
    1459914449
    1460014450    for (i = 0; i < rowSet->n; i++) {
    14601         p4WarpedImfileRow *object = p4WarpedImfileObjectFromMetadata(rowSet->data[i]);
     14451        p4aScfileRow *object = p4aScfileObjectFromMetadata(rowSet->data[i]);
    1460214452        psArrayAdd(returnSet, 0, object);
    1460314453        psFree(object);
    … …  
    1460814458    return returnSet;
    1460914459}
    14610 bool p4WarpedImfileDeleteObject(psDB *dbh, const p4WarpedImfileRow *object)
    14611 {
    14612     psMetadata *where = p4WarpedImfileMetadataFromObject(object);
    14613     long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, 0);
    14614     psFree(where)
     14460bool p4aScfileDeleteObject(psDB *dbh, const p4aScfileRow *object)
     14461{
     14462    psMetadata *where = p4aScfileMetadataFromObject(object);
     14463    long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, 0);
     14464    psFree(where);
    1461514465    if (count < 0) {
    14616         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile");
     14466        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
    1461714467        return false;
    1461814468    }
    … …  
    1462014470        // XXX should this be a psAbort() instead?  It is possible that
    1462114471        // having an object match multiple rows was by design.
    14622         psError(PS_ERR_UNKNOWN, true, "p4WarpedImfileRow object matched more then one row.  Check your database schema");
    14623         return false;
    14624     }
    14625 
    14626     return true;
    14627 }
    14628 long long p4WarpedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14472        psError(PS_ERR_UNKNOWN, true, "p4aScfileRow object matched more then one row.  Check your database schema");
     14473        return false;
     14474    }
     14475
     14476    return true;
     14477}
     14478long long p4aScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1462914479{
    1463014480    long long       deleted = 0;
    1463114481
    1463214482    for (long long i = 0; i < objects->n; i++) {
    14633         p4WarpedImfileRow *object = objects->data[i];
    14634         psMetadata *where = p4WarpedImfileMetadataFromObject(object);
    14635         long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit);
    14636         psFree(where)
     14483        p4aScfileRow *object = objects->data[i];
     14484        psMetadata *where = p4aScfileMetadataFromObject(object);
     14485        long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
     14486        psFree(where);
    1463714487        if (count < 0) {
    14638             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile");
     14488            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
    1463914489            return count;
    1464014490        }
    … …  
    1464514495    return deleted;
    1464614496}
    14647 bool p4WarpedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14497bool p4aScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1464814498{
    1464914499    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1465114501    psMetadata *output = psMetadataAlloc();
    1465214502    for (long i = 0; i < psArrayLength(objects); i++) {
    14653         psMetadata *md = p4WarpedImfileMetadataFromObject(objects->data[i]);
     14503        psMetadata *md = p4aScfileMetadataFromObject(objects->data[i]);
    1465414504        if (!psMetadataAddMetadata(
    1465514505            output,
    1465614506            PS_LIST_TAIL,
    14657             P4WARPEDIMFILE_TABLE_NAME,
     14507            P4ASCFILE_TABLE_NAME,
    1465814508            PS_META_DUPLICATE_OK,
    1465914509            NULL,
    … …  
    1467614526    return true;
    1467714527}
    14678 bool p4WarpedImfilePrintObject(FILE *stream, p4WarpedImfileRow *object, bool mdcf)
     14528bool p4aScfilePrintObject(FILE *stream, p4aScfileRow *object, bool mdcf)
    1467914529{
    1468014530    PS_ASSERT_PTR_NON_NULL(object, false);
    1468114531
    14682     psMetadata *md = p4WarpedImfileMetadataFromObject(object);
     14532    psMetadata *md = p4aScfileMetadataFromObject(object);
    1468314533
    1468414534    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1469114541    return true;
    1469214542}
    14693 static void p4StackedImfileRowFree(p4StackedImfileRow *object);
    14694 
    14695 p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    14696 {
    14697     p4StackedImfileRow *_object;
    14698 
    14699     _object = psAlloc(sizeof(p4StackedImfileRow));
    14700     psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree);
    14701 
    14702     _object->p4_id = p4_id;
    14703     _object->class_id = psStringCopy(class_id);
    14704     _object->uri = psStringCopy(uri);
    14705     _object->b1_uri = psStringCopy(b1_uri);
    14706     _object->b2_uri = psStringCopy(b2_uri);
     14543static void p4bRunRowFree(p4bRunRow *object);
     14544
     14545p4bRunRow *p4bRunRowAlloc(psS32 p4b_id, const char *state, const char *workdir, bool magic)
     14546{
     14547    p4bRunRow       *_object;
     14548
     14549    _object = psAlloc(sizeof(p4bRunRow));
     14550    psMemSetDeallocator(_object, (psFreeFunc)p4bRunRowFree);
     14551
     14552    _object->p4b_id = p4b_id;
     14553    _object->state = psStringCopy(state);
     14554    _object->workdir = psStringCopy(workdir);
     14555    _object->magic = magic;
    1470714556
    1470814557    return _object;
    1470914558}
    1471014559
    14711 static void p4StackedImfileRowFree(p4StackedImfileRow *object)
    14712 {
    14713     psFree(object->class_id);
    14714     psFree(object->uri);
    14715     psFree(object->b1_uri);
    14716     psFree(object->b2_uri);
    14717 }
    14718 
    14719 bool p4StackedImfileCreateTable(psDB *dbh)
     14560static void p4bRunRowFree(p4bRunRow *object)
     14561{
     14562    psFree(object->state);
     14563    psFree(object->workdir);
     14564}
     14565
     14566bool p4bRunCreateTable(psDB *dbh)
    1472014567{
    1472114568    psMetadata *md = psMetadataAlloc();
    14722     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    14723         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    14724         psFree(md);
    14725         return false;
    14726     }
    14727     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    14728         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14729         psFree(md);
    14730         return false;
    14731     }
    14732     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    14733         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    14734         psFree(md);
    14735         return false;
    14736     }
    14737     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, "255")) {
    14738         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14739         psFree(md);
    14740         return false;
    14741     }
    14742     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) {
    14743         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    14744         psFree(md);
    14745         return false;
    14746     }
    14747 
    14748     bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
     14569    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     14570        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     14571        psFree(md);
     14572        return false;
     14573    }
     14574    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
     14575        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     14576        psFree(md);
     14577        return false;
     14578    }
     14579    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
     14580        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     14581        psFree(md);
     14582        return false;
     14583    }
     14584    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
     14585        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     14586        psFree(md);
     14587        return false;
     14588    }
     14589
     14590    bool status = psDBCreateTable(dbh, P4BRUN_TABLE_NAME, md);
    1474914591
    1475014592    psFree(md);
    … …  
    1475314595}
    1475414596
    14755 bool p4StackedImfileDropTable(psDB *dbh)
    14756 {
    14757     return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME);
    14758 }
    14759 
    14760 bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     14597bool p4bRunDropTable(psDB *dbh)
     14598{
     14599    return psDBDropTable(dbh, P4BRUN_TABLE_NAME);
     14600}
     14601
     14602bool p4bRunInsert(psDB * dbh, psS32 p4b_id, const char *state, const char *workdir, bool magic)
    1476114603{
    1476214604    psMetadata *md = psMetadataAlloc();
    14763     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    14764         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    14765         psFree(md);
    14766         return false;
    14767     }
    14768     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    14769         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14770         psFree(md);
    14771         return false;
    14772     }
    14773     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    14774         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    14775         psFree(md);
    14776         return false;
    14777     }
    14778     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) {
    14779         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14780         psFree(md);
    14781         return false;
    14782     }
    14783     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) {
    14784         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    14785         psFree(md);
    14786         return false;
    14787     }
    14788 
    14789     bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
     14605    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, p4b_id)) {
     14606        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     14607        psFree(md);
     14608        return false;
     14609    }
     14610    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
     14611        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     14612        psFree(md);
     14613        return false;
     14614    }
     14615    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
     14616        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     14617        psFree(md);
     14618        return false;
     14619    }
     14620    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
     14621        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     14622        psFree(md);
     14623        return false;
     14624    }
     14625
     14626    bool status = psDBInsertOneRow(dbh, P4BRUN_TABLE_NAME, md);
    1479014627    psFree(md);
    1479114628
    … …  
    1479314630}
    1479414631
    14795 long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14632long long p4bRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1479614633{
    1479714634    long long       deleted = 0;
    1479814635
    14799     long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     14636    long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
    1480014637    if (count < 0) {
    14801         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
     14638        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
    1480214639        return count;
    1480314640
    … …  
    1480714644    return deleted;
    1480814645}
    14809 bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object)
    14810 {
    14811     return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
    14812 }
    14813 
    14814 bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects)
     14646bool p4bRunInsertObject(psDB *dbh, p4bRunRow *object)
     14647{
     14648    return p4bRunInsert(dbh, object->p4b_id, object->state, object->workdir, object->magic);
     14649}
     14650
     14651bool p4bRunInsertObjects(psDB *dbh, psArray *objects)
    1481514652{
    1481614653    for (long i = 0; i < psArrayLength(objects); i++) {
    14817         if (!p4StackedImfileInsertObject(dbh, objects->data[i])) {
     14654        if (!p4bRunInsertObject(dbh, objects->data[i])) {
    1481814655            return false;
    1481914656        }
    … …  
    1482314660}
    1482414661
    14825 bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits)
     14662bool p4bRunInsertFits(psDB *dbh, const psFits *fits)
    1482614663{
    1482714664    psArray         *rowSet;
    1482814665
    14829     // move to (the first?) extension named  P4STACKEDIMFILE_TABLE_NAME
    14830     if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) {
    14831         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME);
     14666    // move to (the first?) extension named  P4BRUN_TABLE_NAME
     14667    if (!psFitsMoveExtName(fits, P4BRUN_TABLE_NAME)) {
     14668        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BRUN_TABLE_NAME);
    1483214669        return false;
    1483314670    }
    … …  
    1484714684    }
    1484814685
    14849     if (!psDBInsertRows(dbh, P4STACKEDIMFILE_TABLE_NAME, rowSet)) {
     14686    if (!psDBInsertRows(dbh, P4BRUN_TABLE_NAME, rowSet)) {
    1485014687        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1485114688        psFree(rowSet);
    … …  
    1485814695}
    1485914696
    14860 bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     14697bool p4bRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1486114698{
    1486214699    psArray         *rowSet;
    1486314700
    14864     rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     14701    rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
    1486514702    if (!rowSet) {
    1486614703        return false;
    … …  
    1486814705
    1486914706    // output to fits
    14870     if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) {
     14707    if (!psFitsWriteTable(fits, NULL, rowSet, P4BRUN_TABLE_NAME)) {
    1487114708        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1487214709        psFree(rowSet);
    … …  
    1487914716}
    1488014717
    14881 psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object)
     14718psMetadata *p4bRunMetadataFromObject(const p4bRunRow *object)
    1488214719{
    1488314720    psMetadata *md = psMetadataAlloc();
    14884     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    14885         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
    14886         psFree(md);
    14887         return false;
    14888     }
    14889     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    14890         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    14891         psFree(md);
    14892         return false;
    14893     }
    14894     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    14895         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    14896         psFree(md);
    14897         return false;
    14898     }
    14899     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) {
    14900         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    14901         psFree(md);
    14902         return false;
    14903     }
    14904     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) {
    14905         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     14721    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, object->p4b_id)) {
     14722        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     14723        psFree(md);
     14724        return false;
     14725    }
     14726    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
     14727        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     14728        psFree(md);
     14729        return false;
     14730    }
     14731    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
     14732        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     14733        psFree(md);
     14734        return false;
     14735    }
     14736    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
     14737        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
    1490614738        psFree(md);
    1490714739        return false;
    … …  
    1491214744}
    1491314745
    14914 p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md)
     14746p4bRunRow *p4bRunObjectFromMetadata(psMetadata *md)
    1491514747{
    1491614748
    1491714749bool status = false;
    14918     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    14919     if (!status) {
    14920         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
    14921         return false;
    14922     }
    14923     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    14924     if (!status) {
    14925         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    14926         return false;
    14927     }
    14928     char* uri = psMetadataLookupPtr(&status, md, "uri");
    14929     if (!status) {
    14930         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    14931         return false;
    14932     }
    14933     char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri");
    14934     if (!status) {
    14935         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    14936         return false;
    14937     }
    14938     char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri");
    14939     if (!status) {
    14940         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    14941         return false;
    14942     }
    14943 
    14944     return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
    14945 }
    14946 psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14750    psS32 p4b_id = psMetadataLookupS32(&status, md, "p4b_id");
     14751    if (!status) {
     14752        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4b_id");
     14753        return false;
     14754    }
     14755    char* state = psMetadataLookupPtr(&status, md, "state");
     14756    if (!status) {
     14757        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
     14758        return false;
     14759    }
     14760    char* workdir = psMetadataLookupPtr(&status, md, "workdir");
     14761    if (!status) {
     14762        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
     14763        return false;
     14764    }
     14765    bool magic = psMetadataLookupBool(&status, md, "magic");
     14766    if (!status) {
     14767        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
     14768        return false;
     14769    }
     14770
     14771    return p4bRunRowAlloc(p4b_id, state, workdir, magic);
     14772}
     14773psArray *p4bRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1494714774{
    1494814775    psArray         *rowSet;
    … …  
    1495014777    psU64           i;
    1495114778
    14952     rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     14779    rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
    1495314780    if (!rowSet) {
    1495414781        return NULL;
    … …  
    1496014787
    1496114788    for (i = 0; i < rowSet->n; i++) {
    14962         p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]);
     14789        p4bRunRow *object = p4bRunObjectFromMetadata(rowSet->data[i]);
    1496314790        psArrayAdd(returnSet, 0, object);
    1496414791        psFree(object);
    … …  
    1496914796    return returnSet;
    1497014797}
    14971 bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object)
    14972 {
    14973     psMetadata *where = p4StackedImfileMetadataFromObject(object);
    14974     long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0);
    14975     psFree(where)
     14798bool p4bRunDeleteObject(psDB *dbh, const p4bRunRow *object)
     14799{
     14800    psMetadata *where = p4bRunMetadataFromObject(object);
     14801    long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, 0);
     14802    psFree(where);
    1497614803    if (count < 0) {
    14977         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
     14804        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
    1497814805        return false;
    1497914806    }
    … …  
    1498114808        // XXX should this be a psAbort() instead?  It is possible that
    1498214809        // having an object match multiple rows was by design.
    14983         psError(PS_ERR_UNKNOWN, true, "p4StackedImfileRow object matched more then one row.  Check your database schema");
    14984         return false;
    14985     }
    14986 
    14987     return true;
    14988 }
    14989 long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     14810        psError(PS_ERR_UNKNOWN, true, "p4bRunRow object matched more then one row.  Check your database schema");
     14811        return false;
     14812    }
     14813
     14814    return true;
     14815}
     14816long long p4bRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1499014817{
    1499114818    long long       deleted = 0;
    1499214819
    1499314820    for (long long i = 0; i < objects->n; i++) {
    14994         p4StackedImfileRow *object = objects->data[i];
    14995         psMetadata *where = p4StackedImfileMetadataFromObject(object);
    14996         long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
    14997         psFree(where)
     14821        p4bRunRow *object = objects->data[i];
     14822        psMetadata *where = p4bRunMetadataFromObject(object);
     14823        long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
     14824        psFree(where);
    1499814825        if (count < 0) {
    14999             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
     14826            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
    1500014827            return count;
    1500114828        }
    … …  
    1500614833    return deleted;
    1500714834}
    15008 bool p4StackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     14835bool p4bRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1500914836{
    1501014837    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1501214839    psMetadata *output = psMetadataAlloc();
    1501314840    for (long i = 0; i < psArrayLength(objects); i++) {
    15014         psMetadata *md = p4StackedImfileMetadataFromObject(objects->data[i]);
     14841        psMetadata *md = p4bRunMetadataFromObject(objects->data[i]);
    1501514842        if (!psMetadataAddMetadata(
    1501614843            output,
    1501714844            PS_LIST_TAIL,
    15018             P4STACKEDIMFILE_TABLE_NAME,
     14845            P4BRUN_TABLE_NAME,
    1501914846            PS_META_DUPLICATE_OK,
    1502014847            NULL,
    … …  
    1503714864    return true;
    1503814865}
    15039 bool p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf)
     14866bool p4bRunPrintObject(FILE *stream, p4bRunRow *object, bool mdcf)
    1504014867{
    1504114868    PS_ASSERT_PTR_NON_NULL(object, false);
    1504214869
    15043     psMetadata *md = p4StackedImfileMetadataFromObject(object);
     14870    psMetadata *md = p4bRunMetadataFromObject(object);
    1504414871
    1504514872    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1505214879    return true;
    1505314880}
    15054 static void p4DiffImfileRowFree(p4DiffImfileRow *object);
    15055 
    15056 p4DiffImfileRow *p4DiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
    15057 {
    15058     p4DiffImfileRow *_object;
    15059 
    15060     _object = psAlloc(sizeof(p4DiffImfileRow));
    15061     psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree);
    15062 
    15063     _object->p4_id = p4_id;
     14881static void p4bInputScfileRowFree(p4bInputScfileRow *object);
     14882
     14883p4bInputScfileRow *p4bInputScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
     14884{
     14885    p4bInputScfileRow *_object;
     14886
     14887    _object = psAlloc(sizeof(p4bInputScfileRow));
     14888    psMemSetDeallocator(_object, (psFreeFunc)p4bInputScfileRowFree);
     14889
     14890    _object->p4b_id = p4b_id;
     14891    _object->skycell_id = psStringCopy(skycell_id);
     14892    _object->tess_id = psStringCopy(tess_id);
    1506414893    _object->exp_tag = psStringCopy(exp_tag);
    1506514894    _object->p3_version = p3_version;
    15066     _object->class_id = psStringCopy(class_id);
    15067     _object->uri = psStringCopy(uri);
    15068     _object->b1_uri = psStringCopy(b1_uri);
    15069     _object->b2_uri = psStringCopy(b2_uri);
     14895    _object->kind = psStringCopy(kind);
    1507014896
    1507114897    return _object;
    1507214898}
    1507314899
    15074 static void p4DiffImfileRowFree(p4DiffImfileRow *object)
    15075 {
     14900static void p4bInputScfileRowFree(p4bInputScfileRow *object)
     14901{
     14902    psFree(object->skycell_id);
     14903    psFree(object->tess_id);
    1507614904    psFree(object->exp_tag);
    15077     psFree(object->class_id);
    15078     psFree(object->uri);
    15079     psFree(object->b1_uri);
    15080     psFree(object->b2_uri);
    15081 }
    15082 
    15083 bool p4DiffImfileCreateTable(psDB *dbh)
     14905    psFree(object->kind);
     14906}
     14907
     14908bool p4bInputScfileCreateTable(psDB *dbh)
    1508414909{
    1508514910    psMetadata *md = psMetadataAlloc();
    15086     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    15087         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14911    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
     14912        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     14913        psFree(md);
     14914        return false;
     14915    }
     14916    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     14917        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14918        psFree(md);
     14919        return false;
     14920    }
     14921    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     14922        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1508814923        psFree(md);
    1508914924        return false;
    … …  
    1509914934        return false;
    1510014935    }
    15101     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    15102         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    15103         psFree(md);
    15104         return false;
    15105     }
    15106     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    15107         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15108         psFree(md);
    15109         return false;
    15110     }
    15111     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, "255")) {
    15112         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    15113         psFree(md);
    15114         return false;
    15115     }
    15116     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) {
    15117         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    15118         psFree(md);
    15119         return false;
    15120     }
    15121 
    15122     bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md);
     14936    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) {
     14937        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
     14938        psFree(md);
     14939        return false;
     14940    }
     14941
     14942    bool status = psDBCreateTable(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
    1512314943
    1512414944    psFree(md);
    … …  
    1512714947}
    1512814948
    15129 bool p4DiffImfileDropTable(psDB *dbh)
    15130 {
    15131     return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME);
    15132 }
    15133 
    15134 bool p4DiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
     14949bool p4bInputScfileDropTable(psDB *dbh)
     14950{
     14951    return psDBDropTable(dbh, P4BINPUTSCFILE_TABLE_NAME);
     14952}
     14953
     14954bool p4bInputScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
    1513514955{
    1513614956    psMetadata *md = psMetadataAlloc();
    15137     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    15138         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     14957    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, p4b_id)) {
     14958        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     14959        psFree(md);
     14960        return false;
     14961    }
     14962    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     14963        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     14964        psFree(md);
     14965        return false;
     14966    }
     14967    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     14968        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1513914969        psFree(md);
    1514014970        return false;
    … …  
    1515014980        return false;
    1515114981    }
    15152     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    15153         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    15154         psFree(md);
    15155         return false;
    15156     }
    15157     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    15158         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15159         psFree(md);
    15160         return false;
    15161     }
    15162     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) {
    15163         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    15164         psFree(md);
    15165         return false;
    15166     }
    15167     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) {
    15168         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
    15169         psFree(md);
    15170         return false;
    15171     }
    15172 
    15173     bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md);
     14982    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) {
     14983        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
     14984        psFree(md);
     14985        return false;
     14986    }
     14987
     14988    bool status = psDBInsertOneRow(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
    1517414989    psFree(md);
    1517514990
    … …  
    1517714992}
    1517814993
    15179 long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     14994long long p4bInputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1518014995{
    1518114996    long long       deleted = 0;
    1518214997
    15183     long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     14998    long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
    1518414999    if (count < 0) {
    15185         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
     15000        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
    1518615001        return count;
    1518715002
    … …  
    1519115006    return deleted;
    1519215007}
    15193 bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object)
    15194 {
    15195     return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
    15196 }
    15197 
    15198 bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects)
     15008bool p4bInputScfileInsertObject(psDB *dbh, p4bInputScfileRow *object)
     15009{
     15010    return p4bInputScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind);
     15011}
     15012
     15013bool p4bInputScfileInsertObjects(psDB *dbh, psArray *objects)
    1519915014{
    1520015015    for (long i = 0; i < psArrayLength(objects); i++) {
    15201         if (!p4DiffImfileInsertObject(dbh, objects->data[i])) {
     15016        if (!p4bInputScfileInsertObject(dbh, objects->data[i])) {
    1520215017            return false;
    1520315018        }
    … …  
    1520715022}
    1520815023
    15209 bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits)
     15024bool p4bInputScfileInsertFits(psDB *dbh, const psFits *fits)
    1521015025{
    1521115026    psArray         *rowSet;
    1521215027
    15213     // move to (the first?) extension named  P4DIFFIMFILE_TABLE_NAME
    15214     if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) {
    15215         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME);
     15028    // move to (the first?) extension named  P4BINPUTSCFILE_TABLE_NAME
     15029    if (!psFitsMoveExtName(fits, P4BINPUTSCFILE_TABLE_NAME)) {
     15030        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BINPUTSCFILE_TABLE_NAME);
    1521615031        return false;
    1521715032    }
    … …  
    1523115046    }
    1523215047
    15233     if (!psDBInsertRows(dbh, P4DIFFIMFILE_TABLE_NAME, rowSet)) {
     15048    if (!psDBInsertRows(dbh, P4BINPUTSCFILE_TABLE_NAME, rowSet)) {
    1523415049        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    1523515050        psFree(rowSet);
    … …  
    1524215057}
    1524315058
    15244 bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15059bool p4bInputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1524515060{
    1524615061    psArray         *rowSet;
    1524715062
    15248     rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     15063    rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
    1524915064    if (!rowSet) {
    1525015065        return false;
    … …  
    1525215067
    1525315068    // output to fits
    15254     if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) {
     15069    if (!psFitsWriteTable(fits, NULL, rowSet, P4BINPUTSCFILE_TABLE_NAME)) {
    1525515070        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
    1525615071        psFree(rowSet);
    … …  
    1526315078}
    1526415079
    15265 psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object)
     15080psMetadata *p4bInputScfileMetadataFromObject(const p4bInputScfileRow *object)
    1526615081{
    1526715082    psMetadata *md = psMetadataAlloc();
    15268     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    15269         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15083    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, object->p4b_id)) {
     15084        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     15085        psFree(md);
     15086        return false;
     15087    }
     15088    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     15089        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15090        psFree(md);
     15091        return false;
     15092    }
     15093    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     15094        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1527015095        psFree(md);
    1527115096        return false;
    … …  
    1528115106        return false;
    1528215107    }
    15283     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
    15284         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    15285         psFree(md);
    15286         return false;
    15287     }
    15288     if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
    15289         psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    15290         psFree(md);
    15291         return false;
    15292     }
    15293     if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) {
    15294         psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri");
    15295         psFree(md);
    15296         return false;
    15297     }
    15298     if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) {
    15299         psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri");
     15108    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) {
     15109        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
    1530015110        psFree(md);
    1530115111        return false;
    … …  
    1530615116}
    1530715117
    15308 p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md)
     15118p4bInputScfileRow *p4bInputScfileObjectFromMetadata(psMetadata *md)
    1530915119{
    1531015120
    1531115121bool status = false;
    15312     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    15313     if (!status) {
    15314         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     15122    psS32 p4b_id = psMetadataLookupS32(&status, md, "p4b_id");
     15123    if (!status) {
     15124        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4b_id");
     15125        return false;
     15126    }
     15127    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     15128    if (!status) {
     15129        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     15130        return false;
     15131    }
     15132    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     15133    if (!status) {
     15134        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
    1531515135        return false;
    1531615136    }
    … …  
    1532515145        return false;
    1532615146    }
    15327     char* class_id = psMetadataLookupPtr(&status, md, "class_id");
    15328     if (!status) {
    15329         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    15330         return false;
    15331     }
    15332     char* uri = psMetadataLookupPtr(&status, md, "uri");
    15333     if (!status) {
    15334         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    15335         return false;
    15336     }
    15337     char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri");
    15338     if (!status) {
    15339         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    15340         return false;
    15341     }
    15342     char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri");
    15343     if (!status) {
    15344         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    15345         return false;
    15346     }
    15347 
    15348     return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
    15349 }
    15350 psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15147    char* kind = psMetadataLookupPtr(&status, md, "kind");
     15148    if (!status) {
     15149        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind");
     15150        return false;
     15151    }
     15152
     15153    return p4bInputScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, kind);
     15154}
     15155psArray *p4bInputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1535115156{
    1535215157    psArray         *rowSet;
    … …  
    1535415159    psU64           i;
    1535515160
    15356     rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     15161    rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
    1535715162    if (!rowSet) {
    1535815163        return NULL;
    … …  
    1536415169
    1536515170    for (i = 0; i < rowSet->n; i++) {
    15366         p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]);
     15171        p4bInputScfileRow *object = p4bInputScfileObjectFromMetadata(rowSet->data[i]);
    1536715172        psArrayAdd(returnSet, 0, object);
    1536815173        psFree(object);
    … …  
    1537315178    return returnSet;
    1537415179}
    15375 bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object)
    15376 {
    15377     psMetadata *where = p4DiffImfileMetadataFromObject(object);
    15378     long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0);
    15379     psFree(where)
     15180bool p4bInputScfileDeleteObject(psDB *dbh, const p4bInputScfileRow *object)
     15181{
     15182    psMetadata *where = p4bInputScfileMetadataFromObject(object);
     15183    long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, 0);
     15184    psFree(where);
    1538015185    if (count < 0) {
    15381         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
     15186        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
    1538215187        return false;
    1538315188    }
    … …  
    1538515190        // XXX should this be a psAbort() instead?  It is possible that
    1538615191        // having an object match multiple rows was by design.
    15387         psError(PS_ERR_UNKNOWN, true, "p4DiffImfileRow object matched more then one row.  Check your database schema");
    15388         return false;
    15389     }
    15390 
    15391     return true;
    15392 }
    15393 long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15192        psError(PS_ERR_UNKNOWN, true, "p4bInputScfileRow object matched more then one row.  Check your database schema");
     15193        return false;
     15194    }
     15195
     15196    return true;
     15197}
     15198long long p4bInputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
    1539415199{
    1539515200    long long       deleted = 0;
    1539615201
    1539715202    for (long long i = 0; i < objects->n; i++) {
    15398         p4DiffImfileRow *object = objects->data[i];
    15399         psMetadata *where = p4DiffImfileMetadataFromObject(object);
    15400         long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
    15401         psFree(where)
     15203        p4bInputScfileRow *object = objects->data[i];
     15204        psMetadata *where = p4bInputScfileMetadataFromObject(object);
     15205        long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
     15206        psFree(where);
    1540215207        if (count < 0) {
    15403             psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
     15208            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
    1540415209            return count;
    1540515210        }
    … …  
    1541015215    return deleted;
    1541115216}
    15412 bool p4DiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15217bool p4bInputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
    1541315218{
    1541415219    PS_ASSERT_PTR_NON_NULL(objects, false);
    … …  
    1541615221    psMetadata *output = psMetadataAlloc();
    1541715222    for (long i = 0; i < psArrayLength(objects); i++) {
    15418         psMetadata *md = p4DiffImfileMetadataFromObject(objects->data[i]);
     15223        psMetadata *md = p4bInputScfileMetadataFromObject(objects->data[i]);
    1541915224        if (!psMetadataAddMetadata(
    1542015225            output,
    1542115226            PS_LIST_TAIL,
    15422             P4DIFFIMFILE_TABLE_NAME,
     15227            P4BINPUTSCFILE_TABLE_NAME,
    1542315228            PS_META_DUPLICATE_OK,
    1542415229            NULL,
    … …  
    1544115246    return true;
    1544215247}
    15443 bool p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf)
     15248bool p4bInputScfilePrintObject(FILE *stream, p4bInputScfileRow *object, bool mdcf)
    1544415249{
    1544515250    PS_ASSERT_PTR_NON_NULL(object, false);
    1544615251
    15447     psMetadata *md = p4DiffImfileMetadataFromObject(object);
     15252    psMetadata *md = p4bInputScfileMetadataFromObject(object);
    1544815253
    1544915254    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
    … …  
    1545615261    return true;
    1545715262}
    15458 static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object);
    15459 
    15460 p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
    15461 {
    15462     p4MagicMaskImfileRow *_object;
    15463 
    15464     _object = psAlloc(sizeof(p4MagicMaskImfileRow));
    15465     psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree);
    15466 
    15467     _object->p4_id = p4_id;
     15263static void p4bDiffScfileRowFree(p4bDiffScfileRow *object);
     15264
     15265p4bDiffScfileRow *p4bDiffScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
     15266{
     15267    p4bDiffScfileRow *_object;
     15268
     15269    _object = psAlloc(sizeof(p4bDiffScfileRow));
     15270    psMemSetDeallocator(_object, (psFreeFunc)p4bDiffScfileRowFree);
     15271
     15272    _object->p4b_id = p4b_id;
     15273    _object->skycell_id = psStringCopy(skycell_id);
     15274    _object->tess_id = psStringCopy(tess_id);
    1546815275    _object->exp_tag = psStringCopy(exp_tag);
    1546915276    _object->p3_version = p3_version;
    15470     _object->class_id = psStringCopy(class_id);
    1547115277    _object->uri = psStringCopy(uri);
     15278    _object->bg = bg;
     15279    _object->bg_mean_stdev = bg_mean_stdev;
    1547215280
    1547315281    return _object;
    1547415282}
    1547515283
    15476 static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object)
    15477 {
     15284static void p4bDiffScfileRowFree(p4bDiffScfileRow *object)
     15285{
     15286    psFree(object->skycell_id);
     15287    psFree(object->tess_id);
    1547815288    psFree(object->exp_tag);
    15479     psFree(object->class_id);
    1548015289    psFree(object->uri);
    1548115290}
    1548215291
    15483 bool p4MagicMaskImfileCreateTable(psDB *dbh)
     15292bool p4bDiffScfileCreateTable(psDB *dbh)
    1548415293{
    1548515294    psMetadata *md = psMetadataAlloc();
    15486     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) {
    15487         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15295    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
     15296        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     15297        psFree(md);
     15298        return false;
     15299    }
     15300    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     15301        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15302        psFree(md);
     15303        return false;
     15304    }
     15305    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     15306        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1548815307        psFree(md);
    1548915308        return false;
    … …  
    1549915318        return false;
    1550015319    }
    15501     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
    15502         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    15503         psFree(md);
    15504         return false;
    15505     }
    1550615320    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
    1550715321        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1550915323        return false;
    1551015324    }
    15511 
    15512     bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     15325    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
     15326        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15327        psFree(md);
     15328        return false;
     15329    }
     15330    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
     15331        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     15332        psFree(md);
     15333        return false;
     15334    }
     15335
     15336    bool status = psDBCreateTable(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
    1551315337
    1551415338    psFree(md);
    … …  
    1551715341}
    1551815342
    15519 bool p4MagicMaskImfileDropTable(psDB *dbh)
    15520 {
    15521     return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME);
    15522 }
    15523 
    15524 bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
     15343bool p4bDiffScfileDropTable(psDB *dbh)
     15344{
     15345    return psDBDropTable(dbh, P4BDIFFSCFILE_TABLE_NAME);
     15346}
     15347
     15348bool p4bDiffScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *uri, psF64 bg, psF64 bg_mean_stdev)
    1552515349{
    1552615350    psMetadata *md = psMetadataAlloc();
    15527     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) {
    15528         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     15351    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, p4b_id)) {
     15352        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     15353        psFree(md);
     15354        return false;
     15355    }
     15356    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     15357        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15358        psFree(md);
     15359        return false;
     15360    }
     15361    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     15362        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
    1552915363        psFree(md);
    1553015364        return false;
    … …  
    1554015374        return false;
    1554115375    }
    15542     if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
    15543         psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
    15544         psFree(md);
    15545         return false;
    15546     }
    1554715376    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
    1554815377        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
    … …  
    1555015379        return false;
    1555115380    }
    15552 
    15553     bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     15381    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
     15382        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15383        psFree(md);
     15384        return false;
     15385    }
     15386    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
     15387        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     15388        psFree(md);
     15389        return false;
     15390    }
     15391
     15392    bool status = psDBInsertOneRow(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
    1555415393    psFree(md);
    1555515394
    … …  
    1555715396}
    1555815397
    15559 long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15398long long p4bDiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
    1556015399{
    1556115400    long long       deleted = 0;
    1556215401
    15563     long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     15402    long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
    1556415403    if (count < 0) {
    15565         psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
     15404        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
    1556615405        return count;
    1556715406
    … …  
    1557115410    return deleted;
    1557215411}
    15573 bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object)
    15574 {
    15575     return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
    15576 }
    15577 
    15578 bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
     15412bool p4bDiffScfileInsertObject(psDB *dbh, p4bDiffScfileRow *object)
     15413{
     15414    return p4bDiffScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
     15415}
     15416
     15417bool p4bDiffScfileInsertObjects(psDB *dbh, psArray *objects)
    1557915418{
    1558015419    for (long i = 0; i < psArrayLength(objects); i++) {
    15581         if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) {
     15420        if (!p4bDiffScfileInsertObject(dbh, objects->data[i])) {
    1558215421            return false;
    1558315422        }
    … …  
    1558715426}
    1558815427
    15589 bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
     15428bool p4bDiffScfileInsertFits(psDB *dbh, const psFits *fits)
    1559015429{
    1559115430    psArray         *rowSet;
    1559215431
    15593     // move to (the first?) extension named  P4MAGICMASKIMFILE_TABLE_NAME
    15594     if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) {
    15595         psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME);
     15432    // move to (the first?) extension named  P4BDIFFSCFILE_TABLE_NAME
     15433    if (!psFitsMoveExtName(fits, P4BDIFFSCFILE_TABLE_NAME)) {
     15434        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BDIFFSCFILE_TABLE_NAME);
    1559615435        return false;
    1559715436    }
    … …  
    1561115450    }
    1561215451
     15452    if (!psDBInsertRows(dbh, P4BDIFFSCFILE_TABLE_NAME, rowSet)) {
     15453        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     15454        psFree(rowSet);
     15455        return false;
     15456    }
     15457
     15458    psFree(rowSet);
     15459
     15460    return true;
     15461}
     15462
     15463bool p4bDiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15464{
     15465    psArray         *rowSet;
     15466
     15467    rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
     15468    if (!rowSet) {
     15469        return false;
     15470    }
     15471
     15472    // output to fits
     15473    if (!psFitsWriteTable(fits, NULL, rowSet, P4BDIFFSCFILE_TABLE_NAME)) {
     15474        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     15475        psFree(rowSet);
     15476        return false;
     15477    }
     15478
     15479    psFree(rowSet);
     15480
     15481    return true;
     15482}
     15483
     15484psMetadata *p4bDiffScfileMetadataFromObject(const p4bDiffScfileRow *object)
     15485{
     15486    psMetadata *md = psMetadataAlloc();
     15487    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, object->p4b_id)) {
     15488        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
     15489        psFree(md);
     15490        return false;
     15491    }
     15492    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     15493        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     15494        psFree(md);
     15495        return false;
     15496    }
     15497    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     15498        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     15499        psFree(md);
     15500        return false;
     15501    }
     15502    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     15503        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     15504        psFree(md);
     15505        return false;
     15506    }
     15507    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
     15508        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     15509        psFree(md);
     15510        return false;
     15511    }
     15512    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
     15513        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     15514        psFree(md);
     15515        return false;
     15516    }
     15517    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
     15518        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
     15519        psFree(md);
     15520        return false;
     15521    }
     15522    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
     15523        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
     15524        psFree(md);
     15525        return false;
     15526    }
     15527
     15528
     15529    return md;
     15530}
     15531
     15532p4bDiffScfileRow *p4bDiffScfileObjectFromMetadata(psMetadata *md)
     15533{
     15534
     15535bool status = false;
     15536    psS32 p4b_id = psMetadataLookupS32(&status, md, "p4b_id");
     15537    if (!status) {
     15538        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4b_id");
     15539        return false;
     15540    }
     15541    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     15542    if (!status) {
     15543        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     15544        return false;
     15545    }
     15546    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     15547    if (!status) {
     15548        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     15549        return false;
     15550    }
     15551    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     15552    if (!status) {
     15553        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     15554        return false;
     15555    }
     15556    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
     15557    if (!status) {
     15558        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     15559        return false;
     15560    }
     15561    char* uri = psMetadataLookupPtr(&status, md, "uri");
     15562    if (!status) {
     15563        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
     15564        return false;
     15565    }
     15566    psF64 bg = psMetadataLookupF64(&status, md, "bg");
     15567    if (!status) {
     15568        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
     15569        return false;
     15570    }
     15571    psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
     15572    if (!status) {
     15573        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
     15574        return false;
     15575    }
     15576
     15577    return p4bDiffScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
     15578}
     15579psArray *p4bDiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15580{
     15581    psArray         *rowSet;
     15582    psArray         *returnSet;
     15583    psU64           i;
     15584
     15585    rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
     15586    if (!rowSet) {
     15587        return NULL;
     15588    }
     15589
     15590    // convert psMetadata rows to row objects
     15591
     15592    returnSet = psArrayAllocEmpty(rowSet->n);
     15593
     15594    for (i = 0; i < rowSet->n; i++) {
     15595        p4bDiffScfileRow *object = p4bDiffScfileObjectFromMetadata(rowSet->data[i]);
     15596        psArrayAdd(returnSet, 0, object);
     15597        psFree(object);
     15598    }
     15599
     15600    psFree(rowSet);
     15601
     15602    return returnSet;
     15603}
     15604bool p4bDiffScfileDeleteObject(psDB *dbh, const p4bDiffScfileRow *object)
     15605{
     15606    psMetadata *where = p4bDiffScfileMetadataFromObject(object);
     15607    long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, 0);
     15608    psFree(where);
     15609    if (count < 0) {
     15610        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
     15611        return false;
     15612    }
     15613    if (count > 1) {
     15614        // XXX should this be a psAbort() instead?  It is possible that
     15615        // having an object match multiple rows was by design.
     15616        psError(PS_ERR_UNKNOWN, true, "p4bDiffScfileRow object matched more then one row.  Check your database schema");
     15617        return false;
     15618    }
     15619
     15620    return true;
     15621}
     15622long long p4bDiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15623{
     15624    long long       deleted = 0;
     15625
     15626    for (long long i = 0; i < objects->n; i++) {
     15627        p4bDiffScfileRow *object = objects->data[i];
     15628        psMetadata *where = p4bDiffScfileMetadataFromObject(object);
     15629        long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
     15630        psFree(where);
     15631        if (count < 0) {
     15632            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
     15633            return count;
     15634        }
     15635
     15636        deleted += count;
     15637    }
     15638
     15639    return deleted;
     15640}
     15641bool p4bDiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15642{
     15643    PS_ASSERT_PTR_NON_NULL(objects, false);
     15644
     15645    psMetadata *output = psMetadataAlloc();
     15646    for (long i = 0; i < psArrayLength(objects); i++) {
     15647        psMetadata *md = p4bDiffScfileMetadataFromObject(objects->data[i]);
     15648        if (!psMetadataAddMetadata(
     15649            output,
     15650            PS_LIST_TAIL,
     15651            P4BDIFFSCFILE_TABLE_NAME,
     15652            PS_META_DUPLICATE_OK,
     15653            NULL,
     15654            md
     15655        )) {
     15656            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     15657            psFree(md);
     15658            psFree(output);
     15659            return false;
     15660        }
     15661        psFree(md);
     15662    }
     15663
     15664    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     15665        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     15666        psFree(output);
     15667    }
     15668    psFree(output);
     15669
     15670    return true;
     15671}
     15672bool p4bDiffScfilePrintObject(FILE *stream, p4bDiffScfileRow *object, bool mdcf)
     15673{
     15674    PS_ASSERT_PTR_NON_NULL(object, false);
     15675
     15676    psMetadata *md = p4bDiffScfileMetadataFromObject(object);
     15677
     15678    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     15679        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     15680        psFree(md);
     15681    }
     15682
     15683    psFree(md);
     15684
     15685    return true;
     15686}
     15687static void p4cRunRowFree(p4cRunRow *object);
     15688
     15689p4cRunRow *p4cRunRowAlloc(psS32 p4c_id, const char *state, const char *workdir, bool magic)
     15690{
     15691    p4cRunRow       *_object;
     15692
     15693    _object = psAlloc(sizeof(p4cRunRow));
     15694    psMemSetDeallocator(_object, (psFreeFunc)p4cRunRowFree);
     15695
     15696    _object->p4c_id = p4c_id;
     15697    _object->state = psStringCopy(state);
     15698    _object->workdir = psStringCopy(workdir);
     15699    _object->magic = magic;
     15700
     15701    return _object;
     15702}
     15703
     15704static void p4cRunRowFree(p4cRunRow *object)
     15705{
     15706    psFree(object->state);
     15707    psFree(object->workdir);
     15708}
     15709
     15710bool p4cRunCreateTable(psDB *dbh)
     15711{
     15712    psMetadata *md = psMetadataAlloc();
     15713    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
     15714        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     15715        psFree(md);
     15716        return false;
     15717    }
     15718    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
     15719        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     15720        psFree(md);
     15721        return false;
     15722    }
     15723    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
     15724        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     15725        psFree(md);
     15726        return false;
     15727    }
     15728    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
     15729        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     15730        psFree(md);
     15731        return false;
     15732    }
     15733
     15734    bool status = psDBCreateTable(dbh, P4CRUN_TABLE_NAME, md);
     15735
     15736    psFree(md);
     15737
     15738    return status;
     15739}
     15740
     15741bool p4cRunDropTable(psDB *dbh)
     15742{
     15743    return psDBDropTable(dbh, P4CRUN_TABLE_NAME);
     15744}
     15745
     15746bool p4cRunInsert(psDB * dbh, psS32 p4c_id, const char *state, const char *workdir, bool magic)
     15747{
     15748    psMetadata *md = psMetadataAlloc();
     15749    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
     15750        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     15751        psFree(md);
     15752        return false;
     15753    }
     15754    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
     15755        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     15756        psFree(md);
     15757        return false;
     15758    }
     15759    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
     15760        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     15761        psFree(md);
     15762        return false;
     15763    }
     15764    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
     15765        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     15766        psFree(md);
     15767        return false;
     15768    }
     15769
     15770    bool status = psDBInsertOneRow(dbh, P4CRUN_TABLE_NAME, md);
     15771    psFree(md);
     15772
     15773    return status;
     15774}
     15775
     15776long long p4cRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15777{
     15778    long long       deleted = 0;
     15779
     15780    long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
     15781    if (count < 0) {
     15782        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
     15783        return count;
     15784
     15785        deleted += count;
     15786    }
     15787
     15788    return deleted;
     15789}
     15790bool p4cRunInsertObject(psDB *dbh, p4cRunRow *object)
     15791{
     15792    return p4cRunInsert(dbh, object->p4c_id, object->state, object->workdir, object->magic);
     15793}
     15794
     15795bool p4cRunInsertObjects(psDB *dbh, psArray *objects)
     15796{
     15797    for (long i = 0; i < psArrayLength(objects); i++) {
     15798        if (!p4cRunInsertObject(dbh, objects->data[i])) {
     15799            return false;
     15800        }
     15801    }
     15802
     15803    return true;
     15804}
     15805
     15806bool p4cRunInsertFits(psDB *dbh, const psFits *fits)
     15807{
     15808    psArray         *rowSet;
     15809
     15810    // move to (the first?) extension named  P4CRUN_TABLE_NAME
     15811    if (!psFitsMoveExtName(fits, P4CRUN_TABLE_NAME)) {
     15812        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CRUN_TABLE_NAME);
     15813        return false;
     15814    }
     15815
     15816    // check HDU type
     15817    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     15818        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     15819        return false;
     15820    }
     15821
     15822    // read fits table
     15823    rowSet = psFitsReadTable(fits);
     15824    if (!rowSet) {
     15825        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     15826        psFree(rowSet);
     15827        return false;
     15828    }
     15829
     15830    if (!psDBInsertRows(dbh, P4CRUN_TABLE_NAME, rowSet)) {
     15831        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     15832        psFree(rowSet);
     15833        return false;
     15834    }
     15835
     15836    psFree(rowSet);
     15837
     15838    return true;
     15839}
     15840
     15841bool p4cRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     15842{
     15843    psArray         *rowSet;
     15844
     15845    rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
     15846    if (!rowSet) {
     15847        return false;
     15848    }
     15849
     15850    // output to fits
     15851    if (!psFitsWriteTable(fits, NULL, rowSet, P4CRUN_TABLE_NAME)) {
     15852        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     15853        psFree(rowSet);
     15854        return false;
     15855    }
     15856
     15857    psFree(rowSet);
     15858
     15859    return true;
     15860}
     15861
     15862psMetadata *p4cRunMetadataFromObject(const p4cRunRow *object)
     15863{
     15864    psMetadata *md = psMetadataAlloc();
     15865    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
     15866        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     15867        psFree(md);
     15868        return false;
     15869    }
     15870    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
     15871        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
     15872        psFree(md);
     15873        return false;
     15874    }
     15875    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
     15876        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
     15877        psFree(md);
     15878        return false;
     15879    }
     15880    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
     15881        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
     15882        psFree(md);
     15883        return false;
     15884    }
     15885
     15886
     15887    return md;
     15888}
     15889
     15890p4cRunRow *p4cRunObjectFromMetadata(psMetadata *md)
     15891{
     15892
     15893bool status = false;
     15894    psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
     15895    if (!status) {
     15896        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
     15897        return false;
     15898    }
     15899    char* state = psMetadataLookupPtr(&status, md, "state");
     15900    if (!status) {
     15901        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
     15902        return false;
     15903    }
     15904    char* workdir = psMetadataLookupPtr(&status, md, "workdir");
     15905    if (!status) {
     15906        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
     15907        return false;
     15908    }
     15909    bool magic = psMetadataLookupBool(&status, md, "magic");
     15910    if (!status) {
     15911        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
     15912        return false;
     15913    }
     15914
     15915    return p4cRunRowAlloc(p4c_id, state, workdir, magic);
     15916}
     15917psArray *p4cRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     15918{
     15919    psArray         *rowSet;
     15920    psArray         *returnSet;
     15921    psU64           i;
     15922
     15923    rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
     15924    if (!rowSet) {
     15925        return NULL;
     15926    }
     15927
     15928    // convert psMetadata rows to row objects
     15929
     15930    returnSet = psArrayAllocEmpty(rowSet->n);
     15931
     15932    for (i = 0; i < rowSet->n; i++) {
     15933        p4cRunRow *object = p4cRunObjectFromMetadata(rowSet->data[i]);
     15934        psArrayAdd(returnSet, 0, object);
     15935        psFree(object);
     15936    }
     15937
     15938    psFree(rowSet);
     15939
     15940    return returnSet;
     15941}
     15942bool p4cRunDeleteObject(psDB *dbh, const p4cRunRow *object)
     15943{
     15944    psMetadata *where = p4cRunMetadataFromObject(object);
     15945    long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, 0);
     15946    psFree(where);
     15947    if (count < 0) {
     15948        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
     15949        return false;
     15950    }
     15951    if (count > 1) {
     15952        // XXX should this be a psAbort() instead?  It is possible that
     15953        // having an object match multiple rows was by design.
     15954        psError(PS_ERR_UNKNOWN, true, "p4cRunRow object matched more then one row.  Check your database schema");
     15955        return false;
     15956    }
     15957
     15958    return true;
     15959}
     15960long long p4cRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     15961{
     15962    long long       deleted = 0;
     15963
     15964    for (long long i = 0; i < objects->n; i++) {
     15965        p4cRunRow *object = objects->data[i];
     15966        psMetadata *where = p4cRunMetadataFromObject(object);
     15967        long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
     15968        psFree(where);
     15969        if (count < 0) {
     15970            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
     15971            return count;
     15972        }
     15973
     15974        deleted += count;
     15975    }
     15976
     15977    return deleted;
     15978}
     15979bool p4cRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     15980{
     15981    PS_ASSERT_PTR_NON_NULL(objects, false);
     15982
     15983    psMetadata *output = psMetadataAlloc();
     15984    for (long i = 0; i < psArrayLength(objects); i++) {
     15985        psMetadata *md = p4cRunMetadataFromObject(objects->data[i]);
     15986        if (!psMetadataAddMetadata(
     15987            output,
     15988            PS_LIST_TAIL,
     15989            P4CRUN_TABLE_NAME,
     15990            PS_META_DUPLICATE_OK,
     15991            NULL,
     15992            md
     15993        )) {
     15994            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     15995            psFree(md);
     15996            psFree(output);
     15997            return false;
     15998        }
     15999        psFree(md);
     16000    }
     16001
     16002    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     16003        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     16004        psFree(output);
     16005    }
     16006    psFree(output);
     16007
     16008    return true;
     16009}
     16010bool p4cRunPrintObject(FILE *stream, p4cRunRow *object, bool mdcf)
     16011{
     16012    PS_ASSERT_PTR_NON_NULL(object, false);
     16013
     16014    psMetadata *md = p4cRunMetadataFromObject(object);
     16015
     16016    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     16017        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     16018        psFree(md);
     16019    }
     16020
     16021    psFree(md);
     16022
     16023    return true;
     16024}
     16025static void p4cInputExpRowFree(p4cInputExpRow *object);
     16026
     16027p4cInputExpRow *p4cInputExpRowAlloc(psS32 p4c_id, const char *exp_tag, psS32 p3_version)
     16028{
     16029    p4cInputExpRow  *_object;
     16030
     16031    _object = psAlloc(sizeof(p4cInputExpRow));
     16032    psMemSetDeallocator(_object, (psFreeFunc)p4cInputExpRowFree);
     16033
     16034    _object->p4c_id = p4c_id;
     16035    _object->exp_tag = psStringCopy(exp_tag);
     16036    _object->p3_version = p3_version;
     16037
     16038    return _object;
     16039}
     16040
     16041static void p4cInputExpRowFree(p4cInputExpRow *object)
     16042{
     16043    psFree(object->exp_tag);
     16044}
     16045
     16046bool p4cInputExpCreateTable(psDB *dbh)
     16047{
     16048    psMetadata *md = psMetadataAlloc();
     16049    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key", 0)) {
     16050        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     16051        psFree(md);
     16052        return false;
     16053    }
     16054    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
     16055        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     16056        psFree(md);
     16057        return false;
     16058    }
     16059    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
     16060        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     16061        psFree(md);
     16062        return false;
     16063    }
     16064
     16065    bool status = psDBCreateTable(dbh, P4CINPUTEXP_TABLE_NAME, md);
     16066
     16067    psFree(md);
     16068
     16069    return status;
     16070}
     16071
     16072bool p4cInputExpDropTable(psDB *dbh)
     16073{
     16074    return psDBDropTable(dbh, P4CINPUTEXP_TABLE_NAME);
     16075}
     16076
     16077bool p4cInputExpInsert(psDB * dbh, psS32 p4c_id, const char *exp_tag, psS32 p3_version)
     16078{
     16079    psMetadata *md = psMetadataAlloc();
     16080    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
     16081        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     16082        psFree(md);
     16083        return false;
     16084    }
     16085    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     16086        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     16087        psFree(md);
     16088        return false;
     16089    }
     16090    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
     16091        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     16092        psFree(md);
     16093        return false;
     16094    }
     16095
     16096    bool status = psDBInsertOneRow(dbh, P4CINPUTEXP_TABLE_NAME, md);
     16097    psFree(md);
     16098
     16099    return status;
     16100}
     16101
     16102long long p4cInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16103{
     16104    long long       deleted = 0;
     16105
     16106    long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
     16107    if (count < 0) {
     16108        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
     16109        return count;
     16110
     16111        deleted += count;
     16112    }
     16113
     16114    return deleted;
     16115}
     16116bool p4cInputExpInsertObject(psDB *dbh, p4cInputExpRow *object)
     16117{
     16118    return p4cInputExpInsert(dbh, object->p4c_id, object->exp_tag, object->p3_version);
     16119}
     16120
     16121bool p4cInputExpInsertObjects(psDB *dbh, psArray *objects)
     16122{
     16123    for (long i = 0; i < psArrayLength(objects); i++) {
     16124        if (!p4cInputExpInsertObject(dbh, objects->data[i])) {
     16125            return false;
     16126        }
     16127    }
     16128
     16129    return true;
     16130}
     16131
     16132bool p4cInputExpInsertFits(psDB *dbh, const psFits *fits)
     16133{
     16134    psArray         *rowSet;
     16135
     16136    // move to (the first?) extension named  P4CINPUTEXP_TABLE_NAME
     16137    if (!psFitsMoveExtName(fits, P4CINPUTEXP_TABLE_NAME)) {
     16138        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CINPUTEXP_TABLE_NAME);
     16139        return false;
     16140    }
     16141
     16142    // check HDU type
     16143    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     16144        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     16145        return false;
     16146    }
     16147
     16148    // read fits table
     16149    rowSet = psFitsReadTable(fits);
     16150    if (!rowSet) {
     16151        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     16152        psFree(rowSet);
     16153        return false;
     16154    }
     16155
     16156    if (!psDBInsertRows(dbh, P4CINPUTEXP_TABLE_NAME, rowSet)) {
     16157        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     16158        psFree(rowSet);
     16159        return false;
     16160    }
     16161
     16162    psFree(rowSet);
     16163
     16164    return true;
     16165}
     16166
     16167bool p4cInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16168{
     16169    psArray         *rowSet;
     16170
     16171    rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
     16172    if (!rowSet) {
     16173        return false;
     16174    }
     16175
     16176    // output to fits
     16177    if (!psFitsWriteTable(fits, NULL, rowSet, P4CINPUTEXP_TABLE_NAME)) {
     16178        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     16179        psFree(rowSet);
     16180        return false;
     16181    }
     16182
     16183    psFree(rowSet);
     16184
     16185    return true;
     16186}
     16187
     16188psMetadata *p4cInputExpMetadataFromObject(const p4cInputExpRow *object)
     16189{
     16190    psMetadata *md = psMetadataAlloc();
     16191    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
     16192        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     16193        psFree(md);
     16194        return false;
     16195    }
     16196    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     16197        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     16198        psFree(md);
     16199        return false;
     16200    }
     16201    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
     16202        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     16203        psFree(md);
     16204        return false;
     16205    }
     16206
     16207
     16208    return md;
     16209}
     16210
     16211p4cInputExpRow *p4cInputExpObjectFromMetadata(psMetadata *md)
     16212{
     16213
     16214bool status = false;
     16215    psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
     16216    if (!status) {
     16217        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
     16218        return false;
     16219    }
     16220    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     16221    if (!status) {
     16222        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     16223        return false;
     16224    }
     16225    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
     16226    if (!status) {
     16227        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
     16228        return false;
     16229    }
     16230
     16231    return p4cInputExpRowAlloc(p4c_id, exp_tag, p3_version);
     16232}
     16233psArray *p4cInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16234{
     16235    psArray         *rowSet;
     16236    psArray         *returnSet;
     16237    psU64           i;
     16238
     16239    rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
     16240    if (!rowSet) {
     16241        return NULL;
     16242    }
     16243
     16244    // convert psMetadata rows to row objects
     16245
     16246    returnSet = psArrayAllocEmpty(rowSet->n);
     16247
     16248    for (i = 0; i < rowSet->n; i++) {
     16249        p4cInputExpRow *object = p4cInputExpObjectFromMetadata(rowSet->data[i]);
     16250        psArrayAdd(returnSet, 0, object);
     16251        psFree(object);
     16252    }
     16253
     16254    psFree(rowSet);
     16255
     16256    return returnSet;
     16257}
     16258bool p4cInputExpDeleteObject(psDB *dbh, const p4cInputExpRow *object)
     16259{
     16260    psMetadata *where = p4cInputExpMetadataFromObject(object);
     16261    long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, 0);
     16262    psFree(where);
     16263    if (count < 0) {
     16264        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
     16265        return false;
     16266    }
     16267    if (count > 1) {
     16268        // XXX should this be a psAbort() instead?  It is possible that
     16269        // having an object match multiple rows was by design.
     16270        psError(PS_ERR_UNKNOWN, true, "p4cInputExpRow object matched more then one row.  Check your database schema");
     16271        return false;
     16272    }
     16273
     16274    return true;
     16275}
     16276long long p4cInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     16277{
     16278    long long       deleted = 0;
     16279
     16280    for (long long i = 0; i < objects->n; i++) {
     16281        p4cInputExpRow *object = objects->data[i];
     16282        psMetadata *where = p4cInputExpMetadataFromObject(object);
     16283        long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
     16284        psFree(where);
     16285        if (count < 0) {
     16286            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
     16287            return count;
     16288        }
     16289
     16290        deleted += count;
     16291    }
     16292
     16293    return deleted;
     16294}
     16295bool p4cInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     16296{
     16297    PS_ASSERT_PTR_NON_NULL(objects, false);
     16298
     16299    psMetadata *output = psMetadataAlloc();
     16300    for (long i = 0; i < psArrayLength(objects); i++) {
     16301        psMetadata *md = p4cInputExpMetadataFromObject(objects->data[i]);
     16302        if (!psMetadataAddMetadata(
     16303            output,
     16304            PS_LIST_TAIL,
     16305            P4CINPUTEXP_TABLE_NAME,
     16306            PS_META_DUPLICATE_OK,
     16307            NULL,
     16308            md
     16309        )) {
     16310            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     16311            psFree(md);
     16312            psFree(output);
     16313            return false;
     16314        }
     16315        psFree(md);
     16316    }
     16317
     16318    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     16319        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     16320        psFree(output);
     16321    }
     16322    psFree(output);
     16323
     16324    return true;
     16325}
     16326bool p4cInputExpPrintObject(FILE *stream, p4cInputExpRow *object, bool mdcf)
     16327{
     16328    PS_ASSERT_PTR_NON_NULL(object, false);
     16329
     16330    psMetadata *md = p4cInputExpMetadataFromObject(object);
     16331
     16332    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     16333        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     16334        psFree(md);
     16335    }
     16336
     16337    psFree(md);
     16338
     16339    return true;
     16340}
     16341static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object);
     16342
     16343p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4c_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
     16344{
     16345    p4MagicMaskImfileRow *_object;
     16346
     16347    _object = psAlloc(sizeof(p4MagicMaskImfileRow));
     16348    psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree);
     16349
     16350    _object->p4c_id = p4c_id;
     16351    _object->exp_tag = psStringCopy(exp_tag);
     16352    _object->p3_version = p3_version;
     16353    _object->class_id = psStringCopy(class_id);
     16354    _object->uri = psStringCopy(uri);
     16355
     16356    return _object;
     16357}
     16358
     16359static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object)
     16360{
     16361    psFree(object->exp_tag);
     16362    psFree(object->class_id);
     16363    psFree(object->uri);
     16364}
     16365
     16366bool p4MagicMaskImfileCreateTable(psDB *dbh)
     16367{
     16368    psMetadata *md = psMetadataAlloc();
     16369    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key", 0)) {
     16370        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     16371        psFree(md);
     16372        return false;
     16373    }
     16374    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
     16375        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     16376        psFree(md);
     16377        return false;
     16378    }
     16379    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
     16380        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     16381        psFree(md);
     16382        return false;
     16383    }
     16384    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     16385        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     16386        psFree(md);
     16387        return false;
     16388    }
     16389    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
     16390        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     16391        psFree(md);
     16392        return false;
     16393    }
     16394
     16395    bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     16396
     16397    psFree(md);
     16398
     16399    return status;
     16400}
     16401
     16402bool p4MagicMaskImfileDropTable(psDB *dbh)
     16403{
     16404    return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME);
     16405}
     16406
     16407bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4c_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
     16408{
     16409    psMetadata *md = psMetadataAlloc();
     16410    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
     16411        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
     16412        psFree(md);
     16413        return false;
     16414    }
     16415    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     16416        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     16417        psFree(md);
     16418        return false;
     16419    }
     16420    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
     16421        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
     16422        psFree(md);
     16423        return false;
     16424    }
     16425    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
     16426        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     16427        psFree(md);
     16428        return false;
     16429    }
     16430    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
     16431        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
     16432        psFree(md);
     16433        return false;
     16434    }
     16435
     16436    bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     16437    psFree(md);
     16438
     16439    return status;
     16440}
     16441
     16442long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16443{
     16444    long long       deleted = 0;
     16445
     16446    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     16447    if (count < 0) {
     16448        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
     16449        return count;
     16450
     16451        deleted += count;
     16452    }
     16453
     16454    return deleted;
     16455}
     16456bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object)
     16457{
     16458    return p4MagicMaskImfileInsert(dbh, object->p4c_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
     16459}
     16460
     16461bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
     16462{
     16463    for (long i = 0; i < psArrayLength(objects); i++) {
     16464        if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) {
     16465            return false;
     16466        }
     16467    }
     16468
     16469    return true;
     16470}
     16471
     16472bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
     16473{
     16474    psArray         *rowSet;
     16475
     16476    // move to (the first?) extension named  P4MAGICMASKIMFILE_TABLE_NAME
     16477    if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) {
     16478        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME);
     16479        return false;
     16480    }
     16481
     16482    // check HDU type
     16483    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     16484        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     16485        return false;
     16486    }
     16487
     16488    // read fits table
     16489    rowSet = psFitsReadTable(fits);
     16490    if (!rowSet) {
     16491        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     16492        psFree(rowSet);
     16493        return false;
     16494    }
     16495
    1561316496    if (!psDBInsertRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) {
    1561416497        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
    … …  
    1564616529{
    1564716530    psMetadata *md = psMetadataAlloc();
    15648     if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) {
    15649         psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id");
     16531    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
     16532        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
    1565016533        psFree(md);
    1565116534        return false;
    … …  
    1568016563
    1568116564bool status = false;
    15682     psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id");
    15683     if (!status) {
    15684         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id");
     16565    psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
     16566    if (!status) {
     16567        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
    1568516568        return false;
    1568616569    }
    … …  
    1570616589    }
    1570716590
    15708     return p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
     16591    return p4MagicMaskImfileRowAlloc(p4c_id, exp_tag, p3_version, class_id, uri);
    1570916592}
    1571016593psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1573716620    psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
    1573816621    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0);
    15739     psFree(where)
     16622    psFree(where);
    1574016623    if (count < 0) {
    1574116624        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
    … …  
    1575916642        psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
    1576016643        long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
    15761         psFree(where)
     16644        psFree(where);
    1576216645        if (count < 0) {
    1576316646            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
    … …  
    1581616699    return true;
    1581716700}
     16701static void skyCellRowFree(skyCellRow *object);
     16702
     16703skyCellRow *skyCellRowAlloc(const char *skycell_id, const char *tess_id, psF64 ra1, psF64 decl1, psF64 ra2, psF64 decl2, psF64 ra3, psF64 decl3, psF64 ra4, psF64 decl4)
     16704{
     16705    skyCellRow      *_object;
     16706
     16707    _object = psAlloc(sizeof(skyCellRow));
     16708    psMemSetDeallocator(_object, (psFreeFunc)skyCellRowFree);
     16709
     16710    _object->skycell_id = psStringCopy(skycell_id);
     16711    _object->tess_id = psStringCopy(tess_id);
     16712    _object->ra1 = ra1;
     16713    _object->decl1 = decl1;
     16714    _object->ra2 = ra2;
     16715    _object->decl2 = decl2;
     16716    _object->ra3 = ra3;
     16717    _object->decl3 = decl3;
     16718    _object->ra4 = ra4;
     16719    _object->decl4 = decl4;
     16720
     16721    return _object;
     16722}
     16723
     16724static void skyCellRowFree(skyCellRow *object)
     16725{
     16726    psFree(object->skycell_id);
     16727    psFree(object->tess_id);
     16728}
     16729
     16730bool skyCellCreateTable(psDB *dbh)
     16731{
     16732    psMetadata *md = psMetadataAlloc();
     16733    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     16734        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16735        psFree(md);
     16736        return false;
     16737    }
     16738    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     16739        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     16740        psFree(md);
     16741        return false;
     16742    }
     16743    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra1", PS_DATA_F64, NULL, 0.0)) {
     16744        psError(PS_ERR_UNKNOWN, false, "failed to add item ra1");
     16745        psFree(md);
     16746        return false;
     16747    }
     16748    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl1", PS_DATA_F64, NULL, 0.0)) {
     16749        psError(PS_ERR_UNKNOWN, false, "failed to add item decl1");
     16750        psFree(md);
     16751        return false;
     16752    }
     16753    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra2", PS_DATA_F64, NULL, 0.0)) {
     16754        psError(PS_ERR_UNKNOWN, false, "failed to add item ra2");
     16755        psFree(md);
     16756        return false;
     16757    }
     16758    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl2", PS_DATA_F64, NULL, 0.0)) {
     16759        psError(PS_ERR_UNKNOWN, false, "failed to add item decl2");
     16760        psFree(md);
     16761        return false;
     16762    }
     16763    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra3", PS_DATA_F64, NULL, 0.0)) {
     16764        psError(PS_ERR_UNKNOWN, false, "failed to add item ra3");
     16765        psFree(md);
     16766        return false;
     16767    }
     16768    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl3", PS_DATA_F64, NULL, 0.0)) {
     16769        psError(PS_ERR_UNKNOWN, false, "failed to add item decl3");
     16770        psFree(md);
     16771        return false;
     16772    }
     16773    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra4", PS_DATA_F64, NULL, 0.0)) {
     16774        psError(PS_ERR_UNKNOWN, false, "failed to add item ra4");
     16775        psFree(md);
     16776        return false;
     16777    }
     16778    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl4", PS_DATA_F64, NULL, 0.0)) {
     16779        psError(PS_ERR_UNKNOWN, false, "failed to add item decl4");
     16780        psFree(md);
     16781        return false;
     16782    }
     16783
     16784    bool status = psDBCreateTable(dbh, SKYCELL_TABLE_NAME, md);
     16785
     16786    psFree(md);
     16787
     16788    return status;
     16789}
     16790
     16791bool skyCellDropTable(psDB *dbh)
     16792{
     16793    return psDBDropTable(dbh, SKYCELL_TABLE_NAME);
     16794}
     16795
     16796bool skyCellInsert(psDB * dbh, const char *skycell_id, const char *tess_id, psF64 ra1, psF64 decl1, psF64 ra2, psF64 decl2, psF64 ra3, psF64 decl3, psF64 ra4, psF64 decl4)
     16797{
     16798    psMetadata *md = psMetadataAlloc();
     16799    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     16800        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16801        psFree(md);
     16802        return false;
     16803    }
     16804    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     16805        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     16806        psFree(md);
     16807        return false;
     16808    }
     16809    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra1", PS_DATA_F64, NULL, ra1)) {
     16810        psError(PS_ERR_UNKNOWN, false, "failed to add item ra1");
     16811        psFree(md);
     16812        return false;
     16813    }
     16814    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl1", PS_DATA_F64, NULL, decl1)) {
     16815        psError(PS_ERR_UNKNOWN, false, "failed to add item decl1");
     16816        psFree(md);
     16817        return false;
     16818    }
     16819    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra2", PS_DATA_F64, NULL, ra2)) {
     16820        psError(PS_ERR_UNKNOWN, false, "failed to add item ra2");
     16821        psFree(md);
     16822        return false;
     16823    }
     16824    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl2", PS_DATA_F64, NULL, decl2)) {
     16825        psError(PS_ERR_UNKNOWN, false, "failed to add item decl2");
     16826        psFree(md);
     16827        return false;
     16828    }
     16829    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra3", PS_DATA_F64, NULL, ra3)) {
     16830        psError(PS_ERR_UNKNOWN, false, "failed to add item ra3");
     16831        psFree(md);
     16832        return false;
     16833    }
     16834    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl3", PS_DATA_F64, NULL, decl3)) {
     16835        psError(PS_ERR_UNKNOWN, false, "failed to add item decl3");
     16836        psFree(md);
     16837        return false;
     16838    }
     16839    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra4", PS_DATA_F64, NULL, ra4)) {
     16840        psError(PS_ERR_UNKNOWN, false, "failed to add item ra4");
     16841        psFree(md);
     16842        return false;
     16843    }
     16844    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl4", PS_DATA_F64, NULL, decl4)) {
     16845        psError(PS_ERR_UNKNOWN, false, "failed to add item decl4");
     16846        psFree(md);
     16847        return false;
     16848    }
     16849
     16850    bool status = psDBInsertOneRow(dbh, SKYCELL_TABLE_NAME, md);
     16851    psFree(md);
     16852
     16853    return status;
     16854}
     16855
     16856long long skyCellDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     16857{
     16858    long long       deleted = 0;
     16859
     16860    long long count = psDBDeleteRows(dbh, SKYCELL_TABLE_NAME, where, limit);
     16861    if (count < 0) {
     16862        psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCell");
     16863        return count;
     16864
     16865        deleted += count;
     16866    }
     16867
     16868    return deleted;
     16869}
     16870bool skyCellInsertObject(psDB *dbh, skyCellRow *object)
     16871{
     16872    return skyCellInsert(dbh, object->skycell_id, object->tess_id, object->ra1, object->decl1, object->ra2, object->decl2, object->ra3, object->decl3, object->ra4, object->decl4);
     16873}
     16874
     16875bool skyCellInsertObjects(psDB *dbh, psArray *objects)
     16876{
     16877    for (long i = 0; i < psArrayLength(objects); i++) {
     16878        if (!skyCellInsertObject(dbh, objects->data[i])) {
     16879            return false;
     16880        }
     16881    }
     16882
     16883    return true;
     16884}
     16885
     16886bool skyCellInsertFits(psDB *dbh, const psFits *fits)
     16887{
     16888    psArray         *rowSet;
     16889
     16890    // move to (the first?) extension named  SKYCELL_TABLE_NAME
     16891    if (!psFitsMoveExtName(fits, SKYCELL_TABLE_NAME)) {
     16892        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", SKYCELL_TABLE_NAME);
     16893        return false;
     16894    }
     16895
     16896    // check HDU type
     16897    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     16898        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     16899        return false;
     16900    }
     16901
     16902    // read fits table
     16903    rowSet = psFitsReadTable(fits);
     16904    if (!rowSet) {
     16905        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     16906        psFree(rowSet);
     16907        return false;
     16908    }
     16909
     16910    if (!psDBInsertRows(dbh, SKYCELL_TABLE_NAME, rowSet)) {
     16911        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     16912        psFree(rowSet);
     16913        return false;
     16914    }
     16915
     16916    psFree(rowSet);
     16917
     16918    return true;
     16919}
     16920
     16921bool skyCellSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     16922{
     16923    psArray         *rowSet;
     16924
     16925    rowSet = psDBSelectRows(dbh, SKYCELL_TABLE_NAME, where, limit);
     16926    if (!rowSet) {
     16927        return false;
     16928    }
     16929
     16930    // output to fits
     16931    if (!psFitsWriteTable(fits, NULL, rowSet, SKYCELL_TABLE_NAME)) {
     16932        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     16933        psFree(rowSet);
     16934        return false;
     16935    }
     16936
     16937    psFree(rowSet);
     16938
     16939    return true;
     16940}
     16941
     16942psMetadata *skyCellMetadataFromObject(const skyCellRow *object)
     16943{
     16944    psMetadata *md = psMetadataAlloc();
     16945    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     16946        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     16947        psFree(md);
     16948        return false;
     16949    }
     16950    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     16951        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     16952        psFree(md);
     16953        return false;
     16954    }
     16955    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra1", PS_DATA_F64, NULL, object->ra1)) {
     16956        psError(PS_ERR_UNKNOWN, false, "failed to add item ra1");
     16957        psFree(md);
     16958        return false;
     16959    }
     16960    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl1", PS_DATA_F64, NULL, object->decl1)) {
     16961        psError(PS_ERR_UNKNOWN, false, "failed to add item decl1");
     16962        psFree(md);
     16963        return false;
     16964    }
     16965    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra2", PS_DATA_F64, NULL, object->ra2)) {
     16966        psError(PS_ERR_UNKNOWN, false, "failed to add item ra2");
     16967        psFree(md);
     16968        return false;
     16969    }
     16970    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl2", PS_DATA_F64, NULL, object->decl2)) {
     16971        psError(PS_ERR_UNKNOWN, false, "failed to add item decl2");
     16972        psFree(md);
     16973        return false;
     16974    }
     16975    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra3", PS_DATA_F64, NULL, object->ra3)) {
     16976        psError(PS_ERR_UNKNOWN, false, "failed to add item ra3");
     16977        psFree(md);
     16978        return false;
     16979    }
     16980    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl3", PS_DATA_F64, NULL, object->decl3)) {
     16981        psError(PS_ERR_UNKNOWN, false, "failed to add item decl3");
     16982        psFree(md);
     16983        return false;
     16984    }
     16985    if (!psMetadataAdd(md, PS_LIST_TAIL, "ra4", PS_DATA_F64, NULL, object->ra4)) {
     16986        psError(PS_ERR_UNKNOWN, false, "failed to add item ra4");
     16987        psFree(md);
     16988        return false;
     16989    }
     16990    if (!psMetadataAdd(md, PS_LIST_TAIL, "decl4", PS_DATA_F64, NULL, object->decl4)) {
     16991        psError(PS_ERR_UNKNOWN, false, "failed to add item decl4");
     16992        psFree(md);
     16993        return false;
     16994    }
     16995
     16996
     16997    return md;
     16998}
     16999
     17000skyCellRow *skyCellObjectFromMetadata(psMetadata *md)
     17001{
     17002
     17003bool status = false;
     17004    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     17005    if (!status) {
     17006        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     17007        return false;
     17008    }
     17009    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     17010    if (!status) {
     17011        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     17012        return false;
     17013    }
     17014    psF64 ra1 = psMetadataLookupF64(&status, md, "ra1");
     17015    if (!status) {
     17016        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra1");
     17017        return false;
     17018    }
     17019    psF64 decl1 = psMetadataLookupF64(&status, md, "decl1");
     17020    if (!status) {
     17021        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl1");
     17022        return false;
     17023    }
     17024    psF64 ra2 = psMetadataLookupF64(&status, md, "ra2");
     17025    if (!status) {
     17026        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra2");
     17027        return false;
     17028    }
     17029    psF64 decl2 = psMetadataLookupF64(&status, md, "decl2");
     17030    if (!status) {
     17031        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl2");
     17032        return false;
     17033    }
     17034    psF64 ra3 = psMetadataLookupF64(&status, md, "ra3");
     17035    if (!status) {
     17036        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra3");
     17037        return false;
     17038    }
     17039    psF64 decl3 = psMetadataLookupF64(&status, md, "decl3");
     17040    if (!status) {
     17041        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl3");
     17042        return false;
     17043    }
     17044    psF64 ra4 = psMetadataLookupF64(&status, md, "ra4");
     17045    if (!status) {
     17046        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra4");
     17047        return false;
     17048    }
     17049    psF64 decl4 = psMetadataLookupF64(&status, md, "decl4");
     17050    if (!status) {
     17051        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl4");
     17052        return false;
     17053    }
     17054
     17055    return skyCellRowAlloc(skycell_id, tess_id, ra1, decl1, ra2, decl2, ra3, decl3, ra4, decl4);
     17056}
     17057psArray *skyCellSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17058{
     17059    psArray         *rowSet;
     17060    psArray         *returnSet;
     17061    psU64           i;
     17062
     17063    rowSet = psDBSelectRows(dbh, SKYCELL_TABLE_NAME, where, limit);
     17064    if (!rowSet) {
     17065        return NULL;
     17066    }
     17067
     17068    // convert psMetadata rows to row objects
     17069
     17070    returnSet = psArrayAllocEmpty(rowSet->n);
     17071
     17072    for (i = 0; i < rowSet->n; i++) {
     17073        skyCellRow *object = skyCellObjectFromMetadata(rowSet->data[i]);
     17074        psArrayAdd(returnSet, 0, object);
     17075        psFree(object);
     17076    }
     17077
     17078    psFree(rowSet);
     17079
     17080    return returnSet;
     17081}
     17082bool skyCellDeleteObject(psDB *dbh, const skyCellRow *object)
     17083{
     17084    psMetadata *where = skyCellMetadataFromObject(object);
     17085    long long count = psDBDeleteRows(dbh, SKYCELL_TABLE_NAME, where, 0);
     17086    psFree(where);
     17087    if (count < 0) {
     17088        psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCell");
     17089        return false;
     17090    }
     17091    if (count > 1) {
     17092        // XXX should this be a psAbort() instead?  It is possible that
     17093        // having an object match multiple rows was by design.
     17094        psError(PS_ERR_UNKNOWN, true, "skyCellRow object matched more then one row.  Check your database schema");
     17095        return false;
     17096    }
     17097
     17098    return true;
     17099}
     17100long long skyCellDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     17101{
     17102    long long       deleted = 0;
     17103
     17104    for (long long i = 0; i < objects->n; i++) {
     17105        skyCellRow *object = objects->data[i];
     17106        psMetadata *where = skyCellMetadataFromObject(object);
     17107        long long count = psDBDeleteRows(dbh, SKYCELL_TABLE_NAME, where, limit);
     17108        psFree(where);
     17109        if (count < 0) {
     17110            psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCell");
     17111            return count;
     17112        }
     17113
     17114        deleted += count;
     17115    }
     17116
     17117    return deleted;
     17118}
     17119bool skyCellPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17120{
     17121    PS_ASSERT_PTR_NON_NULL(objects, false);
     17122
     17123    psMetadata *output = psMetadataAlloc();
     17124    for (long i = 0; i < psArrayLength(objects); i++) {
     17125        psMetadata *md = skyCellMetadataFromObject(objects->data[i]);
     17126        if (!psMetadataAddMetadata(
     17127            output,
     17128            PS_LIST_TAIL,
     17129            SKYCELL_TABLE_NAME,
     17130            PS_META_DUPLICATE_OK,
     17131            NULL,
     17132            md
     17133        )) {
     17134            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     17135            psFree(md);
     17136            psFree(output);
     17137            return false;
     17138        }
     17139        psFree(md);
     17140    }
     17141
     17142    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     17143        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     17144        psFree(output);
     17145    }
     17146    psFree(output);
     17147
     17148    return true;
     17149}
     17150bool skyCellPrintObject(FILE *stream, skyCellRow *object, bool mdcf)
     17151{
     17152    PS_ASSERT_PTR_NON_NULL(object, false);
     17153
     17154    psMetadata *md = skyCellMetadataFromObject(object);
     17155
     17156    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     17157        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     17158        psFree(md);
     17159    }
     17160
     17161    psFree(md);
     17162
     17163    return true;
     17164}
     17165static void skyCellMapRowFree(skyCellMapRow *object);
     17166
     17167skyCellMapRow *skyCellMapRowAlloc(const char *skycell_id, const char *tess_id, const char *exp_tag, const char *class_id)
     17168{
     17169    skyCellMapRow   *_object;
     17170
     17171    _object = psAlloc(sizeof(skyCellMapRow));
     17172    psMemSetDeallocator(_object, (psFreeFunc)skyCellMapRowFree);
     17173
     17174    _object->skycell_id = psStringCopy(skycell_id);
     17175    _object->tess_id = psStringCopy(tess_id);
     17176    _object->exp_tag = psStringCopy(exp_tag);
     17177    _object->class_id = psStringCopy(class_id);
     17178
     17179    return _object;
     17180}
     17181
     17182static void skyCellMapRowFree(skyCellMapRow *object)
     17183{
     17184    psFree(object->skycell_id);
     17185    psFree(object->tess_id);
     17186    psFree(object->exp_tag);
     17187    psFree(object->class_id);
     17188}
     17189
     17190bool skyCellMapCreateTable(psDB *dbh)
     17191{
     17192    psMetadata *md = psMetadataAlloc();
     17193    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
     17194        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     17195        psFree(md);
     17196        return false;
     17197    }
     17198    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
     17199        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     17200        psFree(md);
     17201        return false;
     17202    }
     17203    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
     17204        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     17205        psFree(md);
     17206        return false;
     17207    }
     17208    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) {
     17209        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     17210        psFree(md);
     17211        return false;
     17212    }
     17213
     17214    bool status = psDBCreateTable(dbh, SKYCELLMAP_TABLE_NAME, md);
     17215
     17216    psFree(md);
     17217
     17218    return status;
     17219}
     17220
     17221bool skyCellMapDropTable(psDB *dbh)
     17222{
     17223    return psDBDropTable(dbh, SKYCELLMAP_TABLE_NAME);
     17224}
     17225
     17226bool skyCellMapInsert(psDB * dbh, const char *skycell_id, const char *tess_id, const char *exp_tag, const char *class_id)
     17227{
     17228    psMetadata *md = psMetadataAlloc();
     17229    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
     17230        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     17231        psFree(md);
     17232        return false;
     17233    }
     17234    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
     17235        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     17236        psFree(md);
     17237        return false;
     17238    }
     17239    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
     17240        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     17241        psFree(md);
     17242        return false;
     17243    }
     17244    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) {
     17245        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     17246        psFree(md);
     17247        return false;
     17248    }
     17249
     17250    bool status = psDBInsertOneRow(dbh, SKYCELLMAP_TABLE_NAME, md);
     17251    psFree(md);
     17252
     17253    return status;
     17254}
     17255
     17256long long skyCellMapDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17257{
     17258    long long       deleted = 0;
     17259
     17260    long long count = psDBDeleteRows(dbh, SKYCELLMAP_TABLE_NAME, where, limit);
     17261    if (count < 0) {
     17262        psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCellMap");
     17263        return count;
     17264
     17265        deleted += count;
     17266    }
     17267
     17268    return deleted;
     17269}
     17270bool skyCellMapInsertObject(psDB *dbh, skyCellMapRow *object)
     17271{
     17272    return skyCellMapInsert(dbh, object->skycell_id, object->tess_id, object->exp_tag, object->class_id);
     17273}
     17274
     17275bool skyCellMapInsertObjects(psDB *dbh, psArray *objects)
     17276{
     17277    for (long i = 0; i < psArrayLength(objects); i++) {
     17278        if (!skyCellMapInsertObject(dbh, objects->data[i])) {
     17279            return false;
     17280        }
     17281    }
     17282
     17283    return true;
     17284}
     17285
     17286bool skyCellMapInsertFits(psDB *dbh, const psFits *fits)
     17287{
     17288    psArray         *rowSet;
     17289
     17290    // move to (the first?) extension named  SKYCELLMAP_TABLE_NAME
     17291    if (!psFitsMoveExtName(fits, SKYCELLMAP_TABLE_NAME)) {
     17292        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", SKYCELLMAP_TABLE_NAME);
     17293        return false;
     17294    }
     17295
     17296    // check HDU type
     17297    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
     17298        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
     17299        return false;
     17300    }
     17301
     17302    // read fits table
     17303    rowSet = psFitsReadTable(fits);
     17304    if (!rowSet) {
     17305        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
     17306        psFree(rowSet);
     17307        return false;
     17308    }
     17309
     17310    if (!psDBInsertRows(dbh, SKYCELLMAP_TABLE_NAME, rowSet)) {
     17311        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
     17312        psFree(rowSet);
     17313        return false;
     17314    }
     17315
     17316    psFree(rowSet);
     17317
     17318    return true;
     17319}
     17320
     17321bool skyCellMapSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
     17322{
     17323    psArray         *rowSet;
     17324
     17325    rowSet = psDBSelectRows(dbh, SKYCELLMAP_TABLE_NAME, where, limit);
     17326    if (!rowSet) {
     17327        return false;
     17328    }
     17329
     17330    // output to fits
     17331    if (!psFitsWriteTable(fits, NULL, rowSet, SKYCELLMAP_TABLE_NAME)) {
     17332        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
     17333        psFree(rowSet);
     17334        return false;
     17335    }
     17336
     17337    psFree(rowSet);
     17338
     17339    return true;
     17340}
     17341
     17342psMetadata *skyCellMapMetadataFromObject(const skyCellMapRow *object)
     17343{
     17344    psMetadata *md = psMetadataAlloc();
     17345    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
     17346        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
     17347        psFree(md);
     17348        return false;
     17349    }
     17350    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
     17351        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
     17352        psFree(md);
     17353        return false;
     17354    }
     17355    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
     17356        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
     17357        psFree(md);
     17358        return false;
     17359    }
     17360    if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) {
     17361        psError(PS_ERR_UNKNOWN, false, "failed to add item class_id");
     17362        psFree(md);
     17363        return false;
     17364    }
     17365
     17366
     17367    return md;
     17368}
     17369
     17370skyCellMapRow *skyCellMapObjectFromMetadata(psMetadata *md)
     17371{
     17372
     17373bool status = false;
     17374    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
     17375    if (!status) {
     17376        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
     17377        return false;
     17378    }
     17379    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
     17380    if (!status) {
     17381        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
     17382        return false;
     17383    }
     17384    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
     17385    if (!status) {
     17386        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
     17387        return false;
     17388    }
     17389    char* class_id = psMetadataLookupPtr(&status, md, "class_id");
     17390    if (!status) {
     17391        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
     17392        return false;
     17393    }
     17394
     17395    return skyCellMapRowAlloc(skycell_id, tess_id, exp_tag, class_id);
     17396}
     17397psArray *skyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
     17398{
     17399    psArray         *rowSet;
     17400    psArray         *returnSet;
     17401    psU64           i;
     17402
     17403    rowSet = psDBSelectRows(dbh, SKYCELLMAP_TABLE_NAME, where, limit);
     17404    if (!rowSet) {
     17405        return NULL;
     17406    }
     17407
     17408    // convert psMetadata rows to row objects
     17409
     17410    returnSet = psArrayAllocEmpty(rowSet->n);
     17411
     17412    for (i = 0; i < rowSet->n; i++) {
     17413        skyCellMapRow *object = skyCellMapObjectFromMetadata(rowSet->data[i]);
     17414        psArrayAdd(returnSet, 0, object);
     17415        psFree(object);
     17416    }
     17417
     17418    psFree(rowSet);
     17419
     17420    return returnSet;
     17421}
     17422bool skyCellMapDeleteObject(psDB *dbh, const skyCellMapRow *object)
     17423{
     17424    psMetadata *where = skyCellMapMetadataFromObject(object);
     17425    long long count = psDBDeleteRows(dbh, SKYCELLMAP_TABLE_NAME, where, 0);
     17426    psFree(where);
     17427    if (count < 0) {
     17428        psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCellMap");
     17429        return false;
     17430    }
     17431    if (count > 1) {
     17432        // XXX should this be a psAbort() instead?  It is possible that
     17433        // having an object match multiple rows was by design.
     17434        psError(PS_ERR_UNKNOWN, true, "skyCellMapRow object matched more then one row.  Check your database schema");
     17435        return false;
     17436    }
     17437
     17438    return true;
     17439}
     17440long long skyCellMapDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
     17441{
     17442    long long       deleted = 0;
     17443
     17444    for (long long i = 0; i < objects->n; i++) {
     17445        skyCellMapRow *object = objects->data[i];
     17446        psMetadata *where = skyCellMapMetadataFromObject(object);
     17447        long long count = psDBDeleteRows(dbh, SKYCELLMAP_TABLE_NAME, where, limit);
     17448        psFree(where);
     17449        if (count < 0) {
     17450            psError(PS_ERR_UNKNOWN, true, "failed to delete row from skyCellMap");
     17451            return count;
     17452        }
     17453
     17454        deleted += count;
     17455    }
     17456
     17457    return deleted;
     17458}
     17459bool skyCellMapPrintObjects(FILE *stream, psArray *objects, bool mdcf)
     17460{
     17461    PS_ASSERT_PTR_NON_NULL(objects, false);
     17462
     17463    psMetadata *output = psMetadataAlloc();
     17464    for (long i = 0; i < psArrayLength(objects); i++) {
     17465        psMetadata *md = skyCellMapMetadataFromObject(objects->data[i]);
     17466        if (!psMetadataAddMetadata(
     17467            output,
     17468            PS_LIST_TAIL,
     17469            SKYCELLMAP_TABLE_NAME,
     17470            PS_META_DUPLICATE_OK,
     17471            NULL,
     17472            md
     17473        )) {
     17474            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
     17475            psFree(md);
     17476            psFree(output);
     17477            return false;
     17478        }
     17479        psFree(md);
     17480    }
     17481
     17482    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
     17483        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     17484        psFree(output);
     17485    }
     17486    psFree(output);
     17487
     17488    return true;
     17489}
     17490bool skyCellMapPrintObject(FILE *stream, skyCellMapRow *object, bool mdcf)
     17491{
     17492    PS_ASSERT_PTR_NON_NULL(object, false);
     17493
     17494    psMetadata *md = skyCellMapMetadataFromObject(object);
     17495
     17496    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
     17497        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
     17498        psFree(md);
     17499    }
     17500
     17501    psFree(md);
     17502
     17503    return true;
     17504}
Note: See TracChangeset for help on using the changeset viewer.