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

Timestamp:

Dec 15, 2006, 12:38:13 PM (20 years ago)

Author:

jhoblitt

Message:

VERSION to 0.0.68

File:

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

trunk/ippdb/src/ippdb.c

@@ -66 +66 @@
 #define P4INPUTIMFILE_TABLE_NAME "p4InputImfile"
 #define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile"
-#define P4PSTACKEDIMFILE_TABLE_NAME "p4PStackedImfile"
-#define P4PDIFFIMFILE_TABLE_NAME "p4PDiffImfile"
-#define P4PMAGICMASKIMFILE_TABLE_NAME "p4PMagicMaskImfile"
+#define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile"
+#define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile"
+#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile"
 #define MAX_STRING_LENGTH 1024
 
@@ -14861 +14861 @@
     return true;
 }
-static void p4PStackedImfileRowFree(p4PStackedImfileRow *object);
-
-p4PStackedImfileRow *p4PStackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
-{
-    p4PStackedImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PStackedImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PStackedImfileRowFree);
+static void p4StackedImfileRowFree(p4StackedImfileRow *object);
+
+p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+{
+    p4StackedImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4StackedImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -14879 +14879 @@
 }
 
-static void p4PStackedImfileRowFree(p4PStackedImfileRow *object)
+static void p4StackedImfileRowFree(p4StackedImfileRow *object)
 {
     psFree(object->class_id);
@@ -14887 +14887 @@
 }
 
-bool p4PStackedImfileCreateTable(psDB *dbh)
+bool p4StackedImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14916 +14916 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -14923 +14923 @@
 }
 
-bool p4PStackedImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PSTACKEDIMFILE_TABLE_NAME);
-}
-
-bool p4PStackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+bool p4StackedImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME);
+}
+
+bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -14957 +14957 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PSTACKEDIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -14963 +14963 @@
 }
 
-long long p4PStackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
         return count;
 
@@ -14977 +14977 @@
     return deleted;
 }
-bool p4PStackedImfileInsertObject(psDB *dbh, p4PStackedImfileRow *object)
-{
-    return p4PStackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
-}
-
-bool p4PStackedImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object)
+{
+    return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri);
+}
+
+bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PStackedImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4StackedImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -14993 +14993 @@
 }
 
-bool p4PStackedImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PSTACKEDIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PSTACKEDIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PSTACKEDIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4STACKEDIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME);
         return false;
     }
@@ -15017 +15017 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4STACKEDIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15028 +15028 @@
 }
 
-bool p4PStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15038 +15038 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PSTACKEDIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15049 +15049 @@
 }
 
-psMetadata *p4PStackedImfileMetadataFromObject(const p4PStackedImfileRow *object)
+psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15082 +15082 @@
 }
 
-p4PStackedImfileRow *p4PStackedImfileObjectFromMetadata(psMetadata *md)
+p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15112 +15112 @@
     }
 
-    return p4PStackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
-}
-psArray *p4PStackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri);
+}
+psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15120 +15120 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15130 +15130 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PStackedImfileRow *object = p4PStackedImfileObjectFromMetadata(rowSet->data[i]);
+        p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15139 +15139 @@
     return returnSet;
 }
-bool p4PStackedImfileDeleteObject(psDB *dbh, const p4PStackedImfileRow *object)
-{
-    psMetadata *where = p4PStackedImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, 0);
+bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object)
+{
+    psMetadata *where = p4StackedImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
         return false;
     }
@@ -15151 +15151 @@
         // 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, "p4PStackedImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PStackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4StackedImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PStackedImfileRow *object = objects->data[i];
-        psMetadata *where = p4PStackedImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PSTACKEDIMFILE_TABLE_NAME, where, limit);
+        p4StackedImfileRow *object = objects->data[i];
+        psMetadata *where = p4StackedImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PStackedImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile");
             return count;
         }
@@ -15176 +15176 @@
     return deleted;
 }
-bool p4PStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4StackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15182 +15182 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PStackedImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4StackedImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PSTACKEDIMFILE_TABLE_NAME,
+            P4STACKEDIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15207 +15207 @@
     return true;
 }
-bool p4PStackedImfilePrintObject(FILE *stream, p4PStackedImfileRow *object, bool mdcf)
+bool p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PStackedImfileMetadataFromObject(object);
+    psMetadata *md = p4StackedImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -15222 +15222 @@
     return true;
 }
-static void p4PDiffImfileRowFree(p4PDiffImfileRow *object);
-
-p4PDiffImfileRow *p4PDiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
-{
-    p4PDiffImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PDiffImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PDiffImfileRowFree);
+static void p4DiffImfileRowFree(p4DiffImfileRow *object);
+
+p4DiffImfileRow *p4DiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+{
+    p4DiffImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4DiffImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -15242 +15242 @@
 }
 
-static void p4PDiffImfileRowFree(p4PDiffImfileRow *object)
+static void p4DiffImfileRowFree(p4DiffImfileRow *object)
 {
     psFree(object->exp_tag);
@@ -15251 +15251 @@
 }
 
-bool p4PDiffImfileCreateTable(psDB *dbh)
+bool p4DiffImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15290 +15290 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -15297 +15297 @@
 }
 
-bool p4PDiffImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PDIFFIMFILE_TABLE_NAME);
-}
-
-bool p4PDiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
+bool p4DiffImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME);
+}
+
+bool p4DiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15341 +15341 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PDIFFIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -15347 +15347 @@
 }
 
-long long p4PDiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
         return count;
 
@@ -15361 +15361 @@
     return deleted;
 }
-bool p4PDiffImfileInsertObject(psDB *dbh, p4PDiffImfileRow *object)
-{
-    return p4PDiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
-}
-
-bool p4PDiffImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object)
+{
+    return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri);
+}
+
+bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PDiffImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4DiffImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -15377 +15377 @@
 }
 
-bool p4PDiffImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PDIFFIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PDIFFIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PDIFFIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4DIFFIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME);
         return false;
     }
@@ -15401 +15401 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PDIFFIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4DIFFIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15412 +15412 @@
 }
 
-bool p4PDiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15422 +15422 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PDIFFIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15433 +15433 @@
 }
 
-psMetadata *p4PDiffImfileMetadataFromObject(const p4PDiffImfileRow *object)
+psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15476 +15476 @@
 }
 
-p4PDiffImfileRow *p4PDiffImfileObjectFromMetadata(psMetadata *md)
+p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15516 +15516 @@
     }
 
-    return p4PDiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
-}
-psArray *p4PDiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri);
+}
+psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15524 +15524 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15534 +15534 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PDiffImfileRow *object = p4PDiffImfileObjectFromMetadata(rowSet->data[i]);
+        p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15543 +15543 @@
     return returnSet;
 }
-bool p4PDiffImfileDeleteObject(psDB *dbh, const p4PDiffImfileRow *object)
-{
-    psMetadata *where = p4PDiffImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, 0);
+bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object)
+{
+    psMetadata *where = p4DiffImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
         return false;
     }
@@ -15555 +15555 @@
         // 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, "p4PDiffImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PDiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4DiffImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PDiffImfileRow *object = objects->data[i];
-        psMetadata *where = p4PDiffImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PDIFFIMFILE_TABLE_NAME, where, limit);
+        p4DiffImfileRow *object = objects->data[i];
+        psMetadata *where = p4DiffImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PDiffImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile");
             return count;
         }
@@ -15580 +15580 @@
     return deleted;
 }
-bool p4PDiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4DiffImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15586 +15586 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PDiffImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4DiffImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PDIFFIMFILE_TABLE_NAME,
+            P4DIFFIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15611 +15611 @@
     return true;
 }
-bool p4PDiffImfilePrintObject(FILE *stream, p4PDiffImfileRow *object, bool mdcf)
+bool p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PDiffImfileMetadataFromObject(object);
+    psMetadata *md = p4DiffImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {
@@ -15626 +15626 @@
     return true;
 }
-static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object);
-
-p4PMagicMaskImfileRow *p4PMagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
-{
-    p4PMagicMaskImfileRow *_object;
-
-    _object = psAlloc(sizeof(p4PMagicMaskImfileRow));
-    psMemSetDeallocator(_object, (psFreeFunc)p4PMagicMaskImfileRowFree);
+static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object);
+
+p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
+{
+    p4MagicMaskImfileRow *_object;
+
+    _object = psAlloc(sizeof(p4MagicMaskImfileRow));
+    psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree);
 
     _object->p4_id = p4_id;
@@ -15644 +15644 @@
 }
 
-static void p4PMagicMaskImfileRowFree(p4PMagicMaskImfileRow *object)
+static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object)
 {
     psFree(object->exp_tag);
@@ -15651 +15651 @@
 }
 
-bool p4PMagicMaskImfileCreateTable(psDB *dbh)
+bool p4MagicMaskImfileCreateTable(psDB *dbh)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15680 +15680 @@
     }
 
-    bool status = psDBCreateTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
+    bool status = psDBCreateTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
 
     psFree(md);
@@ -15687 +15687 @@
 }
 
-bool p4PMagicMaskImfileDropTable(psDB *dbh)
-{
-    return psDBDropTable(dbh, P4PMAGICMASKIMFILE_TABLE_NAME);
-}
-
-bool p4PMagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
+bool p4MagicMaskImfileDropTable(psDB *dbh)
+{
+    return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME);
+}
+
+bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15721 +15721 @@
     }
 
-    bool status = psDBInsertOneRow(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, md);
+    bool status = psDBInsertOneRow(dbh, P4MAGICMASKIMFILE_TABLE_NAME, md);
     psFree(md);
 
@@ -15727 +15727 @@
 }
 
-long long p4PMagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
+long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     long long       deleted = 0;
 
-    long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
         return count;
 
@@ -15741 +15741 @@
     return deleted;
 }
-bool p4PMagicMaskImfileInsertObject(psDB *dbh, p4PMagicMaskImfileRow *object)
-{
-    return p4PMagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
-}
-
-bool p4PMagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
+bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object)
+{
+    return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri);
+}
+
+bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects)
 {
     for (long i = 0; i < psArrayLength(objects); i++) {
-        if (!p4PMagicMaskImfileInsertObject(dbh, objects->data[i])) {
+        if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) {
             return false;
         }
@@ -15757 +15757 @@
 }
 
-bool p4PMagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
+bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits)
 {
     psArray         *rowSet;
 
-    // move to (the first?) extension named  P4PMAGICMASKIMFILE_TABLE_NAME
-    if (!psFitsMoveExtName(fits, P4PMAGICMASKIMFILE_TABLE_NAME)) {
-        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4PMAGICMASKIMFILE_TABLE_NAME);
+    // move to (the first?) extension named  P4MAGICMASKIMFILE_TABLE_NAME
+    if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) {
+        psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME);
         return false;
     }
@@ -15781 +15781 @@
     }
 
-    if (!psDBInsertRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, rowSet)) {
+    if (!psDBInsertRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) {
         psError(PS_ERR_UNKNOWN, false, "databse insert failed");
         psFree(rowSet);
@@ -15792 +15792 @@
 }
 
-bool p4PMagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
+bool p4MagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
 
-    rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return false;
@@ -15802 +15802 @@
 
     // output to fits
-    if (!psFitsWriteTable(fits, NULL, rowSet, P4PMAGICMASKIMFILE_TABLE_NAME)) {
+    if (!psFitsWriteTable(fits, NULL, rowSet, P4MAGICMASKIMFILE_TABLE_NAME)) {
         psError(PS_ERR_UNKNOWN, false, "FITS table write failed");
         psFree(rowSet);
@@ -15813 +15813 @@
 }
 
-psMetadata *p4PMagicMaskImfileMetadataFromObject(const p4PMagicMaskImfileRow *object)
+psMetadata *p4MagicMaskImfileMetadataFromObject(const p4MagicMaskImfileRow *object)
 {
     psMetadata *md = psMetadataAlloc();
@@ -15846 +15846 @@
 }
 
-p4PMagicMaskImfileRow *p4PMagicMaskImfileObjectFromMetadata(psMetadata *md)
+p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(psMetadata *md)
 {
 
@@ -15876 +15876 @@
     }
 
-    return p4PMagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
-}
-psArray *p4PMagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
+    return p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri);
+}
+psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
 {
     psArray         *rowSet;
@@ -15884 +15884 @@
     psU64           i;
 
-    rowSet = psDBSelectRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+    rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
     if (!rowSet) {
         return NULL;
@@ -15894 +15894 @@
 
     for (i = 0; i < rowSet->n; i++) {
-        p4PMagicMaskImfileRow *object = p4PMagicMaskImfileObjectFromMetadata(rowSet->data[i]);
+        p4MagicMaskImfileRow *object = p4MagicMaskImfileObjectFromMetadata(rowSet->data[i]);
         psArrayAdd(returnSet, 0, object);
         psFree(object);
@@ -15903 +15903 @@
     return returnSet;
 }
-bool p4PMagicMaskImfileDeleteObject(psDB *dbh, const p4PMagicMaskImfileRow *object)
-{
-    psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
-    long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, 0);
+bool p4MagicMaskImfileDeleteObject(psDB *dbh, const p4MagicMaskImfileRow *object)
+{
+    psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
+    long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0);
     psFree(where)
     if (count < 0) {
-        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+        psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
         return false;
     }
@@ -15915 +15915 @@
         // 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, "p4PMagicMaskImfileRow object matched more then one row.  Check your database schema");
-        return false;
-    }
-
-    return true;
-}
-long long p4PMagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
+        psError(PS_ERR_UNKNOWN, true, "p4MagicMaskImfileRow object matched more then one row.  Check your database schema");
+        return false;
+    }
+
+    return true;
+}
+long long p4MagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit)
 {
     long long       deleted = 0;
 
     for (long long i = 0; i < objects->n; i++) {
-        p4PMagicMaskImfileRow *object = objects->data[i];
-        psMetadata *where = p4PMagicMaskImfileMetadataFromObject(object);
-        long long count = psDBDeleteRows(dbh, P4PMAGICMASKIMFILE_TABLE_NAME, where, limit);
+        p4MagicMaskImfileRow *object = objects->data[i];
+        psMetadata *where = p4MagicMaskImfileMetadataFromObject(object);
+        long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit);
         psFree(where)
         if (count < 0) {
-            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4PMagicMaskImfile");
+            psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile");
             return count;
         }
@@ -15940 +15940 @@
     return deleted;
 }
-bool p4PMagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
+bool p4MagicMaskImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(objects, false);
@@ -15946 +15946 @@
     psMetadata *output = psMetadataAlloc();
     for (long i = 0; i < psArrayLength(objects); i++) {
-        psMetadata *md = p4PMagicMaskImfileMetadataFromObject(objects->data[i]);
+        psMetadata *md = p4MagicMaskImfileMetadataFromObject(objects->data[i]);
         if (!psMetadataAddMetadata(
             output,
             PS_LIST_TAIL,
-            P4PMAGICMASKIMFILE_TABLE_NAME,
+            P4MAGICMASKIMFILE_TABLE_NAME,
             PS_META_DUPLICATE_OK,
             NULL,
@@ -15971 +15971 @@
     return true;
 }
-bool p4PMagicMaskImfilePrintObject(FILE *stream, p4PMagicMaskImfileRow *object, bool mdcf)
+bool p4MagicMaskImfilePrintObject(FILE *stream, p4MagicMaskImfileRow *object, bool mdcf)
 {
     PS_ASSERT_PTR_NON_NULL(object, false);
 
-    psMetadata *md = p4PMagicMaskImfileMetadataFromObject(object);
+    psMetadata *md = p4MagicMaskImfileMetadataFromObject(object);
 
     if (!ippdbPrintMetadataRaw(stream, md, mdcf)) {