Changeset 11720 for trunk/ippdb/src/ippdb.c

Timestamp:

Feb 8, 2007, 3:18:04 PM (19 years ago)

Author:

jhoblitt

Message:

VERSION 1.1.3

File:

• trunk/ippdb/src/ippdb.c (modified) (112 diffs)

trunk/ippdb/src/ippdb.c

@@ -20 +20 @@
 /*
  *
- * This file was generated by glueforge 0.36
+ * This file was generated by glueforge 1.00
  *
  * Do NOT directly edit this file.
@@ -62 +62 @@
 #define DETRESIDEXP_TABLE_NAME "detResidExp"
 #define DETRUNSUMMARY_TABLE_NAME "detRunSummary"
-#define P4ARUN_TABLE_NAME "p4aRun"
-#define P4AINPUTEXP_TABLE_NAME "p4aInputExp"
-#define P4ASCFILE_TABLE_NAME "p4aScfile"
-#define P4BRUN_TABLE_NAME "p4bRun"
-#define P4BINPUTSCFILE_TABLE_NAME "p4bInputScfile"
-#define P4BDIFFSCFILE_TABLE_NAME "p4bDiffScfile"
-#define P4CRUN_TABLE_NAME "p4cRun"
-#define P4CINPUTEXP_TABLE_NAME "p4cInputExp"
+#define P4RUN_TABLE_NAME "p4Run"
+#define P4INPUTEXP_TABLE_NAME "p4InputExp"
+#define P4SCFILE_TABLE_NAME "p4Scfile"
+#define P4INPUTSCFILE_TABLE_NAME "p4InputScfile"
+#define P4DIFFSCFILE_TABLE_NAME "p4DiffScfile"
 #define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
 #define SKYCELL_TABLE_NAME "skyCell"
@@ -13463 +13460 @@
     return true;
 }
-static void p4aRunRowFree(p4aRunRow *object);
-
-p4aRunRow *p4aRunRowAlloc(psS32 p4a_id, const char *state, const char *workdir, bool magic)
-{
-    p4aRunRow       *_object;
-
-    _object = psAlloc(sizeof(p4aRunRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4aRunRowFree);
+static void p4RunRowFree(p4RunRow *object);
+
+p4RunRow *p4RunRowAlloc(psS32 p4a_id, const char *mode, const char *state, const char *workdir, psTime* registered)
+{
+    p4RunRow        *_object;
+
+    _object = psAlloc(sizeof(p4RunRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4RunRowFree);
 
     _object->p4a_id = p4a_id;
+    _object->mode = psStringCopy(mode);
     _object->state = psStringCopy(state);
     _object->workdir = psStringCopy(workdir);
-    _object->magic = magic;
+    _object->registered = psTimeCopy(registered);
 
     return _object;
 }
 
-static void p4aRunRowFree(p4aRunRow *object)
-{
+static void p4RunRowFree(p4RunRow *object)
+{
+    psFree(object->mode);
     psFree(object->state);
     psFree(object->workdir);
-}
-
-bool p4aRunCreateTable(psDB *dbh)
+    psFree(object->registered);
+}
+
+bool p4RunCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13494 +13494 @@
         return false;
     }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, "Key", "64")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
+        psFree(md);
+        return false;
+    }
     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
@@ -13504 +13509 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4ARUN_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBCreateTable(dbh, P4RUN_TABLE_NAME, md);
 
     psFree(md);
@@ -13517 +13522 @@
 }
 
-bool p4aRunDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4ARUN_TABLE_NAME);
-}
-
-bool p4aRunInsert(psDB * dbh, psS32 p4a_id, const char *state, const char *workdir, bool magic)
+bool p4RunDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4RUN_TABLE_NAME);
+}
+
+bool p4RunInsert(psDB * dbh, psS32 p4a_id, const char *mode, const char *state, const char *workdir, psTime* registered)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13530 +13535 @@
         return false;
     }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, mode)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
+        psFree(md);
+        return false;
+    }
     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
@@ -13540 +13550 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4ARUN_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBInsertOneRow(dbh, P4RUN_TABLE_NAME, md);
     psFree(md);
 
@@ -13552 +13562 @@
 }
 
-long long p4aRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
         return count;
 
@@ -13566 +13576 @@
     return deleted;
 }
-bool p4aRunInsertObject(psDB *dbh, p4aRunRow *object)
-{
-    return p4aRunInsert(dbh, object->p4a_id, object->state, object->workdir, object->magic);
-}
-
-bool p4aRunInsertObjects(psDB *dbh, psArray *objects)
+bool p4RunInsertObject(psDB *dbh, p4RunRow *object)
+{
+    return p4RunInsert(dbh, object->p4a_id, object->mode, object->state, object->workdir, object->registered);
+}
+
+bool p4RunInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4aRunInsertObject(dbh, objects->data[i])) {
+        if (!p4RunInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -13582 +13592 @@
 }
 
-bool p4aRunInsertFits(psDB *dbh, const psFits *fits)
+bool p4RunInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4ARUN_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4ARUN_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ARUN_TABLE_NAME);
+    // move to (the first?) extension named  P4RUN_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4RUN_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4RUN_TABLE_NAME);
         return false;
     }
@@ -13606 +13616 @@
     }
 
-    if (!psDBInsertRows(dbh, P4ARUN_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4RUN_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -13617 +13627 @@
 }
 
-bool p4aRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -13627 +13637 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4ARUN_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4RUN_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -13638 +13648 @@
 }
 
-psMetadata *p4aRunMetadataFromObject(const p4aRunRow *object)
+psMetadata *p4RunMetadataFromObject(const p4RunRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13646 +13656 @@
         return false;
     }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, object->mode)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item mode");
+        psFree(md);
+        return false;
+    }
     if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
         psError(PS_ERR_UNKNOWN, false, "failed to add item state");
@@ -13656 +13671 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item registered");
         psFree(md);
         return false;
@@ -13666 +13681 @@
 }
 
-p4aRunRow *p4aRunObjectFromMetadata(psMetadata *md)
+p4RunRow *p4RunObjectFromMetadata(psMetadata *md)
 {
 
@@ -13675 +13690 @@
         return false;
     }
+    char* mode = psMetadataLookupPtr(&status, md, "mode");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item mode");
+        return false;
+    }
     char* state = psMetadataLookupPtr(&status, md, "state");
     if (!status) {
@@ -13685 +13705 @@
         return false;
     }
-    bool magic = psMetadataLookupBool(&status, md, "magic");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
-        return false;
-    }
-
-    return p4aRunRowAlloc(p4a_id, state, workdir, magic);
-}
-psArray *p4aRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    psTime* registered = psMetadataLookupPtr(&status, md, "registered");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered");
+        return false;
+    }
+
+    return p4RunRowAlloc(p4a_id, mode, state, workdir, registered);
+}
+psArray *p4RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -13699 +13719 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4ARUN_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -13709 +13729 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4aRunRow *object = p4aRunObjectFromMetadata(rowSet->data[i]);
+        p4RunRow *object = p4RunObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -13718 +13738 @@
     return returnSet;
 }
-bool p4aRunDeleteObject(psDB *dbh, const p4aRunRow *object)
-{
-    psMetadata *where = p4aRunMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, 0);
+bool p4RunDeleteObject(psDB *dbh, const p4RunRow *object)
+{
+    psMetadata *where = p4RunMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, 0);
     psFree(where);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
         return false;
     }
@@ -13730 +13750 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4aRunRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4aRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4RunRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4aRunRow *object = objects->data[i];
-        psMetadata *where = p4aRunMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4ARUN_TABLE_NAME, where, limit);
+        p4RunRow *object = objects->data[i];
+        psMetadata *where = p4RunMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit);
         psFree(where);
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aRun");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run");
             return count;
         }
@@ -13755 +13775 @@
     return deleted;
 }
-bool p4aRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4RunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -13761 +13781 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4aRunMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4RunMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4ARUN_TABLE_NAME,
+            P4RUN_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -13786 +13806 @@
     return true;
 }
-bool p4aRunPrintObject(FILE *stream, p4aRunRow *object, bool mdcf)
+bool p4RunPrintObject(FILE *stream, p4RunRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4aRunMetadataFromObject(object);
+    psMetadata *md = p4RunMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -13801 +13821 @@
     return true;
 }
-static void p4aInputExpRowFree(p4aInputExpRow *object);
-
-p4aInputExpRow *p4aInputExpRowAlloc(psS32 p4a_id, const char *exp_tag, psS32 p3_version)
-{
-    p4aInputExpRow  *_object;
-
-    _object = psAlloc(sizeof(p4aInputExpRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4aInputExpRowFree);
+static void p4InputExpRowFree(p4InputExpRow *object);
+
+p4InputExpRow *p4InputExpRowAlloc(psS32 p4a_id, const char *exp_tag, psS32 p3_version, bool magiced)
+{
+    p4InputExpRow   *_object;
+
+    _object = psAlloc(sizeof(p4InputExpRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4InputExpRowFree);
 
     _object->p4a_id = p4a_id;
     _object->exp_tag = psStringCopy(exp_tag);
     _object->p3_version = p3_version;
+    _object->magiced = magiced;
 
     return _object;
 }
 
-static void p4aInputExpRowFree(p4aInputExpRow *object)
+static void p4InputExpRowFree(p4InputExpRow *object)
 {
     psFree(object->exp_tag);
 }
 
-bool p4aInputExpCreateTable(psDB *dbh)
+bool p4InputExpCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13840 +13861 @@
         return false;
     }
-
-    bool status = psDBCreateTable(dbh, P4AINPUTEXP_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, "Primary Key", 0)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBCreateTable(dbh, P4INPUTEXP_TABLE_NAME, md);
 
     psFree(md);
@@ -13848 +13874 @@
 }
 
-bool p4aInputExpDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4AINPUTEXP_TABLE_NAME);
-}
-
-bool p4aInputExpInsert(psDB * dbh, psS32 p4a_id, const char *exp_tag, psS32 p3_version)
+bool p4InputExpDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4INPUTEXP_TABLE_NAME);
+}
+
+bool p4InputExpInsert(psDB * dbh, psS32 p4a_id, const char *exp_tag, psS32 p3_version, bool magiced)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13871 +13897 @@
         return false;
     }
-
-    bool status = psDBInsertOneRow(dbh, P4AINPUTEXP_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, magiced)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBInsertOneRow(dbh, P4INPUTEXP_TABLE_NAME, md);
     psFree(md);
 
@@ -13878 +13909 @@
 }
 
-long long p4aInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4InputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
         return count;
 
@@ -13892 +13923 @@
     return deleted;
 }
-bool p4aInputExpInsertObject(psDB *dbh, p4aInputExpRow *object)
-{
-    return p4aInputExpInsert(dbh, object->p4a_id, object->exp_tag, object->p3_version);
-}
-
-bool p4aInputExpInsertObjects(psDB *dbh, psArray *objects)
+bool p4InputExpInsertObject(psDB *dbh, p4InputExpRow *object)
+{
+    return p4InputExpInsert(dbh, object->p4a_id, object->exp_tag, object->p3_version, object->magiced);
+}
+
+bool p4InputExpInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4aInputExpInsertObject(dbh, objects->data[i])) {
+        if (!p4InputExpInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -13908 +13939 @@
 }
 
-bool p4aInputExpInsertFits(psDB *dbh, const psFits *fits)
+bool p4InputExpInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4AINPUTEXP_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4AINPUTEXP_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4AINPUTEXP_TABLE_NAME);
+    // move to (the first?) extension named  P4INPUTEXP_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4INPUTEXP_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTEXP_TABLE_NAME);
         return false;
     }
@@ -13932 +13963 @@
     }
 
-    if (!psDBInsertRows(dbh, P4AINPUTEXP_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4INPUTEXP_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -13943 +13974 @@
 }
 
-bool p4aInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4InputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -13953 +13984 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4AINPUTEXP_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTEXP_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -13964 +13995 @@
 }
 
-psMetadata *p4aInputExpMetadataFromObject(const p4aInputExpRow *object)
+psMetadata *p4InputExpMetadataFromObject(const p4InputExpRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -13982 +14013 @@
         return false;
     }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, object->magiced)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item magiced");
+        psFree(md);
+        return false;
+    }
 
 
@@ -13987 +14023 @@
 }
 
-p4aInputExpRow *p4aInputExpObjectFromMetadata(psMetadata *md)
+p4InputExpRow *p4InputExpObjectFromMetadata(psMetadata *md)
 {
 
@@ -14006 +14042 @@
         return false;
     }
-
-    return p4aInputExpRowAlloc(p4a_id, exp_tag, p3_version);
-}
-psArray *p4aInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    bool magiced = psMetadataLookupBool(&status, md, "magiced");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magiced");
+        return false;
+    }
+
+    return p4InputExpRowAlloc(p4a_id, exp_tag, p3_version, magiced);
+}
+psArray *p4InputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -14015 +14056 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -14025 +14066 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4aInputExpRow *object = p4aInputExpObjectFromMetadata(rowSet->data[i]);
+        p4InputExpRow *object = p4InputExpObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -14034 +14075 @@
     return returnSet;
 }
-bool p4aInputExpDeleteObject(psDB *dbh, const p4aInputExpRow *object)
-{
-    psMetadata *where = p4aInputExpMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, 0);
+bool p4InputExpDeleteObject(psDB *dbh, const p4InputExpRow *object)
+{
+    psMetadata *where = p4InputExpMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, 0);
     psFree(where);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
         return false;
     }
@@ -14046 +14087 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4aInputExpRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4aInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4InputExpRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4InputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4aInputExpRow *object = objects->data[i];
-        psMetadata *where = p4aInputExpMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4AINPUTEXP_TABLE_NAME, where, limit);
+        p4InputExpRow *object = objects->data[i];
+        psMetadata *where = p4InputExpMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4INPUTEXP_TABLE_NAME, where, limit);
         psFree(where);
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aInputExp");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputExp");
             return count;
         }
@@ -14071 +14112 @@
     return deleted;
 }
-bool p4aInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4InputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -14077 +14118 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4aInputExpMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4InputExpMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4AINPUTEXP_TABLE_NAME,
+            P4INPUTEXP_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -14102 +14143 @@
     return true;
 }
-bool p4aInputExpPrintObject(FILE *stream, p4aInputExpRow *object, bool mdcf)
+bool p4InputExpPrintObject(FILE *stream, p4InputExpRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4aInputExpMetadataFromObject(object);
+    psMetadata *md = p4InputExpMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -14117 +14158 @@
     return true;
 }
-static void p4aScfileRowFree(p4aScfileRow *object);
-
-p4aScfileRow *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)
-{
-    p4aScfileRow    *_object;
-
-    _object = psAlloc(sizeof(p4aScfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4aScfileRowFree);
+static void p4ScfileRowFree(p4ScfileRow *object);
+
+p4ScfileRow *p4ScfileRowAlloc(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)
+{
+    p4ScfileRow     *_object;
+
+    _object = psAlloc(sizeof(p4ScfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4ScfileRowFree);
 
     _object->p4a_id = p4a_id;
@@ -14138 +14179 @@
 }
 
-static void p4aScfileRowFree(p4aScfileRow *object)
+static void p4ScfileRowFree(p4ScfileRow *object)
 {
     psFree(object->skycell_id);
@@ -14146 +14187 @@
 }
 
-bool p4aScfileCreateTable(psDB *dbh)
+bool p4ScfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14190 +14231 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4ASCFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4SCFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -14197 +14238 @@
 }
 
-bool p4aScfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4ASCFILE_TABLE_NAME);
-}
-
-bool 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)
+bool p4ScfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4SCFILE_TABLE_NAME);
+}
+
+bool p4ScfileInsert(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)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14246 +14287 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4ASCFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4SCFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -14252 +14293 @@
 }
 
-long long p4aScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4ScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
         return count;
 
@@ -14266 +14307 @@
     return deleted;
 }
-bool p4aScfileInsertObject(psDB *dbh, p4aScfileRow *object)
-{
-    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);
-}
-
-bool p4aScfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4ScfileInsertObject(psDB *dbh, p4ScfileRow *object)
+{
+    return p4ScfileInsert(dbh, object->p4a_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
+}
+
+bool p4ScfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4aScfileInsertObject(dbh, objects->data[i])) {
+        if (!p4ScfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -14282 +14323 @@
 }
 
-bool p4aScfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4ScfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4ASCFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4ASCFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4ASCFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4SCFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4SCFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4SCFILE_TABLE_NAME);
         return false;
     }
@@ -14306 +14347 @@
     }
 
-    if (!psDBInsertRows(dbh, P4ASCFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4SCFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -14317 +14358 @@
 }
 
-bool p4aScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4ScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -14327 +14368 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4ASCFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4SCFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -14338 +14379 @@
 }
 
-psMetadata *p4aScfileMetadataFromObject(const p4aScfileRow *object)
+psMetadata *p4ScfileMetadataFromObject(const p4ScfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14386 +14427 @@
 }
 
-p4aScfileRow *p4aScfileObjectFromMetadata(psMetadata *md)
+p4ScfileRow *p4ScfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -14431 +14472 @@
     }
 
-    return p4aScfileRowAlloc(p4a_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
-}
-psArray *p4aScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4ScfileRowAlloc(p4a_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
+}
+psArray *p4ScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -14439 +14480 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -14449 +14490 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4aScfileRow *object = p4aScfileObjectFromMetadata(rowSet->data[i]);
+        p4ScfileRow *object = p4ScfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -14458 +14499 @@
     return returnSet;
 }
-bool p4aScfileDeleteObject(psDB *dbh, const p4aScfileRow *object)
-{
-    psMetadata *where = p4aScfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, 0);
+bool p4ScfileDeleteObject(psDB *dbh, const p4ScfileRow *object)
+{
+    psMetadata *where = p4ScfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, 0);
     psFree(where);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
         return false;
     }
@@ -14470 +14511 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4aScfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4aScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4ScfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4ScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4aScfileRow *object = objects->data[i];
-        psMetadata *where = p4aScfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4ASCFILE_TABLE_NAME, where, limit);
+        p4ScfileRow *object = objects->data[i];
+        psMetadata *where = p4ScfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4SCFILE_TABLE_NAME, where, limit);
         psFree(where);
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4aScfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Scfile");
             return count;
         }
@@ -14495 +14536 @@
     return deleted;
 }
-bool p4aScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4ScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -14501 +14542 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4aScfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4ScfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4ASCFILE_TABLE_NAME,
+            P4SCFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -14526 +14567 @@
     return true;
 }
-bool p4aScfilePrintObject(FILE *stream, p4aScfileRow *object, bool mdcf)
+bool p4ScfilePrintObject(FILE *stream, p4ScfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4aScfileMetadataFromObject(object);
+    psMetadata *md = p4ScfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -14541 +14582 @@
     return true;
 }
-static void p4bRunRowFree(p4bRunRow *object);
-
-p4bRunRow *p4bRunRowAlloc(psS32 p4b_id, const char *state, const char *workdir, bool magic)
-{
-    p4bRunRow       *_object;
-
-    _object = psAlloc(sizeof(p4bRunRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4bRunRowFree);
+static void p4InputScfileRowFree(p4InputScfileRow *object);
+
+p4InputScfileRow *p4InputScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
+{
+    p4InputScfileRow *_object;
+
+    _object = psAlloc(sizeof(p4InputScfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4InputScfileRowFree);
 
     _object->p4b_id = p4b_id;
-    _object->state = psStringCopy(state);
-    _object->workdir = psStringCopy(workdir);
-    _object->magic = magic;
+    _object->skycell_id = psStringCopy(skycell_id);
+    _object->tess_id = psStringCopy(tess_id);
+    _object->exp_tag = psStringCopy(exp_tag);
+    _object->p3_version = p3_version;
+    _object->kind = psStringCopy(kind);
 
     return _object;
 }
 
-static void p4bRunRowFree(p4bRunRow *object)
-{
-    psFree(object->state);
-    psFree(object->workdir);
-}
-
-bool p4bRunCreateTable(psDB *dbh)
+static void p4InputScfileRowFree(p4InputScfileRow *object)
+{
+    psFree(object->skycell_id);
+    psFree(object->tess_id);
+    psFree(object->exp_tag);
+    psFree(object->kind);
+}
+
+bool p4InputScfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
         psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
         psFree(md);
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4BRUN_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBCreateTable(dbh, P4INPUTSCFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -14595 +14650 @@
 }
 
-bool p4bRunDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4BRUN_TABLE_NAME);
-}
-
-bool p4bRunInsert(psDB * dbh, psS32 p4b_id, const char *state, const char *workdir, bool magic)
+bool p4InputScfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4INPUTSCFILE_TABLE_NAME);
+}
+
+bool p4InputScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14608 +14663 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4BRUN_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBInsertOneRow(dbh, P4INPUTSCFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -14630 +14695 @@
 }
 
-long long p4bRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4InputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
         return count;
 
@@ -14644 +14709 @@
     return deleted;
 }
-bool p4bRunInsertObject(psDB *dbh, p4bRunRow *object)
-{
-    return p4bRunInsert(dbh, object->p4b_id, object->state, object->workdir, object->magic);
-}
-
-bool p4bRunInsertObjects(psDB *dbh, psArray *objects)
+bool p4InputScfileInsertObject(psDB *dbh, p4InputScfileRow *object)
+{
+    return p4InputScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind);
+}
+
+bool p4InputScfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4bRunInsertObject(dbh, objects->data[i])) {
+        if (!p4InputScfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -14660 +14725 @@
 }
 
-bool p4bRunInsertFits(psDB *dbh, const psFits *fits)
+bool p4InputScfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4BRUN_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4BRUN_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BRUN_TABLE_NAME);
+    // move to (the first?) extension named  P4INPUTSCFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4INPUTSCFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTSCFILE_TABLE_NAME);
         return false;
     }
@@ -14684 +14749 @@
     }
 
-    if (!psDBInsertRows(dbh, P4BRUN_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4INPUTSCFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -14695 +14760 @@
 }
 
-bool p4bRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4InputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -14705 +14770 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4BRUN_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTSCFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -14716 +14781 @@
 }
 
-psMetadata *p4bRunMetadataFromObject(const p4bRunRow *object)
+psMetadata *p4InputScfileMetadataFromObject(const p4InputScfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14724 +14789 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
         psFree(md);
         return false;
@@ -14744 +14819 @@
 }
 
-p4bRunRow *p4bRunObjectFromMetadata(psMetadata *md)
+p4InputScfileRow *p4InputScfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -14753 +14828 @@
         return false;
     }
-    char* state = psMetadataLookupPtr(&status, md, "state");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
-        return false;
-    }
-    char* workdir = psMetadataLookupPtr(&status, md, "workdir");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
-        return false;
-    }
-    bool magic = psMetadataLookupBool(&status, md, "magic");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
-        return false;
-    }
-
-    return p4bRunRowAlloc(p4b_id, state, workdir, magic);
-}
-psArray *p4bRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
+        return false;
+    }
+    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
+        return false;
+    }
+    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
+        return false;
+    }
+    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
+        return false;
+    }
+    char* kind = psMetadataLookupPtr(&status, md, "kind");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind");
+        return false;
+    }
+
+    return p4InputScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, kind);
+}
+psArray *p4InputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -14777 +14862 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4BRUN_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -14787 +14872 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4bRunRow *object = p4bRunObjectFromMetadata(rowSet->data[i]);
+        p4InputScfileRow *object = p4InputScfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -14796 +14881 @@
     return returnSet;
 }
-bool p4bRunDeleteObject(psDB *dbh, const p4bRunRow *object)
-{
-    psMetadata *where = p4bRunMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, 0);
+bool p4InputScfileDeleteObject(psDB *dbh, const p4InputScfileRow *object)
+{
+    psMetadata *where = p4InputScfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, 0);
     psFree(where);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
         return false;
     }
@@ -14808 +14893 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4bRunRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4bRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4InputScfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4InputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4bRunRow *object = objects->data[i];
-        psMetadata *where = p4bRunMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4BRUN_TABLE_NAME, where, limit);
+        p4InputScfileRow *object = objects->data[i];
+        psMetadata *where = p4InputScfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4INPUTSCFILE_TABLE_NAME, where, limit);
         psFree(where);
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bRun");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputScfile");
             return count;
         }
@@ -14833 +14918 @@
     return deleted;
 }
-bool p4bRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4InputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -14839 +14924 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4bRunMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4InputScfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4BRUN_TABLE_NAME,
+            P4INPUTSCFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -14864 +14949 @@
     return true;
 }
-bool p4bRunPrintObject(FILE *stream, p4bRunRow *object, bool mdcf)
+bool p4InputScfilePrintObject(FILE *stream, p4InputScfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4bRunMetadataFromObject(object);
+    psMetadata *md = p4InputScfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -14879 +14964 @@
     return true;
 }
-static void p4bInputScfileRowFree(p4bInputScfileRow *object);
-
-p4bInputScfileRow *p4bInputScfileRowAlloc(psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
-{
-    p4bInputScfileRow *_object;
-
-    _object = psAlloc(sizeof(p4bInputScfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4bInputScfileRowFree);
+static void p4DiffScfileRowFree(p4DiffScfileRow *object);
+
+p4DiffScfileRow *p4DiffScfileRowAlloc(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)
+{
+    p4DiffScfileRow *_object;
+
+    _object = psAlloc(sizeof(p4DiffScfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4DiffScfileRowFree);
 
     _object->p4b_id = p4b_id;
@@ -14893 +14978 @@
     _object->exp_tag = psStringCopy(exp_tag);
     _object->p3_version = p3_version;
-    _object->kind = psStringCopy(kind);
+    _object->uri = psStringCopy(uri);
+    _object->bg = bg;
+    _object->bg_mean_stdev = bg_mean_stdev;
 
     return _object;
 }
 
-static void p4bInputScfileRowFree(p4bInputScfileRow *object)
+static void p4DiffScfileRowFree(p4DiffScfileRow *object)
 {
     psFree(object->skycell_id);
     psFree(object->tess_id);
     psFree(object->exp_tag);
-    psFree(object->kind);
-}
-
-bool p4bInputScfileCreateTable(psDB *dbh)
+    psFree(object->uri);
+}
+
+bool p4DiffScfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14934 +15021 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBCreateTable(dbh, P4DIFFSCFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -14947 +15044 @@
 }
 
-bool p4bInputScfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4BINPUTSCFILE_TABLE_NAME);
-}
-
-bool p4bInputScfileInsert(psDB * dbh, psS32 p4b_id, const char *skycell_id, const char *tess_id, const char *exp_tag, psS32 p3_version, const char *kind)
+bool p4DiffScfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4DIFFSCFILE_TABLE_NAME);
+}
+
+bool p4DiffScfileInsert(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)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14980 +15077 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4BINPUTSCFILE_TABLE_NAME, md);
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
+        psFree(md);
+        return false;
+    }
+
+    bool status = psDBInsertOneRow(dbh, P4DIFFSCFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -14992 +15099 @@
 }
 
-long long p4bInputScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4DiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
         return count;
 
@@ -15006 +15113 @@
     return deleted;
 }
-bool p4bInputScfileInsertObject(psDB *dbh, p4bInputScfileRow *object)
-{
-    return p4bInputScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->kind);
-}
-
-bool p4bInputScfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4DiffScfileInsertObject(psDB *dbh, p4DiffScfileRow *object)
+{
+    return p4DiffScfileInsert(dbh, object->p4b_id, object->skycell_id, object->tess_id, object->exp_tag, object->p3_version, object->uri, object->bg, object->bg_mean_stdev);
+}
+
+bool p4DiffScfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4bInputScfileInsertObject(dbh, objects->data[i])) {
+        if (!p4DiffScfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -15022 +15129 @@
 }
 
-bool p4bInputScfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4DiffScfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4BINPUTSCFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4BINPUTSCFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BINPUTSCFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4DIFFSCFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4DIFFSCFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFSCFILE_TABLE_NAME);
         return false;
     }
@@ -15046 +15153 @@
     }
 
-    if (!psDBInsertRows(dbh, P4BINPUTSCFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4DIFFSCFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15057 +15164 @@
 }
 
-bool p4bInputScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4DiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15067 +15174 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4BINPUTSCFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFSCFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15078 +15185 @@
 }
 
-psMetadata *p4bInputScfileMetadataFromObject(const p4bInputScfileRow *object)
+psMetadata *p4DiffScfileMetadataFromObject(const p4DiffScfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15106 +15213 @@
         return false;
     }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item kind");
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
+        psFree(md);
+        return false;
+    }
+    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
+        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
         psFree(md);
         return false;
@@ -15116 +15233 @@
 }
 
-p4bInputScfileRow *p4bInputScfileObjectFromMetadata(psMetadata *md)
+p4DiffScfileRow *p4DiffScfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15145 +15262 @@
         return false;
     }
-    char* kind = psMetadataLookupPtr(&status, md, "kind");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind");
-        return false;
-    }
-
-    return p4bInputScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, kind);
-}
-psArray *p4bInputScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    char* uri = psMetadataLookupPtr(&status, md, "uri");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
+        return false;
+    }
+    psF64 bg = psMetadataLookupF64(&status, md, "bg");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
+        return false;
+    }
+    psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
+    if (!status) {
+        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
+        return false;
+    }
+
+    return p4DiffScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
+}
+psArray *p4DiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15159 +15286 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15169 +15296 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4bInputScfileRow *object = p4bInputScfileObjectFromMetadata(rowSet->data[i]);
+        p4DiffScfileRow *object = p4DiffScfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15178 +15305 @@
     return returnSet;
 }
-bool p4bInputScfileDeleteObject(psDB *dbh, const p4bInputScfileRow *object)
-{
-    psMetadata *where = p4bInputScfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, 0);
+bool p4DiffScfileDeleteObject(psDB *dbh, const p4DiffScfileRow *object)
+{
+    psMetadata *where = p4DiffScfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, 0);
     psFree(where);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
         return false;
     }
@@ -15190 +15317 @@
         // XXX should this be a psAbort() instead?  It is possible that
         // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4bInputScfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4bInputScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4DiffScfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4DiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4bInputScfileRow *object = objects->data[i];
-        psMetadata *where = p4bInputScfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4BINPUTSCFILE_TABLE_NAME, where, limit);
+        p4DiffScfileRow *object = objects->data[i];
+        psMetadata *where = p4DiffScfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4DIFFSCFILE_TABLE_NAME, where, limit);
         psFree(where);
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bInputScfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffScfile");
             return count;
         }
@@ -15215 +15342 @@
     return deleted;
 }
-bool p4bInputScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4DiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15221 +15348 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4bInputScfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4DiffScfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4BINPUTSCFILE_TABLE_NAME,
+            P4DIFFSCFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15246 +15373 @@
     return true;
 }
-bool p4bInputScfilePrintObject(FILE *stream, p4bInputScfileRow *object, bool mdcf)
+bool p4DiffScfilePrintObject(FILE *stream, p4DiffScfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4bInputScfileMetadataFromObject(object);
-
-    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(md);
-    }
-
-    psFree(md);
-
-    return true;
-}
-static void p4bDiffScfileRowFree(p4bDiffScfileRow *object);
-
-p4bDiffScfileRow *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)
-{
-    p4bDiffScfileRow *_object;
-
-    _object = psAlloc(sizeof(p4bDiffScfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4bDiffScfileRowFree);
-
-    _object->p4b_id = p4b_id;
-    _object->skycell_id = psStringCopy(skycell_id);
-    _object->tess_id = psStringCopy(tess_id);
-    _object->exp_tag = psStringCopy(exp_tag);
-    _object->p3_version = p3_version;
-    _object->uri = psStringCopy(uri);
-    _object->bg = bg;
-    _object->bg_mean_stdev = bg_mean_stdev;
-
-    return _object;
-}
-
-static void p4bDiffScfileRowFree(p4bDiffScfileRow *object)
-{
-    psFree(object->skycell_id);
-    psFree(object->tess_id);
-    psFree(object->exp_tag);
-    psFree(object->uri);
-}
-
-bool p4bDiffScfileCreateTable(psDB *dbh)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
-
-    psFree(md);
-
-    return status;
-}
-
-bool p4bDiffScfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4BDIFFSCFILE_TABLE_NAME);
-}
-
-bool 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)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, p4b_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4BDIFFSCFILE_TABLE_NAME, md);
-    psFree(md);
-
-    return status;
-}
-
-long long p4bDiffScfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
-        return count;
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4bDiffScfileInsertObject(psDB *dbh, p4bDiffScfileRow *object)
-{
-    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);
-}
-
-bool p4bDiffScfileInsertObjects(psDB *dbh, psArray *objects)
-{
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4bDiffScfileInsertObject(dbh, objects->data[i])) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool p4bDiffScfileInsertFits(psDB *dbh, const psFits *fits)
-{
-    psArray         *rowSet;
-
-    // move to (the first?) extension named  P4BDIFFSCFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4BDIFFSCFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4BDIFFSCFILE_TABLE_NAME);
-        return false;
-    }
-
-    // check HDU type
-    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
-        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
-        return false;
-    }
-
-    // read fits table
-    rowSet = psFitsReadTable(fits);
-    if (!rowSet) {
-        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
-        psFree(rowSet);
-        return false;
-    }
-
-    if (!psDBInsertRows(dbh, P4BDIFFSCFILE_TABLE_NAME, rowSet)) {
-        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-bool p4bDiffScfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-
-    rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return false;
-    }
-
-    // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4BDIFFSCFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-psMetadata *p4bDiffScfileMetadataFromObject(const p4bDiffScfileRow *object)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4b_id", PS_DATA_S32, NULL, object->p4b_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4b_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item uri");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev");
-        psFree(md);
-        return false;
-    }
-
-
-    return md;
-}
-
-p4bDiffScfileRow *p4bDiffScfileObjectFromMetadata(psMetadata *md)
-{
-
-bool status = false;
-    psS32 p4b_id = psMetadataLookupS32(&status, md, "p4b_id");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4b_id");
-        return false;
-    }
-    char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id");
-        return false;
-    }
-    char* tess_id = psMetadataLookupPtr(&status, md, "tess_id");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id");
-        return false;
-    }
-    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
-        return false;
-    }
-    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
-        return false;
-    }
-    char* uri = psMetadataLookupPtr(&status, md, "uri");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
-        return false;
-    }
-    psF64 bg = psMetadataLookupF64(&status, md, "bg");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
-        return false;
-    }
-    psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
-        return false;
-    }
-
-    return p4bDiffScfileRowAlloc(p4b_id, skycell_id, tess_id, exp_tag, p3_version, uri, bg, bg_mean_stdev);
-}
-psArray *p4bDiffScfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-    psArray         *returnSet;
-    psU64           i;
-
-    rowSet = psDBSelectRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return NULL;
-    }
-
-    // convert psMetadata rows to row objects
-
-    returnSet = psArrayAllocEmpty(rowSet->n);
-
-    for (i = 0; i < rowSet->n; i++) {
-        p4bDiffScfileRow *object = p4bDiffScfileObjectFromMetadata(rowSet->data[i]);
-        psArrayAdd(returnSet, 0, object);
-        psFree(object);
-    }
-
-    psFree(rowSet);
-
-    return returnSet;
-}
-bool p4bDiffScfileDeleteObject(psDB *dbh, const p4bDiffScfileRow *object)
-{
-    psMetadata *where = p4bDiffScfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, 0);
-    psFree(where);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
-        return false;
-    }
-    if (count > 1) {
-        // XXX should this be a psAbort() instead?  It is possible that
-        // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4bDiffScfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4bDiffScfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    for (long long i = 0; i < objects->n; i++) {
-        p4bDiffScfileRow *object = objects->data[i];
-        psMetadata *where = p4bDiffScfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4BDIFFSCFILE_TABLE_NAME, where, limit);
-        psFree(where);
-        if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4bDiffScfile");
-            return count;
-        }
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4bDiffScfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(objects, false);
-
-    psMetadata *output = psMetadataAlloc();
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4bDiffScfileMetadataFromObject(objects->data[i]);
-        if (!psMetadataAddMetadata(
-            output,
-            PS_LIST_TAIL,
-            P4BDIFFSCFILE_TABLE_NAME,
-            PS_META_DUPLICATE_OK,
-            NULL,
-            md
-        )) {
-            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
-            psFree(md);
-            psFree(output);
-            return false;
-        }
-        psFree(md);
-    }
-
-    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(output);
-    }
-    psFree(output);
-
-    return true;
-}
-bool p4bDiffScfilePrintObject(FILE *stream, p4bDiffScfileRow *object, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(object, false);
-
-    psMetadata *md = p4bDiffScfileMetadataFromObject(object);
-
-    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(md);
-    }
-
-    psFree(md);
-
-    return true;
-}
-static void p4cRunRowFree(p4cRunRow *object);
-
-p4cRunRow *p4cRunRowAlloc(psS32 p4c_id, const char *state, const char *workdir, bool magic)
-{
-    p4cRunRow       *_object;
-
-    _object = psAlloc(sizeof(p4cRunRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4cRunRowFree);
-
-    _object->p4c_id = p4c_id;
-    _object->state = psStringCopy(state);
-    _object->workdir = psStringCopy(workdir);
-    _object->magic = magic;
-
-    return _object;
-}
-
-static void p4cRunRowFree(p4cRunRow *object)
-{
-    psFree(object->state);
-    psFree(object->workdir);
-}
-
-bool p4cRunCreateTable(psDB *dbh)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4CRUN_TABLE_NAME, md);
-
-    psFree(md);
-
-    return status;
-}
-
-bool p4cRunDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4CRUN_TABLE_NAME);
-}
-
-bool p4cRunInsert(psDB * dbh, psS32 p4c_id, const char *state, const char *workdir, bool magic)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4CRUN_TABLE_NAME, md);
-    psFree(md);
-
-    return status;
-}
-
-long long p4cRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
-        return count;
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4cRunInsertObject(psDB *dbh, p4cRunRow *object)
-{
-    return p4cRunInsert(dbh, object->p4c_id, object->state, object->workdir, object->magic);
-}
-
-bool p4cRunInsertObjects(psDB *dbh, psArray *objects)
-{
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4cRunInsertObject(dbh, objects->data[i])) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool p4cRunInsertFits(psDB *dbh, const psFits *fits)
-{
-    psArray         *rowSet;
-
-    // move to (the first?) extension named  P4CRUN_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4CRUN_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CRUN_TABLE_NAME);
-        return false;
-    }
-
-    // check HDU type
-    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
-        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
-        return false;
-    }
-
-    // read fits table
-    rowSet = psFitsReadTable(fits);
-    if (!rowSet) {
-        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
-        psFree(rowSet);
-        return false;
-    }
-
-    if (!psDBInsertRows(dbh, P4CRUN_TABLE_NAME, rowSet)) {
-        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-bool p4cRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-
-    rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return false;
-    }
-
-    // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4CRUN_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-psMetadata *p4cRunMetadataFromObject(const p4cRunRow *object)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item state");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item workdir");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "magic", PS_DATA_BOOL, NULL, object->magic)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item magic");
-        psFree(md);
-        return false;
-    }
-
-
-    return md;
-}
-
-p4cRunRow *p4cRunObjectFromMetadata(psMetadata *md)
-{
-
-bool status = false;
-    psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
-        return false;
-    }
-    char* state = psMetadataLookupPtr(&status, md, "state");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
-        return false;
-    }
-    char* workdir = psMetadataLookupPtr(&status, md, "workdir");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir");
-        return false;
-    }
-    bool magic = psMetadataLookupBool(&status, md, "magic");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic");
-        return false;
-    }
-
-    return p4cRunRowAlloc(p4c_id, state, workdir, magic);
-}
-psArray *p4cRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-    psArray         *returnSet;
-    psU64           i;
-
-    rowSet = psDBSelectRows(dbh, P4CRUN_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return NULL;
-    }
-
-    // convert psMetadata rows to row objects
-
-    returnSet = psArrayAllocEmpty(rowSet->n);
-
-    for (i = 0; i < rowSet->n; i++) {
-        p4cRunRow *object = p4cRunObjectFromMetadata(rowSet->data[i]);
-        psArrayAdd(returnSet, 0, object);
-        psFree(object);
-    }
-
-    psFree(rowSet);
-
-    return returnSet;
-}
-bool p4cRunDeleteObject(psDB *dbh, const p4cRunRow *object)
-{
-    psMetadata *where = p4cRunMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, 0);
-    psFree(where);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
-        return false;
-    }
-    if (count > 1) {
-        // XXX should this be a psAbort() instead?  It is possible that
-        // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4cRunRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4cRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    for (long long i = 0; i < objects->n; i++) {
-        p4cRunRow *object = objects->data[i];
-        psMetadata *where = p4cRunMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4CRUN_TABLE_NAME, where, limit);
-        psFree(where);
-        if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cRun");
-            return count;
-        }
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4cRunPrintObjects(FILE *stream, psArray *objects, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(objects, false);
-
-    psMetadata *output = psMetadataAlloc();
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4cRunMetadataFromObject(objects->data[i]);
-        if (!psMetadataAddMetadata(
-            output,
-            PS_LIST_TAIL,
-            P4CRUN_TABLE_NAME,
-            PS_META_DUPLICATE_OK,
-            NULL,
-            md
-        )) {
-            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
-            psFree(md);
-            psFree(output);
-            return false;
-        }
-        psFree(md);
-    }
-
-    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(output);
-    }
-    psFree(output);
-
-    return true;
-}
-bool p4cRunPrintObject(FILE *stream, p4cRunRow *object, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(object, false);
-
-    psMetadata *md = p4cRunMetadataFromObject(object);
-
-    if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(md);
-    }
-
-    psFree(md);
-
-    return true;
-}
-static void p4cInputExpRowFree(p4cInputExpRow *object);
-
-p4cInputExpRow *p4cInputExpRowAlloc(psS32 p4c_id, const char *exp_tag, psS32 p3_version)
-{
-    p4cInputExpRow  *_object;
-
-    _object = psAlloc(sizeof(p4cInputExpRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4cInputExpRowFree);
-
-    _object->p4c_id = p4c_id;
-    _object->exp_tag = psStringCopy(exp_tag);
-    _object->p3_version = p3_version;
-
-    return _object;
-}
-
-static void p4cInputExpRowFree(p4cInputExpRow *object)
-{
-    psFree(object->exp_tag);
-}
-
-bool p4cInputExpCreateTable(psDB *dbh)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBCreateTable(dbh, P4CINPUTEXP_TABLE_NAME, md);
-
-    psFree(md);
-
-    return status;
-}
-
-bool p4cInputExpDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4CINPUTEXP_TABLE_NAME);
-}
-
-bool p4cInputExpInsert(psDB * dbh, psS32 p4c_id, const char *exp_tag, psS32 p3_version)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, p4c_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-
-    bool status = psDBInsertOneRow(dbh, P4CINPUTEXP_TABLE_NAME, md);
-    psFree(md);
-
-    return status;
-}
-
-long long p4cInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
-        return count;
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4cInputExpInsertObject(psDB *dbh, p4cInputExpRow *object)
-{
-    return p4cInputExpInsert(dbh, object->p4c_id, object->exp_tag, object->p3_version);
-}
-
-bool p4cInputExpInsertObjects(psDB *dbh, psArray *objects)
-{
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4cInputExpInsertObject(dbh, objects->data[i])) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool p4cInputExpInsertFits(psDB *dbh, const psFits *fits)
-{
-    psArray         *rowSet;
-
-    // move to (the first?) extension named  P4CINPUTEXP_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4CINPUTEXP_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4CINPUTEXP_TABLE_NAME);
-        return false;
-    }
-
-    // check HDU type
-    if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE)  {
-        psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE");
-        return false;
-    }
-
-    // read fits table
-    rowSet = psFitsReadTable(fits);
-    if (!rowSet) {
-        psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty");
-        psFree(rowSet);
-        return false;
-    }
-
-    if (!psDBInsertRows(dbh, P4CINPUTEXP_TABLE_NAME, rowSet)) {
-        psError(PS_ERR_UNKNOWN, false, "databse insert failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-bool p4cInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-
-    rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return false;
-    }
-
-    // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4CINPUTEXP_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
-        psFree(rowSet);
-        return false;
-    }
-
-    psFree(rowSet);
-
-    return true;
-}
-
-psMetadata *p4cInputExpMetadataFromObject(const p4cInputExpRow *object)
-{
-    psMetadata *md = psMetadataAlloc();
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p4c_id", PS_DATA_S32, NULL, object->p4c_id)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p4c_id");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
-        psFree(md);
-        return false;
-    }
-    if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version");
-        psFree(md);
-        return false;
-    }
-
-
-    return md;
-}
-
-p4cInputExpRow *p4cInputExpObjectFromMetadata(psMetadata *md)
-{
-
-bool status = false;
-    psS32 p4c_id = psMetadataLookupS32(&status, md, "p4c_id");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4c_id");
-        return false;
-    }
-    char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
-        return false;
-    }
-    psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version");
-    if (!status) {
-        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
-        return false;
-    }
-
-    return p4cInputExpRowAlloc(p4c_id, exp_tag, p3_version);
-}
-psArray *p4cInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
-{
-    psArray         *rowSet;
-    psArray         *returnSet;
-    psU64           i;
-
-    rowSet = psDBSelectRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
-    if (!rowSet) {
-        return NULL;
-    }
-
-    // convert psMetadata rows to row objects
-
-    returnSet = psArrayAllocEmpty(rowSet->n);
-
-    for (i = 0; i < rowSet->n; i++) {
-        p4cInputExpRow *object = p4cInputExpObjectFromMetadata(rowSet->data[i]);
-        psArrayAdd(returnSet, 0, object);
-        psFree(object);
-    }
-
-    psFree(rowSet);
-
-    return returnSet;
-}
-bool p4cInputExpDeleteObject(psDB *dbh, const p4cInputExpRow *object)
-{
-    psMetadata *where = p4cInputExpMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, 0);
-    psFree(where);
-    if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
-        return false;
-    }
-    if (count > 1) {
-        // XXX should this be a psAbort() instead?  It is possible that
-        // having an object match multiple rows was by design.
-        psError(PS_ERR_UNKNOWN, true, "p4cInputExpRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4cInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
-{
-    long long       deleted = 0;
-
-    for (long long i = 0; i < objects->n; i++) {
-        p4cInputExpRow *object = objects->data[i];
-        psMetadata *where = p4cInputExpMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4CINPUTEXP_TABLE_NAME, where, limit);
-        psFree(where);
-        if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4cInputExp");
-            return count;
-        }
-
-        deleted += count;
-    }
-
-    return deleted;
-}
-bool p4cInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(objects, false);
-
-    psMetadata *output = psMetadataAlloc();
-    for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4cInputExpMetadataFromObject(objects->data[i]);
-        if (!psMetadataAddMetadata(
-            output,
-            PS_LIST_TAIL,
-            P4CINPUTEXP_TABLE_NAME,
-            PS_META_DUPLICATE_OK,
-            NULL,
-            md
-        )) {
-            psError(PS_ERR_UNKNOWN, false, "failed to add metadata");
-            psFree(md);
-            psFree(output);
-            return false;
-        }
-        psFree(md);
-    }
-
-    if (!ippdbPrintMetadataRaw(stream, output, mdcf)) {
-        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
-        psFree(output);
-    }
-    psFree(output);
-
-    return true;
-}
-bool p4cInputExpPrintObject(FILE *stream, p4cInputExpRow *object, bool mdcf)
-{
-    PS_ASSERT_PTR_NON_NULL(object, false);
-
-    psMetadata *md = p4cInputExpMetadataFromObject(object);
+    psMetadata *md = p4DiffScfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {