Changeset 11720 for trunk/ippdb/src

Timestamp:

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

Author:

jhoblitt

Message:

VERSION 1.1.3

Location:

trunk/ippdb/src

Files:

• ippdb.c (modified) (112 diffs)
• ippdb.h (modified) (74 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)) {

trunk/ippdb/src/ippdb.h

@@ -20 +20 @@
 /*
  *
- * This file was generated by glueforge 0.36
+ * This file was generated by glueforge 1.00
  *
  * Do NOT directly edit this file.
@@ -6830 +6830 @@
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** p4aRunRow data structure
- *
- * Structure for representing a single row of p4aRun table data.
+/** p4RunRow data structure
+ *
+ * Structure for representing a single row of p4Run table data.
  */
 
 typedef struct {
     psS32           p4a_id;
+    char            *mode;
     char            *state;
     char            *workdir;
-    bool            magic;
-} p4aRunRow;
-
-/** Creates a new p4aRunRow object
- *
- *  @return A new p4aRunRow object or NULL on failure.
- */
-
-p4aRunRow *p4aRunRowAlloc(
+    psTime*         registered;
+} p4RunRow;
+
+/** Creates a new p4RunRow object
+ *
+ *  @return A new p4RunRow object or NULL on failure.
+ */
+
+p4RunRow *p4RunRowAlloc(
     psS32           p4a_id,
+    const char      *mode,
     const char      *state,
     const char      *workdir,
-    bool            magic
-);
-
-/** Creates a new p4aRun table
- *
- * @return true on success
- */
-
-bool p4aRunCreateTable(
+    psTime*         registered
+);
+
+/** Creates a new p4Run table
+ *
+ * @return true on success
+ */
+
+bool p4RunCreateTable(
     psDB            *dbh                ///< Database handle
 );
 
-/** Deletes a p4aRun table
- *
- * @return true on success
- */
-
-bool p4aRunDropTable(
+/** Deletes a p4Run table
+ *
+ * @return true on success
+ */
+
+bool p4RunDropTable(
     psDB            *dbh                ///< Database handle
 );
@@ -6879 +6881 @@
  */
 
-bool p4aRunInsert(
+bool p4RunInsert(
     psDB            *dbh,               ///< Database handle
     psS32           p4a_id,
+    const char      *mode,
     const char      *state,
     const char      *workdir,
-    bool            magic
+    psTime*         registered
 );
 
@@ -6892 +6895 @@
  */
 
-long long p4aRunDelete(
+long long p4RunDelete(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
@@ -6898 +6901 @@
 );
 
-/** Insert a single p4aRunRow object into a table
+/** Insert a single p4RunRow object into a table
  *
  * This function constructs and inserts a single row based on it's parameters.
@@ -6905 +6908 @@
  */
 
-bool p4aRunInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4aRunRow       *object             ///< p4aRunRow object
-);
-
-/** Insert an array of p4aRunRow object into a table
+bool p4RunInsertObject(
+    psDB            *dbh,               ///< Database handle
+    p4RunRow        *object             ///< p4RunRow object
+);
+
+/** Insert an array of p4RunRow object into a table
  *
  * This function constructs and inserts multiple rows based on it's parameters.
@@ -6917 +6920 @@
  */
 
-bool p4aRunInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4aRunRow objects
-);
-
-/** Insert data from a binary FITS table p4aRunRow into the database
+bool p4RunInsertObjects(
+    psDB            *dbh,               ///< Database handle
+    psArray         *objects            ///< array of p4RunRow objects
+);
+
+/** Insert data from a binary FITS table p4RunRow into the database
  *
  * This function expects a psFits object with a FITS table as the first
@@ -6932 +6935 @@
  */
 
-bool p4aRunInsertFits(
+bool p4RunInsertFits(
     psDB            *dbh,               ///< Database handle
     const psFits    *fits               ///< psFits object
@@ -6947 +6950 @@
  */
 
-bool p4aRunSelectRowsFits(
+bool p4RunSelectRowsFits(
     psDB            *dbh,               ///< Database handle
     psFits          *fits,              ///< psFits object
@@ -6954 +6957 @@
 );
 
-/** Convert a p4aRunRow into an equivalent psMetadata
+/** Convert a p4RunRow into an equivalent psMetadata
  *
  * @return A psMetadata pointer or NULL on error
  */
 
-psMetadata *p4aRunMetadataFromObject(
-    const p4aRunRow *object             ///< fooRow to convert into a psMetadata
+psMetadata *p4RunMetadataFromObject(
+    const p4RunRow  *object             ///< fooRow to convert into a psMetadata
 );
 
 /** Convert a psMetadata into an equivalent fooRow
  *
- * @return A p4aRunRow pointer or NULL on error
- */
-
-p4aRunRow *p4aRunObjectFromMetadata(
+ * @return A p4RunRow pointer or NULL on error
+ */
+
+p4RunRow *p4RunObjectFromMetadata(
     psMetadata      *md                 ///< psMetadata to convert into a fooRow
 );
-/** Selects up to limit rows from the database and returns as p4aRunRow objects in a psArray
+/** Selects up to limit rows from the database and returns as p4RunRow objects in a psArray
  *
  *  See psDBSelectRows() for documentation on the format of where.
@@ -6978 +6981 @@
  */
 
-psArray *p4aRunSelectRowObjects(
+psArray *p4RunSelectRowObjects(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
     unsigned long long limit            ///< Maximum number of elements to return
 );
-/** Deletes a row from the database coresponding to an p4aRun
+/** Deletes a row from the database coresponding to an p4Run
  *
  *  Note that a 'where' search psMetadata is constructed from each object and
@@ -6991 +6994 @@
  */
 
-bool p4aRunDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4aRunRow *object    ///< Object to delete
+bool p4RunDeleteObject(
+    psDB            *dbh,               ///< Database handle
+    const p4RunRow *object    ///< Object to delete
 );
 /** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
@@ -7003 +7006 @@
  */
 
-long long p4aRunDeleteRowObjects(
+long long p4RunDeleteRowObjects(
     psDB            *dbh,               ///< Database handle
     const psArray   *objects,           ///< Array of objects to delete
     unsigned long long limit            ///< Maximum number of elements to delete 
 );
-/** Formats and prints an array of p4aRunRow objects
+/** Formats and prints an array of p4RunRow objects
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7016 +7019 @@
  */
 
-bool p4aRunPrintObjects(
+bool p4RunPrintObjects(
     FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4aRunRow objects
+    psArray         *objects,           ///< An array of p4RunRow objects
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** Formats and prints an p4aRunRow object
+/** Formats and prints an p4RunRow object
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7029 +7032 @@
  */
 
-bool p4aRunPrintObject(
+bool p4RunPrintObject(
     FILE            *stream,            ///< a stream
-    p4aRunRow *object,    ///< an p4aRunRow object
+    p4RunRow *object,    ///< an p4RunRow object
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** p4aInputExpRow data structure
- *
- * Structure for representing a single row of p4aInputExp table data.
+/** p4InputExpRow data structure
+ *
+ * Structure for representing a single row of p4InputExp table data.
  */
 
@@ -7043 +7046 @@
     char            *exp_tag;
     psS32           p3_version;
-} p4aInputExpRow;
-
-/** Creates a new p4aInputExpRow object
- *
- *  @return A new p4aInputExpRow object or NULL on failure.
- */
-
-p4aInputExpRow *p4aInputExpRowAlloc(
+    bool            magiced;
+} p4InputExpRow;
+
+/** Creates a new p4InputExpRow object
+ *
+ *  @return A new p4InputExpRow object or NULL on failure.
+ */
+
+p4InputExpRow *p4InputExpRowAlloc(
     psS32           p4a_id,
     const char      *exp_tag,
-    psS32           p3_version
-);
-
-/** Creates a new p4aInputExp table
- *
- * @return true on success
- */
-
-bool p4aInputExpCreateTable(
+    psS32           p3_version,
+    bool            magiced
+);
+
+/** Creates a new p4InputExp table
+ *
+ * @return true on success
+ */
+
+bool p4InputExpCreateTable(
     psDB            *dbh                ///< Database handle
 );
 
-/** Deletes a p4aInputExp table
- *
- * @return true on success
- */
-
-bool p4aInputExpDropTable(
+/** Deletes a p4InputExp table
+ *
+ * @return true on success
+ */
+
+bool p4InputExpDropTable(
     psDB            *dbh                ///< Database handle
 );
@@ -7081 +7086 @@
  */
 
-bool p4aInputExpInsert(
+bool p4InputExpInsert(
     psDB            *dbh,               ///< Database handle
     psS32           p4a_id,
     const char      *exp_tag,
-    psS32           p3_version
+    psS32           p3_version,
+    bool            magiced
 );
 
@@ -7093 +7099 @@
  */
 
-long long p4aInputExpDelete(
+long long p4InputExpDelete(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
@@ -7099 +7105 @@
 );
 
-/** Insert a single p4aInputExpRow object into a table
+/** Insert a single p4InputExpRow object into a table
  *
  * This function constructs and inserts a single row based on it's parameters.
@@ -7106 +7112 @@
  */
 
-bool p4aInputExpInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4aInputExpRow  *object             ///< p4aInputExpRow object
-);
-
-/** Insert an array of p4aInputExpRow object into a table
+bool p4InputExpInsertObject(
+    psDB            *dbh,               ///< Database handle
+    p4InputExpRow   *object             ///< p4InputExpRow object
+);
+
+/** Insert an array of p4InputExpRow object into a table
  *
  * This function constructs and inserts multiple rows based on it's parameters.
@@ -7118 +7124 @@
  */
 
-bool p4aInputExpInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4aInputExpRow objects
-);
-
-/** Insert data from a binary FITS table p4aInputExpRow into the database
+bool p4InputExpInsertObjects(
+    psDB            *dbh,               ///< Database handle
+    psArray         *objects            ///< array of p4InputExpRow objects
+);
+
+/** Insert data from a binary FITS table p4InputExpRow into the database
  *
  * This function expects a psFits object with a FITS table as the first
@@ -7133 +7139 @@
  */
 
-bool p4aInputExpInsertFits(
+bool p4InputExpInsertFits(
     psDB            *dbh,               ///< Database handle
     const psFits    *fits               ///< psFits object
@@ -7148 +7154 @@
  */
 
-bool p4aInputExpSelectRowsFits(
+bool p4InputExpSelectRowsFits(
     psDB            *dbh,               ///< Database handle
     psFits          *fits,              ///< psFits object
@@ -7155 +7161 @@
 );
 
-/** Convert a p4aInputExpRow into an equivalent psMetadata
+/** Convert a p4InputExpRow into an equivalent psMetadata
  *
  * @return A psMetadata pointer or NULL on error
  */
 
-psMetadata *p4aInputExpMetadataFromObject(
-    const p4aInputExpRow *object             ///< fooRow to convert into a psMetadata
+psMetadata *p4InputExpMetadataFromObject(
+    const p4InputExpRow *object             ///< fooRow to convert into a psMetadata
 );
 
 /** Convert a psMetadata into an equivalent fooRow
  *
- * @return A p4aInputExpRow pointer or NULL on error
- */
-
-p4aInputExpRow *p4aInputExpObjectFromMetadata(
+ * @return A p4InputExpRow pointer or NULL on error
+ */
+
+p4InputExpRow *p4InputExpObjectFromMetadata(
     psMetadata      *md                 ///< psMetadata to convert into a fooRow
 );
-/** Selects up to limit rows from the database and returns as p4aInputExpRow objects in a psArray
+/** Selects up to limit rows from the database and returns as p4InputExpRow objects in a psArray
  *
  *  See psDBSelectRows() for documentation on the format of where.
@@ -7179 +7185 @@
  */
 
-psArray *p4aInputExpSelectRowObjects(
+psArray *p4InputExpSelectRowObjects(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
     unsigned long long limit            ///< Maximum number of elements to return
 );
-/** Deletes a row from the database coresponding to an p4aInputExp
+/** Deletes a row from the database coresponding to an p4InputExp
  *
  *  Note that a 'where' search psMetadata is constructed from each object and
@@ -7192 +7198 @@
  */
 
-bool p4aInputExpDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4aInputExpRow *object    ///< Object to delete
+bool p4InputExpDeleteObject(
+    psDB            *dbh,               ///< Database handle
+    const p4InputExpRow *object    ///< Object to delete
 );
 /** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
@@ -7204 +7210 @@
  */
 
-long long p4aInputExpDeleteRowObjects(
+long long p4InputExpDeleteRowObjects(
     psDB            *dbh,               ///< Database handle
     const psArray   *objects,           ///< Array of objects to delete
     unsigned long long limit            ///< Maximum number of elements to delete 
 );
-/** Formats and prints an array of p4aInputExpRow objects
+/** Formats and prints an array of p4InputExpRow objects
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7217 +7223 @@
  */
 
-bool p4aInputExpPrintObjects(
+bool p4InputExpPrintObjects(
     FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4aInputExpRow objects
+    psArray         *objects,           ///< An array of p4InputExpRow objects
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** Formats and prints an p4aInputExpRow object
+/** Formats and prints an p4InputExpRow object
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7230 +7236 @@
  */
 
-bool p4aInputExpPrintObject(
+bool p4InputExpPrintObject(
     FILE            *stream,            ///< a stream
-    p4aInputExpRow *object,    ///< an p4aInputExpRow object
+    p4InputExpRow *object,    ///< an p4InputExpRow object
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** p4aScfileRow data structure
- *
- * Structure for representing a single row of p4aScfile table data.
+/** p4ScfileRow data structure
+ *
+ * Structure for representing a single row of p4Scfile table data.
  */
 
@@ -7249 +7255 @@
     psF64           bg;
     psF64           bg_mean_stdev;
-} p4aScfileRow;
-
-/** Creates a new p4aScfileRow object
- *
- *  @return A new p4aScfileRow object or NULL on failure.
- */
-
-p4aScfileRow *p4aScfileRowAlloc(
+} p4ScfileRow;
+
+/** Creates a new p4ScfileRow object
+ *
+ *  @return A new p4ScfileRow object or NULL on failure.
+ */
+
+p4ScfileRow *p4ScfileRowAlloc(
     psS32           p4a_id,
     const char      *skycell_id,
@@ -7267 +7273 @@
 );
 
-/** Creates a new p4aScfile table
- *
- * @return true on success
- */
-
-bool p4aScfileCreateTable(
+/** Creates a new p4Scfile table
+ *
+ * @return true on success
+ */
+
+bool p4ScfileCreateTable(
     psDB            *dbh                ///< Database handle
 );
 
-/** Deletes a p4aScfile table
- *
- * @return true on success
- */
-
-bool p4aScfileDropTable(
+/** Deletes a p4Scfile table
+ *
+ * @return true on success
+ */
+
+bool p4ScfileDropTable(
     psDB            *dbh                ///< Database handle
 );
@@ -7292 +7298 @@
  */
 
-bool p4aScfileInsert(
+bool p4ScfileInsert(
     psDB            *dbh,               ///< Database handle
     psS32           p4a_id,
@@ -7309 +7315 @@
  */
 
-long long p4aScfileDelete(
+long long p4ScfileDelete(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
@@ -7315 +7321 @@
 );
 
-/** Insert a single p4aScfileRow object into a table
+/** Insert a single p4ScfileRow object into a table
  *
  * This function constructs and inserts a single row based on it's parameters.
@@ -7322 +7328 @@
  */
 
-bool p4aScfileInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4aScfileRow    *object             ///< p4aScfileRow object
-);
-
-/** Insert an array of p4aScfileRow object into a table
+bool p4ScfileInsertObject(
+    psDB            *dbh,               ///< Database handle
+    p4ScfileRow     *object             ///< p4ScfileRow object
+);
+
+/** Insert an array of p4ScfileRow object into a table
  *
  * This function constructs and inserts multiple rows based on it's parameters.
@@ -7334 +7340 @@
  */
 
-bool p4aScfileInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4aScfileRow objects
-);
-
-/** Insert data from a binary FITS table p4aScfileRow into the database
+bool p4ScfileInsertObjects(
+    psDB            *dbh,               ///< Database handle
+    psArray         *objects            ///< array of p4ScfileRow objects
+);
+
+/** Insert data from a binary FITS table p4ScfileRow into the database
  *
  * This function expects a psFits object with a FITS table as the first
@@ -7349 +7355 @@
  */
 
-bool p4aScfileInsertFits(
+bool p4ScfileInsertFits(
     psDB            *dbh,               ///< Database handle
     const psFits    *fits               ///< psFits object
@@ -7364 +7370 @@
  */
 
-bool p4aScfileSelectRowsFits(
+bool p4ScfileSelectRowsFits(
     psDB            *dbh,               ///< Database handle
     psFits          *fits,              ///< psFits object
@@ -7371 +7377 @@
 );
 
-/** Convert a p4aScfileRow into an equivalent psMetadata
+/** Convert a p4ScfileRow into an equivalent psMetadata
  *
  * @return A psMetadata pointer or NULL on error
  */
 
-psMetadata *p4aScfileMetadataFromObject(
-    const p4aScfileRow *object             ///< fooRow to convert into a psMetadata
+psMetadata *p4ScfileMetadataFromObject(
+    const p4ScfileRow *object             ///< fooRow to convert into a psMetadata
 );
 
 /** Convert a psMetadata into an equivalent fooRow
  *
- * @return A p4aScfileRow pointer or NULL on error
- */
-
-p4aScfileRow *p4aScfileObjectFromMetadata(
+ * @return A p4ScfileRow pointer or NULL on error
+ */
+
+p4ScfileRow *p4ScfileObjectFromMetadata(
     psMetadata      *md                 ///< psMetadata to convert into a fooRow
 );
-/** Selects up to limit rows from the database and returns as p4aScfileRow objects in a psArray
+/** Selects up to limit rows from the database and returns as p4ScfileRow objects in a psArray
  *
  *  See psDBSelectRows() for documentation on the format of where.
@@ -7395 +7401 @@
  */
 
-psArray *p4aScfileSelectRowObjects(
+psArray *p4ScfileSelectRowObjects(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
     unsigned long long limit            ///< Maximum number of elements to return
 );
-/** Deletes a row from the database coresponding to an p4aScfile
+/** Deletes a row from the database coresponding to an p4Scfile
  *
  *  Note that a 'where' search psMetadata is constructed from each object and
@@ -7408 +7414 @@
  */
 
-bool p4aScfileDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4aScfileRow *object    ///< Object to delete
+bool p4ScfileDeleteObject(
+    psDB            *dbh,               ///< Database handle
+    const p4ScfileRow *object    ///< Object to delete
 );
 /** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
@@ -7420 +7426 @@
  */
 
-long long p4aScfileDeleteRowObjects(
+long long p4ScfileDeleteRowObjects(
     psDB            *dbh,               ///< Database handle
     const psArray   *objects,           ///< Array of objects to delete
     unsigned long long limit            ///< Maximum number of elements to delete 
 );
-/** Formats and prints an array of p4aScfileRow objects
+/** Formats and prints an array of p4ScfileRow objects
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7433 +7439 @@
  */
 
-bool p4aScfilePrintObjects(
+bool p4ScfilePrintObjects(
     FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4aScfileRow objects
+    psArray         *objects,           ///< An array of p4ScfileRow objects
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** Formats and prints an p4aScfileRow object
+/** Formats and prints an p4ScfileRow object
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7446 +7452 @@
  */
 
-bool p4aScfilePrintObject(
+bool p4ScfilePrintObject(
     FILE            *stream,            ///< a stream
-    p4aScfileRow *object,    ///< an p4aScfileRow object
+    p4ScfileRow *object,    ///< an p4ScfileRow object
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** p4bRunRow data structure
- *
- * Structure for representing a single row of p4bRun table data.
- */
-
-typedef struct {
-    psS32           p4b_id;
-    char            *state;
-    char            *workdir;
-    bool            magic;
-} p4bRunRow;
-
-/** Creates a new p4bRunRow object
- *
- *  @return A new p4bRunRow object or NULL on failure.
- */
-
-p4bRunRow *p4bRunRowAlloc(
-    psS32           p4b_id,
-    const char      *state,
-    const char      *workdir,
-    bool            magic
-);
-
-/** Creates a new p4bRun table
- *
- * @return true on success
- */
-
-bool p4bRunCreateTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Deletes a p4bRun table
- *
- * @return true on success
- */
-
-bool p4bRunDropTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Insert a single row into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4bRunInsert(
-    psDB            *dbh,               ///< Database handle
-    psS32           p4b_id,
-    const char      *state,
-    const char      *workdir,
-    bool            magic
-);
-
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4bRunDelete(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-
-/** Insert a single p4bRunRow object into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4bRunInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4bRunRow       *object             ///< p4bRunRow object
-);
-
-/** Insert an array of p4bRunRow object into a table
- *
- * This function constructs and inserts multiple rows based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4bRunInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4bRunRow objects
-);
-
-/** Insert data from a binary FITS table p4bRunRow into the database
- *
- * This function expects a psFits object with a FITS table as the first
- * extension.  The table must have at least one row of data in it, that is of
- * the appropriate format (number of columns and their type).  All other
- * extensions are ignored.
- *
- * @return true on success
- */
-
-bool p4bRunInsertFits(
-    psDB            *dbh,               ///< Database handle
-    const psFits    *fits               ///< psFits object
-);
-
-/** Selects up to limit from the database and returns them in a binary FITS table
- *
- * This function assumes an empty psFits object and will create a FITS table
- * as the first extension.
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return true on success
- */
-
-bool p4bRunSelectRowsFits(
-    psDB            *dbh,               ///< Database handle
-    psFits          *fits,              ///< psFits object
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-
-/** Convert a p4bRunRow into an equivalent psMetadata
- *
- * @return A psMetadata pointer or NULL on error
- */
-
-psMetadata *p4bRunMetadataFromObject(
-    const p4bRunRow *object             ///< fooRow to convert into a psMetadata
-);
-
-/** Convert a psMetadata into an equivalent fooRow
- *
- * @return A p4bRunRow pointer or NULL on error
- */
-
-p4bRunRow *p4bRunObjectFromMetadata(
-    psMetadata      *md                 ///< psMetadata to convert into a fooRow
-);
-/** Selects up to limit rows from the database and returns as p4bRunRow objects in a psArray
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return A psArray pointer or NULL on error
- */
-
-psArray *p4bRunSelectRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-/** Deletes a row from the database coresponding to an p4bRun
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-bool p4bRunDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4bRunRow *object    ///< Object to delete
-);
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4bRunDeleteRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psArray   *objects,           ///< Array of objects to delete
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-/** Formats and prints an array of p4bRunRow objects
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4bRunPrintObjects(
-    FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4bRunRow objects
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** Formats and prints an p4bRunRow object
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4bRunPrintObject(
-    FILE            *stream,            ///< a stream
-    p4bRunRow *object,    ///< an p4bRunRow object
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** p4bInputScfileRow data structure
- *
- * Structure for representing a single row of p4bInputScfile table data.
+/** p4InputScfileRow data structure
+ *
+ * Structure for representing a single row of p4InputScfile table data.
  */
 
@@ -7667 +7469 @@
     psS32           p3_version;
     char            *kind;
-} p4bInputScfileRow;
-
-/** Creates a new p4bInputScfileRow object
- *
- *  @return A new p4bInputScfileRow object or NULL on failure.
- */
-
-p4bInputScfileRow *p4bInputScfileRowAlloc(
+} p4InputScfileRow;
+
+/** Creates a new p4InputScfileRow object
+ *
+ *  @return A new p4InputScfileRow object or NULL on failure.
+ */
+
+p4InputScfileRow *p4InputScfileRowAlloc(
     psS32           p4b_id,
     const char      *skycell_id,
@@ -7683 +7485 @@
 );
 
-/** Creates a new p4bInputScfile table
- *
- * @return true on success
- */
-
-bool p4bInputScfileCreateTable(
+/** Creates a new p4InputScfile table
+ *
+ * @return true on success
+ */
+
+bool p4InputScfileCreateTable(
     psDB            *dbh                ///< Database handle
 );
 
-/** Deletes a p4bInputScfile table
- *
- * @return true on success
- */
-
-bool p4bInputScfileDropTable(
+/** Deletes a p4InputScfile table
+ *
+ * @return true on success
+ */
+
+bool p4InputScfileDropTable(
     psDB            *dbh                ///< Database handle
 );
@@ -7708 +7510 @@
  */
 
-bool p4bInputScfileInsert(
+bool p4InputScfileInsert(
     psDB            *dbh,               ///< Database handle
     psS32           p4b_id,
@@ -7723 +7525 @@
  */
 
-long long p4bInputScfileDelete(
+long long p4InputScfileDelete(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
@@ -7729 +7531 @@
 );
 
-/** Insert a single p4bInputScfileRow object into a table
+/** Insert a single p4InputScfileRow object into a table
  *
  * This function constructs and inserts a single row based on it's parameters.
@@ -7736 +7538 @@
  */
 
-bool p4bInputScfileInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4bInputScfileRow *object             ///< p4bInputScfileRow object
-);
-
-/** Insert an array of p4bInputScfileRow object into a table
+bool p4InputScfileInsertObject(
+    psDB            *dbh,               ///< Database handle
+    p4InputScfileRow *object             ///< p4InputScfileRow object
+);
+
+/** Insert an array of p4InputScfileRow object into a table
  *
  * This function constructs and inserts multiple rows based on it's parameters.
@@ -7748 +7550 @@
  */
 
-bool p4bInputScfileInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4bInputScfileRow objects
-);
-
-/** Insert data from a binary FITS table p4bInputScfileRow into the database
+bool p4InputScfileInsertObjects(
+    psDB            *dbh,               ///< Database handle
+    psArray         *objects            ///< array of p4InputScfileRow objects
+);
+
+/** Insert data from a binary FITS table p4InputScfileRow into the database
  *
  * This function expects a psFits object with a FITS table as the first
@@ -7763 +7565 @@
  */
 
-bool p4bInputScfileInsertFits(
+bool p4InputScfileInsertFits(
     psDB            *dbh,               ///< Database handle
     const psFits    *fits               ///< psFits object
@@ -7778 +7580 @@
  */
 
-bool p4bInputScfileSelectRowsFits(
+bool p4InputScfileSelectRowsFits(
     psDB            *dbh,               ///< Database handle
     psFits          *fits,              ///< psFits object
@@ -7785 +7587 @@
 );
 
-/** Convert a p4bInputScfileRow into an equivalent psMetadata
+/** Convert a p4InputScfileRow into an equivalent psMetadata
  *
  * @return A psMetadata pointer or NULL on error
  */
 
-psMetadata *p4bInputScfileMetadataFromObject(
-    const p4bInputScfileRow *object             ///< fooRow to convert into a psMetadata
+psMetadata *p4InputScfileMetadataFromObject(
+    const p4InputScfileRow *object             ///< fooRow to convert into a psMetadata
 );
 
 /** Convert a psMetadata into an equivalent fooRow
  *
- * @return A p4bInputScfileRow pointer or NULL on error
- */
-
-p4bInputScfileRow *p4bInputScfileObjectFromMetadata(
+ * @return A p4InputScfileRow pointer or NULL on error
+ */
+
+p4InputScfileRow *p4InputScfileObjectFromMetadata(
     psMetadata      *md                 ///< psMetadata to convert into a fooRow
 );
-/** Selects up to limit rows from the database and returns as p4bInputScfileRow objects in a psArray
+/** Selects up to limit rows from the database and returns as p4InputScfileRow objects in a psArray
  *
  *  See psDBSelectRows() for documentation on the format of where.
@@ -7809 +7611 @@
  */
 
-psArray *p4bInputScfileSelectRowObjects(
+psArray *p4InputScfileSelectRowObjects(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
     unsigned long long limit            ///< Maximum number of elements to return
 );
-/** Deletes a row from the database coresponding to an p4bInputScfile
+/** Deletes a row from the database coresponding to an p4InputScfile
  *
  *  Note that a 'where' search psMetadata is constructed from each object and
@@ -7822 +7624 @@
  */
 
-bool p4bInputScfileDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4bInputScfileRow *object    ///< Object to delete
+bool p4InputScfileDeleteObject(
+    psDB            *dbh,               ///< Database handle
+    const p4InputScfileRow *object    ///< Object to delete
 );
 /** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
@@ -7834 +7636 @@
  */
 
-long long p4bInputScfileDeleteRowObjects(
+long long p4InputScfileDeleteRowObjects(
     psDB            *dbh,               ///< Database handle
     const psArray   *objects,           ///< Array of objects to delete
     unsigned long long limit            ///< Maximum number of elements to delete 
 );
-/** Formats and prints an array of p4bInputScfileRow objects
+/** Formats and prints an array of p4InputScfileRow objects
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7847 +7649 @@
  */
 
-bool p4bInputScfilePrintObjects(
+bool p4InputScfilePrintObjects(
     FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4bInputScfileRow objects
+    psArray         *objects,           ///< An array of p4InputScfileRow objects
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** Formats and prints an p4bInputScfileRow object
+/** Formats and prints an p4InputScfileRow object
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -7860 +7662 @@
  */
 
-bool p4bInputScfilePrintObject(
+bool p4InputScfilePrintObject(
     FILE            *stream,            ///< a stream
-    p4bInputScfileRow *object,    ///< an p4bInputScfileRow object
+    p4InputScfileRow *object,    ///< an p4InputScfileRow object
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** p4bDiffScfileRow data structure
- *
- * Structure for representing a single row of p4bDiffScfile table data.
+/** p4DiffScfileRow data structure
+ *
+ * Structure for representing a single row of p4DiffScfile table data.
  */
 
@@ -7879 +7681 @@
     psF64           bg;
     psF64           bg_mean_stdev;
-} p4bDiffScfileRow;
-
-/** Creates a new p4bDiffScfileRow object
- *
- *  @return A new p4bDiffScfileRow object or NULL on failure.
- */
-
-p4bDiffScfileRow *p4bDiffScfileRowAlloc(
+} p4DiffScfileRow;
+
+/** Creates a new p4DiffScfileRow object
+ *
+ *  @return A new p4DiffScfileRow object or NULL on failure.
+ */
+
+p4DiffScfileRow *p4DiffScfileRowAlloc(
     psS32           p4b_id,
     const char      *skycell_id,
@@ -7897 +7699 @@
 );
 
-/** Creates a new p4bDiffScfile table
- *
- * @return true on success
- */
-
-bool p4bDiffScfileCreateTable(
+/** Creates a new p4DiffScfile table
+ *
+ * @return true on success
+ */
+
+bool p4DiffScfileCreateTable(
     psDB            *dbh                ///< Database handle
 );
 
-/** Deletes a p4bDiffScfile table
- *
- * @return true on success
- */
-
-bool p4bDiffScfileDropTable(
+/** Deletes a p4DiffScfile table
+ *
+ * @return true on success
+ */
+
+bool p4DiffScfileDropTable(
     psDB            *dbh                ///< Database handle
 );
@@ -7922 +7724 @@
  */
 
-bool p4bDiffScfileInsert(
+bool p4DiffScfileInsert(
     psDB            *dbh,               ///< Database handle
     psS32           p4b_id,
@@ -7939 +7741 @@
  */
 
-long long p4bDiffScfileDelete(
+long long p4DiffScfileDelete(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
@@ -7945 +7747 @@
 );
 
-/** Insert a single p4bDiffScfileRow object into a table
+/** Insert a single p4DiffScfileRow object into a table
  *
  * This function constructs and inserts a single row based on it's parameters.
@@ -7952 +7754 @@
  */
 
-bool p4bDiffScfileInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4bDiffScfileRow *object             ///< p4bDiffScfileRow object
-);
-
-/** Insert an array of p4bDiffScfileRow object into a table
+bool p4DiffScfileInsertObject(
+    psDB            *dbh,               ///< Database handle
+    p4DiffScfileRow *object             ///< p4DiffScfileRow object
+);
+
+/** Insert an array of p4DiffScfileRow object into a table
  *
  * This function constructs and inserts multiple rows based on it's parameters.
@@ -7964 +7766 @@
  */
 
-bool p4bDiffScfileInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4bDiffScfileRow objects
-);
-
-/** Insert data from a binary FITS table p4bDiffScfileRow into the database
+bool p4DiffScfileInsertObjects(
+    psDB            *dbh,               ///< Database handle
+    psArray         *objects            ///< array of p4DiffScfileRow objects
+);
+
+/** Insert data from a binary FITS table p4DiffScfileRow into the database
  *
  * This function expects a psFits object with a FITS table as the first
@@ -7979 +7781 @@
  */
 
-bool p4bDiffScfileInsertFits(
+bool p4DiffScfileInsertFits(
     psDB            *dbh,               ///< Database handle
     const psFits    *fits               ///< psFits object
@@ -7994 +7796 @@
  */
 
-bool p4bDiffScfileSelectRowsFits(
+bool p4DiffScfileSelectRowsFits(
     psDB            *dbh,               ///< Database handle
     psFits          *fits,              ///< psFits object
@@ -8001 +7803 @@
 );
 
-/** Convert a p4bDiffScfileRow into an equivalent psMetadata
+/** Convert a p4DiffScfileRow into an equivalent psMetadata
  *
  * @return A psMetadata pointer or NULL on error
  */
 
-psMetadata *p4bDiffScfileMetadataFromObject(
-    const p4bDiffScfileRow *object             ///< fooRow to convert into a psMetadata
+psMetadata *p4DiffScfileMetadataFromObject(
+    const p4DiffScfileRow *object             ///< fooRow to convert into a psMetadata
 );
 
 /** Convert a psMetadata into an equivalent fooRow
  *
- * @return A p4bDiffScfileRow pointer or NULL on error
- */
-
-p4bDiffScfileRow *p4bDiffScfileObjectFromMetadata(
+ * @return A p4DiffScfileRow pointer or NULL on error
+ */
+
+p4DiffScfileRow *p4DiffScfileObjectFromMetadata(
     psMetadata      *md                 ///< psMetadata to convert into a fooRow
 );
-/** Selects up to limit rows from the database and returns as p4bDiffScfileRow objects in a psArray
+/** Selects up to limit rows from the database and returns as p4DiffScfileRow objects in a psArray
  *
  *  See psDBSelectRows() for documentation on the format of where.
@@ -8025 +7827 @@
  */
 
-psArray *p4bDiffScfileSelectRowObjects(
+psArray *p4DiffScfileSelectRowObjects(
     psDB            *dbh,               ///< Database handle
     const psMetadata *where,            ///< Row match criteria
     unsigned long long limit            ///< Maximum number of elements to return
 );
-/** Deletes a row from the database coresponding to an p4bDiffScfile
+/** Deletes a row from the database coresponding to an p4DiffScfile
  *
  *  Note that a 'where' search psMetadata is constructed from each object and
@@ -8038 +7840 @@
  */
 
-bool p4bDiffScfileDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4bDiffScfileRow *object    ///< Object to delete
+bool p4DiffScfileDeleteObject(
+    psDB            *dbh,               ///< Database handle
+    const p4DiffScfileRow *object    ///< Object to delete
 );
 /** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
@@ -8050 +7852 @@
  */
 
-long long p4bDiffScfileDeleteRowObjects(
+long long p4DiffScfileDeleteRowObjects(
     psDB            *dbh,               ///< Database handle
     const psArray   *objects,           ///< Array of objects to delete
     unsigned long long limit            ///< Maximum number of elements to delete 
 );
-/** Formats and prints an array of p4bDiffScfileRow objects
+/** Formats and prints an array of p4DiffScfileRow objects
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -8063 +7865 @@
  */
 
-bool p4bDiffScfilePrintObjects(
+bool p4DiffScfilePrintObjects(
     FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4bDiffScfileRow objects
+    psArray         *objects,           ///< An array of p4DiffScfileRow objects
     bool            mdcf                ///< format as mdconfig or simple
 );
-/** Formats and prints an p4bDiffScfileRow object
+/** Formats and prints an p4DiffScfileRow object
  *
  * When mdcf is set the formated output is in psMetadataConfig
@@ -8076 +7878 @@
  */
 
-bool p4bDiffScfilePrintObject(
+bool p4DiffScfilePrintObject(
     FILE            *stream,            ///< a stream
-    p4bDiffScfileRow *object,    ///< an p4bDiffScfileRow object
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** p4cRunRow data structure
- *
- * Structure for representing a single row of p4cRun table data.
- */
-
-typedef struct {
-    psS32           p4c_id;
-    char            *state;
-    char            *workdir;
-    bool            magic;
-} p4cRunRow;
-
-/** Creates a new p4cRunRow object
- *
- *  @return A new p4cRunRow object or NULL on failure.
- */
-
-p4cRunRow *p4cRunRowAlloc(
-    psS32           p4c_id,
-    const char      *state,
-    const char      *workdir,
-    bool            magic
-);
-
-/** Creates a new p4cRun table
- *
- * @return true on success
- */
-
-bool p4cRunCreateTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Deletes a p4cRun table
- *
- * @return true on success
- */
-
-bool p4cRunDropTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Insert a single row into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cRunInsert(
-    psDB            *dbh,               ///< Database handle
-    psS32           p4c_id,
-    const char      *state,
-    const char      *workdir,
-    bool            magic
-);
-
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4cRunDelete(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-
-/** Insert a single p4cRunRow object into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cRunInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4cRunRow       *object             ///< p4cRunRow object
-);
-
-/** Insert an array of p4cRunRow object into a table
- *
- * This function constructs and inserts multiple rows based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cRunInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4cRunRow objects
-);
-
-/** Insert data from a binary FITS table p4cRunRow into the database
- *
- * This function expects a psFits object with a FITS table as the first
- * extension.  The table must have at least one row of data in it, that is of
- * the appropriate format (number of columns and their type).  All other
- * extensions are ignored.
- *
- * @return true on success
- */
-
-bool p4cRunInsertFits(
-    psDB            *dbh,               ///< Database handle
-    const psFits    *fits               ///< psFits object
-);
-
-/** Selects up to limit from the database and returns them in a binary FITS table
- *
- * This function assumes an empty psFits object and will create a FITS table
- * as the first extension.
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return true on success
- */
-
-bool p4cRunSelectRowsFits(
-    psDB            *dbh,               ///< Database handle
-    psFits          *fits,              ///< psFits object
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-
-/** Convert a p4cRunRow into an equivalent psMetadata
- *
- * @return A psMetadata pointer or NULL on error
- */
-
-psMetadata *p4cRunMetadataFromObject(
-    const p4cRunRow *object             ///< fooRow to convert into a psMetadata
-);
-
-/** Convert a psMetadata into an equivalent fooRow
- *
- * @return A p4cRunRow pointer or NULL on error
- */
-
-p4cRunRow *p4cRunObjectFromMetadata(
-    psMetadata      *md                 ///< psMetadata to convert into a fooRow
-);
-/** Selects up to limit rows from the database and returns as p4cRunRow objects in a psArray
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return A psArray pointer or NULL on error
- */
-
-psArray *p4cRunSelectRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-/** Deletes a row from the database coresponding to an p4cRun
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-bool p4cRunDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4cRunRow *object    ///< Object to delete
-);
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4cRunDeleteRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psArray   *objects,           ///< Array of objects to delete
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-/** Formats and prints an array of p4cRunRow objects
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4cRunPrintObjects(
-    FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4cRunRow objects
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** Formats and prints an p4cRunRow object
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4cRunPrintObject(
-    FILE            *stream,            ///< a stream
-    p4cRunRow *object,    ///< an p4cRunRow object
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** p4cInputExpRow data structure
- *
- * Structure for representing a single row of p4cInputExp table data.
- */
-
-typedef struct {
-    psS32           p4c_id;
-    char            *exp_tag;
-    psS32           p3_version;
-} p4cInputExpRow;
-
-/** Creates a new p4cInputExpRow object
- *
- *  @return A new p4cInputExpRow object or NULL on failure.
- */
-
-p4cInputExpRow *p4cInputExpRowAlloc(
-    psS32           p4c_id,
-    const char      *exp_tag,
-    psS32           p3_version
-);
-
-/** Creates a new p4cInputExp table
- *
- * @return true on success
- */
-
-bool p4cInputExpCreateTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Deletes a p4cInputExp table
- *
- * @return true on success
- */
-
-bool p4cInputExpDropTable(
-    psDB            *dbh                ///< Database handle
-);
-
-/** Insert a single row into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cInputExpInsert(
-    psDB            *dbh,               ///< Database handle
-    psS32           p4c_id,
-    const char      *exp_tag,
-    psS32           p3_version
-);
-
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4cInputExpDelete(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-
-/** Insert a single p4cInputExpRow object into a table
- *
- * This function constructs and inserts a single row based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cInputExpInsertObject(
-    psDB            *dbh,               ///< Database handle
-    p4cInputExpRow  *object             ///< p4cInputExpRow object
-);
-
-/** Insert an array of p4cInputExpRow object into a table
- *
- * This function constructs and inserts multiple rows based on it's parameters.
- *
- * @return true on success
- */
-
-bool p4cInputExpInsertObjects(
-    psDB            *dbh,               ///< Database handle
-    psArray         *objects            ///< array of p4cInputExpRow objects
-);
-
-/** Insert data from a binary FITS table p4cInputExpRow into the database
- *
- * This function expects a psFits object with a FITS table as the first
- * extension.  The table must have at least one row of data in it, that is of
- * the appropriate format (number of columns and their type).  All other
- * extensions are ignored.
- *
- * @return true on success
- */
-
-bool p4cInputExpInsertFits(
-    psDB            *dbh,               ///< Database handle
-    const psFits    *fits               ///< psFits object
-);
-
-/** Selects up to limit from the database and returns them in a binary FITS table
- *
- * This function assumes an empty psFits object and will create a FITS table
- * as the first extension.
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return true on success
- */
-
-bool p4cInputExpSelectRowsFits(
-    psDB            *dbh,               ///< Database handle
-    psFits          *fits,              ///< psFits object
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-
-/** Convert a p4cInputExpRow into an equivalent psMetadata
- *
- * @return A psMetadata pointer or NULL on error
- */
-
-psMetadata *p4cInputExpMetadataFromObject(
-    const p4cInputExpRow *object             ///< fooRow to convert into a psMetadata
-);
-
-/** Convert a psMetadata into an equivalent fooRow
- *
- * @return A p4cInputExpRow pointer or NULL on error
- */
-
-p4cInputExpRow *p4cInputExpObjectFromMetadata(
-    psMetadata      *md                 ///< psMetadata to convert into a fooRow
-);
-/** Selects up to limit rows from the database and returns as p4cInputExpRow objects in a psArray
- *
- *  See psDBSelectRows() for documentation on the format of where.
- *
- * @return A psArray pointer or NULL on error
- */
-
-psArray *p4cInputExpSelectRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psMetadata *where,            ///< Row match criteria
-    unsigned long long limit            ///< Maximum number of elements to return
-);
-/** Deletes a row from the database coresponding to an p4cInputExp
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-bool p4cInputExpDeleteObject(
-    psDB            *dbh,               ///< Database handle
-    const p4cInputExpRow *object    ///< Object to delete
-);
-/** Deletes up to limit rows from the database and returns the number of rows actually deleted. 
- *
- *  Note that a 'where' search psMetadata is constructed from each object and
- *  used to find rows to delete.
- *
- * @return A The number of rows removed or a negative value on error
- */
-
-long long p4cInputExpDeleteRowObjects(
-    psDB            *dbh,               ///< Database handle
-    const psArray   *objects,           ///< Array of objects to delete
-    unsigned long long limit            ///< Maximum number of elements to delete 
-);
-/** Formats and prints an array of p4cInputExpRow objects
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4cInputExpPrintObjects(
-    FILE            *stream,            ///< a stream
-    psArray         *objects,           ///< An array of p4cInputExpRow objects
-    bool            mdcf                ///< format as mdconfig or simple
-);
-/** Formats and prints an p4cInputExpRow object
- *
- * When mdcf is set the formated output is in psMetadataConfig
- * format, otherwise it is in a simple tabular format.
- *
- * @return true on success
- */
-
-bool p4cInputExpPrintObject(
-    FILE            *stream,            ///< a stream
-    p4cInputExpRow *object,    ///< an p4cInputExpRow object
+    p4DiffScfileRow *object,    ///< an p4DiffScfileRow object
     bool            mdcf                ///< format as mdconfig or simple
 );