IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9423


Ignore:
Timestamp:
Oct 9, 2006, 1:43:03 PM (20 years ago)
Author:
jhoblitt
Message:

VERSION 0.0.49

Location:
trunk/ippdb
Files:
3 deleted
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippdb/configure.ac

    r9307 r9423  
    11dnl
    2 dnl This file was generated by glueforge 0.25
     2dnl This file was generated by glueforge 0.29
    33dnl
    44dnl Do NOT directly edit this file.
    … …  
    77AC_PREREQ(2.59)
    88
    9 AC_INIT([ippdb], [0.0.48], [pan-starrs.ifa.hawaii.edu])
     9AC_INIT([ippdb], [0.0.49], [pan-starrs.ifa.hawaii.edu])
    1010AC_CONFIG_SRCDIR([ippdb.pc.in])
    1111

  • trunk/ippdb/src/ippdb.c

    r9307 r9423  
     1/*
     2 * code.c
     3 *
     4 * Copyright (C) 2006  Joshua Hoblitt
     5 *
     6 * This program is free software; you can redistribute it and/or modify it
     7 * under the terms of the GNU General Public License as published by the Free
     8 * Software Foundation; version 2 of the License.
     9 *
     10 * This program is distributed in the hope that it will be useful, but WITHOUT
     11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
     13 * more details.
     14 *
     15 * You should have received a copy of the GNU General Public License along with
     16 * program; see the file COPYING. If not, write to the Free Software
     17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
     18 */
     19
    120/*
    221 *
    3  * This file was generated by glueforge 0.25
     22 * This file was generated by glueforge 0.29
    423 *
    524 * Do NOT directly edit this file.
    … …  
    1231#include "ippdb.h"
    1332
    14 #define IPPDB_DEFAULT_INDEX_NAME "position"
    1533#define WEATHER_TABLE_NAME "weather"
    16 #define WEATHER_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    1734#define SKYP_TRANSPARENCY_TABLE_NAME "skyp_transparency"
    18 #define SKYP_TRANSPARENCY_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    1935#define SKYP_ABSORPTION_TABLE_NAME "skyp_absorption"
    20 #define SKYP_ABSORPTION_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    2136#define SKYP_EMISSION_TABLE_NAME "skyp_emission"
    22 #define SKYP_EMISSION_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    2337#define DIMM_TABLE_NAME "dimm"
    24 #define DIMM_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    2538#define SKYP_IR_TABLE_NAME "skyp_ir"
    26 #define SKYP_IR_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    2739#define DOME_TABLE_NAME "dome"
    28 #define DOME_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    2940#define TELESCOPE_TABLE_NAME "telescope"
    30 #define TELESCOPE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    3141#define SUMMITEXP_TABLE_NAME "summitExp"
    32 #define SUMMITEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    3342#define PZPENDINGEXP_TABLE_NAME "pzPendingExp"
    34 #define PZPENDINGEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    3543#define PZPENDINGIMFILE_TABLE_NAME "pzPendingImfile"
    36 #define PZPENDINGIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    3744#define NEWEXP_TABLE_NAME "newExp"
    38 #define NEWEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    3945#define NEWIMFILE_TABLE_NAME "newImfile"
    40 #define NEWIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    4146#define RAWDETRENDEXP_TABLE_NAME "rawDetrendExp"
    42 #define RAWDETRENDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    4347#define RAWSCIENCEEXP_TABLE_NAME "rawScienceExp"
    44 #define RAWSCIENCEEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    4548#define RAWIMFILE_TABLE_NAME "rawImfile"
    46 #define RAWIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    4749#define P1PENDINGEXP_TABLE_NAME "p1PendingExp"
    48 #define P1PENDINGEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    4950#define P2PENDINGEXP_TABLE_NAME "p2PendingExp"
    50 #define P2PENDINGEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5151#define P2PENDINGIMFILE_TABLE_NAME "p2PendingImfile"
    52 #define P2PENDINGIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5352#define P2PROCESSEDEXP_TABLE_NAME "p2ProcessedExp"
    54 #define P2PROCESSEDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5553#define P2PROCESSEDIMFILE_TABLE_NAME "p2ProcessedImfile"
    56 #define P2PROCESSEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5754#define P3PENDINGEXP_TABLE_NAME "p3PendingExp"
    58 #define P3PENDINGEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    5955#define P3PROCESSEDEXP_TABLE_NAME "p3ProcessedExp"
    60 #define P3PROCESSEDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    6156#define DETRUN_TABLE_NAME "detRun"
    62 #define DETRUN_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    6357#define DETINPUTEXP_TABLE_NAME "detInputExp"
    64 #define DETINPUTEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    6558#define DETPROCESSEDIMFILE_TABLE_NAME "detProcessedImfile"
    66 #define DETPROCESSEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    6759#define DETPROCESSEDEXP_TABLE_NAME "detProcessedExp"
    68 #define DETPROCESSEDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    6960#define DETSTACKEDIMFILE_TABLE_NAME "detStackedImfile"
    70 #define DETSTACKEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    7161#define DETNORMALIZEDSTATIMFILE_TABLE_NAME "detNormalizedStatImfile"
    72 #define DETNORMALIZEDSTATIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    7362#define DETNORMALIZEDIMFILE_TABLE_NAME "detNormalizedImfile"
    74 #define DETNORMALIZEDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    7563#define DETNORMALIZEDEXP_TABLE_NAME "detNormalizedExp"
    76 #define DETNORMALIZEDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    7764#define DETMASTERFRAME_TABLE_NAME "detMasterFrame"
    78 #define DETMASTERFRAME_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    7965#define DETMASTERIMFILE_TABLE_NAME "detMasterImfile"
    80 #define DETMASTERIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    8166#define DETRESIDIMFILE_TABLE_NAME "detResidImfile"
    82 #define DETRESIDIMFILE_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    8367#define DETRESIDEXP_TABLE_NAME "detResidExp"
    84 #define DETRESIDEXP_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    8568#define DETRUNSUMMARY_TABLE_NAME "detRunSummary"
    86 #define DETRUNSUMMARY_INDEX_NAME IPPDB_DEFAULT_INDEX_NAME
    8769#define MAX_STRING_LENGTH 1024
    8870
    89 psDB *ippdbInit(const char *host, const char *user, const char *passwd, const char *dbname)
    90 {
    91     return psDBInit(host, user, passwd, dbname);
     71psDB *ippdbInit(const char *host, const char *user, const char *passwd, const char *dbname, unsigned int port)
     72{
     73    return psDBInit(host, user, passwd, dbname, port);
    9274}
    9375
    … …  
    10385    psMetadata *clean = psMetadataCopy(NULL, md);
    10486
    105     // don't bother to check the return status as the key we are trying to
    106     // remove may or may not be there
    107     // XXX someday psErr should be checked -- the only acceptable error is key
    108     // not found
    109     psMetadataRemoveKey(clean, IPPDB_DEFAULT_INDEX_NAME);
    110    
    11187    if (!ippdbPrintMetadataRaw(stream, clean, mdcf)) {
    11288        psError(PS_ERR_UNKNOWN, false, "failed to print metadata");
    … …  
    205181    for (long i = 0; i < psArrayLength(mds); i++) {
    206182        psMetadata *md = psMetadataCopy(NULL, mds->data[i]);
    207         // don't bother to check the return status as the key we are trying to
    208         // remove may or may not be there
    209         // XXX someday psErr should be checked -- the only acceptable error
    210         // is key not found
    211 
    212         psMetadataRemoveKey(md, IPPDB_DEFAULT_INDEX_NAME);
    213183        if (!psMetadataAddMetadata(output, PS_LIST_TAIL, mdname, PS_META_DUPLICATE_OK, NULL, md)) {
    214184            psError(PS_ERR_UNKNOWN, false, "failed to add a metadata item");
    … …  
    288258
    289259    md = psMetadataAlloc();
    290     if (!psMetadataAdd(md, PS_LIST_TAIL, WEATHER_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    291         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", WEATHER_INDEX_NAME);
    292         psFree(md);
    293         return false;
    294     }
    295260    if (!psMetadataAddF32(md, PS_LIST_TAIL, "temp01", 0, NULL, 0.0)) {
    296261        psError(PS_ERR_UNKNOWN, false, "failed to add item temp01");
    … …  
    403368    return deleted;
    404369}
    405 bool weatherPop(psDB *dbh, psF32 *temp01, psF32 *humi01, psF32 *temp02, psF32 *humi02, psF32 *temp03, psF32 *humi03, psF32 *pressure)
    406 {
    407     psArray         *rowSet;
    408     psMetadata      *row;
    409     psMetadata      *popped;
    410     long            deleted;
    411     bool            status;
    412     int             rowID;
    413 
    414     rowSet = psDBSelectRows(dbh, WEATHER_TABLE_NAME, NULL, 1);
    415     if (!rowSet) {
    416         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", WEATHER_INDEX_NAME);
    417         psFree(rowSet);
    418         return NULL;
    419     }
    420 
    421     row = psArrayGet(rowSet, 0);
    422     psMemIncrRefCounter(row);
    423     if (!row) {
    424         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    425         return NULL;
    426     }
    427     psFree(rowSet);
    428 
    429     rowID = psMetadataLookupS32(&status, row, WEATHER_INDEX_NAME);
    430     if (!status) {
    431         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", WEATHER_INDEX_NAME);
    432         psFree(row);
    433         return NULL;
    434     }
    435 
    436     popped = psMetadataAlloc();
    437     psMetadataAddS32(popped, PS_LIST_TAIL, WEATHER_INDEX_NAME, 0, NULL, rowID);
    438 
    439     deleted = psDBDeleteRows(dbh, WEATHER_TABLE_NAME, popped, 0);
    440     if (deleted != 1) {
    441         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    442         psFree(popped);
    443         psFree(row);
    444         return NULL;
    445     }
    446 
    447     psFree(popped);
    448 
    449     *temp01 = psMetadataLookupF32(&status, row, "temp01");
    450     if (!status) {
    451         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item temp01");
    452         psFree(row);
    453         return false;
    454     }
    455     *humi01 = psMetadataLookupF32(&status, row, "humi01");
    456     if (!status) {
    457         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item humi01");
    458         psFree(row);
    459         return false;
    460     }
    461     *temp02 = psMetadataLookupF32(&status, row, "temp02");
    462     if (!status) {
    463         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item temp02");
    464         psFree(row);
    465         return false;
    466     }
    467     *humi02 = psMetadataLookupF32(&status, row, "humi02");
    468     if (!status) {
    469         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item humi02");
    470         psFree(row);
    471         return false;
    472     }
    473     *temp03 = psMetadataLookupF32(&status, row, "temp03");
    474     if (!status) {
    475         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item temp03");
    476         psFree(row);
    477         return false;
    478     }
    479     *humi03 = psMetadataLookupF32(&status, row, "humi03");
    480     if (!status) {
    481         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item humi03");
    482         psFree(row);
    483         return false;
    484     }
    485     *pressure = psMetadataLookupF32(&status, row, "pressure");
    486     if (!status) {
    487         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item pressure");
    488         psFree(row);
    489         return false;
    490     }
    491 
    492     psFree(row);
    493 
    494     return true;
    495 }
    496 
    497370bool weatherInsertObject(psDB *dbh, weatherRow *object)
    498371{
    … …  
    509382
    510383    return true;
    511 }
    512 
    513 weatherRow *weatherPopObject(psDB *dbh)
    514 {
    515     psF32           temp01;
    516     psF32           humi01;
    517     psF32           temp02;
    518     psF32           humi02;
    519     psF32           temp03;
    520     psF32           humi03;
    521     psF32           pressure;
    522 
    523     if (!weatherPop(dbh, &temp01, &humi01, &temp02, &humi02, &temp03, &humi03, &pressure)) {
    524         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    525         return NULL;
    526     }
    527 
    528     return weatherRowAlloc(temp01, humi01, temp02, humi02, temp03, humi03, pressure);
    529384}
    530385
    … …  
    564419}
    565420
    566 bool weatherPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    567 {
    568     char            query[MAX_STRING_LENGTH];
    569 
    570     if (!weatherSelectRowsFits(dbh, fits, NULL, limit)) {
    571         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    572         return false;
    573     }
    574 
    575     // remove limit rows from the end of the database
    576     if (snprintf(query, MAX_STRING_LENGTH,
    577                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    578                 WEATHER_TABLE_NAME, WEATHER_INDEX_NAME, limit) < 0) {
    579         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    580         return false;
    581     }
    582            
    583     if (!p_psDBRunQuery(dbh, query)) {
    584         psError(PS_ERR_UNKNOWN, false, "database query failed");
    585         return false;
    586     }
    587 
    588     return true;
    589 }
    590 
    591421bool weatherSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    592422{
    593423    psArray         *rowSet;
    594     psU64           i;
    595424
    596425    rowSet = psDBSelectRows(dbh, WEATHER_TABLE_NAME, where, limit);
    597426    if (!rowSet) {
    598427        return false;
    599     }
    600 
    601     // strip index column
    602     for (i = 0; i < rowSet->n; i++) {
    603         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, WEATHER_INDEX_NAME)) {
    604             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", WEATHER_INDEX_NAME);
    605             psFree(rowSet);
    606             return false;
    607         }
    608428    }
    609429
    … …  
    722542    if (!rowSet) {
    723543        return NULL;
    724     }
    725 
    726     // strip index column
    727     for (i = 0; i < rowSet->n; i++) {
    728         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, WEATHER_INDEX_NAME)) {
    729             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", WEATHER_INDEX_NAME);
    730             psFree(rowSet);
    731             return false;
    732         }
    733544    }
    734545
    … …  
    847658
    848659    md = psMetadataAlloc();
    849     if (!psMetadataAdd(md, PS_LIST_TAIL, SKYP_TRANSPARENCY_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    850         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", SKYP_TRANSPARENCY_INDEX_NAME);
    851         psFree(md);
    852         return false;
    853     }
    854660    if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "255")) {
    855661        psError(PS_ERR_UNKNOWN, false, "failed to add item filter");
    … …  
    962768    return deleted;
    963769}
    964 bool skyp_transparencyPop(psDB *dbh, char **filter, psF64 *trans, psS32 *nstars, psF64 *ra, psF64 *decl, psF32 *exptime, psF64 *sky_bright)
    965 {
    966     psArray         *rowSet;
    967     psMetadata      *row;
    968     psMetadata      *popped;
    969     long            deleted;
    970     bool            status;
    971     int             rowID;
    972 
    973     rowSet = psDBSelectRows(dbh, SKYP_TRANSPARENCY_TABLE_NAME, NULL, 1);
    974     if (!rowSet) {
    975         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_TRANSPARENCY_INDEX_NAME);
    976         psFree(rowSet);
    977         return NULL;
    978     }
    979 
    980     row = psArrayGet(rowSet, 0);
    981     psMemIncrRefCounter(row);
    982     if (!row) {
    983         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    984         return NULL;
    985     }
    986     psFree(rowSet);
    987 
    988     rowID = psMetadataLookupS32(&status, row, SKYP_TRANSPARENCY_INDEX_NAME);
    989     if (!status) {
    990         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_TRANSPARENCY_INDEX_NAME);
    991         psFree(row);
    992         return NULL;
    993     }
    994 
    995     popped = psMetadataAlloc();
    996     psMetadataAddS32(popped, PS_LIST_TAIL, SKYP_TRANSPARENCY_INDEX_NAME, 0, NULL, rowID);
    997 
    998     deleted = psDBDeleteRows(dbh, SKYP_TRANSPARENCY_TABLE_NAME, popped, 0);
    999     if (deleted != 1) {
    1000         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    1001         psFree(popped);
    1002         psFree(row);
    1003         return NULL;
    1004     }
    1005 
    1006     psFree(popped);
    1007 
    1008     *filter = psMetadataLookupPtr(&status, row, "filter");
    1009     if (!status) {
    1010         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    1011         psFree(row);
    1012         return false;
    1013     }
    1014     *trans = psMetadataLookupF64(&status, row, "trans");
    1015     if (!status) {
    1016         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item trans");
    1017         psFree(row);
    1018         return false;
    1019     }
    1020     *nstars = psMetadataLookupS32(&status, row, "nstars");
    1021     if (!status) {
    1022         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nstars");
    1023         psFree(row);
    1024         return false;
    1025     }
    1026     *ra = psMetadataLookupF64(&status, row, "ra");
    1027     if (!status) {
    1028         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    1029         psFree(row);
    1030         return false;
    1031     }
    1032     *decl = psMetadataLookupF64(&status, row, "decl");
    1033     if (!status) {
    1034         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    1035         psFree(row);
    1036         return false;
    1037     }
    1038     *exptime = psMetadataLookupF32(&status, row, "exptime");
    1039     if (!status) {
    1040         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exptime");
    1041         psFree(row);
    1042         return false;
    1043     }
    1044     *sky_bright = psMetadataLookupF64(&status, row, "sky_bright");
    1045     if (!status) {
    1046         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sky_bright");
    1047         psFree(row);
    1048         return false;
    1049     }
    1050 
    1051     psFree(row);
    1052 
    1053     return true;
    1054 }
    1055 
    1056770bool skyp_transparencyInsertObject(psDB *dbh, skyp_transparencyRow *object)
    1057771{
    … …  
    1068782
    1069783    return true;
    1070 }
    1071 
    1072 skyp_transparencyRow *skyp_transparencyPopObject(psDB *dbh)
    1073 {
    1074     char            filter[256];
    1075     psF64           trans;
    1076     psS32           nstars;
    1077     psF64           ra;
    1078     psF64           decl;
    1079     psF32           exptime;
    1080     psF64           sky_bright;
    1081 
    1082     if (!skyp_transparencyPop(dbh, (char **)&filter, &trans, &nstars, &ra, &decl, &exptime, &sky_bright)) {
    1083         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    1084         return NULL;
    1085     }
    1086 
    1087     return skyp_transparencyRowAlloc(filter, trans, nstars, ra, decl, exptime, sky_bright);
    1088784}
    1089785
    … …  
    1123819}
    1124820
    1125 bool skyp_transparencyPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    1126 {
    1127     char            query[MAX_STRING_LENGTH];
    1128 
    1129     if (!skyp_transparencySelectRowsFits(dbh, fits, NULL, limit)) {
    1130         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    1131         return false;
    1132     }
    1133 
    1134     // remove limit rows from the end of the database
    1135     if (snprintf(query, MAX_STRING_LENGTH,
    1136                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    1137                 SKYP_TRANSPARENCY_TABLE_NAME, SKYP_TRANSPARENCY_INDEX_NAME, limit) < 0) {
    1138         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    1139         return false;
    1140     }
    1141            
    1142     if (!p_psDBRunQuery(dbh, query)) {
    1143         psError(PS_ERR_UNKNOWN, false, "database query failed");
    1144         return false;
    1145     }
    1146 
    1147     return true;
    1148 }
    1149 
    1150821bool skyp_transparencySelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1151822{
    1152823    psArray         *rowSet;
    1153     psU64           i;
    1154824
    1155825    rowSet = psDBSelectRows(dbh, SKYP_TRANSPARENCY_TABLE_NAME, where, limit);
    1156826    if (!rowSet) {
    1157827        return false;
    1158     }
    1159 
    1160     // strip index column
    1161     for (i = 0; i < rowSet->n; i++) {
    1162         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, SKYP_TRANSPARENCY_INDEX_NAME)) {
    1163             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_TRANSPARENCY_INDEX_NAME);
    1164             psFree(rowSet);
    1165             return false;
    1166         }
    1167828    }
    1168829
    … …  
    1281942    if (!rowSet) {
    1282943        return NULL;
    1283     }
    1284 
    1285     // strip index column
    1286     for (i = 0; i < rowSet->n; i++) {
    1287         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, SKYP_TRANSPARENCY_INDEX_NAME)) {
    1288             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_TRANSPARENCY_INDEX_NAME);
    1289             psFree(rowSet);
    1290             return false;
    1291         }
    1292944    }
    1293945
    … …  
    14081060
    14091061    md = psMetadataAlloc();
    1410     if (!psMetadataAdd(md, PS_LIST_TAIL, SKYP_ABSORPTION_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    1411         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", SKYP_ABSORPTION_INDEX_NAME);
    1412         psFree(md);
    1413         return false;
    1414     }
    14151062    if (!psMetadataAddStr(md, PS_LIST_TAIL, "disperser_id", 0, NULL, "255")) {
    14161063        psError(PS_ERR_UNKNOWN, false, "failed to add item disperser_id");
    … …  
    15431190    return deleted;
    15441191}
    1545 bool skyp_absorptionPop(psDB *dbh, char **disperser_id, psF32 *atmcomp1, psF32 *atmcomp2, psF32 *atmcomp3, psS32 *nstars, psF64 *ra, psF64 *decl, psF32 *exptime, psF64 *sky_bright)
    1546 {
    1547     psArray         *rowSet;
    1548     psMetadata      *row;
    1549     psMetadata      *popped;
    1550     long            deleted;
    1551     bool            status;
    1552     int             rowID;
    1553 
    1554     rowSet = psDBSelectRows(dbh, SKYP_ABSORPTION_TABLE_NAME, NULL, 1);
    1555     if (!rowSet) {
    1556         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_ABSORPTION_INDEX_NAME);
    1557         psFree(rowSet);
    1558         return NULL;
    1559     }
    1560 
    1561     row = psArrayGet(rowSet, 0);
    1562     psMemIncrRefCounter(row);
    1563     if (!row) {
    1564         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    1565         return NULL;
    1566     }
    1567     psFree(rowSet);
    1568 
    1569     rowID = psMetadataLookupS32(&status, row, SKYP_ABSORPTION_INDEX_NAME);
    1570     if (!status) {
    1571         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_ABSORPTION_INDEX_NAME);
    1572         psFree(row);
    1573         return NULL;
    1574     }
    1575 
    1576     popped = psMetadataAlloc();
    1577     psMetadataAddS32(popped, PS_LIST_TAIL, SKYP_ABSORPTION_INDEX_NAME, 0, NULL, rowID);
    1578 
    1579     deleted = psDBDeleteRows(dbh, SKYP_ABSORPTION_TABLE_NAME, popped, 0);
    1580     if (deleted != 1) {
    1581         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    1582         psFree(popped);
    1583         psFree(row);
    1584         return NULL;
    1585     }
    1586 
    1587     psFree(popped);
    1588 
    1589     *disperser_id = psMetadataLookupPtr(&status, row, "disperser_id");
    1590     if (!status) {
    1591         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item disperser_id");
    1592         psFree(row);
    1593         return false;
    1594     }
    1595     *atmcomp1 = psMetadataLookupF32(&status, row, "atmcomp1");
    1596     if (!status) {
    1597         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp1");
    1598         psFree(row);
    1599         return false;
    1600     }
    1601     *atmcomp2 = psMetadataLookupF32(&status, row, "atmcomp2");
    1602     if (!status) {
    1603         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp2");
    1604         psFree(row);
    1605         return false;
    1606     }
    1607     *atmcomp3 = psMetadataLookupF32(&status, row, "atmcomp3");
    1608     if (!status) {
    1609         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp3");
    1610         psFree(row);
    1611         return false;
    1612     }
    1613     *nstars = psMetadataLookupS32(&status, row, "nstars");
    1614     if (!status) {
    1615         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nstars");
    1616         psFree(row);
    1617         return false;
    1618     }
    1619     *ra = psMetadataLookupF64(&status, row, "ra");
    1620     if (!status) {
    1621         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    1622         psFree(row);
    1623         return false;
    1624     }
    1625     *decl = psMetadataLookupF64(&status, row, "decl");
    1626     if (!status) {
    1627         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    1628         psFree(row);
    1629         return false;
    1630     }
    1631     *exptime = psMetadataLookupF32(&status, row, "exptime");
    1632     if (!status) {
    1633         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exptime");
    1634         psFree(row);
    1635         return false;
    1636     }
    1637     *sky_bright = psMetadataLookupF64(&status, row, "sky_bright");
    1638     if (!status) {
    1639         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sky_bright");
    1640         psFree(row);
    1641         return false;
    1642     }
    1643 
    1644     psFree(row);
    1645 
    1646     return true;
    1647 }
    1648 
    16491192bool skyp_absorptionInsertObject(psDB *dbh, skyp_absorptionRow *object)
    16501193{
    … …  
    16611204
    16621205    return true;
    1663 }
    1664 
    1665 skyp_absorptionRow *skyp_absorptionPopObject(psDB *dbh)
    1666 {
    1667     char            disperser_id[256];
    1668     psF32           atmcomp1;
    1669     psF32           atmcomp2;
    1670     psF32           atmcomp3;
    1671     psS32           nstars;
    1672     psF64           ra;
    1673     psF64           decl;
    1674     psF32           exptime;
    1675     psF64           sky_bright;
    1676 
    1677     if (!skyp_absorptionPop(dbh, (char **)&disperser_id, &atmcomp1, &atmcomp2, &atmcomp3, &nstars, &ra, &decl, &exptime, &sky_bright)) {
    1678         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    1679         return NULL;
    1680     }
    1681 
    1682     return skyp_absorptionRowAlloc(disperser_id, atmcomp1, atmcomp2, atmcomp3, nstars, ra, decl, exptime, sky_bright);
    16831206}
    16841207
    … …  
    17181241}
    17191242
    1720 bool skyp_absorptionPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    1721 {
    1722     char            query[MAX_STRING_LENGTH];
    1723 
    1724     if (!skyp_absorptionSelectRowsFits(dbh, fits, NULL, limit)) {
    1725         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    1726         return false;
    1727     }
    1728 
    1729     // remove limit rows from the end of the database
    1730     if (snprintf(query, MAX_STRING_LENGTH,
    1731                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    1732                 SKYP_ABSORPTION_TABLE_NAME, SKYP_ABSORPTION_INDEX_NAME, limit) < 0) {
    1733         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    1734         return false;
    1735     }
    1736            
    1737     if (!p_psDBRunQuery(dbh, query)) {
    1738         psError(PS_ERR_UNKNOWN, false, "database query failed");
    1739         return false;
    1740     }
    1741 
    1742     return true;
    1743 }
    1744 
    17451243bool skyp_absorptionSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    17461244{
    17471245    psArray         *rowSet;
    1748     psU64           i;
    17491246
    17501247    rowSet = psDBSelectRows(dbh, SKYP_ABSORPTION_TABLE_NAME, where, limit);
    17511248    if (!rowSet) {
    17521249        return false;
    1753     }
    1754 
    1755     // strip index column
    1756     for (i = 0; i < rowSet->n; i++) {
    1757         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, SKYP_ABSORPTION_INDEX_NAME)) {
    1758             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_ABSORPTION_INDEX_NAME);
    1759             psFree(rowSet);
    1760             return false;
    1761         }
    17621250    }
    17631251
    … …  
    18981386    if (!rowSet) {
    18991387        return NULL;
    1900     }
    1901 
    1902     // strip index column
    1903     for (i = 0; i < rowSet->n; i++) {
    1904         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, SKYP_ABSORPTION_INDEX_NAME)) {
    1905             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_ABSORPTION_INDEX_NAME);
    1906             psFree(rowSet);
    1907             return false;
    1908         }
    19091388    }
    19101389
    … …  
    20221501
    20231502    md = psMetadataAlloc();
    2024     if (!psMetadataAdd(md, PS_LIST_TAIL, SKYP_EMISSION_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    2025         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", SKYP_EMISSION_INDEX_NAME);
    2026         psFree(md);
    2027         return false;
    2028     }
    20291503    if (!psMetadataAddStr(md, PS_LIST_TAIL, "disperser_id", 0, NULL, "255")) {
    20301504        psError(PS_ERR_UNKNOWN, false, "failed to add item disperser_id");
    … …  
    21271601    return deleted;
    21281602}
    2129 bool skyp_emissionPop(psDB *dbh, char **disperser_id, psF32 *atmcomp1, psF32 *atmcomp2, psF32 *atmcomp3, psF32 *continuum, psF32 *exptime)
    2130 {
    2131     psArray         *rowSet;
    2132     psMetadata      *row;
    2133     psMetadata      *popped;
    2134     long            deleted;
    2135     bool            status;
    2136     int             rowID;
    2137 
    2138     rowSet = psDBSelectRows(dbh, SKYP_EMISSION_TABLE_NAME, NULL, 1);
    2139     if (!rowSet) {
    2140         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_EMISSION_INDEX_NAME);
    2141         psFree(rowSet);
    2142         return NULL;
    2143     }
    2144 
    2145     row = psArrayGet(rowSet, 0);
    2146     psMemIncrRefCounter(row);
    2147     if (!row) {
    2148         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    2149         return NULL;
    2150     }
    2151     psFree(rowSet);
    2152 
    2153     rowID = psMetadataLookupS32(&status, row, SKYP_EMISSION_INDEX_NAME);
    2154     if (!status) {
    2155         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_EMISSION_INDEX_NAME);
    2156         psFree(row);
    2157         return NULL;
    2158     }
    2159 
    2160     popped = psMetadataAlloc();
    2161     psMetadataAddS32(popped, PS_LIST_TAIL, SKYP_EMISSION_INDEX_NAME, 0, NULL, rowID);
    2162 
    2163     deleted = psDBDeleteRows(dbh, SKYP_EMISSION_TABLE_NAME, popped, 0);
    2164     if (deleted != 1) {
    2165         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    2166         psFree(popped);
    2167         psFree(row);
    2168         return NULL;
    2169     }
    2170 
    2171     psFree(popped);
    2172 
    2173     *disperser_id = psMetadataLookupPtr(&status, row, "disperser_id");
    2174     if (!status) {
    2175         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item disperser_id");
    2176         psFree(row);
    2177         return false;
    2178     }
    2179     *atmcomp1 = psMetadataLookupF32(&status, row, "atmcomp1");
    2180     if (!status) {
    2181         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp1");
    2182         psFree(row);
    2183         return false;
    2184     }
    2185     *atmcomp2 = psMetadataLookupF32(&status, row, "atmcomp2");
    2186     if (!status) {
    2187         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp2");
    2188         psFree(row);
    2189         return false;
    2190     }
    2191     *atmcomp3 = psMetadataLookupF32(&status, row, "atmcomp3");
    2192     if (!status) {
    2193         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item atmcomp3");
    2194         psFree(row);
    2195         return false;
    2196     }
    2197     *continuum = psMetadataLookupF32(&status, row, "continuum");
    2198     if (!status) {
    2199         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item continuum");
    2200         psFree(row);
    2201         return false;
    2202     }
    2203     *exptime = psMetadataLookupF32(&status, row, "exptime");
    2204     if (!status) {
    2205         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exptime");
    2206         psFree(row);
    2207         return false;
    2208     }
    2209 
    2210     psFree(row);
    2211 
    2212     return true;
    2213 }
    2214 
    22151603bool skyp_emissionInsertObject(psDB *dbh, skyp_emissionRow *object)
    22161604{
    … …  
    22271615
    22281616    return true;
    2229 }
    2230 
    2231 skyp_emissionRow *skyp_emissionPopObject(psDB *dbh)
    2232 {
    2233     char            disperser_id[256];
    2234     psF32           atmcomp1;
    2235     psF32           atmcomp2;
    2236     psF32           atmcomp3;
    2237     psF32           continuum;
    2238     psF32           exptime;
    2239 
    2240     if (!skyp_emissionPop(dbh, (char **)&disperser_id, &atmcomp1, &atmcomp2, &atmcomp3, &continuum, &exptime)) {
    2241         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    2242         return NULL;
    2243     }
    2244 
    2245     return skyp_emissionRowAlloc(disperser_id, atmcomp1, atmcomp2, atmcomp3, continuum, exptime);
    22461617}
    22471618
    … …  
    22811652}
    22821653
    2283 bool skyp_emissionPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    2284 {
    2285     char            query[MAX_STRING_LENGTH];
    2286 
    2287     if (!skyp_emissionSelectRowsFits(dbh, fits, NULL, limit)) {
    2288         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    2289         return false;
    2290     }
    2291 
    2292     // remove limit rows from the end of the database
    2293     if (snprintf(query, MAX_STRING_LENGTH,
    2294                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    2295                 SKYP_EMISSION_TABLE_NAME, SKYP_EMISSION_INDEX_NAME, limit) < 0) {
    2296         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    2297         return false;
    2298     }
    2299            
    2300     if (!p_psDBRunQuery(dbh, query)) {
    2301         psError(PS_ERR_UNKNOWN, false, "database query failed");
    2302         return false;
    2303     }
    2304 
    2305     return true;
    2306 }
    2307 
    23081654bool skyp_emissionSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    23091655{
    23101656    psArray         *rowSet;
    2311     psU64           i;
    23121657
    23131658    rowSet = psDBSelectRows(dbh, SKYP_EMISSION_TABLE_NAME, where, limit);
    23141659    if (!rowSet) {
    23151660        return false;
    2316     }
    2317 
    2318     // strip index column
    2319     for (i = 0; i < rowSet->n; i++) {
    2320         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, SKYP_EMISSION_INDEX_NAME)) {
    2321             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_EMISSION_INDEX_NAME);
    2322             psFree(rowSet);
    2323             return false;
    2324         }
    23251661    }
    23261662
    … …  
    24281764    if (!rowSet) {
    24291765        return NULL;
    2430     }
    2431 
    2432     // strip index column
    2433     for (i = 0; i < rowSet->n; i++) {
    2434         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, SKYP_EMISSION_INDEX_NAME)) {
    2435             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_EMISSION_INDEX_NAME);
    2436             psFree(rowSet);
    2437             return false;
    2438         }
    24391766    }
    24401767
    … …  
    25531880
    25541881    md = psMetadataAlloc();
    2555     if (!psMetadataAdd(md, PS_LIST_TAIL, DIMM_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    2556         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DIMM_INDEX_NAME);
    2557         psFree(md);
    2558         return false;
    2559     }
    25601882    if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigmax", 0, NULL, 0.0)) {
    25611883        psError(PS_ERR_UNKNOWN, false, "failed to add item sigmax");
    … …  
    26681990    return deleted;
    26691991}
    2670 bool dimmPop(psDB *dbh, psF32 *sigmax, psF32 *sigmay, psF32 *fwhm, psF64 *ra, psF64 *decl, psF32 *expttime, char **telescope_id)
    2671 {
    2672     psArray         *rowSet;
    2673     psMetadata      *row;
    2674     psMetadata      *popped;
    2675     long            deleted;
    2676     bool            status;
    2677     int             rowID;
    2678 
    2679     rowSet = psDBSelectRows(dbh, DIMM_TABLE_NAME, NULL, 1);
    2680     if (!rowSet) {
    2681         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DIMM_INDEX_NAME);
    2682         psFree(rowSet);
    2683         return NULL;
    2684     }
    2685 
    2686     row = psArrayGet(rowSet, 0);
    2687     psMemIncrRefCounter(row);
    2688     if (!row) {
    2689         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    2690         return NULL;
    2691     }
    2692     psFree(rowSet);
    2693 
    2694     rowID = psMetadataLookupS32(&status, row, DIMM_INDEX_NAME);
    2695     if (!status) {
    2696         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DIMM_INDEX_NAME);
    2697         psFree(row);
    2698         return NULL;
    2699     }
    2700 
    2701     popped = psMetadataAlloc();
    2702     psMetadataAddS32(popped, PS_LIST_TAIL, DIMM_INDEX_NAME, 0, NULL, rowID);
    2703 
    2704     deleted = psDBDeleteRows(dbh, DIMM_TABLE_NAME, popped, 0);
    2705     if (deleted != 1) {
    2706         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    2707         psFree(popped);
    2708         psFree(row);
    2709         return NULL;
    2710     }
    2711 
    2712     psFree(popped);
    2713 
    2714     *sigmax = psMetadataLookupF32(&status, row, "sigmax");
    2715     if (!status) {
    2716         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigmax");
    2717         psFree(row);
    2718         return false;
    2719     }
    2720     *sigmay = psMetadataLookupF32(&status, row, "sigmay");
    2721     if (!status) {
    2722         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigmay");
    2723         psFree(row);
    2724         return false;
    2725     }
    2726     *fwhm = psMetadataLookupF32(&status, row, "fwhm");
    2727     if (!status) {
    2728         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm");
    2729         psFree(row);
    2730         return false;
    2731     }
    2732     *ra = psMetadataLookupF64(&status, row, "ra");
    2733     if (!status) {
    2734         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    2735         psFree(row);
    2736         return false;
    2737     }
    2738     *decl = psMetadataLookupF64(&status, row, "decl");
    2739     if (!status) {
    2740         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    2741         psFree(row);
    2742         return false;
    2743     }
    2744     *expttime = psMetadataLookupF32(&status, row, "expttime");
    2745     if (!status) {
    2746         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item expttime");
    2747         psFree(row);
    2748         return false;
    2749     }
    2750     *telescope_id = psMetadataLookupPtr(&status, row, "telescope_id");
    2751     if (!status) {
    2752         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope_id");
    2753         psFree(row);
    2754         return false;
    2755     }
    2756 
    2757     psFree(row);
    2758 
    2759     return true;
    2760 }
    2761 
    27621992bool dimmInsertObject(psDB *dbh, dimmRow *object)
    27631993{
    … …  
    27742004
    27752005    return true;
    2776 }
    2777 
    2778 dimmRow *dimmPopObject(psDB *dbh)
    2779 {
    2780     psF32           sigmax;
    2781     psF32           sigmay;
    2782     psF32           fwhm;
    2783     psF64           ra;
    2784     psF64           decl;
    2785     psF32           expttime;
    2786     char            telescope_id[256];
    2787 
    2788     if (!dimmPop(dbh, &sigmax, &sigmay, &fwhm, &ra, &decl, &expttime, (char **)&telescope_id)) {
    2789         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    2790         return NULL;
    2791     }
    2792 
    2793     return dimmRowAlloc(sigmax, sigmay, fwhm, ra, decl, expttime, telescope_id);
    27942006}
    27952007
    … …  
    28292041}
    28302042
    2831 bool dimmPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    2832 {
    2833     char            query[MAX_STRING_LENGTH];
    2834 
    2835     if (!dimmSelectRowsFits(dbh, fits, NULL, limit)) {
    2836         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    2837         return false;
    2838     }
    2839 
    2840     // remove limit rows from the end of the database
    2841     if (snprintf(query, MAX_STRING_LENGTH,
    2842                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    2843                 DIMM_TABLE_NAME, DIMM_INDEX_NAME, limit) < 0) {
    2844         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    2845         return false;
    2846     }
    2847            
    2848     if (!p_psDBRunQuery(dbh, query)) {
    2849         psError(PS_ERR_UNKNOWN, false, "database query failed");
    2850         return false;
    2851     }
    2852 
    2853     return true;
    2854 }
    2855 
    28562043bool dimmSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    28572044{
    28582045    psArray         *rowSet;
    2859     psU64           i;
    28602046
    28612047    rowSet = psDBSelectRows(dbh, DIMM_TABLE_NAME, where, limit);
    28622048    if (!rowSet) {
    28632049        return false;
    2864     }
    2865 
    2866     // strip index column
    2867     for (i = 0; i < rowSet->n; i++) {
    2868         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DIMM_INDEX_NAME)) {
    2869             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DIMM_INDEX_NAME);
    2870             psFree(rowSet);
    2871             return false;
    2872         }
    28732050    }
    28742051
    … …  
    29872164    if (!rowSet) {
    29882165        return NULL;
    2989     }
    2990 
    2991     // strip index column
    2992     for (i = 0; i < rowSet->n; i++) {
    2993         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DIMM_INDEX_NAME)) {
    2994             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DIMM_INDEX_NAME);
    2995             psFree(rowSet);
    2996             return false;
    2997         }
    29982166    }
    29992167
    … …  
    31102278
    31112279    md = psMetadataAlloc();
    3112     if (!psMetadataAdd(md, PS_LIST_TAIL, SKYP_IR_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    3113         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", SKYP_IR_INDEX_NAME);
    3114         psFree(md);
    3115         return false;
    3116     }
    31172280    if (!psMetadataAddF64(md, PS_LIST_TAIL, "sky_bright", 0, NULL, 0.0)) {
    31182281        psError(PS_ERR_UNKNOWN, false, "failed to add item sky_bright");
    … …  
    32152378    return deleted;
    32162379}
    3217 bool skyp_irPop(psDB *dbh, psF64 *sky_bright, psF64 *sky_var, psF64 *ra, psF64 *decl, psF32 *fov_x, psF32 *fov_y)
    3218 {
    3219     psArray         *rowSet;
    3220     psMetadata      *row;
    3221     psMetadata      *popped;
    3222     long            deleted;
    3223     bool            status;
    3224     int             rowID;
    3225 
    3226     rowSet = psDBSelectRows(dbh, SKYP_IR_TABLE_NAME, NULL, 1);
    3227     if (!rowSet) {
    3228         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_IR_INDEX_NAME);
    3229         psFree(rowSet);
    3230         return NULL;
    3231     }
    3232 
    3233     row = psArrayGet(rowSet, 0);
    3234     psMemIncrRefCounter(row);
    3235     if (!row) {
    3236         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    3237         return NULL;
    3238     }
    3239     psFree(rowSet);
    3240 
    3241     rowID = psMetadataLookupS32(&status, row, SKYP_IR_INDEX_NAME);
    3242     if (!status) {
    3243         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SKYP_IR_INDEX_NAME);
    3244         psFree(row);
    3245         return NULL;
    3246     }
    3247 
    3248     popped = psMetadataAlloc();
    3249     psMetadataAddS32(popped, PS_LIST_TAIL, SKYP_IR_INDEX_NAME, 0, NULL, rowID);
    3250 
    3251     deleted = psDBDeleteRows(dbh, SKYP_IR_TABLE_NAME, popped, 0);
    3252     if (deleted != 1) {
    3253         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    3254         psFree(popped);
    3255         psFree(row);
    3256         return NULL;
    3257     }
    3258 
    3259     psFree(popped);
    3260 
    3261     *sky_bright = psMetadataLookupF64(&status, row, "sky_bright");
    3262     if (!status) {
    3263         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sky_bright");
    3264         psFree(row);
    3265         return false;
    3266     }
    3267     *sky_var = psMetadataLookupF64(&status, row, "sky_var");
    3268     if (!status) {
    3269         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sky_var");
    3270         psFree(row);
    3271         return false;
    3272     }
    3273     *ra = psMetadataLookupF64(&status, row, "ra");
    3274     if (!status) {
    3275         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    3276         psFree(row);
    3277         return false;
    3278     }
    3279     *decl = psMetadataLookupF64(&status, row, "decl");
    3280     if (!status) {
    3281         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    3282         psFree(row);
    3283         return false;
    3284     }
    3285     *fov_x = psMetadataLookupF32(&status, row, "fov_x");
    3286     if (!status) {
    3287         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fov_x");
    3288         psFree(row);
    3289         return false;
    3290     }
    3291     *fov_y = psMetadataLookupF32(&status, row, "fov_y");
    3292     if (!status) {
    3293         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fov_y");
    3294         psFree(row);
    3295         return false;
    3296     }
    3297 
    3298     psFree(row);
    3299 
    3300     return true;
    3301 }
    3302 
    33032380bool skyp_irInsertObject(psDB *dbh, skyp_irRow *object)
    33042381{
    … …  
    33152392
    33162393    return true;
    3317 }
    3318 
    3319 skyp_irRow *skyp_irPopObject(psDB *dbh)
    3320 {
    3321     psF64           sky_bright;
    3322     psF64           sky_var;
    3323     psF64           ra;
    3324     psF64           decl;
    3325     psF32           fov_x;
    3326     psF32           fov_y;
    3327 
    3328     if (!skyp_irPop(dbh, &sky_bright, &sky_var, &ra, &decl, &fov_x, &fov_y)) {
    3329         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    3330         return NULL;
    3331     }
    3332 
    3333     return skyp_irRowAlloc(sky_bright, sky_var, ra, decl, fov_x, fov_y);
    33342394}
    33352395
    … …  
    33692429}
    33702430
    3371 bool skyp_irPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    3372 {
    3373     char            query[MAX_STRING_LENGTH];
    3374 
    3375     if (!skyp_irSelectRowsFits(dbh, fits, NULL, limit)) {
    3376         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    3377         return false;
    3378     }
    3379 
    3380     // remove limit rows from the end of the database
    3381     if (snprintf(query, MAX_STRING_LENGTH,
    3382                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    3383                 SKYP_IR_TABLE_NAME, SKYP_IR_INDEX_NAME, limit) < 0) {
    3384         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    3385         return false;
    3386     }
    3387            
    3388     if (!p_psDBRunQuery(dbh, query)) {
    3389         psError(PS_ERR_UNKNOWN, false, "database query failed");
    3390         return false;
    3391     }
    3392 
    3393     return true;
    3394 }
    3395 
    33962431bool skyp_irSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    33972432{
    33982433    psArray         *rowSet;
    3399     psU64           i;
    34002434
    34012435    rowSet = psDBSelectRows(dbh, SKYP_IR_TABLE_NAME, where, limit);
    34022436    if (!rowSet) {
    34032437        return false;
    3404     }
    3405 
    3406     // strip index column
    3407     for (i = 0; i < rowSet->n; i++) {
    3408         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, SKYP_IR_INDEX_NAME)) {
    3409             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_IR_INDEX_NAME);
    3410             psFree(rowSet);
    3411             return false;
    3412         }
    34132438    }
    34142439
    … …  
    35162541    if (!rowSet) {
    35172542        return NULL;
    3518     }
    3519 
    3520     // strip index column
    3521     for (i = 0; i < rowSet->n; i++) {
    3522         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, SKYP_IR_INDEX_NAME)) {
    3523             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SKYP_IR_INDEX_NAME);
    3524             psFree(rowSet);
    3525             return false;
    3526         }
    35272543    }
    35282544
    … …  
    36372653
    36382654    md = psMetadataAlloc();
    3639     if (!psMetadataAdd(md, PS_LIST_TAIL, DOME_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    3640         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DOME_INDEX_NAME);
    3641         psFree(md);
    3642         return false;
    3643     }
    36442655    if (!psMetadataAddF32(md, PS_LIST_TAIL, "az", 0, NULL, 0.0)) {
    36452656        psError(PS_ERR_UNKNOWN, false, "failed to add item az");
    … …  
    37222733    return deleted;
    37232734}
    3724 bool domePop(psDB *dbh, psF32 *az, bool *open, bool *light, bool *track)
    3725 {
    3726     psArray         *rowSet;
    3727     psMetadata      *row;
    3728     psMetadata      *popped;
    3729     long            deleted;
    3730     bool            status;
    3731     int             rowID;
    3732 
    3733     rowSet = psDBSelectRows(dbh, DOME_TABLE_NAME, NULL, 1);
    3734     if (!rowSet) {
    3735         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DOME_INDEX_NAME);
    3736         psFree(rowSet);
    3737         return NULL;
    3738     }
    3739 
    3740     row = psArrayGet(rowSet, 0);
    3741     psMemIncrRefCounter(row);
    3742     if (!row) {
    3743         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    3744         return NULL;
    3745     }
    3746     psFree(rowSet);
    3747 
    3748     rowID = psMetadataLookupS32(&status, row, DOME_INDEX_NAME);
    3749     if (!status) {
    3750         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DOME_INDEX_NAME);
    3751         psFree(row);
    3752         return NULL;
    3753     }
    3754 
    3755     popped = psMetadataAlloc();
    3756     psMetadataAddS32(popped, PS_LIST_TAIL, DOME_INDEX_NAME, 0, NULL, rowID);
    3757 
    3758     deleted = psDBDeleteRows(dbh, DOME_TABLE_NAME, popped, 0);
    3759     if (deleted != 1) {
    3760         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    3761         psFree(popped);
    3762         psFree(row);
    3763         return NULL;
    3764     }
    3765 
    3766     psFree(popped);
    3767 
    3768     *az = psMetadataLookupF32(&status, row, "az");
    3769     if (!status) {
    3770         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    3771         psFree(row);
    3772         return false;
    3773     }
    3774     *open = psMetadataLookupBool(&status, row, "open");
    3775     if (!status) {
    3776         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item open");
    3777         psFree(row);
    3778         return false;
    3779     }
    3780     *light = psMetadataLookupBool(&status, row, "light");
    3781     if (!status) {
    3782         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item light");
    3783         psFree(row);
    3784         return false;
    3785     }
    3786     *track = psMetadataLookupBool(&status, row, "track");
    3787     if (!status) {
    3788         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item track");
    3789         psFree(row);
    3790         return false;
    3791     }
    3792 
    3793     psFree(row);
    3794 
    3795     return true;
    3796 }
    3797 
    37982735bool domeInsertObject(psDB *dbh, domeRow *object)
    37992736{
    … …  
    38102747
    38112748    return true;
    3812 }
    3813 
    3814 domeRow *domePopObject(psDB *dbh)
    3815 {
    3816     psF32           az;
    3817     bool            open;
    3818     bool            light;
    3819     bool            track;
    3820 
    3821     if (!domePop(dbh, &az, &open, &light, &track)) {
    3822         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    3823         return NULL;
    3824     }
    3825 
    3826     return domeRowAlloc(az, open, light, track);
    38272749}
    38282750
    … …  
    38622784}
    38632785
    3864 bool domePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    3865 {
    3866     char            query[MAX_STRING_LENGTH];
    3867 
    3868     if (!domeSelectRowsFits(dbh, fits, NULL, limit)) {
    3869         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    3870         return false;
    3871     }
    3872 
    3873     // remove limit rows from the end of the database
    3874     if (snprintf(query, MAX_STRING_LENGTH,
    3875                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    3876                 DOME_TABLE_NAME, DOME_INDEX_NAME, limit) < 0) {
    3877         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    3878         return false;
    3879     }
    3880            
    3881     if (!p_psDBRunQuery(dbh, query)) {
    3882         psError(PS_ERR_UNKNOWN, false, "database query failed");
    3883         return false;
    3884     }
    3885 
    3886     return true;
    3887 }
    3888 
    38892786bool domeSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    38902787{
    38912788    psArray         *rowSet;
    3892     psU64           i;
    38932789
    38942790    rowSet = psDBSelectRows(dbh, DOME_TABLE_NAME, where, limit);
    38952791    if (!rowSet) {
    38962792        return false;
    3897     }
    3898 
    3899     // strip index column
    3900     for (i = 0; i < rowSet->n; i++) {
    3901         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DOME_INDEX_NAME)) {
    3902             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DOME_INDEX_NAME);
    3903             psFree(rowSet);
    3904             return false;
    3905         }
    39062793    }
    39072794
    … …  
    39872874    if (!rowSet) {
    39882875        return NULL;
    3989     }
    3990 
    3991     // strip index column
    3992     for (i = 0; i < rowSet->n; i++) {
    3993         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DOME_INDEX_NAME)) {
    3994             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DOME_INDEX_NAME);
    3995             psFree(rowSet);
    3996             return false;
    3997         }
    39982876    }
    39992877
    … …  
    41102988
    41112989    md = psMetadataAlloc();
    4112     if (!psMetadataAdd(md, PS_LIST_TAIL, TELESCOPE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    4113         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", TELESCOPE_INDEX_NAME);
    4114         psFree(md);
    4115         return false;
    4116     }
    41172990    if (!psMetadataAddStr(md, PS_LIST_TAIL, "guide", 0, NULL, "255")) {
    41182991        psError(PS_ERR_UNKNOWN, false, "failed to add item guide");
    … …  
    42053078    return deleted;
    42063079}
    4207 bool telescopePop(psDB *dbh, char **guide, psF32 *alt, psF32 *az, psF64 *ra, psF64 *decl)
    4208 {
    4209     psArray         *rowSet;
    4210     psMetadata      *row;
    4211     psMetadata      *popped;
    4212     long            deleted;
    4213     bool            status;
    4214     int             rowID;
    4215 
    4216     rowSet = psDBSelectRows(dbh, TELESCOPE_TABLE_NAME, NULL, 1);
    4217     if (!rowSet) {
    4218         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", TELESCOPE_INDEX_NAME);
    4219         psFree(rowSet);
    4220         return NULL;
    4221     }
    4222 
    4223     row = psArrayGet(rowSet, 0);
    4224     psMemIncrRefCounter(row);
    4225     if (!row) {
    4226         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    4227         return NULL;
    4228     }
    4229     psFree(rowSet);
    4230 
    4231     rowID = psMetadataLookupS32(&status, row, TELESCOPE_INDEX_NAME);
    4232     if (!status) {
    4233         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", TELESCOPE_INDEX_NAME);
    4234         psFree(row);
    4235         return NULL;
    4236     }
    4237 
    4238     popped = psMetadataAlloc();
    4239     psMetadataAddS32(popped, PS_LIST_TAIL, TELESCOPE_INDEX_NAME, 0, NULL, rowID);
    4240 
    4241     deleted = psDBDeleteRows(dbh, TELESCOPE_TABLE_NAME, popped, 0);
    4242     if (deleted != 1) {
    4243         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    4244         psFree(popped);
    4245         psFree(row);
    4246         return NULL;
    4247     }
    4248 
    4249     psFree(popped);
    4250 
    4251     *guide = psMetadataLookupPtr(&status, row, "guide");
    4252     if (!status) {
    4253         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide");
    4254         psFree(row);
    4255         return false;
    4256     }
    4257     *alt = psMetadataLookupF32(&status, row, "alt");
    4258     if (!status) {
    4259         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt");
    4260         psFree(row);
    4261         return false;
    4262     }
    4263     *az = psMetadataLookupF32(&status, row, "az");
    4264     if (!status) {
    4265         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    4266         psFree(row);
    4267         return false;
    4268     }
    4269     *ra = psMetadataLookupF64(&status, row, "ra");
    4270     if (!status) {
    4271         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    4272         psFree(row);
    4273         return false;
    4274     }
    4275     *decl = psMetadataLookupF64(&status, row, "decl");
    4276     if (!status) {
    4277         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    4278         psFree(row);
    4279         return false;
    4280     }
    4281 
    4282     psFree(row);
    4283 
    4284     return true;
    4285 }
    4286 
    42873080bool telescopeInsertObject(psDB *dbh, telescopeRow *object)
    42883081{
    … …  
    42993092
    43003093    return true;
    4301 }
    4302 
    4303 telescopeRow *telescopePopObject(psDB *dbh)
    4304 {
    4305     char            guide[256];
    4306     psF32           alt;
    4307     psF32           az;
    4308     psF64           ra;
    4309     psF64           decl;
    4310 
    4311     if (!telescopePop(dbh, (char **)&guide, &alt, &az, &ra, &decl)) {
    4312         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    4313         return NULL;
    4314     }
    4315 
    4316     return telescopeRowAlloc(guide, alt, az, ra, decl);
    43173094}
    43183095
    … …  
    43523129}
    43533130
    4354 bool telescopePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    4355 {
    4356     char            query[MAX_STRING_LENGTH];
    4357 
    4358     if (!telescopeSelectRowsFits(dbh, fits, NULL, limit)) {
    4359         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    4360         return false;
    4361     }
    4362 
    4363     // remove limit rows from the end of the database
    4364     if (snprintf(query, MAX_STRING_LENGTH,
    4365                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    4366                 TELESCOPE_TABLE_NAME, TELESCOPE_INDEX_NAME, limit) < 0) {
    4367         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    4368         return false;
    4369     }
    4370            
    4371     if (!p_psDBRunQuery(dbh, query)) {
    4372         psError(PS_ERR_UNKNOWN, false, "database query failed");
    4373         return false;
    4374     }
    4375 
    4376     return true;
    4377 }
    4378 
    43793131bool telescopeSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    43803132{
    43813133    psArray         *rowSet;
    4382     psU64           i;
    43833134
    43843135    rowSet = psDBSelectRows(dbh, TELESCOPE_TABLE_NAME, where, limit);
    43853136    if (!rowSet) {
    43863137        return false;
    4387     }
    4388 
    4389     // strip index column
    4390     for (i = 0; i < rowSet->n; i++) {
    4391         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, TELESCOPE_INDEX_NAME)) {
    4392             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", TELESCOPE_INDEX_NAME);
    4393             psFree(rowSet);
    4394             return false;
    4395         }
    43963138    }
    43973139
    … …  
    44883230    if (!rowSet) {
    44893231        return NULL;
    4490     }
    4491 
    4492     // strip index column
    4493     for (i = 0; i < rowSet->n; i++) {
    4494         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, TELESCOPE_INDEX_NAME)) {
    4495             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", TELESCOPE_INDEX_NAME);
    4496             psFree(rowSet);
    4497             return false;
    4498         }
    44993232    }
    45003233
    … …  
    46153348
    46163349    md = psMetadataAlloc();
    4617     if (!psMetadataAdd(md, PS_LIST_TAIL, SUMMITEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    4618         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", SUMMITEXP_INDEX_NAME);
    4619         psFree(md);
    4620         return false;
    4621     }
    46223350    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, "Primary Key", "64")) {
    46233351        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    47103438    return deleted;
    47113439}
    4712 bool summitExpPop(psDB *dbh, char **exp_id, char **camera, char **telescope, char **exp_type, char **uri)
    4713 {
    4714     psArray         *rowSet;
    4715     psMetadata      *row;
    4716     psMetadata      *popped;
    4717     long            deleted;
    4718     bool            status;
    4719     int             rowID;
    4720 
    4721     rowSet = psDBSelectRows(dbh, SUMMITEXP_TABLE_NAME, NULL, 1);
    4722     if (!rowSet) {
    4723         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SUMMITEXP_INDEX_NAME);
    4724         psFree(rowSet);
    4725         return NULL;
    4726     }
    4727 
    4728     row = psArrayGet(rowSet, 0);
    4729     psMemIncrRefCounter(row);
    4730     if (!row) {
    4731         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    4732         return NULL;
    4733     }
    4734     psFree(rowSet);
    4735 
    4736     rowID = psMetadataLookupS32(&status, row, SUMMITEXP_INDEX_NAME);
    4737     if (!status) {
    4738         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", SUMMITEXP_INDEX_NAME);
    4739         psFree(row);
    4740         return NULL;
    4741     }
    4742 
    4743     popped = psMetadataAlloc();
    4744     psMetadataAddS32(popped, PS_LIST_TAIL, SUMMITEXP_INDEX_NAME, 0, NULL, rowID);
    4745 
    4746     deleted = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, popped, 0);
    4747     if (deleted != 1) {
    4748         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    4749         psFree(popped);
    4750         psFree(row);
    4751         return NULL;
    4752     }
    4753 
    4754     psFree(popped);
    4755 
    4756     *exp_id = psMetadataLookupPtr(&status, row, "exp_id");
    4757     if (!status) {
    4758         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
    4759         psFree(row);
    4760         return false;
    4761     }
    4762     *camera = psMetadataLookupPtr(&status, row, "camera");
    4763     if (!status) {
    4764         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    4765         psFree(row);
    4766         return false;
    4767     }
    4768     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    4769     if (!status) {
    4770         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    4771         psFree(row);
    4772         return false;
    4773     }
    4774     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    4775     if (!status) {
    4776         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    4777         psFree(row);
    4778         return false;
    4779     }
    4780     *uri = psMetadataLookupPtr(&status, row, "uri");
    4781     if (!status) {
    4782         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    4783         psFree(row);
    4784         return false;
    4785     }
    4786 
    4787     psFree(row);
    4788 
    4789     return true;
    4790 }
    4791 
    47923440bool summitExpInsertObject(psDB *dbh, summitExpRow *object)
    47933441{
    … …  
    48043452
    48053453    return true;
    4806 }
    4807 
    4808 summitExpRow *summitExpPopObject(psDB *dbh)
    4809 {
    4810     char            exp_id[256];
    4811     char            camera[256];
    4812     char            telescope[256];
    4813     char            exp_type[256];
    4814     char            uri[256];
    4815 
    4816     if (!summitExpPop(dbh, (char **)&exp_id, (char **)&camera, (char **)&telescope, (char **)&exp_type, (char **)&uri)) {
    4817         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    4818         return NULL;
    4819     }
    4820 
    4821     return summitExpRowAlloc(exp_id, camera, telescope, exp_type, uri);
    48223454}
    48233455
    … …  
    48573489}
    48583490
    4859 bool summitExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    4860 {
    4861     char            query[MAX_STRING_LENGTH];
    4862 
    4863     if (!summitExpSelectRowsFits(dbh, fits, NULL, limit)) {
    4864         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    4865         return false;
    4866     }
    4867 
    4868     // remove limit rows from the end of the database
    4869     if (snprintf(query, MAX_STRING_LENGTH,
    4870                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    4871                 SUMMITEXP_TABLE_NAME, SUMMITEXP_INDEX_NAME, limit) < 0) {
    4872         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    4873         return false;
    4874     }
    4875            
    4876     if (!p_psDBRunQuery(dbh, query)) {
    4877         psError(PS_ERR_UNKNOWN, false, "database query failed");
    4878         return false;
    4879     }
    4880 
    4881     return true;
    4882 }
    4883 
    48843491bool summitExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    48853492{
    48863493    psArray         *rowSet;
    4887     psU64           i;
    48883494
    48893495    rowSet = psDBSelectRows(dbh, SUMMITEXP_TABLE_NAME, where, limit);
    48903496    if (!rowSet) {
    48913497        return false;
    4892     }
    4893 
    4894     // strip index column
    4895     for (i = 0; i < rowSet->n; i++) {
    4896         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, SUMMITEXP_INDEX_NAME)) {
    4897             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SUMMITEXP_INDEX_NAME);
    4898             psFree(rowSet);
    4899             return false;
    4900         }
    49013498    }
    49023499
    … …  
    49933590    if (!rowSet) {
    49943591        return NULL;
    4995     }
    4996 
    4997     // strip index column
    4998     for (i = 0; i < rowSet->n; i++) {
    4999         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, SUMMITEXP_INDEX_NAME)) {
    5000             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", SUMMITEXP_INDEX_NAME);
    5001             psFree(rowSet);
    5002             return false;
    5003         }
    50043592    }
    50053593
    … …  
    51193707
    51203708    md = psMetadataAlloc();
    5121     if (!psMetadataAdd(md, PS_LIST_TAIL, PZPENDINGEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    5122         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", PZPENDINGEXP_INDEX_NAME);
    5123         psFree(md);
    5124         return false;
    5125     }
    51263709    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, "Primary Key", "64")) {
    51273710        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    52143797    return deleted;
    52153798}
    5216 bool pzPendingExpPop(psDB *dbh, char **exp_id, char **camera, char **telescope, char **exp_type, psS32 *imfiles)
    5217 {
    5218     psArray         *rowSet;
    5219     psMetadata      *row;
    5220     psMetadata      *popped;
    5221     long            deleted;
    5222     bool            status;
    5223     int             rowID;
    5224 
    5225     rowSet = psDBSelectRows(dbh, PZPENDINGEXP_TABLE_NAME, NULL, 1);
    5226     if (!rowSet) {
    5227         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", PZPENDINGEXP_INDEX_NAME);
    5228         psFree(rowSet);
    5229         return NULL;
    5230     }
    5231 
    5232     row = psArrayGet(rowSet, 0);
    5233     psMemIncrRefCounter(row);
    5234     if (!row) {
    5235         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    5236         return NULL;
    5237     }
    5238     psFree(rowSet);
    5239 
    5240     rowID = psMetadataLookupS32(&status, row, PZPENDINGEXP_INDEX_NAME);
    5241     if (!status) {
    5242         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", PZPENDINGEXP_INDEX_NAME);
    5243         psFree(row);
    5244         return NULL;
    5245     }
    5246 
    5247     popped = psMetadataAlloc();
    5248     psMetadataAddS32(popped, PS_LIST_TAIL, PZPENDINGEXP_INDEX_NAME, 0, NULL, rowID);
    5249 
    5250     deleted = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, popped, 0);
    5251     if (deleted != 1) {
    5252         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    5253         psFree(popped);
    5254         psFree(row);
    5255         return NULL;
    5256     }
    5257 
    5258     psFree(popped);
    5259 
    5260     *exp_id = psMetadataLookupPtr(&status, row, "exp_id");
    5261     if (!status) {
    5262         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
    5263         psFree(row);
    5264         return false;
    5265     }
    5266     *camera = psMetadataLookupPtr(&status, row, "camera");
    5267     if (!status) {
    5268         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    5269         psFree(row);
    5270         return false;
    5271     }
    5272     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    5273     if (!status) {
    5274         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    5275         psFree(row);
    5276         return false;
    5277     }
    5278     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    5279     if (!status) {
    5280         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    5281         psFree(row);
    5282         return false;
    5283     }
    5284     *imfiles = psMetadataLookupS32(&status, row, "imfiles");
    5285     if (!status) {
    5286         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    5287         psFree(row);
    5288         return false;
    5289     }
    5290 
    5291     psFree(row);
    5292 
    5293     return true;
    5294 }
    5295 
    52963799bool pzPendingExpInsertObject(psDB *dbh, pzPendingExpRow *object)
    52973800{
    … …  
    53083811
    53093812    return true;
    5310 }
    5311 
    5312 pzPendingExpRow *pzPendingExpPopObject(psDB *dbh)
    5313 {
    5314     char            exp_id[256];
    5315     char            camera[256];
    5316     char            telescope[256];
    5317     char            exp_type[256];
    5318     psS32           imfiles;
    5319 
    5320     if (!pzPendingExpPop(dbh, (char **)&exp_id, (char **)&camera, (char **)&telescope, (char **)&exp_type, &imfiles)) {
    5321         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    5322         return NULL;
    5323     }
    5324 
    5325     return pzPendingExpRowAlloc(exp_id, camera, telescope, exp_type, imfiles);
    53263813}
    53273814
    … …  
    53613848}
    53623849
    5363 bool pzPendingExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    5364 {
    5365     char            query[MAX_STRING_LENGTH];
    5366 
    5367     if (!pzPendingExpSelectRowsFits(dbh, fits, NULL, limit)) {
    5368         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    5369         return false;
    5370     }
    5371 
    5372     // remove limit rows from the end of the database
    5373     if (snprintf(query, MAX_STRING_LENGTH,
    5374                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    5375                 PZPENDINGEXP_TABLE_NAME, PZPENDINGEXP_INDEX_NAME, limit) < 0) {
    5376         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    5377         return false;
    5378     }
    5379            
    5380     if (!p_psDBRunQuery(dbh, query)) {
    5381         psError(PS_ERR_UNKNOWN, false, "database query failed");
    5382         return false;
    5383     }
    5384 
    5385     return true;
    5386 }
    5387 
    53883850bool pzPendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    53893851{
    53903852    psArray         *rowSet;
    5391     psU64           i;
    53923853
    53933854    rowSet = psDBSelectRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit);
    53943855    if (!rowSet) {
    53953856        return false;
    5396     }
    5397 
    5398     // strip index column
    5399     for (i = 0; i < rowSet->n; i++) {
    5400         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, PZPENDINGEXP_INDEX_NAME)) {
    5401             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", PZPENDINGEXP_INDEX_NAME);
    5402             psFree(rowSet);
    5403             return false;
    5404         }
    54053857    }
    54063858
    … …  
    54973949    if (!rowSet) {
    54983950        return NULL;
    5499     }
    5500 
    5501     // strip index column
    5502     for (i = 0; i < rowSet->n; i++) {
    5503         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, PZPENDINGEXP_INDEX_NAME)) {
    5504             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", PZPENDINGEXP_INDEX_NAME);
    5505             psFree(rowSet);
    5506             return false;
    5507         }
    55083951    }
    55093952
    … …  
    56294072
    56304073    md = psMetadataAlloc();
    5631     if (!psMetadataAdd(md, PS_LIST_TAIL, PZPENDINGIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    5632         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", PZPENDINGIMFILE_INDEX_NAME);
    5633         psFree(md);
    5634         return false;
    5635     }
    56364074    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 0, "Primary Key", "64")) {
    56374075        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id");
    … …  
    57544192    return deleted;
    57554193}
    5756 bool pzPendingImfilePop(psDB *dbh, char **exp_id, char **camera, char **telescope, psS32 *bytes, char **md5sum, char **class, char **class_id, char **uri)
    5757 {
    5758     psArray         *rowSet;
    5759     psMetadata      *row;
    5760     psMetadata      *popped;
    5761     long            deleted;
    5762     bool            status;
    5763     int             rowID;
    5764 
    5765     rowSet = psDBSelectRows(dbh, PZPENDINGIMFILE_TABLE_NAME, NULL, 1);
    5766     if (!rowSet) {
    5767         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", PZPENDINGIMFILE_INDEX_NAME);
    5768         psFree(rowSet);
    5769         return NULL;
    5770     }
    5771 
    5772     row = psArrayGet(rowSet, 0);
    5773     psMemIncrRefCounter(row);
    5774     if (!row) {
    5775         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    5776         return NULL;
    5777     }
    5778     psFree(rowSet);
    5779 
    5780     rowID = psMetadataLookupS32(&status, row, PZPENDINGIMFILE_INDEX_NAME);
    5781     if (!status) {
    5782         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", PZPENDINGIMFILE_INDEX_NAME);
    5783         psFree(row);
    5784         return NULL;
    5785     }
    5786 
    5787     popped = psMetadataAlloc();
    5788     psMetadataAddS32(popped, PS_LIST_TAIL, PZPENDINGIMFILE_INDEX_NAME, 0, NULL, rowID);
    5789 
    5790     deleted = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, popped, 0);
    5791     if (deleted != 1) {
    5792         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    5793         psFree(popped);
    5794         psFree(row);
    5795         return NULL;
    5796     }
    5797 
    5798     psFree(popped);
    5799 
    5800     *exp_id = psMetadataLookupPtr(&status, row, "exp_id");
    5801     if (!status) {
    5802         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
    5803         psFree(row);
    5804         return false;
    5805     }
    5806     *camera = psMetadataLookupPtr(&status, row, "camera");
    5807     if (!status) {
    5808         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    5809         psFree(row);
    5810         return false;
    5811     }
    5812     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    5813     if (!status) {
    5814         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    5815         psFree(row);
    5816         return false;
    5817     }
    5818     *bytes = psMetadataLookupS32(&status, row, "bytes");
    5819     if (!status) {
    5820         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bytes");
    5821         psFree(row);
    5822         return false;
    5823     }
    5824     *md5sum = psMetadataLookupPtr(&status, row, "md5sum");
    5825     if (!status) {
    5826         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item md5sum");
    5827         psFree(row);
    5828         return false;
    5829     }
    5830     *class = psMetadataLookupPtr(&status, row, "class");
    5831     if (!status) {
    5832         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class");
    5833         psFree(row);
    5834         return false;
    5835     }
    5836     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    5837     if (!status) {
    5838         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    5839         psFree(row);
    5840         return false;
    5841     }
    5842     *uri = psMetadataLookupPtr(&status, row, "uri");
    5843     if (!status) {
    5844         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    5845         psFree(row);
    5846         return false;
    5847     }
    5848 
    5849     psFree(row);
    5850 
    5851     return true;
    5852 }
    5853 
    58544194bool pzPendingImfileInsertObject(psDB *dbh, pzPendingImfileRow *object)
    58554195{
    … …  
    58664206
    58674207    return true;
    5868 }
    5869 
    5870 pzPendingImfileRow *pzPendingImfilePopObject(psDB *dbh)
    5871 {
    5872     char            exp_id[256];
    5873     char            camera[256];
    5874     char            telescope[256];
    5875     psS32           bytes;
    5876     char            md5sum[256];
    5877     char            class[256];
    5878     char            class_id[256];
    5879     char            uri[256];
    5880 
    5881     if (!pzPendingImfilePop(dbh, (char **)&exp_id, (char **)&camera, (char **)&telescope, &bytes, (char **)&md5sum, (char **)&class, (char **)&class_id, (char **)&uri)) {
    5882         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    5883         return NULL;
    5884     }
    5885 
    5886     return pzPendingImfileRowAlloc(exp_id, camera, telescope, bytes, md5sum, class, class_id, uri);
    58874208}
    58884209
    … …  
    59224243}
    59234244
    5924 bool pzPendingImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    5925 {
    5926     char            query[MAX_STRING_LENGTH];
    5927 
    5928     if (!pzPendingImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    5929         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    5930         return false;
    5931     }
    5932 
    5933     // remove limit rows from the end of the database
    5934     if (snprintf(query, MAX_STRING_LENGTH,
    5935                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    5936                 PZPENDINGIMFILE_TABLE_NAME, PZPENDINGIMFILE_INDEX_NAME, limit) < 0) {
    5937         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    5938         return false;
    5939     }
    5940            
    5941     if (!p_psDBRunQuery(dbh, query)) {
    5942         psError(PS_ERR_UNKNOWN, false, "database query failed");
    5943         return false;
    5944     }
    5945 
    5946     return true;
    5947 }
    5948 
    59494245bool pzPendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    59504246{
    59514247    psArray         *rowSet;
    5952     psU64           i;
    59534248
    59544249    rowSet = psDBSelectRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit);
    59554250    if (!rowSet) {
    59564251        return false;
    5957     }
    5958 
    5959     // strip index column
    5960     for (i = 0; i < rowSet->n; i++) {
    5961         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, PZPENDINGIMFILE_INDEX_NAME)) {
    5962             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", PZPENDINGIMFILE_INDEX_NAME);
    5963             psFree(rowSet);
    5964             return false;
    5965         }
    59664252    }
    59674253
    … …  
    60914377    if (!rowSet) {
    60924378        return NULL;
    6093     }
    6094 
    6095     // strip index column
    6096     for (i = 0; i < rowSet->n; i++) {
    6097         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, PZPENDINGIMFILE_INDEX_NAME)) {
    6098             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", PZPENDINGIMFILE_INDEX_NAME);
    6099             psFree(rowSet);
    6100             return false;
    6101         }
    61024379    }
    61034380
    … …  
    62194496
    62204497    md = psMetadataAlloc();
    6221     if (!psMetadataAdd(md, PS_LIST_TAIL, NEWEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    6222         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", NEWEXP_INDEX_NAME);
    6223         psFree(md);
    6224         return false;
    6225     }
    62264498    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    62274499        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    63244596    return deleted;
    63254597}
    6326 bool newExpPop(psDB *dbh, char **exp_tag, char **exp_id, char **camera, char **telescope, char **exp_type, psS32 *imfiles)
    6327 {
    6328     psArray         *rowSet;
    6329     psMetadata      *row;
    6330     psMetadata      *popped;
    6331     long            deleted;
    6332     bool            status;
    6333     int             rowID;
    6334 
    6335     rowSet = psDBSelectRows(dbh, NEWEXP_TABLE_NAME, NULL, 1);
    6336     if (!rowSet) {
    6337         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", NEWEXP_INDEX_NAME);
    6338         psFree(rowSet);
    6339         return NULL;
    6340     }
    6341 
    6342     row = psArrayGet(rowSet, 0);
    6343     psMemIncrRefCounter(row);
    6344     if (!row) {
    6345         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    6346         return NULL;
    6347     }
    6348     psFree(rowSet);
    6349 
    6350     rowID = psMetadataLookupS32(&status, row, NEWEXP_INDEX_NAME);
    6351     if (!status) {
    6352         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", NEWEXP_INDEX_NAME);
    6353         psFree(row);
    6354         return NULL;
    6355     }
    6356 
    6357     popped = psMetadataAlloc();
    6358     psMetadataAddS32(popped, PS_LIST_TAIL, NEWEXP_INDEX_NAME, 0, NULL, rowID);
    6359 
    6360     deleted = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, popped, 0);
    6361     if (deleted != 1) {
    6362         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    6363         psFree(popped);
    6364         psFree(row);
    6365         return NULL;
    6366     }
    6367 
    6368     psFree(popped);
    6369 
    6370     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    6371     if (!status) {
    6372         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    6373         psFree(row);
    6374         return false;
    6375     }
    6376     *exp_id = psMetadataLookupPtr(&status, row, "exp_id");
    6377     if (!status) {
    6378         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id");
    6379         psFree(row);
    6380         return false;
    6381     }
    6382     *camera = psMetadataLookupPtr(&status, row, "camera");
    6383     if (!status) {
    6384         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    6385         psFree(row);
    6386         return false;
    6387     }
    6388     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    6389     if (!status) {
    6390         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    6391         psFree(row);
    6392         return false;
    6393     }
    6394     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    6395     if (!status) {
    6396         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    6397         psFree(row);
    6398         return false;
    6399     }
    6400     *imfiles = psMetadataLookupS32(&status, row, "imfiles");
    6401     if (!status) {
    6402         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    6403         psFree(row);
    6404         return false;
    6405     }
    6406 
    6407     psFree(row);
    6408 
    6409     return true;
    6410 }
    6411 
    64124598bool newExpInsertObject(psDB *dbh, newExpRow *object)
    64134599{
    … …  
    64244610
    64254611    return true;
    6426 }
    6427 
    6428 newExpRow *newExpPopObject(psDB *dbh)
    6429 {
    6430     char            exp_tag[256];
    6431     char            exp_id[256];
    6432     char            camera[256];
    6433     char            telescope[256];
    6434     char            exp_type[256];
    6435     psS32           imfiles;
    6436 
    6437     if (!newExpPop(dbh, (char **)&exp_tag, (char **)&exp_id, (char **)&camera, (char **)&telescope, (char **)&exp_type, &imfiles)) {
    6438         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    6439         return NULL;
    6440     }
    6441 
    6442     return newExpRowAlloc(exp_tag, exp_id, camera, telescope, exp_type, imfiles);
    64434612}
    64444613
    … …  
    64784647}
    64794648
    6480 bool newExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    6481 {
    6482     char            query[MAX_STRING_LENGTH];
    6483 
    6484     if (!newExpSelectRowsFits(dbh, fits, NULL, limit)) {
    6485         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    6486         return false;
    6487     }
    6488 
    6489     // remove limit rows from the end of the database
    6490     if (snprintf(query, MAX_STRING_LENGTH,
    6491                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    6492                 NEWEXP_TABLE_NAME, NEWEXP_INDEX_NAME, limit) < 0) {
    6493         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    6494         return false;
    6495     }
    6496            
    6497     if (!p_psDBRunQuery(dbh, query)) {
    6498         psError(PS_ERR_UNKNOWN, false, "database query failed");
    6499         return false;
    6500     }
    6501 
    6502     return true;
    6503 }
    6504 
    65054649bool newExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    65064650{
    65074651    psArray         *rowSet;
    6508     psU64           i;
    65094652
    65104653    rowSet = psDBSelectRows(dbh, NEWEXP_TABLE_NAME, where, limit);
    65114654    if (!rowSet) {
    65124655        return false;
    6513     }
    6514 
    6515     // strip index column
    6516     for (i = 0; i < rowSet->n; i++) {
    6517         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, NEWEXP_INDEX_NAME)) {
    6518             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", NEWEXP_INDEX_NAME);
    6519             psFree(rowSet);
    6520             return false;
    6521         }
    65224656    }
    65234657
    … …  
    66254759    if (!rowSet) {
    66264760        return NULL;
    6627     }
    6628 
    6629     // strip index column
    6630     for (i = 0; i < rowSet->n; i++) {
    6631         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, NEWEXP_INDEX_NAME)) {
    6632             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", NEWEXP_INDEX_NAME);
    6633             psFree(rowSet);
    6634             return false;
    6635         }
    66364761    }
    66374762
    … …  
    67504875
    67514876    md = psMetadataAlloc();
    6752     if (!psMetadataAdd(md, PS_LIST_TAIL, NEWIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    6753         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", NEWIMFILE_INDEX_NAME);
    6754         psFree(md);
    6755         return false;
    6756     }
    67574877    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    67584878        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    68354955    return deleted;
    68364956}
    6837 bool newImfilePop(psDB *dbh, char **exp_tag, char **class, char **class_id, char **uri)
    6838 {
    6839     psArray         *rowSet;
    6840     psMetadata      *row;
    6841     psMetadata      *popped;
    6842     long            deleted;
    6843     bool            status;
    6844     int             rowID;
    6845 
    6846     rowSet = psDBSelectRows(dbh, NEWIMFILE_TABLE_NAME, NULL, 1);
    6847     if (!rowSet) {
    6848         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", NEWIMFILE_INDEX_NAME);
    6849         psFree(rowSet);
    6850         return NULL;
    6851     }
    6852 
    6853     row = psArrayGet(rowSet, 0);
    6854     psMemIncrRefCounter(row);
    6855     if (!row) {
    6856         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    6857         return NULL;
    6858     }
    6859     psFree(rowSet);
    6860 
    6861     rowID = psMetadataLookupS32(&status, row, NEWIMFILE_INDEX_NAME);
    6862     if (!status) {
    6863         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", NEWIMFILE_INDEX_NAME);
    6864         psFree(row);
    6865         return NULL;
    6866     }
    6867 
    6868     popped = psMetadataAlloc();
    6869     psMetadataAddS32(popped, PS_LIST_TAIL, NEWIMFILE_INDEX_NAME, 0, NULL, rowID);
    6870 
    6871     deleted = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, popped, 0);
    6872     if (deleted != 1) {
    6873         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    6874         psFree(popped);
    6875         psFree(row);
    6876         return NULL;
    6877     }
    6878 
    6879     psFree(popped);
    6880 
    6881     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    6882     if (!status) {
    6883         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    6884         psFree(row);
    6885         return false;
    6886     }
    6887     *class = psMetadataLookupPtr(&status, row, "class");
    6888     if (!status) {
    6889         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class");
    6890         psFree(row);
    6891         return false;
    6892     }
    6893     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    6894     if (!status) {
    6895         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    6896         psFree(row);
    6897         return false;
    6898     }
    6899     *uri = psMetadataLookupPtr(&status, row, "uri");
    6900     if (!status) {
    6901         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    6902         psFree(row);
    6903         return false;
    6904     }
    6905 
    6906     psFree(row);
    6907 
    6908     return true;
    6909 }
    6910 
    69114957bool newImfileInsertObject(psDB *dbh, newImfileRow *object)
    69124958{
    … …  
    69234969
    69244970    return true;
    6925 }
    6926 
    6927 newImfileRow *newImfilePopObject(psDB *dbh)
    6928 {
    6929     char            exp_tag[256];
    6930     char            class[256];
    6931     char            class_id[256];
    6932     char            uri[256];
    6933 
    6934     if (!newImfilePop(dbh, (char **)&exp_tag, (char **)&class, (char **)&class_id, (char **)&uri)) {
    6935         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    6936         return NULL;
    6937     }
    6938 
    6939     return newImfileRowAlloc(exp_tag, class, class_id, uri);
    69404971}
    69414972
    … …  
    69755006}
    69765007
    6977 bool newImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    6978 {
    6979     char            query[MAX_STRING_LENGTH];
    6980 
    6981     if (!newImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    6982         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    6983         return false;
    6984     }
    6985 
    6986     // remove limit rows from the end of the database
    6987     if (snprintf(query, MAX_STRING_LENGTH,
    6988                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    6989                 NEWIMFILE_TABLE_NAME, NEWIMFILE_INDEX_NAME, limit) < 0) {
    6990         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    6991         return false;
    6992     }
    6993            
    6994     if (!p_psDBRunQuery(dbh, query)) {
    6995         psError(PS_ERR_UNKNOWN, false, "database query failed");
    6996         return false;
    6997     }
    6998 
    6999     return true;
    7000 }
    7001 
    70025008bool newImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    70035009{
    70045010    psArray         *rowSet;
    7005     psU64           i;
    70065011
    70075012    rowSet = psDBSelectRows(dbh, NEWIMFILE_TABLE_NAME, where, limit);
    70085013    if (!rowSet) {
    70095014        return false;
    7010     }
    7011 
    7012     // strip index column
    7013     for (i = 0; i < rowSet->n; i++) {
    7014         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, NEWIMFILE_INDEX_NAME)) {
    7015             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", NEWIMFILE_INDEX_NAME);
    7016             psFree(rowSet);
    7017             return false;
    7018         }
    70195015    }
    70205016
    … …  
    71005096    if (!rowSet) {
    71015097        return NULL;
    7102     }
    7103 
    7104     // strip index column
    7105     for (i = 0; i < rowSet->n; i++) {
    7106         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, NEWIMFILE_INDEX_NAME)) {
    7107             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", NEWIMFILE_INDEX_NAME);
    7108             psFree(rowSet);
    7109             return false;
    7110         }
    71115098    }
    71125099
    … …  
    72415228
    72425229    md = psMetadataAlloc();
    7243     if (!psMetadataAdd(md, PS_LIST_TAIL, RAWDETRENDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    7244         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", RAWDETRENDEXP_INDEX_NAME);
    7245         psFree(md);
    7246         return false;
    7247     }
    72485230    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    72495231        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    74665448    return deleted;
    74675449}
    7468 bool rawDetrendExpPop(psDB *dbh, char **exp_tag, char **camera, char **telescope, char **exp_type, psS32 *imfiles, char **filter, psF32 *airmass, psF64 *ra, psF64 *decl, psF32 *exp_time, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, psF64 *alt, psF64 *az, psF32 *ccd_temp, psF64 *posang, char **object)
    7469 {
    7470     psArray         *rowSet;
    7471     psMetadata      *row;
    7472     psMetadata      *popped;
    7473     long            deleted;
    7474     bool            status;
    7475     int             rowID;
    7476 
    7477     rowSet = psDBSelectRows(dbh, RAWDETRENDEXP_TABLE_NAME, NULL, 1);
    7478     if (!rowSet) {
    7479         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWDETRENDEXP_INDEX_NAME);
    7480         psFree(rowSet);
    7481         return NULL;
    7482     }
    7483 
    7484     row = psArrayGet(rowSet, 0);
    7485     psMemIncrRefCounter(row);
    7486     if (!row) {
    7487         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    7488         return NULL;
    7489     }
    7490     psFree(rowSet);
    7491 
    7492     rowID = psMetadataLookupS32(&status, row, RAWDETRENDEXP_INDEX_NAME);
    7493     if (!status) {
    7494         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWDETRENDEXP_INDEX_NAME);
    7495         psFree(row);
    7496         return NULL;
    7497     }
    7498 
    7499     popped = psMetadataAlloc();
    7500     psMetadataAddS32(popped, PS_LIST_TAIL, RAWDETRENDEXP_INDEX_NAME, 0, NULL, rowID);
    7501 
    7502     deleted = psDBDeleteRows(dbh, RAWDETRENDEXP_TABLE_NAME, popped, 0);
    7503     if (deleted != 1) {
    7504         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    7505         psFree(popped);
    7506         psFree(row);
    7507         return NULL;
    7508     }
    7509 
    7510     psFree(popped);
    7511 
    7512     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    7513     if (!status) {
    7514         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    7515         psFree(row);
    7516         return false;
    7517     }
    7518     *camera = psMetadataLookupPtr(&status, row, "camera");
    7519     if (!status) {
    7520         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    7521         psFree(row);
    7522         return false;
    7523     }
    7524     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    7525     if (!status) {
    7526         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    7527         psFree(row);
    7528         return false;
    7529     }
    7530     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    7531     if (!status) {
    7532         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    7533         psFree(row);
    7534         return false;
    7535     }
    7536     *imfiles = psMetadataLookupS32(&status, row, "imfiles");
    7537     if (!status) {
    7538         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    7539         psFree(row);
    7540         return false;
    7541     }
    7542     *filter = psMetadataLookupPtr(&status, row, "filter");
    7543     if (!status) {
    7544         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    7545         psFree(row);
    7546         return false;
    7547     }
    7548     *airmass = psMetadataLookupF32(&status, row, "airmass");
    7549     if (!status) {
    7550         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass");
    7551         psFree(row);
    7552         return false;
    7553     }
    7554     *ra = psMetadataLookupF64(&status, row, "ra");
    7555     if (!status) {
    7556         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    7557         psFree(row);
    7558         return false;
    7559     }
    7560     *decl = psMetadataLookupF64(&status, row, "decl");
    7561     if (!status) {
    7562         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    7563         psFree(row);
    7564         return false;
    7565     }
    7566     *exp_time = psMetadataLookupF32(&status, row, "exp_time");
    7567     if (!status) {
    7568         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time");
    7569         psFree(row);
    7570         return false;
    7571     }
    7572     *bg = psMetadataLookupF64(&status, row, "bg");
    7573     if (!status) {
    7574         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    7575         psFree(row);
    7576         return false;
    7577     }
    7578     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    7579     if (!status) {
    7580         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    7581         psFree(row);
    7582         return false;
    7583     }
    7584     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    7585     if (!status) {
    7586         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    7587         psFree(row);
    7588         return false;
    7589     }
    7590     *alt = psMetadataLookupF64(&status, row, "alt");
    7591     if (!status) {
    7592         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt");
    7593         psFree(row);
    7594         return false;
    7595     }
    7596     *az = psMetadataLookupF64(&status, row, "az");
    7597     if (!status) {
    7598         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    7599         psFree(row);
    7600         return false;
    7601     }
    7602     *ccd_temp = psMetadataLookupF32(&status, row, "ccd_temp");
    7603     if (!status) {
    7604         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp");
    7605         psFree(row);
    7606         return false;
    7607     }
    7608     *posang = psMetadataLookupF64(&status, row, "posang");
    7609     if (!status) {
    7610         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang");
    7611         psFree(row);
    7612         return false;
    7613     }
    7614     *object = psMetadataLookupPtr(&status, row, "object");
    7615     if (!status) {
    7616         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object");
    7617         psFree(row);
    7618         return false;
    7619     }
    7620 
    7621     psFree(row);
    7622 
    7623     return true;
    7624 }
    7625 
    76265450bool rawDetrendExpInsertObject(psDB *dbh, rawDetrendExpRow *object)
    76275451{
    … …  
    76385462
    76395463    return true;
    7640 }
    7641 
    7642 rawDetrendExpRow *rawDetrendExpPopObject(psDB *dbh)
    7643 {
    7644     char            exp_tag[256];
    7645     char            camera[256];
    7646     char            telescope[256];
    7647     char            exp_type[256];
    7648     psS32           imfiles;
    7649     char            filter[256];
    7650     psF32           airmass;
    7651     psF64           ra;
    7652     psF64           decl;
    7653     psF32           exp_time;
    7654     psF64           bg;
    7655     psF64           bg_stdev;
    7656     psF64           bg_mean_stdev;
    7657     psF64           alt;
    7658     psF64           az;
    7659     psF32           ccd_temp;
    7660     psF64           posang;
    7661     char            object[256];
    7662 
    7663     if (!rawDetrendExpPop(dbh, (char **)&exp_tag, (char **)&camera, (char **)&telescope, (char **)&exp_type, &imfiles, (char **)&filter, &airmass, &ra, &decl, &exp_time, &bg, &bg_stdev, &bg_mean_stdev, &alt, &az, &ccd_temp, &posang, (char **)&object)) {
    7664         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    7665         return NULL;
    7666     }
    7667 
    7668     return rawDetrendExpRowAlloc(exp_tag, camera, telescope, exp_type, imfiles, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object);
    76695464}
    76705465
    … …  
    77045499}
    77055500
    7706 bool rawDetrendExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    7707 {
    7708     char            query[MAX_STRING_LENGTH];
    7709 
    7710     if (!rawDetrendExpSelectRowsFits(dbh, fits, NULL, limit)) {
    7711         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    7712         return false;
    7713     }
    7714 
    7715     // remove limit rows from the end of the database
    7716     if (snprintf(query, MAX_STRING_LENGTH,
    7717                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    7718                 RAWDETRENDEXP_TABLE_NAME, RAWDETRENDEXP_INDEX_NAME, limit) < 0) {
    7719         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    7720         return false;
    7721     }
    7722            
    7723     if (!p_psDBRunQuery(dbh, query)) {
    7724         psError(PS_ERR_UNKNOWN, false, "database query failed");
    7725         return false;
    7726     }
    7727 
    7728     return true;
    7729 }
    7730 
    77315501bool rawDetrendExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    77325502{
    77335503    psArray         *rowSet;
    7734     psU64           i;
    77355504
    77365505    rowSet = psDBSelectRows(dbh, RAWDETRENDEXP_TABLE_NAME, where, limit);
    77375506    if (!rowSet) {
    77385507        return false;
    7739     }
    7740 
    7741     // strip index column
    7742     for (i = 0; i < rowSet->n; i++) {
    7743         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, RAWDETRENDEXP_INDEX_NAME)) {
    7744             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWDETRENDEXP_INDEX_NAME);
    7745             psFree(rowSet);
    7746             return false;
    7747         }
    77485508    }
    77495509
    … …  
    79855745    }
    79865746
    7987     // strip index column
    7988     for (i = 0; i < rowSet->n; i++) {
    7989         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, RAWDETRENDEXP_INDEX_NAME)) {
    7990             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWDETRENDEXP_INDEX_NAME);
    7991             psFree(rowSet);
    7992             return false;
    7993         }
    7994     }
    7995 
    79965747    // convert psMetadata rows to row objects
    79975748
    … …  
    81245875
    81255876    md = psMetadataAlloc();
    8126     if (!psMetadataAdd(md, PS_LIST_TAIL, RAWSCIENCEEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    8127         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", RAWSCIENCEEXP_INDEX_NAME);
    8128         psFree(md);
    8129         return false;
    8130     }
    81315877    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    81325878        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    83496095    return deleted;
    83506096}
    8351 bool rawScienceExpPop(psDB *dbh, char **exp_tag, char **camera, char **telescope, char **exp_type, psS32 *imfiles, char **filter, psF32 *airmass, psF64 *ra, psF64 *decl, psF32 *exp_time, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, psF64 *alt, psF64 *az, psF32 *ccd_temp, psF64 *posang, char **object)
    8352 {
    8353     psArray         *rowSet;
    8354     psMetadata      *row;
    8355     psMetadata      *popped;
    8356     long            deleted;
    8357     bool            status;
    8358     int             rowID;
    8359 
    8360     rowSet = psDBSelectRows(dbh, RAWSCIENCEEXP_TABLE_NAME, NULL, 1);
    8361     if (!rowSet) {
    8362         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWSCIENCEEXP_INDEX_NAME);
    8363         psFree(rowSet);
    8364         return NULL;
    8365     }
    8366 
    8367     row = psArrayGet(rowSet, 0);
    8368     psMemIncrRefCounter(row);
    8369     if (!row) {
    8370         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    8371         return NULL;
    8372     }
    8373     psFree(rowSet);
    8374 
    8375     rowID = psMetadataLookupS32(&status, row, RAWSCIENCEEXP_INDEX_NAME);
    8376     if (!status) {
    8377         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWSCIENCEEXP_INDEX_NAME);
    8378         psFree(row);
    8379         return NULL;
    8380     }
    8381 
    8382     popped = psMetadataAlloc();
    8383     psMetadataAddS32(popped, PS_LIST_TAIL, RAWSCIENCEEXP_INDEX_NAME, 0, NULL, rowID);
    8384 
    8385     deleted = psDBDeleteRows(dbh, RAWSCIENCEEXP_TABLE_NAME, popped, 0);
    8386     if (deleted != 1) {
    8387         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    8388         psFree(popped);
    8389         psFree(row);
    8390         return NULL;
    8391     }
    8392 
    8393     psFree(popped);
    8394 
    8395     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    8396     if (!status) {
    8397         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    8398         psFree(row);
    8399         return false;
    8400     }
    8401     *camera = psMetadataLookupPtr(&status, row, "camera");
    8402     if (!status) {
    8403         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera");
    8404         psFree(row);
    8405         return false;
    8406     }
    8407     *telescope = psMetadataLookupPtr(&status, row, "telescope");
    8408     if (!status) {
    8409         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope");
    8410         psFree(row);
    8411         return false;
    8412     }
    8413     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    8414     if (!status) {
    8415         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    8416         psFree(row);
    8417         return false;
    8418     }
    8419     *imfiles = psMetadataLookupS32(&status, row, "imfiles");
    8420     if (!status) {
    8421         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles");
    8422         psFree(row);
    8423         return false;
    8424     }
    8425     *filter = psMetadataLookupPtr(&status, row, "filter");
    8426     if (!status) {
    8427         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    8428         psFree(row);
    8429         return false;
    8430     }
    8431     *airmass = psMetadataLookupF32(&status, row, "airmass");
    8432     if (!status) {
    8433         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass");
    8434         psFree(row);
    8435         return false;
    8436     }
    8437     *ra = psMetadataLookupF64(&status, row, "ra");
    8438     if (!status) {
    8439         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    8440         psFree(row);
    8441         return false;
    8442     }
    8443     *decl = psMetadataLookupF64(&status, row, "decl");
    8444     if (!status) {
    8445         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    8446         psFree(row);
    8447         return false;
    8448     }
    8449     *exp_time = psMetadataLookupF32(&status, row, "exp_time");
    8450     if (!status) {
    8451         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time");
    8452         psFree(row);
    8453         return false;
    8454     }
    8455     *bg = psMetadataLookupF64(&status, row, "bg");
    8456     if (!status) {
    8457         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    8458         psFree(row);
    8459         return false;
    8460     }
    8461     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    8462     if (!status) {
    8463         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    8464         psFree(row);
    8465         return false;
    8466     }
    8467     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    8468     if (!status) {
    8469         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    8470         psFree(row);
    8471         return false;
    8472     }
    8473     *alt = psMetadataLookupF64(&status, row, "alt");
    8474     if (!status) {
    8475         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt");
    8476         psFree(row);
    8477         return false;
    8478     }
    8479     *az = psMetadataLookupF64(&status, row, "az");
    8480     if (!status) {
    8481         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    8482         psFree(row);
    8483         return false;
    8484     }
    8485     *ccd_temp = psMetadataLookupF32(&status, row, "ccd_temp");
    8486     if (!status) {
    8487         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp");
    8488         psFree(row);
    8489         return false;
    8490     }
    8491     *posang = psMetadataLookupF64(&status, row, "posang");
    8492     if (!status) {
    8493         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang");
    8494         psFree(row);
    8495         return false;
    8496     }
    8497     *object = psMetadataLookupPtr(&status, row, "object");
    8498     if (!status) {
    8499         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object");
    8500         psFree(row);
    8501         return false;
    8502     }
    8503 
    8504     psFree(row);
    8505 
    8506     return true;
    8507 }
    8508 
    85096097bool rawScienceExpInsertObject(psDB *dbh, rawScienceExpRow *object)
    85106098{
    … …  
    85216109
    85226110    return true;
    8523 }
    8524 
    8525 rawScienceExpRow *rawScienceExpPopObject(psDB *dbh)
    8526 {
    8527     char            exp_tag[256];
    8528     char            camera[256];
    8529     char            telescope[256];
    8530     char            exp_type[256];
    8531     psS32           imfiles;
    8532     char            filter[256];
    8533     psF32           airmass;
    8534     psF64           ra;
    8535     psF64           decl;
    8536     psF32           exp_time;
    8537     psF64           bg;
    8538     psF64           bg_stdev;
    8539     psF64           bg_mean_stdev;
    8540     psF64           alt;
    8541     psF64           az;
    8542     psF32           ccd_temp;
    8543     psF64           posang;
    8544     char            object[256];
    8545 
    8546     if (!rawScienceExpPop(dbh, (char **)&exp_tag, (char **)&camera, (char **)&telescope, (char **)&exp_type, &imfiles, (char **)&filter, &airmass, &ra, &decl, &exp_time, &bg, &bg_stdev, &bg_mean_stdev, &alt, &az, &ccd_temp, &posang, (char **)&object)) {
    8547         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    8548         return NULL;
    8549     }
    8550 
    8551     return rawScienceExpRowAlloc(exp_tag, camera, telescope, exp_type, imfiles, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object);
    85526111}
    85536112
    … …  
    85876146}
    85886147
    8589 bool rawScienceExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    8590 {
    8591     char            query[MAX_STRING_LENGTH];
    8592 
    8593     if (!rawScienceExpSelectRowsFits(dbh, fits, NULL, limit)) {
    8594         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    8595         return false;
    8596     }
    8597 
    8598     // remove limit rows from the end of the database
    8599     if (snprintf(query, MAX_STRING_LENGTH,
    8600                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    8601                 RAWSCIENCEEXP_TABLE_NAME, RAWSCIENCEEXP_INDEX_NAME, limit) < 0) {
    8602         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    8603         return false;
    8604     }
    8605            
    8606     if (!p_psDBRunQuery(dbh, query)) {
    8607         psError(PS_ERR_UNKNOWN, false, "database query failed");
    8608         return false;
    8609     }
    8610 
    8611     return true;
    8612 }
    8613 
    86146148bool rawScienceExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    86156149{
    86166150    psArray         *rowSet;
    8617     psU64           i;
    86186151
    86196152    rowSet = psDBSelectRows(dbh, RAWSCIENCEEXP_TABLE_NAME, where, limit);
    86206153    if (!rowSet) {
    86216154        return false;
    8622     }
    8623 
    8624     // strip index column
    8625     for (i = 0; i < rowSet->n; i++) {
    8626         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, RAWSCIENCEEXP_INDEX_NAME)) {
    8627             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWSCIENCEEXP_INDEX_NAME);
    8628             psFree(rowSet);
    8629             return false;
    8630         }
    86316155    }
    86326156
    … …  
    88686392    }
    88696393
    8870     // strip index column
    8871     for (i = 0; i < rowSet->n; i++) {
    8872         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, RAWSCIENCEEXP_INDEX_NAME)) {
    8873             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWSCIENCEEXP_INDEX_NAME);
    8874             psFree(rowSet);
    8875             return false;
    8876         }
    8877     }
    8878 
    88796394    // convert psMetadata rows to row objects
    88806395
    … …  
    90086523
    90096524    md = psMetadataAlloc();
    9010     if (!psMetadataAdd(md, PS_LIST_TAIL, RAWIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    9011         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", RAWIMFILE_INDEX_NAME);
    9012         psFree(md);
    9013         return false;
    9014     }
    90156525    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    90166526        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    92336743    return deleted;
    92346744}
    9235 bool rawImfilePop(psDB *dbh, char **exp_tag, char **class, char **class_id, char **uri, char **exp_type, char **filter, psF32 *airmass, psF64 *ra, psF64 *decl, psF32 *exp_time, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, psF64 *alt, psF64 *az, psF32 *ccd_temp, psF64 *posang, char **object)
    9236 {
    9237     psArray         *rowSet;
    9238     psMetadata      *row;
    9239     psMetadata      *popped;
    9240     long            deleted;
    9241     bool            status;
    9242     int             rowID;
    9243 
    9244     rowSet = psDBSelectRows(dbh, RAWIMFILE_TABLE_NAME, NULL, 1);
    9245     if (!rowSet) {
    9246         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWIMFILE_INDEX_NAME);
    9247         psFree(rowSet);
    9248         return NULL;
    9249     }
    9250 
    9251     row = psArrayGet(rowSet, 0);
    9252     psMemIncrRefCounter(row);
    9253     if (!row) {
    9254         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    9255         return NULL;
    9256     }
    9257     psFree(rowSet);
    9258 
    9259     rowID = psMetadataLookupS32(&status, row, RAWIMFILE_INDEX_NAME);
    9260     if (!status) {
    9261         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", RAWIMFILE_INDEX_NAME);
    9262         psFree(row);
    9263         return NULL;
    9264     }
    9265 
    9266     popped = psMetadataAlloc();
    9267     psMetadataAddS32(popped, PS_LIST_TAIL, RAWIMFILE_INDEX_NAME, 0, NULL, rowID);
    9268 
    9269     deleted = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, popped, 0);
    9270     if (deleted != 1) {
    9271         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    9272         psFree(popped);
    9273         psFree(row);
    9274         return NULL;
    9275     }
    9276 
    9277     psFree(popped);
    9278 
    9279     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    9280     if (!status) {
    9281         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    9282         psFree(row);
    9283         return false;
    9284     }
    9285     *class = psMetadataLookupPtr(&status, row, "class");
    9286     if (!status) {
    9287         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class");
    9288         psFree(row);
    9289         return false;
    9290     }
    9291     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    9292     if (!status) {
    9293         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    9294         psFree(row);
    9295         return false;
    9296     }
    9297     *uri = psMetadataLookupPtr(&status, row, "uri");
    9298     if (!status) {
    9299         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    9300         psFree(row);
    9301         return false;
    9302     }
    9303     *exp_type = psMetadataLookupPtr(&status, row, "exp_type");
    9304     if (!status) {
    9305         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type");
    9306         psFree(row);
    9307         return false;
    9308     }
    9309     *filter = psMetadataLookupPtr(&status, row, "filter");
    9310     if (!status) {
    9311         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter");
    9312         psFree(row);
    9313         return false;
    9314     }
    9315     *airmass = psMetadataLookupF32(&status, row, "airmass");
    9316     if (!status) {
    9317         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass");
    9318         psFree(row);
    9319         return false;
    9320     }
    9321     *ra = psMetadataLookupF64(&status, row, "ra");
    9322     if (!status) {
    9323         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra");
    9324         psFree(row);
    9325         return false;
    9326     }
    9327     *decl = psMetadataLookupF64(&status, row, "decl");
    9328     if (!status) {
    9329         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl");
    9330         psFree(row);
    9331         return false;
    9332     }
    9333     *exp_time = psMetadataLookupF32(&status, row, "exp_time");
    9334     if (!status) {
    9335         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time");
    9336         psFree(row);
    9337         return false;
    9338     }
    9339     *bg = psMetadataLookupF64(&status, row, "bg");
    9340     if (!status) {
    9341         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    9342         psFree(row);
    9343         return false;
    9344     }
    9345     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    9346     if (!status) {
    9347         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    9348         psFree(row);
    9349         return false;
    9350     }
    9351     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    9352     if (!status) {
    9353         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    9354         psFree(row);
    9355         return false;
    9356     }
    9357     *alt = psMetadataLookupF64(&status, row, "alt");
    9358     if (!status) {
    9359         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt");
    9360         psFree(row);
    9361         return false;
    9362     }
    9363     *az = psMetadataLookupF64(&status, row, "az");
    9364     if (!status) {
    9365         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az");
    9366         psFree(row);
    9367         return false;
    9368     }
    9369     *ccd_temp = psMetadataLookupF32(&status, row, "ccd_temp");
    9370     if (!status) {
    9371         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp");
    9372         psFree(row);
    9373         return false;
    9374     }
    9375     *posang = psMetadataLookupF64(&status, row, "posang");
    9376     if (!status) {
    9377         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang");
    9378         psFree(row);
    9379         return false;
    9380     }
    9381     *object = psMetadataLookupPtr(&status, row, "object");
    9382     if (!status) {
    9383         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object");
    9384         psFree(row);
    9385         return false;
    9386     }
    9387 
    9388     psFree(row);
    9389 
    9390     return true;
    9391 }
    9392 
    93936745bool rawImfileInsertObject(psDB *dbh, rawImfileRow *object)
    93946746{
    … …  
    94056757
    94066758    return true;
    9407 }
    9408 
    9409 rawImfileRow *rawImfilePopObject(psDB *dbh)
    9410 {
    9411     char            exp_tag[256];
    9412     char            class[256];
    9413     char            class_id[256];
    9414     char            uri[256];
    9415     char            exp_type[256];
    9416     char            filter[256];
    9417     psF32           airmass;
    9418     psF64           ra;
    9419     psF64           decl;
    9420     psF32           exp_time;
    9421     psF64           bg;
    9422     psF64           bg_stdev;
    9423     psF64           bg_mean_stdev;
    9424     psF64           alt;
    9425     psF64           az;
    9426     psF32           ccd_temp;
    9427     psF64           posang;
    9428     char            object[256];
    9429 
    9430     if (!rawImfilePop(dbh, (char **)&exp_tag, (char **)&class, (char **)&class_id, (char **)&uri, (char **)&exp_type, (char **)&filter, &airmass, &ra, &decl, &exp_time, &bg, &bg_stdev, &bg_mean_stdev, &alt, &az, &ccd_temp, &posang, (char **)&object)) {
    9431         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    9432         return NULL;
    9433     }
    9434 
    9435     return rawImfileRowAlloc(exp_tag, class, class_id, uri, exp_type, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object);
    94366759}
    94376760
    … …  
    94716794}
    94726795
    9473 bool rawImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    9474 {
    9475     char            query[MAX_STRING_LENGTH];
    9476 
    9477     if (!rawImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    9478         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    9479         return false;
    9480     }
    9481 
    9482     // remove limit rows from the end of the database
    9483     if (snprintf(query, MAX_STRING_LENGTH,
    9484                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    9485                 RAWIMFILE_TABLE_NAME, RAWIMFILE_INDEX_NAME, limit) < 0) {
    9486         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    9487         return false;
    9488     }
    9489            
    9490     if (!p_psDBRunQuery(dbh, query)) {
    9491         psError(PS_ERR_UNKNOWN, false, "database query failed");
    9492         return false;
    9493     }
    9494 
    9495     return true;
    9496 }
    9497 
    94986796bool rawImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    94996797{
    95006798    psArray         *rowSet;
    9501     psU64           i;
    95026799
    95036800    rowSet = psDBSelectRows(dbh, RAWIMFILE_TABLE_NAME, where, limit);
    95046801    if (!rowSet) {
    95056802        return false;
    9506     }
    9507 
    9508     // strip index column
    9509     for (i = 0; i < rowSet->n; i++) {
    9510         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, RAWIMFILE_INDEX_NAME)) {
    9511             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWIMFILE_INDEX_NAME);
    9512             psFree(rowSet);
    9513             return false;
    9514         }
    95156803    }
    95166804
    … …  
    97527040    }
    97537041
    9754     // strip index column
    9755     for (i = 0; i < rowSet->n; i++) {
    9756         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, RAWIMFILE_INDEX_NAME)) {
    9757             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", RAWIMFILE_INDEX_NAME);
    9758             psFree(rowSet);
    9759             return false;
    9760         }
    9761     }
    9762 
    97637042    // convert psMetadata rows to row objects
    97647043
    … …  
    98727151
    98737152    md = psMetadataAlloc();
    9874     if (!psMetadataAdd(md, PS_LIST_TAIL, P1PENDINGEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    9875         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P1PENDINGEXP_INDEX_NAME);
    9876         psFree(md);
    9877         return false;
    9878     }
    98797153    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    98807154        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    99477221    return deleted;
    99487222}
    9949 bool p1PendingExpPop(psDB *dbh, char **exp_tag, char **recipe, psS32 *p1_version)
    9950 {
    9951     psArray         *rowSet;
    9952     psMetadata      *row;
    9953     psMetadata      *popped;
    9954     long            deleted;
    9955     bool            status;
    9956     int             rowID;
    9957 
    9958     rowSet = psDBSelectRows(dbh, P1PENDINGEXP_TABLE_NAME, NULL, 1);
    9959     if (!rowSet) {
    9960         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P1PENDINGEXP_INDEX_NAME);
    9961         psFree(rowSet);
    9962         return NULL;
    9963     }
    9964 
    9965     row = psArrayGet(rowSet, 0);
    9966     psMemIncrRefCounter(row);
    9967     if (!row) {
    9968         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    9969         return NULL;
    9970     }
    9971     psFree(rowSet);
    9972 
    9973     rowID = psMetadataLookupS32(&status, row, P1PENDINGEXP_INDEX_NAME);
    9974     if (!status) {
    9975         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P1PENDINGEXP_INDEX_NAME);
    9976         psFree(row);
    9977         return NULL;
    9978     }
    9979 
    9980     popped = psMetadataAlloc();
    9981     psMetadataAddS32(popped, PS_LIST_TAIL, P1PENDINGEXP_INDEX_NAME, 0, NULL, rowID);
    9982 
    9983     deleted = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, popped, 0);
    9984     if (deleted != 1) {
    9985         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    9986         psFree(popped);
    9987         psFree(row);
    9988         return NULL;
    9989     }
    9990 
    9991     psFree(popped);
    9992 
    9993     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    9994     if (!status) {
    9995         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    9996         psFree(row);
    9997         return false;
    9998     }
    9999     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    10000     if (!status) {
    10001         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    10002         psFree(row);
    10003         return false;
    10004     }
    10005     *p1_version = psMetadataLookupS32(&status, row, "p1_version");
    10006     if (!status) {
    10007         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
    10008         psFree(row);
    10009         return false;
    10010     }
    10011 
    10012     psFree(row);
    10013 
    10014     return true;
    10015 }
    10016 
    100177223bool p1PendingExpInsertObject(psDB *dbh, p1PendingExpRow *object)
    100187224{
    … …  
    100297235
    100307236    return true;
    10031 }
    10032 
    10033 p1PendingExpRow *p1PendingExpPopObject(psDB *dbh)
    10034 {
    10035     char            exp_tag[256];
    10036     char            recipe[256];
    10037     psS32           p1_version;
    10038 
    10039     if (!p1PendingExpPop(dbh, (char **)&exp_tag, (char **)&recipe, &p1_version)) {
    10040         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    10041         return NULL;
    10042     }
    10043 
    10044     return p1PendingExpRowAlloc(exp_tag, recipe, p1_version);
    100457237}
    100467238
    … …  
    100807272}
    100817273
    10082 bool p1PendingExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    10083 {
    10084     char            query[MAX_STRING_LENGTH];
    10085 
    10086     if (!p1PendingExpSelectRowsFits(dbh, fits, NULL, limit)) {
    10087         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    10088         return false;
    10089     }
    10090 
    10091     // remove limit rows from the end of the database
    10092     if (snprintf(query, MAX_STRING_LENGTH,
    10093                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    10094                 P1PENDINGEXP_TABLE_NAME, P1PENDINGEXP_INDEX_NAME, limit) < 0) {
    10095         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    10096         return false;
    10097     }
    10098            
    10099     if (!p_psDBRunQuery(dbh, query)) {
    10100         psError(PS_ERR_UNKNOWN, false, "database query failed");
    10101         return false;
    10102     }
    10103 
    10104     return true;
    10105 }
    10106 
    101077274bool p1PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    101087275{
    101097276    psArray         *rowSet;
    10110     psU64           i;
    101117277
    101127278    rowSet = psDBSelectRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit);
    101137279    if (!rowSet) {
    101147280        return false;
    10115     }
    10116 
    10117     // strip index column
    10118     for (i = 0; i < rowSet->n; i++) {
    10119         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P1PENDINGEXP_INDEX_NAME)) {
    10120             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P1PENDINGEXP_INDEX_NAME);
    10121             psFree(rowSet);
    10122             return false;
    10123         }
    101247281    }
    101257282
    … …  
    101947351    if (!rowSet) {
    101957352        return NULL;
    10196     }
    10197 
    10198     // strip index column
    10199     for (i = 0; i < rowSet->n; i++) {
    10200         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P1PENDINGEXP_INDEX_NAME)) {
    10201             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P1PENDINGEXP_INDEX_NAME);
    10202             psFree(rowSet);
    10203             return false;
    10204         }
    102057353    }
    102067354
    … …  
    103177465
    103187466    md = psMetadataAlloc();
    10319     if (!psMetadataAdd(md, PS_LIST_TAIL, P2PENDINGEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    10320         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P2PENDINGEXP_INDEX_NAME);
    10321         psFree(md);
    10322         return false;
    10323     }
    103247467    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    103257468        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    104027545    return deleted;
    104037546}
    10404 bool p2PendingExpPop(psDB *dbh, char **exp_tag, char **recipe, psS32 *p1_version, psS32 *p2_version)
    10405 {
    10406     psArray         *rowSet;
    10407     psMetadata      *row;
    10408     psMetadata      *popped;
    10409     long            deleted;
    10410     bool            status;
    10411     int             rowID;
    10412 
    10413     rowSet = psDBSelectRows(dbh, P2PENDINGEXP_TABLE_NAME, NULL, 1);
    10414     if (!rowSet) {
    10415         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PENDINGEXP_INDEX_NAME);
    10416         psFree(rowSet);
    10417         return NULL;
    10418     }
    10419 
    10420     row = psArrayGet(rowSet, 0);
    10421     psMemIncrRefCounter(row);
    10422     if (!row) {
    10423         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    10424         return NULL;
    10425     }
    10426     psFree(rowSet);
    10427 
    10428     rowID = psMetadataLookupS32(&status, row, P2PENDINGEXP_INDEX_NAME);
    10429     if (!status) {
    10430         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PENDINGEXP_INDEX_NAME);
    10431         psFree(row);
    10432         return NULL;
    10433     }
    10434 
    10435     popped = psMetadataAlloc();
    10436     psMetadataAddS32(popped, PS_LIST_TAIL, P2PENDINGEXP_INDEX_NAME, 0, NULL, rowID);
    10437 
    10438     deleted = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, popped, 0);
    10439     if (deleted != 1) {
    10440         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    10441         psFree(popped);
    10442         psFree(row);
    10443         return NULL;
    10444     }
    10445 
    10446     psFree(popped);
    10447 
    10448     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    10449     if (!status) {
    10450         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    10451         psFree(row);
    10452         return false;
    10453     }
    10454     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    10455     if (!status) {
    10456         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    10457         psFree(row);
    10458         return false;
    10459     }
    10460     *p1_version = psMetadataLookupS32(&status, row, "p1_version");
    10461     if (!status) {
    10462         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
    10463         psFree(row);
    10464         return false;
    10465     }
    10466     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    10467     if (!status) {
    10468         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    10469         psFree(row);
    10470         return false;
    10471     }
    10472 
    10473     psFree(row);
    10474 
    10475     return true;
    10476 }
    10477 
    104787547bool p2PendingExpInsertObject(psDB *dbh, p2PendingExpRow *object)
    104797548{
    … …  
    104907559
    104917560    return true;
    10492 }
    10493 
    10494 p2PendingExpRow *p2PendingExpPopObject(psDB *dbh)
    10495 {
    10496     char            exp_tag[256];
    10497     char            recipe[256];
    10498     psS32           p1_version;
    10499     psS32           p2_version;
    10500 
    10501     if (!p2PendingExpPop(dbh, (char **)&exp_tag, (char **)&recipe, &p1_version, &p2_version)) {
    10502         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    10503         return NULL;
    10504     }
    10505 
    10506     return p2PendingExpRowAlloc(exp_tag, recipe, p1_version, p2_version);
    105077561}
    105087562
    … …  
    105427596}
    105437597
    10544 bool p2PendingExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    10545 {
    10546     char            query[MAX_STRING_LENGTH];
    10547 
    10548     if (!p2PendingExpSelectRowsFits(dbh, fits, NULL, limit)) {
    10549         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    10550         return false;
    10551     }
    10552 
    10553     // remove limit rows from the end of the database
    10554     if (snprintf(query, MAX_STRING_LENGTH,
    10555                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    10556                 P2PENDINGEXP_TABLE_NAME, P2PENDINGEXP_INDEX_NAME, limit) < 0) {
    10557         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    10558         return false;
    10559     }
    10560            
    10561     if (!p_psDBRunQuery(dbh, query)) {
    10562         psError(PS_ERR_UNKNOWN, false, "database query failed");
    10563         return false;
    10564     }
    10565 
    10566     return true;
    10567 }
    10568 
    105697598bool p2PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    105707599{
    105717600    psArray         *rowSet;
    10572     psU64           i;
    105737601
    105747602    rowSet = psDBSelectRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit);
    105757603    if (!rowSet) {
    105767604        return false;
    10577     }
    10578 
    10579     // strip index column
    10580     for (i = 0; i < rowSet->n; i++) {
    10581         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P2PENDINGEXP_INDEX_NAME)) {
    10582             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PENDINGEXP_INDEX_NAME);
    10583             psFree(rowSet);
    10584             return false;
    10585         }
    105867605    }
    105877606
    … …  
    106677686    if (!rowSet) {
    106687687        return NULL;
    10669     }
    10670 
    10671     // strip index column
    10672     for (i = 0; i < rowSet->n; i++) {
    10673         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P2PENDINGEXP_INDEX_NAME)) {
    10674             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PENDINGEXP_INDEX_NAME);
    10675             psFree(rowSet);
    10676             return false;
    10677         }
    106787688    }
    106797689
    … …  
    107947804
    107957805    md = psMetadataAlloc();
    10796     if (!psMetadataAdd(md, PS_LIST_TAIL, P2PENDINGIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    10797         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P2PENDINGIMFILE_INDEX_NAME);
    10798         psFree(md);
    10799         return false;
    10800     }
    108017806    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    108027807        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    108997904    return deleted;
    109007905}
    10901 bool p2PendingImfilePop(psDB *dbh, char **exp_tag, char **class_id, char **uri, char **recipe, psS32 *p1_version, psS32 *p2_version)
    10902 {
    10903     psArray         *rowSet;
    10904     psMetadata      *row;
    10905     psMetadata      *popped;
    10906     long            deleted;
    10907     bool            status;
    10908     int             rowID;
    10909 
    10910     rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_TABLE_NAME, NULL, 1);
    10911     if (!rowSet) {
    10912         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PENDINGIMFILE_INDEX_NAME);
    10913         psFree(rowSet);
    10914         return NULL;
    10915     }
    10916 
    10917     row = psArrayGet(rowSet, 0);
    10918     psMemIncrRefCounter(row);
    10919     if (!row) {
    10920         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    10921         return NULL;
    10922     }
    10923     psFree(rowSet);
    10924 
    10925     rowID = psMetadataLookupS32(&status, row, P2PENDINGIMFILE_INDEX_NAME);
    10926     if (!status) {
    10927         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PENDINGIMFILE_INDEX_NAME);
    10928         psFree(row);
    10929         return NULL;
    10930     }
    10931 
    10932     popped = psMetadataAlloc();
    10933     psMetadataAddS32(popped, PS_LIST_TAIL, P2PENDINGIMFILE_INDEX_NAME, 0, NULL, rowID);
    10934 
    10935     deleted = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, popped, 0);
    10936     if (deleted != 1) {
    10937         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    10938         psFree(popped);
    10939         psFree(row);
    10940         return NULL;
    10941     }
    10942 
    10943     psFree(popped);
    10944 
    10945     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    10946     if (!status) {
    10947         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    10948         psFree(row);
    10949         return false;
    10950     }
    10951     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    10952     if (!status) {
    10953         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    10954         psFree(row);
    10955         return false;
    10956     }
    10957     *uri = psMetadataLookupPtr(&status, row, "uri");
    10958     if (!status) {
    10959         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    10960         psFree(row);
    10961         return false;
    10962     }
    10963     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    10964     if (!status) {
    10965         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    10966         psFree(row);
    10967         return false;
    10968     }
    10969     *p1_version = psMetadataLookupS32(&status, row, "p1_version");
    10970     if (!status) {
    10971         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
    10972         psFree(row);
    10973         return false;
    10974     }
    10975     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    10976     if (!status) {
    10977         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    10978         psFree(row);
    10979         return false;
    10980     }
    10981 
    10982     psFree(row);
    10983 
    10984     return true;
    10985 }
    10986 
    109877906bool p2PendingImfileInsertObject(psDB *dbh, p2PendingImfileRow *object)
    109887907{
    … …  
    109997918
    110007919    return true;
    11001 }
    11002 
    11003 p2PendingImfileRow *p2PendingImfilePopObject(psDB *dbh)
    11004 {
    11005     char            exp_tag[256];
    11006     char            class_id[256];
    11007     char            uri[256];
    11008     char            recipe[256];
    11009     psS32           p1_version;
    11010     psS32           p2_version;
    11011 
    11012     if (!p2PendingImfilePop(dbh, (char **)&exp_tag, (char **)&class_id, (char **)&uri, (char **)&recipe, &p1_version, &p2_version)) {
    11013         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    11014         return NULL;
    11015     }
    11016 
    11017     return p2PendingImfileRowAlloc(exp_tag, class_id, uri, recipe, p1_version, p2_version);
    110187920}
    110197921
    … …  
    110537955}
    110547956
    11055 bool p2PendingImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    11056 {
    11057     char            query[MAX_STRING_LENGTH];
    11058 
    11059     if (!p2PendingImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    11060         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    11061         return false;
    11062     }
    11063 
    11064     // remove limit rows from the end of the database
    11065     if (snprintf(query, MAX_STRING_LENGTH,
    11066                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    11067                 P2PENDINGIMFILE_TABLE_NAME, P2PENDINGIMFILE_INDEX_NAME, limit) < 0) {
    11068         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    11069         return false;
    11070     }
    11071            
    11072     if (!p_psDBRunQuery(dbh, query)) {
    11073         psError(PS_ERR_UNKNOWN, false, "database query failed");
    11074         return false;
    11075     }
    11076 
    11077     return true;
    11078 }
    11079 
    110807957bool p2PendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    110817958{
    110827959    psArray         *rowSet;
    11083     psU64           i;
    110847960
    110857961    rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit);
    110867962    if (!rowSet) {
    110877963        return false;
    11088     }
    11089 
    11090     // strip index column
    11091     for (i = 0; i < rowSet->n; i++) {
    11092         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P2PENDINGIMFILE_INDEX_NAME)) {
    11093             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PENDINGIMFILE_INDEX_NAME);
    11094             psFree(rowSet);
    11095             return false;
    11096         }
    110977964    }
    110987965
    … …  
    112008067    if (!rowSet) {
    112018068        return NULL;
    11202     }
    11203 
    11204     // strip index column
    11205     for (i = 0; i < rowSet->n; i++) {
    11206         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P2PENDINGIMFILE_INDEX_NAME)) {
    11207             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PENDINGIMFILE_INDEX_NAME);
    11208             psFree(rowSet);
    11209             return false;
    11210         }
    112118069    }
    112128070
    … …  
    113218179
    113228180    md = psMetadataAlloc();
    11323     if (!psMetadataAdd(md, PS_LIST_TAIL, P2PROCESSEDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    11324         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P2PROCESSEDEXP_INDEX_NAME);
    11325         psFree(md);
    11326         return false;
    11327     }
    113288181    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    113298182        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    113968249    return deleted;
    113978250}
    11398 bool p2ProcessedExpPop(psDB *dbh, char **exp_tag, psS32 *p1_version, psS32 *p2_version)
    11399 {
    11400     psArray         *rowSet;
    11401     psMetadata      *row;
    11402     psMetadata      *popped;
    11403     long            deleted;
    11404     bool            status;
    11405     int             rowID;
    11406 
    11407     rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_TABLE_NAME, NULL, 1);
    11408     if (!rowSet) {
    11409         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PROCESSEDEXP_INDEX_NAME);
    11410         psFree(rowSet);
    11411         return NULL;
    11412     }
    11413 
    11414     row = psArrayGet(rowSet, 0);
    11415     psMemIncrRefCounter(row);
    11416     if (!row) {
    11417         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    11418         return NULL;
    11419     }
    11420     psFree(rowSet);
    11421 
    11422     rowID = psMetadataLookupS32(&status, row, P2PROCESSEDEXP_INDEX_NAME);
    11423     if (!status) {
    11424         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PROCESSEDEXP_INDEX_NAME);
    11425         psFree(row);
    11426         return NULL;
    11427     }
    11428 
    11429     popped = psMetadataAlloc();
    11430     psMetadataAddS32(popped, PS_LIST_TAIL, P2PROCESSEDEXP_INDEX_NAME, 0, NULL, rowID);
    11431 
    11432     deleted = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, popped, 0);
    11433     if (deleted != 1) {
    11434         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    11435         psFree(popped);
    11436         psFree(row);
    11437         return NULL;
    11438     }
    11439 
    11440     psFree(popped);
    11441 
    11442     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    11443     if (!status) {
    11444         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    11445         psFree(row);
    11446         return false;
    11447     }
    11448     *p1_version = psMetadataLookupS32(&status, row, "p1_version");
    11449     if (!status) {
    11450         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
    11451         psFree(row);
    11452         return false;
    11453     }
    11454     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    11455     if (!status) {
    11456         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    11457         psFree(row);
    11458         return false;
    11459     }
    11460 
    11461     psFree(row);
    11462 
    11463     return true;
    11464 }
    11465 
    114668251bool p2ProcessedExpInsertObject(psDB *dbh, p2ProcessedExpRow *object)
    114678252{
    … …  
    114788263
    114798264    return true;
    11480 }
    11481 
    11482 p2ProcessedExpRow *p2ProcessedExpPopObject(psDB *dbh)
    11483 {
    11484     char            exp_tag[256];
    11485     psS32           p1_version;
    11486     psS32           p2_version;
    11487 
    11488     if (!p2ProcessedExpPop(dbh, (char **)&exp_tag, &p1_version, &p2_version)) {
    11489         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    11490         return NULL;
    11491     }
    11492 
    11493     return p2ProcessedExpRowAlloc(exp_tag, p1_version, p2_version);
    114948265}
    114958266
    … …  
    115298300}
    115308301
    11531 bool p2ProcessedExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    11532 {
    11533     char            query[MAX_STRING_LENGTH];
    11534 
    11535     if (!p2ProcessedExpSelectRowsFits(dbh, fits, NULL, limit)) {
    11536         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    11537         return false;
    11538     }
    11539 
    11540     // remove limit rows from the end of the database
    11541     if (snprintf(query, MAX_STRING_LENGTH,
    11542                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    11543                 P2PROCESSEDEXP_TABLE_NAME, P2PROCESSEDEXP_INDEX_NAME, limit) < 0) {
    11544         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    11545         return false;
    11546     }
    11547            
    11548     if (!p_psDBRunQuery(dbh, query)) {
    11549         psError(PS_ERR_UNKNOWN, false, "database query failed");
    11550         return false;
    11551     }
    11552 
    11553     return true;
    11554 }
    11555 
    115568302bool p2ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    115578303{
    115588304    psArray         *rowSet;
    11559     psU64           i;
    115608305
    115618306    rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit);
    115628307    if (!rowSet) {
    115638308        return false;
    11564     }
    11565 
    11566     // strip index column
    11567     for (i = 0; i < rowSet->n; i++) {
    11568         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P2PROCESSEDEXP_INDEX_NAME)) {
    11569             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PROCESSEDEXP_INDEX_NAME);
    11570             psFree(rowSet);
    11571             return false;
    11572         }
    115738309    }
    115748310
    … …  
    116438379    if (!rowSet) {
    116448380        return NULL;
    11645     }
    11646 
    11647     // strip index column
    11648     for (i = 0; i < rowSet->n; i++) {
    11649         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P2PROCESSEDEXP_INDEX_NAME)) {
    11650             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PROCESSEDEXP_INDEX_NAME);
    11651             psFree(rowSet);
    11652             return false;
    11653         }
    116548381    }
    116558382
    … …  
    117778504
    117788505    md = psMetadataAlloc();
    11779     if (!psMetadataAdd(md, PS_LIST_TAIL, P2PROCESSEDIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    11780         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P2PROCESSEDIMFILE_INDEX_NAME);
    11781         psFree(md);
    11782         return false;
    11783     }
    117848506    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    117858507        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    119328654    return deleted;
    119338655}
    11934 bool p2ProcessedImfilePop(psDB *dbh, char **exp_tag, char **class_id, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri, psS32 *p1_version, psS32 *p2_version)
    11935 {
    11936     psArray         *rowSet;
    11937     psMetadata      *row;
    11938     psMetadata      *popped;
    11939     long            deleted;
    11940     bool            status;
    11941     int             rowID;
    11942 
    11943     rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, NULL, 1);
    11944     if (!rowSet) {
    11945         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PROCESSEDIMFILE_INDEX_NAME);
    11946         psFree(rowSet);
    11947         return NULL;
    11948     }
    11949 
    11950     row = psArrayGet(rowSet, 0);
    11951     psMemIncrRefCounter(row);
    11952     if (!row) {
    11953         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    11954         return NULL;
    11955     }
    11956     psFree(rowSet);
    11957 
    11958     rowID = psMetadataLookupS32(&status, row, P2PROCESSEDIMFILE_INDEX_NAME);
    11959     if (!status) {
    11960         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P2PROCESSEDIMFILE_INDEX_NAME);
    11961         psFree(row);
    11962         return NULL;
    11963     }
    11964 
    11965     popped = psMetadataAlloc();
    11966     psMetadataAddS32(popped, PS_LIST_TAIL, P2PROCESSEDIMFILE_INDEX_NAME, 0, NULL, rowID);
    11967 
    11968     deleted = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, popped, 0);
    11969     if (deleted != 1) {
    11970         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    11971         psFree(popped);
    11972         psFree(row);
    11973         return NULL;
    11974     }
    11975 
    11976     psFree(popped);
    11977 
    11978     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    11979     if (!status) {
    11980         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    11981         psFree(row);
    11982         return false;
    11983     }
    11984     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    11985     if (!status) {
    11986         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    11987         psFree(row);
    11988         return false;
    11989     }
    11990     *uri = psMetadataLookupPtr(&status, row, "uri");
    11991     if (!status) {
    11992         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    11993         psFree(row);
    11994         return false;
    11995     }
    11996     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    11997     if (!status) {
    11998         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    11999         psFree(row);
    12000         return false;
    12001     }
    12002     *bg = psMetadataLookupF64(&status, row, "bg");
    12003     if (!status) {
    12004         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    12005         psFree(row);
    12006         return false;
    12007     }
    12008     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    12009     if (!status) {
    12010         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    12011         psFree(row);
    12012         return false;
    12013     }
    12014     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    12015     if (!status) {
    12016         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    12017         psFree(row);
    12018         return false;
    12019     }
    12020     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    12021     if (!status) {
    12022         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    12023         psFree(row);
    12024         return false;
    12025     }
    12026     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    12027     if (!status) {
    12028         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    12029         psFree(row);
    12030         return false;
    12031     }
    12032     *p1_version = psMetadataLookupS32(&status, row, "p1_version");
    12033     if (!status) {
    12034         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version");
    12035         psFree(row);
    12036         return false;
    12037     }
    12038     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    12039     if (!status) {
    12040         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    12041         psFree(row);
    12042         return false;
    12043     }
    12044 
    12045     psFree(row);
    12046 
    12047     return true;
    12048 }
    12049 
    120508656bool p2ProcessedImfileInsertObject(psDB *dbh, p2ProcessedImfileRow *object)
    120518657{
    … …  
    120628668
    120638669    return true;
    12064 }
    12065 
    12066 p2ProcessedImfileRow *p2ProcessedImfilePopObject(psDB *dbh)
    12067 {
    12068     char            exp_tag[256];
    12069     char            class_id[256];
    12070     char            uri[256];
    12071     char            recipe[256];
    12072     psF64           bg;
    12073     psF64           bg_stdev;
    12074     psF64           bg_mean_stdev;
    12075     char            b1_uri[256];
    12076     char            b2_uri[256];
    12077     psS32           p1_version;
    12078     psS32           p2_version;
    12079 
    12080     if (!p2ProcessedImfilePop(dbh, (char **)&exp_tag, (char **)&class_id, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri, &p1_version, &p2_version)) {
    12081         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    12082         return NULL;
    12083     }
    12084 
    12085     return p2ProcessedImfileRowAlloc(exp_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, p1_version, p2_version);
    120868670}
    120878671
    … …  
    121218705}
    121228706
    12123 bool p2ProcessedImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    12124 {
    12125     char            query[MAX_STRING_LENGTH];
    12126 
    12127     if (!p2ProcessedImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    12128         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    12129         return false;
    12130     }
    12131 
    12132     // remove limit rows from the end of the database
    12133     if (snprintf(query, MAX_STRING_LENGTH,
    12134                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    12135                 P2PROCESSEDIMFILE_TABLE_NAME, P2PROCESSEDIMFILE_INDEX_NAME, limit) < 0) {
    12136         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    12137         return false;
    12138     }
    12139            
    12140     if (!p_psDBRunQuery(dbh, query)) {
    12141         psError(PS_ERR_UNKNOWN, false, "database query failed");
    12142         return false;
    12143     }
    12144 
    12145     return true;
    12146 }
    12147 
    121488707bool p2ProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    121498708{
    121508709    psArray         *rowSet;
    12151     psU64           i;
    121528710
    121538711    rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit);
    121548712    if (!rowSet) {
    121558713        return false;
    12156     }
    12157 
    12158     // strip index column
    12159     for (i = 0; i < rowSet->n; i++) {
    12160         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P2PROCESSEDIMFILE_INDEX_NAME)) {
    12161             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PROCESSEDIMFILE_INDEX_NAME);
    12162             psFree(rowSet);
    12163             return false;
    12164         }
    121658714    }
    121668715
    … …  
    123238872    if (!rowSet) {
    123248873        return NULL;
    12325     }
    12326 
    12327     // strip index column
    12328     for (i = 0; i < rowSet->n; i++) {
    12329         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P2PROCESSEDIMFILE_INDEX_NAME)) {
    12330             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P2PROCESSEDIMFILE_INDEX_NAME);
    12331             psFree(rowSet);
    12332             return false;
    12333         }
    123348874    }
    123358875
    … …  
    124448984
    124458985    md = psMetadataAlloc();
    12446     if (!psMetadataAdd(md, PS_LIST_TAIL, P3PENDINGEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    12447         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P3PENDINGEXP_INDEX_NAME);
    12448         psFree(md);
    12449         return false;
    12450     }
    124518986    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    124528987        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    125199054    return deleted;
    125209055}
    12521 bool p3PendingExpPop(psDB *dbh, char **exp_tag, psS32 *p2_version, psS32 *p3_version)
    12522 {
    12523     psArray         *rowSet;
    12524     psMetadata      *row;
    12525     psMetadata      *popped;
    12526     long            deleted;
    12527     bool            status;
    12528     int             rowID;
    12529 
    12530     rowSet = psDBSelectRows(dbh, P3PENDINGEXP_TABLE_NAME, NULL, 1);
    12531     if (!rowSet) {
    12532         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PENDINGEXP_INDEX_NAME);
    12533         psFree(rowSet);
    12534         return NULL;
    12535     }
    12536 
    12537     row = psArrayGet(rowSet, 0);
    12538     psMemIncrRefCounter(row);
    12539     if (!row) {
    12540         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    12541         return NULL;
    12542     }
    12543     psFree(rowSet);
    12544 
    12545     rowID = psMetadataLookupS32(&status, row, P3PENDINGEXP_INDEX_NAME);
    12546     if (!status) {
    12547         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PENDINGEXP_INDEX_NAME);
    12548         psFree(row);
    12549         return NULL;
    12550     }
    12551 
    12552     popped = psMetadataAlloc();
    12553     psMetadataAddS32(popped, PS_LIST_TAIL, P3PENDINGEXP_INDEX_NAME, 0, NULL, rowID);
    12554 
    12555     deleted = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, popped, 0);
    12556     if (deleted != 1) {
    12557         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    12558         psFree(popped);
    12559         psFree(row);
    12560         return NULL;
    12561     }
    12562 
    12563     psFree(popped);
    12564 
    12565     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    12566     if (!status) {
    12567         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    12568         psFree(row);
    12569         return false;
    12570     }
    12571     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    12572     if (!status) {
    12573         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    12574         psFree(row);
    12575         return false;
    12576     }
    12577     *p3_version = psMetadataLookupS32(&status, row, "p3_version");
    12578     if (!status) {
    12579         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    12580         psFree(row);
    12581         return false;
    12582     }
    12583 
    12584     psFree(row);
    12585 
    12586     return true;
    12587 }
    12588 
    125899056bool p3PendingExpInsertObject(psDB *dbh, p3PendingExpRow *object)
    125909057{
    … …  
    126019068
    126029069    return true;
    12603 }
    12604 
    12605 p3PendingExpRow *p3PendingExpPopObject(psDB *dbh)
    12606 {
    12607     char            exp_tag[256];
    12608     psS32           p2_version;
    12609     psS32           p3_version;
    12610 
    12611     if (!p3PendingExpPop(dbh, (char **)&exp_tag, &p2_version, &p3_version)) {
    12612         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    12613         return NULL;
    12614     }
    12615 
    12616     return p3PendingExpRowAlloc(exp_tag, p2_version, p3_version);
    126179070}
    126189071
    … …  
    126529105}
    126539106
    12654 bool p3PendingExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    12655 {
    12656     char            query[MAX_STRING_LENGTH];
    12657 
    12658     if (!p3PendingExpSelectRowsFits(dbh, fits, NULL, limit)) {
    12659         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    12660         return false;
    12661     }
    12662 
    12663     // remove limit rows from the end of the database
    12664     if (snprintf(query, MAX_STRING_LENGTH,
    12665                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    12666                 P3PENDINGEXP_TABLE_NAME, P3PENDINGEXP_INDEX_NAME, limit) < 0) {
    12667         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    12668         return false;
    12669     }
    12670            
    12671     if (!p_psDBRunQuery(dbh, query)) {
    12672         psError(PS_ERR_UNKNOWN, false, "database query failed");
    12673         return false;
    12674     }
    12675 
    12676     return true;
    12677 }
    12678 
    126799107bool p3PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    126809108{
    126819109    psArray         *rowSet;
    12682     psU64           i;
    126839110
    126849111    rowSet = psDBSelectRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit);
    126859112    if (!rowSet) {
    126869113        return false;
    12687     }
    12688 
    12689     // strip index column
    12690     for (i = 0; i < rowSet->n; i++) {
    12691         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P3PENDINGEXP_INDEX_NAME)) {
    12692             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PENDINGEXP_INDEX_NAME);
    12693             psFree(rowSet);
    12694             return false;
    12695         }
    126969114    }
    126979115
    … …  
    127669184    if (!rowSet) {
    127679185        return NULL;
    12768     }
    12769 
    12770     // strip index column
    12771     for (i = 0; i < rowSet->n; i++) {
    12772         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P3PENDINGEXP_INDEX_NAME)) {
    12773             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PENDINGEXP_INDEX_NAME);
    12774             psFree(rowSet);
    12775             return false;
    12776         }
    127779186    }
    127789187
    … …  
    129039312
    129049313    md = psMetadataAlloc();
    12905     if (!psMetadataAdd(md, PS_LIST_TAIL, P3PROCESSEDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    12906         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", P3PROCESSEDEXP_INDEX_NAME);
    12907         psFree(md);
    12908         return false;
    12909     }
    129109314    if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, "Primary Key", "64")) {
    129119315        psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag");
    … …  
    130989502    return deleted;
    130999503}
    13100 bool p3ProcessedExpPop(psDB *dbh, char **exp_tag, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, psF32 *sigma_ra, psF32 *sigma_dec, psS32 *nastro, char **b1_uri, char **b2_uri, psF32 *zp_mean, psF32 *zp_stdev, psS32 *p2_version, psS32 *p3_version)
    13101 {
    13102     psArray         *rowSet;
    13103     psMetadata      *row;
    13104     psMetadata      *popped;
    13105     long            deleted;
    13106     bool            status;
    13107     int             rowID;
    13108 
    13109     rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, NULL, 1);
    13110     if (!rowSet) {
    13111         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PROCESSEDEXP_INDEX_NAME);
    13112         psFree(rowSet);
    13113         return NULL;
    13114     }
    13115 
    13116     row = psArrayGet(rowSet, 0);
    13117     psMemIncrRefCounter(row);
    13118     if (!row) {
    13119         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    13120         return NULL;
    13121     }
    13122     psFree(rowSet);
    13123 
    13124     rowID = psMetadataLookupS32(&status, row, P3PROCESSEDEXP_INDEX_NAME);
    13125     if (!status) {
    13126         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", P3PROCESSEDEXP_INDEX_NAME);
    13127         psFree(row);
    13128         return NULL;
    13129     }
    13130 
    13131     popped = psMetadataAlloc();
    13132     psMetadataAddS32(popped, PS_LIST_TAIL, P3PROCESSEDEXP_INDEX_NAME, 0, NULL, rowID);
    13133 
    13134     deleted = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, popped, 0);
    13135     if (deleted != 1) {
    13136         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    13137         psFree(popped);
    13138         psFree(row);
    13139         return NULL;
    13140     }
    13141 
    13142     psFree(popped);
    13143 
    13144     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    13145     if (!status) {
    13146         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    13147         psFree(row);
    13148         return false;
    13149     }
    13150     *uri = psMetadataLookupPtr(&status, row, "uri");
    13151     if (!status) {
    13152         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    13153         psFree(row);
    13154         return false;
    13155     }
    13156     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    13157     if (!status) {
    13158         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    13159         psFree(row);
    13160         return false;
    13161     }
    13162     *bg = psMetadataLookupF64(&status, row, "bg");
    13163     if (!status) {
    13164         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    13165         psFree(row);
    13166         return false;
    13167     }
    13168     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    13169     if (!status) {
    13170         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    13171         psFree(row);
    13172         return false;
    13173     }
    13174     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    13175     if (!status) {
    13176         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    13177         psFree(row);
    13178         return false;
    13179     }
    13180     *sigma_ra = psMetadataLookupF32(&status, row, "sigma_ra");
    13181     if (!status) {
    13182         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra");
    13183         psFree(row);
    13184         return false;
    13185     }
    13186     *sigma_dec = psMetadataLookupF32(&status, row, "sigma_dec");
    13187     if (!status) {
    13188         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec");
    13189         psFree(row);
    13190         return false;
    13191     }
    13192     *nastro = psMetadataLookupS32(&status, row, "nastro");
    13193     if (!status) {
    13194         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nastro");
    13195         psFree(row);
    13196         return false;
    13197     }
    13198     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    13199     if (!status) {
    13200         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    13201         psFree(row);
    13202         return false;
    13203     }
    13204     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    13205     if (!status) {
    13206         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    13207         psFree(row);
    13208         return false;
    13209     }
    13210     *zp_mean = psMetadataLookupF32(&status, row, "zp_mean");
    13211     if (!status) {
    13212         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_mean");
    13213         psFree(row);
    13214         return false;
    13215     }
    13216     *zp_stdev = psMetadataLookupF32(&status, row, "zp_stdev");
    13217     if (!status) {
    13218         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_stdev");
    13219         psFree(row);
    13220         return false;
    13221     }
    13222     *p2_version = psMetadataLookupS32(&status, row, "p2_version");
    13223     if (!status) {
    13224         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version");
    13225         psFree(row);
    13226         return false;
    13227     }
    13228     *p3_version = psMetadataLookupS32(&status, row, "p3_version");
    13229     if (!status) {
    13230         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version");
    13231         psFree(row);
    13232         return false;
    13233     }
    13234 
    13235     psFree(row);
    13236 
    13237     return true;
    13238 }
    13239 
    132409504bool p3ProcessedExpInsertObject(psDB *dbh, p3ProcessedExpRow *object)
    132419505{
    … …  
    132529516
    132539517    return true;
    13254 }
    13255 
    13256 p3ProcessedExpRow *p3ProcessedExpPopObject(psDB *dbh)
    13257 {
    13258     char            exp_tag[256];
    13259     char            uri[256];
    13260     char            recipe[256];
    13261     psF64           bg;
    13262     psF64           bg_stdev;
    13263     psF64           bg_mean_stdev;
    13264     psF32           sigma_ra;
    13265     psF32           sigma_dec;
    13266     psS32           nastro;
    13267     char            b1_uri[256];
    13268     char            b2_uri[256];
    13269     psF32           zp_mean;
    13270     psF32           zp_stdev;
    13271     psS32           p2_version;
    13272     psS32           p3_version;
    13273 
    13274     if (!p3ProcessedExpPop(dbh, (char **)&exp_tag, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, &sigma_ra, &sigma_dec, &nastro, (char **)&b1_uri, (char **)&b2_uri, &zp_mean, &zp_stdev, &p2_version, &p3_version)) {
    13275         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    13276         return NULL;
    13277     }
    13278 
    13279     return p3ProcessedExpRowAlloc(exp_tag, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, zp_mean, zp_stdev, p2_version, p3_version);
    132809518}
    132819519
    … …  
    133159553}
    133169554
    13317 bool p3ProcessedExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    13318 {
    13319     char            query[MAX_STRING_LENGTH];
    13320 
    13321     if (!p3ProcessedExpSelectRowsFits(dbh, fits, NULL, limit)) {
    13322         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    13323         return false;
    13324     }
    13325 
    13326     // remove limit rows from the end of the database
    13327     if (snprintf(query, MAX_STRING_LENGTH,
    13328                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    13329                 P3PROCESSEDEXP_TABLE_NAME, P3PROCESSEDEXP_INDEX_NAME, limit) < 0) {
    13330         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    13331         return false;
    13332     }
    13333            
    13334     if (!p_psDBRunQuery(dbh, query)) {
    13335         psError(PS_ERR_UNKNOWN, false, "database query failed");
    13336         return false;
    13337     }
    13338 
    13339     return true;
    13340 }
    13341 
    133429555bool p3ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    133439556{
    133449557    psArray         *rowSet;
    13345     psU64           i;
    133469558
    133479559    rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit);
    133489560    if (!rowSet) {
    133499561        return false;
    13350     }
    13351 
    13352     // strip index column
    13353     for (i = 0; i < rowSet->n; i++) {
    13354         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, P3PROCESSEDEXP_INDEX_NAME)) {
    13355             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PROCESSEDEXP_INDEX_NAME);
    13356             psFree(rowSet);
    13357             return false;
    13358         }
    133599562    }
    133609563
    … …  
    135639766    }
    135649767
    13565     // strip index column
    13566     for (i = 0; i < rowSet->n; i++) {
    13567         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, P3PROCESSEDEXP_INDEX_NAME)) {
    13568             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", P3PROCESSEDEXP_INDEX_NAME);
    13569             psFree(rowSet);
    13570             return false;
    13571         }
    13572     }
    13573 
    135749768    // convert psMetadata rows to row objects
    135759769
    … …  
    136579851static void detRunRowFree(detRunRow *object);
    136589852
    13659 detRunRow *detRunRowAlloc(psS32 iteration, const char *det_type, const char *state)
     9853detRunRow *detRunRowAlloc(psS32 det_id, psS32 iteration, const char *det_type, const char *state)
    136609854{
    136619855    detRunRow       *_object;
    … …  
    136649858    psMemSetDeallocator(_object, (psFreeFunc)detRunRowFree);
    136659859
     9860    _object->det_id = det_id;
    136669861    _object->iteration = iteration;
    136679862    _object->det_type = psStringCopy(det_type);
    … …  
    136839878
    136849879    md = psMetadataAlloc();
    13685     if (!psMetadataAdd(md, PS_LIST_TAIL, DETRUN_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    13686         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETRUN_INDEX_NAME);
     9880    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key AUTO_INCREMENT", 0)) {
     9881        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    136879882        psFree(md);
    136889883        return false;
    … …  
    137169911}
    137179912
    13718 bool detRunInsert(psDB * dbh, psS32 iteration, const char *det_type, const char *state)
     9913bool detRunInsert(psDB * dbh, psS32 det_id, psS32 iteration, const char *det_type, const char *state)
    137199914{
    137209915    psMetadata      *md;
    … …  
    137229917
    137239918    md = psMetadataAlloc();
     9919    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, det_id)) {
     9920        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
     9921        psFree(md);
     9922        return false;
     9923    }
    137249924    if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, iteration)) {
    137259925        psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    … …  
    137589958    return deleted;
    137599959}
    13760 bool detRunPop(psDB *dbh, psS32 *iteration, char **det_type, char **state)
    13761 {
    13762     psArray         *rowSet;
    13763     psMetadata      *row;
    13764     psMetadata      *popped;
    13765     long            deleted;
    13766     bool            status;
    13767     int             rowID;
    13768 
    13769     rowSet = psDBSelectRows(dbh, DETRUN_TABLE_NAME, NULL, 1);
    13770     if (!rowSet) {
    13771         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRUN_INDEX_NAME);
    13772         psFree(rowSet);
    13773         return NULL;
    13774     }
    13775 
    13776     row = psArrayGet(rowSet, 0);
    13777     psMemIncrRefCounter(row);
    13778     if (!row) {
    13779         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    13780         return NULL;
    13781     }
    13782     psFree(rowSet);
    13783 
    13784     rowID = psMetadataLookupS32(&status, row, DETRUN_INDEX_NAME);
    13785     if (!status) {
    13786         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRUN_INDEX_NAME);
    13787         psFree(row);
    13788         return NULL;
    13789     }
    13790 
    13791     popped = psMetadataAlloc();
    13792     psMetadataAddS32(popped, PS_LIST_TAIL, DETRUN_INDEX_NAME, 0, NULL, rowID);
    13793 
    13794     deleted = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, popped, 0);
    13795     if (deleted != 1) {
    13796         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    13797         psFree(popped);
    13798         psFree(row);
    13799         return NULL;
    13800     }
    13801 
    13802     psFree(popped);
    13803 
    13804     *iteration = psMetadataLookupS32(&status, row, "iteration");
    13805     if (!status) {
    13806         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    13807         psFree(row);
    13808         return false;
    13809     }
    13810     *det_type = psMetadataLookupPtr(&status, row, "det_type");
    13811     if (!status) {
    13812         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_type");
    13813         psFree(row);
    13814         return false;
    13815     }
    13816     *state = psMetadataLookupPtr(&status, row, "state");
    13817     if (!status) {
    13818         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state");
    13819         psFree(row);
    13820         return false;
    13821     }
    13822 
    13823     psFree(row);
    13824 
    13825     return true;
    13826 }
    13827 
    138289960bool detRunInsertObject(psDB *dbh, detRunRow *object)
    138299961{
    13830     return detRunInsert(dbh, object->iteration, object->det_type, object->state);
     9962    return detRunInsert(dbh, object->det_id, object->iteration, object->det_type, object->state);
    138319963}
    138329964
    … …  
    138409972
    138419973    return true;
    13842 }
    13843 
    13844 detRunRow *detRunPopObject(psDB *dbh)
    13845 {
    13846     psS32           iteration;
    13847     char            det_type[256];
    13848     char            state[256];
    13849 
    13850     if (!detRunPop(dbh, &iteration, (char **)&det_type, (char **)&state)) {
    13851         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    13852         return NULL;
    13853     }
    13854 
    13855     return detRunRowAlloc(iteration, det_type, state);
    138569974}
    138579975
    … …  
    1389110009}
    1389210010
    13893 bool detRunPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    13894 {
    13895     char            query[MAX_STRING_LENGTH];
    13896 
    13897     if (!detRunSelectRowsFits(dbh, fits, NULL, limit)) {
    13898         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    13899         return false;
    13900     }
    13901 
    13902     // remove limit rows from the end of the database
    13903     if (snprintf(query, MAX_STRING_LENGTH,
    13904                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    13905                 DETRUN_TABLE_NAME, DETRUN_INDEX_NAME, limit) < 0) {
    13906         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    13907         return false;
    13908     }
    13909            
    13910     if (!p_psDBRunQuery(dbh, query)) {
    13911         psError(PS_ERR_UNKNOWN, false, "database query failed");
    13912         return false;
    13913     }
    13914 
    13915     return true;
    13916 }
    13917 
    1391810011bool detRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1391910012{
    1392010013    psArray         *rowSet;
    13921     psU64           i;
    1392210014
    1392310015    rowSet = psDBSelectRows(dbh, DETRUN_TABLE_NAME, where, limit);
    1392410016    if (!rowSet) {
    1392510017        return false;
    13926     }
    13927 
    13928     // strip index column
    13929     for (i = 0; i < rowSet->n; i++) {
    13930         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETRUN_INDEX_NAME)) {
    13931             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRUN_INDEX_NAME);
    13932             psFree(rowSet);
    13933             return false;
    13934         }
    1393510018    }
    1393610019
    … …  
    1395210035
    1395310036    md = psMetadataAlloc();
     10037    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, object->det_id)) {
     10038        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
     10039        psFree(md);
     10040        return NULL;
     10041    }
    1395410042    if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, object->iteration)) {
    1395510043        psError(PS_ERR_UNKNOWN, false, "failed to add item iteration");
    … …  
    1397410062{
    1397510063    bool            status;
     10064    psS32           det_id;
    1397610065    psS32           iteration;
    1397710066    char            *det_type;
    1397810067    char            *state;
    1397910068
     10069    det_id = psMetadataLookupS32(&status, md, "det_id");
     10070    if (!status) {
     10071        psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
     10072        return false;
     10073    }
    1398010074    iteration = psMetadataLookupS32(&status, md, "iteration");
    1398110075    if (!status) {
    … …  
    1399410088    }
    1399510089
    13996     return detRunRowAlloc(iteration, det_type, state);
     10090    return detRunRowAlloc(det_id, iteration, det_type, state);
    1399710091}
    1399810092psArray *detRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit)
    … …  
    1400510099    if (!rowSet) {
    1400610100        return NULL;
    14007     }
    14008 
    14009     // strip index column
    14010     for (i = 0; i < rowSet->n; i++) {
    14011         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETRUN_INDEX_NAME)) {
    14012             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRUN_INDEX_NAME);
    14013             psFree(rowSet);
    14014             return false;
    14015         }
    1401610101    }
    1401710102
    … …  
    1412710212
    1412810213    md = psMetadataAlloc();
    14129     if (!psMetadataAdd(md, PS_LIST_TAIL, DETINPUTEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    14130         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETINPUTEXP_INDEX_NAME);
    14131         psFree(md);
    14132         return false;
    14133     }
    1413410214    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1413510215        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1421210292    return deleted;
    1421310293}
    14214 bool detInputExpPop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **exp_tag, bool *include)
    14215 {
    14216     psArray         *rowSet;
    14217     psMetadata      *row;
    14218     psMetadata      *popped;
    14219     long            deleted;
    14220     bool            status;
    14221     int             rowID;
    14222 
    14223     rowSet = psDBSelectRows(dbh, DETINPUTEXP_TABLE_NAME, NULL, 1);
    14224     if (!rowSet) {
    14225         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETINPUTEXP_INDEX_NAME);
    14226         psFree(rowSet);
    14227         return NULL;
    14228     }
    14229 
    14230     row = psArrayGet(rowSet, 0);
    14231     psMemIncrRefCounter(row);
    14232     if (!row) {
    14233         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    14234         return NULL;
    14235     }
    14236     psFree(rowSet);
    14237 
    14238     rowID = psMetadataLookupS32(&status, row, DETINPUTEXP_INDEX_NAME);
    14239     if (!status) {
    14240         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETINPUTEXP_INDEX_NAME);
    14241         psFree(row);
    14242         return NULL;
    14243     }
    14244 
    14245     popped = psMetadataAlloc();
    14246     psMetadataAddS32(popped, PS_LIST_TAIL, DETINPUTEXP_INDEX_NAME, 0, NULL, rowID);
    14247 
    14248     deleted = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, popped, 0);
    14249     if (deleted != 1) {
    14250         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    14251         psFree(popped);
    14252         psFree(row);
    14253         return NULL;
    14254     }
    14255 
    14256     psFree(popped);
    14257 
    14258     *det_id = psMetadataLookupS32(&status, row, "det_id");
    14259     if (!status) {
    14260         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    14261         psFree(row);
    14262         return false;
    14263     }
    14264     *iteration = psMetadataLookupS32(&status, row, "iteration");
    14265     if (!status) {
    14266         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    14267         psFree(row);
    14268         return false;
    14269     }
    14270     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    14271     if (!status) {
    14272         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    14273         psFree(row);
    14274         return false;
    14275     }
    14276     *include = psMetadataLookupBool(&status, row, "include");
    14277     if (!status) {
    14278         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item include");
    14279         psFree(row);
    14280         return false;
    14281     }
    14282 
    14283     psFree(row);
    14284 
    14285     return true;
    14286 }
    14287 
    1428810294bool detInputExpInsertObject(psDB *dbh, detInputExpRow *object)
    1428910295{
    … …  
    1430010306
    1430110307    return true;
    14302 }
    14303 
    14304 detInputExpRow *detInputExpPopObject(psDB *dbh)
    14305 {
    14306     psS32           det_id;
    14307     psS32           iteration;
    14308     char            exp_tag[256];
    14309     bool            include;
    14310 
    14311     if (!detInputExpPop(dbh, &det_id, &iteration, (char **)&exp_tag, &include)) {
    14312         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    14313         return NULL;
    14314     }
    14315 
    14316     return detInputExpRowAlloc(det_id, iteration, exp_tag, include);
    1431710308}
    1431810309
    … …  
    1435210343}
    1435310344
    14354 bool detInputExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    14355 {
    14356     char            query[MAX_STRING_LENGTH];
    14357 
    14358     if (!detInputExpSelectRowsFits(dbh, fits, NULL, limit)) {
    14359         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    14360         return false;
    14361     }
    14362 
    14363     // remove limit rows from the end of the database
    14364     if (snprintf(query, MAX_STRING_LENGTH,
    14365                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    14366                 DETINPUTEXP_TABLE_NAME, DETINPUTEXP_INDEX_NAME, limit) < 0) {
    14367         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    14368         return false;
    14369     }
    14370            
    14371     if (!p_psDBRunQuery(dbh, query)) {
    14372         psError(PS_ERR_UNKNOWN, false, "database query failed");
    14373         return false;
    14374     }
    14375 
    14376     return true;
    14377 }
    14378 
    1437910345bool detInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1438010346{
    1438110347    psArray         *rowSet;
    14382     psU64           i;
    1438310348
    1438410349    rowSet = psDBSelectRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit);
    1438510350    if (!rowSet) {
    1438610351        return false;
    14387     }
    14388 
    14389     // strip index column
    14390     for (i = 0; i < rowSet->n; i++) {
    14391         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETINPUTEXP_INDEX_NAME)) {
    14392             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETINPUTEXP_INDEX_NAME);
    14393             psFree(rowSet);
    14394             return false;
    14395         }
    1439610352    }
    1439710353
    … …  
    1447710433    if (!rowSet) {
    1447810434        return NULL;
    14479     }
    14480 
    14481     // strip index column
    14482     for (i = 0; i < rowSet->n; i++) {
    14483         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETINPUTEXP_INDEX_NAME)) {
    14484             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETINPUTEXP_INDEX_NAME);
    14485             psFree(rowSet);
    14486             return false;
    14487         }
    1448810435    }
    1448910436
    … …  
    1461010557
    1461110558    md = psMetadataAlloc();
    14612     if (!psMetadataAdd(md, PS_LIST_TAIL, DETPROCESSEDIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    14613         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETPROCESSEDIMFILE_INDEX_NAME);
    14614         psFree(md);
    14615         return false;
    14616     }
    1461710559    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1461810560        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1475510697    return deleted;
    1475610698}
    14757 bool detProcessedImfilePop(psDB *dbh, psS32 *det_id, char **exp_tag, char **class_id, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri)
    14758 {
    14759     psArray         *rowSet;
    14760     psMetadata      *row;
    14761     psMetadata      *popped;
    14762     long            deleted;
    14763     bool            status;
    14764     int             rowID;
    14765 
    14766     rowSet = psDBSelectRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, NULL, 1);
    14767     if (!rowSet) {
    14768         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETPROCESSEDIMFILE_INDEX_NAME);
    14769         psFree(rowSet);
    14770         return NULL;
    14771     }
    14772 
    14773     row = psArrayGet(rowSet, 0);
    14774     psMemIncrRefCounter(row);
    14775     if (!row) {
    14776         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    14777         return NULL;
    14778     }
    14779     psFree(rowSet);
    14780 
    14781     rowID = psMetadataLookupS32(&status, row, DETPROCESSEDIMFILE_INDEX_NAME);
    14782     if (!status) {
    14783         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETPROCESSEDIMFILE_INDEX_NAME);
    14784         psFree(row);
    14785         return NULL;
    14786     }
    14787 
    14788     popped = psMetadataAlloc();
    14789     psMetadataAddS32(popped, PS_LIST_TAIL, DETPROCESSEDIMFILE_INDEX_NAME, 0, NULL, rowID);
    14790 
    14791     deleted = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, popped, 0);
    14792     if (deleted != 1) {
    14793         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    14794         psFree(popped);
    14795         psFree(row);
    14796         return NULL;
    14797     }
    14798 
    14799     psFree(popped);
    14800 
    14801     *det_id = psMetadataLookupS32(&status, row, "det_id");
    14802     if (!status) {
    14803         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    14804         psFree(row);
    14805         return false;
    14806     }
    14807     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    14808     if (!status) {
    14809         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    14810         psFree(row);
    14811         return false;
    14812     }
    14813     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    14814     if (!status) {
    14815         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    14816         psFree(row);
    14817         return false;
    14818     }
    14819     *uri = psMetadataLookupPtr(&status, row, "uri");
    14820     if (!status) {
    14821         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    14822         psFree(row);
    14823         return false;
    14824     }
    14825     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    14826     if (!status) {
    14827         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    14828         psFree(row);
    14829         return false;
    14830     }
    14831     *bg = psMetadataLookupF64(&status, row, "bg");
    14832     if (!status) {
    14833         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    14834         psFree(row);
    14835         return false;
    14836     }
    14837     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    14838     if (!status) {
    14839         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    14840         psFree(row);
    14841         return false;
    14842     }
    14843     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    14844     if (!status) {
    14845         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    14846         psFree(row);
    14847         return false;
    14848     }
    14849     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    14850     if (!status) {
    14851         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    14852         psFree(row);
    14853         return false;
    14854     }
    14855     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    14856     if (!status) {
    14857         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    14858         psFree(row);
    14859         return false;
    14860     }
    14861 
    14862     psFree(row);
    14863 
    14864     return true;
    14865 }
    14866 
    1486710699bool detProcessedImfileInsertObject(psDB *dbh, detProcessedImfileRow *object)
    1486810700{
    … …  
    1487910711
    1488010712    return true;
    14881 }
    14882 
    14883 detProcessedImfileRow *detProcessedImfilePopObject(psDB *dbh)
    14884 {
    14885     psS32           det_id;
    14886     char            exp_tag[256];
    14887     char            class_id[256];
    14888     char            uri[256];
    14889     char            recipe[256];
    14890     psF64           bg;
    14891     psF64           bg_stdev;
    14892     psF64           bg_mean_stdev;
    14893     char            b1_uri[256];
    14894     char            b2_uri[256];
    14895 
    14896     if (!detProcessedImfilePop(dbh, &det_id, (char **)&exp_tag, (char **)&class_id, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri)) {
    14897         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    14898         return NULL;
    14899     }
    14900 
    14901     return detProcessedImfileRowAlloc(det_id, exp_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri);
    1490210713}
    1490310714
    … …  
    1493710748}
    1493810749
    14939 bool detProcessedImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    14940 {
    14941     char            query[MAX_STRING_LENGTH];
    14942 
    14943     if (!detProcessedImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    14944         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    14945         return false;
    14946     }
    14947 
    14948     // remove limit rows from the end of the database
    14949     if (snprintf(query, MAX_STRING_LENGTH,
    14950                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    14951                 DETPROCESSEDIMFILE_TABLE_NAME, DETPROCESSEDIMFILE_INDEX_NAME, limit) < 0) {
    14952         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    14953         return false;
    14954     }
    14955            
    14956     if (!p_psDBRunQuery(dbh, query)) {
    14957         psError(PS_ERR_UNKNOWN, false, "database query failed");
    14958         return false;
    14959     }
    14960 
    14961     return true;
    14962 }
    14963 
    1496410750bool detProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1496510751{
    1496610752    psArray         *rowSet;
    14967     psU64           i;
    1496810753
    1496910754    rowSet = psDBSelectRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit);
    1497010755    if (!rowSet) {
    1497110756        return false;
    14972     }
    14973 
    14974     // strip index column
    14975     for (i = 0; i < rowSet->n; i++) {
    14976         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETPROCESSEDIMFILE_INDEX_NAME)) {
    14977             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETPROCESSEDIMFILE_INDEX_NAME);
    14978             psFree(rowSet);
    14979             return false;
    14980         }
    1498110757    }
    1498210758
    … …  
    1512810904    if (!rowSet) {
    1512910905        return NULL;
    15130     }
    15131 
    15132     // strip index column
    15133     for (i = 0; i < rowSet->n; i++) {
    15134         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETPROCESSEDIMFILE_INDEX_NAME)) {
    15135             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETPROCESSEDIMFILE_INDEX_NAME);
    15136             psFree(rowSet);
    15137             return false;
    15138         }
    1513910906    }
    1514010907
    … …  
    1525711024
    1525811025    md = psMetadataAlloc();
    15259     if (!psMetadataAdd(md, PS_LIST_TAIL, DETPROCESSEDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    15260         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETPROCESSEDEXP_INDEX_NAME);
    15261         psFree(md);
    15262         return false;
    15263     }
    1526411026    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1526511027        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1538211144    return deleted;
    1538311145}
    15384 bool detProcessedExpPop(psDB *dbh, psS32 *det_id, char **exp_tag, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri)
    15385 {
    15386     psArray         *rowSet;
    15387     psMetadata      *row;
    15388     psMetadata      *popped;
    15389     long            deleted;
    15390     bool            status;
    15391     int             rowID;
    15392 
    15393     rowSet = psDBSelectRows(dbh, DETPROCESSEDEXP_TABLE_NAME, NULL, 1);
    15394     if (!rowSet) {
    15395         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETPROCESSEDEXP_INDEX_NAME);
    15396         psFree(rowSet);
    15397         return NULL;
    15398     }
    15399 
    15400     row = psArrayGet(rowSet, 0);
    15401     psMemIncrRefCounter(row);
    15402     if (!row) {
    15403         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    15404         return NULL;
    15405     }
    15406     psFree(rowSet);
    15407 
    15408     rowID = psMetadataLookupS32(&status, row, DETPROCESSEDEXP_INDEX_NAME);
    15409     if (!status) {
    15410         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETPROCESSEDEXP_INDEX_NAME);
    15411         psFree(row);
    15412         return NULL;
    15413     }
    15414 
    15415     popped = psMetadataAlloc();
    15416     psMetadataAddS32(popped, PS_LIST_TAIL, DETPROCESSEDEXP_INDEX_NAME, 0, NULL, rowID);
    15417 
    15418     deleted = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, popped, 0);
    15419     if (deleted != 1) {
    15420         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    15421         psFree(popped);
    15422         psFree(row);
    15423         return NULL;
    15424     }
    15425 
    15426     psFree(popped);
    15427 
    15428     *det_id = psMetadataLookupS32(&status, row, "det_id");
    15429     if (!status) {
    15430         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    15431         psFree(row);
    15432         return false;
    15433     }
    15434     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    15435     if (!status) {
    15436         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    15437         psFree(row);
    15438         return false;
    15439     }
    15440     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    15441     if (!status) {
    15442         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    15443         psFree(row);
    15444         return false;
    15445     }
    15446     *bg = psMetadataLookupF64(&status, row, "bg");
    15447     if (!status) {
    15448         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    15449         psFree(row);
    15450         return false;
    15451     }
    15452     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    15453     if (!status) {
    15454         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    15455         psFree(row);
    15456         return false;
    15457     }
    15458     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    15459     if (!status) {
    15460         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    15461         psFree(row);
    15462         return false;
    15463     }
    15464     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    15465     if (!status) {
    15466         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    15467         psFree(row);
    15468         return false;
    15469     }
    15470     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    15471     if (!status) {
    15472         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    15473         psFree(row);
    15474         return false;
    15475     }
    15476 
    15477     psFree(row);
    15478 
    15479     return true;
    15480 }
    15481 
    1548211146bool detProcessedExpInsertObject(psDB *dbh, detProcessedExpRow *object)
    1548311147{
    … …  
    1549411158
    1549511159    return true;
    15496 }
    15497 
    15498 detProcessedExpRow *detProcessedExpPopObject(psDB *dbh)
    15499 {
    15500     psS32           det_id;
    15501     char            exp_tag[256];
    15502     char            recipe[256];
    15503     psF64           bg;
    15504     psF64           bg_stdev;
    15505     psF64           bg_mean_stdev;
    15506     char            b1_uri[256];
    15507     char            b2_uri[256];
    15508 
    15509     if (!detProcessedExpPop(dbh, &det_id, (char **)&exp_tag, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri)) {
    15510         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    15511         return NULL;
    15512     }
    15513 
    15514     return detProcessedExpRowAlloc(det_id, exp_tag, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri);
    1551511160}
    1551611161
    … …  
    1555011195}
    1555111196
    15552 bool detProcessedExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    15553 {
    15554     char            query[MAX_STRING_LENGTH];
    15555 
    15556     if (!detProcessedExpSelectRowsFits(dbh, fits, NULL, limit)) {
    15557         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    15558         return false;
    15559     }
    15560 
    15561     // remove limit rows from the end of the database
    15562     if (snprintf(query, MAX_STRING_LENGTH,
    15563                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    15564                 DETPROCESSEDEXP_TABLE_NAME, DETPROCESSEDEXP_INDEX_NAME, limit) < 0) {
    15565         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    15566         return false;
    15567     }
    15568            
    15569     if (!p_psDBRunQuery(dbh, query)) {
    15570         psError(PS_ERR_UNKNOWN, false, "database query failed");
    15571         return false;
    15572     }
    15573 
    15574     return true;
    15575 }
    15576 
    1557711197bool detProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1557811198{
    1557911199    psArray         *rowSet;
    15580     psU64           i;
    1558111200
    1558211201    rowSet = psDBSelectRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit);
    1558311202    if (!rowSet) {
    1558411203        return false;
    15585     }
    15586 
    15587     // strip index column
    15588     for (i = 0; i < rowSet->n; i++) {
    15589         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETPROCESSEDEXP_INDEX_NAME)) {
    15590             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETPROCESSEDEXP_INDEX_NAME);
    15591             psFree(rowSet);
    15592             return false;
    15593         }
    1559411204    }
    1559511205
    … …  
    1571911329    if (!rowSet) {
    1572011330        return NULL;
    15721     }
    15722 
    15723     // strip index column
    15724     for (i = 0; i < rowSet->n; i++) {
    15725         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETPROCESSEDEXP_INDEX_NAME)) {
    15726             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETPROCESSEDEXP_INDEX_NAME);
    15727             psFree(rowSet);
    15728             return false;
    15729         }
    1573011331    }
    1573111332
    … …  
    1584711448
    1584811449    md = psMetadataAlloc();
    15849     if (!psMetadataAdd(md, PS_LIST_TAIL, DETSTACKEDIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    15850         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETSTACKEDIMFILE_INDEX_NAME);
    15851         psFree(md);
    15852         return false;
    15853     }
    1585411450    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1585511451        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1597211568    return deleted;
    1597311569}
    15974 bool detStackedImfilePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **class_id, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev)
    15975 {
    15976     psArray         *rowSet;
    15977     psMetadata      *row;
    15978     psMetadata      *popped;
    15979     long            deleted;
    15980     bool            status;
    15981     int             rowID;
    15982 
    15983     rowSet = psDBSelectRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, NULL, 1);
    15984     if (!rowSet) {
    15985         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETSTACKEDIMFILE_INDEX_NAME);
    15986         psFree(rowSet);
    15987         return NULL;
    15988     }
    15989 
    15990     row = psArrayGet(rowSet, 0);
    15991     psMemIncrRefCounter(row);
    15992     if (!row) {
    15993         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    15994         return NULL;
    15995     }
    15996     psFree(rowSet);
    15997 
    15998     rowID = psMetadataLookupS32(&status, row, DETSTACKEDIMFILE_INDEX_NAME);
    15999     if (!status) {
    16000         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETSTACKEDIMFILE_INDEX_NAME);
    16001         psFree(row);
    16002         return NULL;
    16003     }
    16004 
    16005     popped = psMetadataAlloc();
    16006     psMetadataAddS32(popped, PS_LIST_TAIL, DETSTACKEDIMFILE_INDEX_NAME, 0, NULL, rowID);
    16007 
    16008     deleted = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, popped, 0);
    16009     if (deleted != 1) {
    16010         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    16011         psFree(popped);
    16012         psFree(row);
    16013         return NULL;
    16014     }
    16015 
    16016     psFree(popped);
    16017 
    16018     *det_id = psMetadataLookupS32(&status, row, "det_id");
    16019     if (!status) {
    16020         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    16021         psFree(row);
    16022         return false;
    16023     }
    16024     *iteration = psMetadataLookupS32(&status, row, "iteration");
    16025     if (!status) {
    16026         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    16027         psFree(row);
    16028         return false;
    16029     }
    16030     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    16031     if (!status) {
    16032         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    16033         psFree(row);
    16034         return false;
    16035     }
    16036     *uri = psMetadataLookupPtr(&status, row, "uri");
    16037     if (!status) {
    16038         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    16039         psFree(row);
    16040         return false;
    16041     }
    16042     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    16043     if (!status) {
    16044         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    16045         psFree(row);
    16046         return false;
    16047     }
    16048     *bg = psMetadataLookupF64(&status, row, "bg");
    16049     if (!status) {
    16050         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    16051         psFree(row);
    16052         return false;
    16053     }
    16054     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    16055     if (!status) {
    16056         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    16057         psFree(row);
    16058         return false;
    16059     }
    16060     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    16061     if (!status) {
    16062         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    16063         psFree(row);
    16064         return false;
    16065     }
    16066 
    16067     psFree(row);
    16068 
    16069     return true;
    16070 }
    16071 
    1607211570bool detStackedImfileInsertObject(psDB *dbh, detStackedImfileRow *object)
    1607311571{
    … …  
    1608411582
    1608511583    return true;
    16086 }
    16087 
    16088 detStackedImfileRow *detStackedImfilePopObject(psDB *dbh)
    16089 {
    16090     psS32           det_id;
    16091     psS32           iteration;
    16092     char            class_id[256];
    16093     char            uri[256];
    16094     char            recipe[256];
    16095     psF64           bg;
    16096     psF64           bg_stdev;
    16097     psF64           bg_mean_stdev;
    16098 
    16099     if (!detStackedImfilePop(dbh, &det_id, &iteration, (char **)&class_id, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev)) {
    16100         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    16101         return NULL;
    16102     }
    16103 
    16104     return detStackedImfileRowAlloc(det_id, iteration, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev);
    1610511584}
    1610611585
    … …  
    1614011619}
    1614111620
    16142 bool detStackedImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    16143 {
    16144     char            query[MAX_STRING_LENGTH];
    16145 
    16146     if (!detStackedImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    16147         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    16148         return false;
    16149     }
    16150 
    16151     // remove limit rows from the end of the database
    16152     if (snprintf(query, MAX_STRING_LENGTH,
    16153                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    16154                 DETSTACKEDIMFILE_TABLE_NAME, DETSTACKEDIMFILE_INDEX_NAME, limit) < 0) {
    16155         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    16156         return false;
    16157     }
    16158            
    16159     if (!p_psDBRunQuery(dbh, query)) {
    16160         psError(PS_ERR_UNKNOWN, false, "database query failed");
    16161         return false;
    16162     }
    16163 
    16164     return true;
    16165 }
    16166 
    1616711621bool detStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1616811622{
    1616911623    psArray         *rowSet;
    16170     psU64           i;
    1617111624
    1617211625    rowSet = psDBSelectRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit);
    1617311626    if (!rowSet) {
    1617411627        return false;
    16175     }
    16176 
    16177     // strip index column
    16178     for (i = 0; i < rowSet->n; i++) {
    16179         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETSTACKEDIMFILE_INDEX_NAME)) {
    16180             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETSTACKEDIMFILE_INDEX_NAME);
    16181             psFree(rowSet);
    16182             return false;
    16183         }
    1618411628    }
    1618511629
    … …  
    1630911753    if (!rowSet) {
    1631011754        return NULL;
    16311     }
    16312 
    16313     // strip index column
    16314     for (i = 0; i < rowSet->n; i++) {
    16315         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETSTACKEDIMFILE_INDEX_NAME)) {
    16316             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETSTACKEDIMFILE_INDEX_NAME);
    16317             psFree(rowSet);
    16318             return false;
    16319         }
    1632011755    }
    1632111756
    … …  
    1643111866
    1643211867    md = psMetadataAlloc();
    16433     if (!psMetadataAdd(md, PS_LIST_TAIL, DETNORMALIZEDSTATIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    16434         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16435         psFree(md);
    16436         return false;
    16437     }
    1643811868    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1643911869        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1651611946    return deleted;
    1651711947}
    16518 bool detNormalizedStatImfilePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **class_id, psF32 *norm)
    16519 {
    16520     psArray         *rowSet;
    16521     psMetadata      *row;
    16522     psMetadata      *popped;
    16523     long            deleted;
    16524     bool            status;
    16525     int             rowID;
    16526 
    16527     rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, NULL, 1);
    16528     if (!rowSet) {
    16529         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16530         psFree(rowSet);
    16531         return NULL;
    16532     }
    16533 
    16534     row = psArrayGet(rowSet, 0);
    16535     psMemIncrRefCounter(row);
    16536     if (!row) {
    16537         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    16538         return NULL;
    16539     }
    16540     psFree(rowSet);
    16541 
    16542     rowID = psMetadataLookupS32(&status, row, DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16543     if (!status) {
    16544         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16545         psFree(row);
    16546         return NULL;
    16547     }
    16548 
    16549     popped = psMetadataAlloc();
    16550     psMetadataAddS32(popped, PS_LIST_TAIL, DETNORMALIZEDSTATIMFILE_INDEX_NAME, 0, NULL, rowID);
    16551 
    16552     deleted = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, popped, 0);
    16553     if (deleted != 1) {
    16554         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    16555         psFree(popped);
    16556         psFree(row);
    16557         return NULL;
    16558     }
    16559 
    16560     psFree(popped);
    16561 
    16562     *det_id = psMetadataLookupS32(&status, row, "det_id");
    16563     if (!status) {
    16564         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    16565         psFree(row);
    16566         return false;
    16567     }
    16568     *iteration = psMetadataLookupS32(&status, row, "iteration");
    16569     if (!status) {
    16570         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    16571         psFree(row);
    16572         return false;
    16573     }
    16574     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    16575     if (!status) {
    16576         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    16577         psFree(row);
    16578         return false;
    16579     }
    16580     *norm = psMetadataLookupF32(&status, row, "norm");
    16581     if (!status) {
    16582         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item norm");
    16583         psFree(row);
    16584         return false;
    16585     }
    16586 
    16587     psFree(row);
    16588 
    16589     return true;
    16590 }
    16591 
    1659211948bool detNormalizedStatImfileInsertObject(psDB *dbh, detNormalizedStatImfileRow *object)
    1659311949{
    … …  
    1660411960
    1660511961    return true;
    16606 }
    16607 
    16608 detNormalizedStatImfileRow *detNormalizedStatImfilePopObject(psDB *dbh)
    16609 {
    16610     psS32           det_id;
    16611     psS32           iteration;
    16612     char            class_id[256];
    16613     psF32           norm;
    16614 
    16615     if (!detNormalizedStatImfilePop(dbh, &det_id, &iteration, (char **)&class_id, &norm)) {
    16616         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    16617         return NULL;
    16618     }
    16619 
    16620     return detNormalizedStatImfileRowAlloc(det_id, iteration, class_id, norm);
    1662111962}
    1662211963
    … …  
    1665611997}
    1665711998
    16658 bool detNormalizedStatImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    16659 {
    16660     char            query[MAX_STRING_LENGTH];
    16661 
    16662     if (!detNormalizedStatImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    16663         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    16664         return false;
    16665     }
    16666 
    16667     // remove limit rows from the end of the database
    16668     if (snprintf(query, MAX_STRING_LENGTH,
    16669                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    16670                 DETNORMALIZEDSTATIMFILE_TABLE_NAME, DETNORMALIZEDSTATIMFILE_INDEX_NAME, limit) < 0) {
    16671         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    16672         return false;
    16673     }
    16674            
    16675     if (!p_psDBRunQuery(dbh, query)) {
    16676         psError(PS_ERR_UNKNOWN, false, "database query failed");
    16677         return false;
    16678     }
    16679 
    16680     return true;
    16681 }
    16682 
    1668311999bool detNormalizedStatImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1668412000{
    1668512001    psArray         *rowSet;
    16686     psU64           i;
    1668712002
    1668812003    rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit);
    1668912004    if (!rowSet) {
    1669012005        return false;
    16691     }
    16692 
    16693     // strip index column
    16694     for (i = 0; i < rowSet->n; i++) {
    16695         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETNORMALIZEDSTATIMFILE_INDEX_NAME)) {
    16696             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16697             psFree(rowSet);
    16698             return false;
    16699         }
    1670012006    }
    1670112007
    … …  
    1678112087    if (!rowSet) {
    1678212088        return NULL;
    16783     }
    16784 
    16785     // strip index column
    16786     for (i = 0; i < rowSet->n; i++) {
    16787         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETNORMALIZEDSTATIMFILE_INDEX_NAME)) {
    16788             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDSTATIMFILE_INDEX_NAME);
    16789             psFree(rowSet);
    16790             return false;
    16791         }
    1679212089    }
    1679312090
    … …  
    1691112208
    1691212209    md = psMetadataAlloc();
    16913     if (!psMetadataAdd(md, PS_LIST_TAIL, DETNORMALIZEDIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    16914         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETNORMALIZEDIMFILE_INDEX_NAME);
    16915         psFree(md);
    16916         return false;
    16917     }
    1691812210    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1691912211        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1704612338    return deleted;
    1704712339}
    17048 bool detNormalizedImfilePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **class_id, char **uri, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri)
    17049 {
    17050     psArray         *rowSet;
    17051     psMetadata      *row;
    17052     psMetadata      *popped;
    17053     long            deleted;
    17054     bool            status;
    17055     int             rowID;
    17056 
    17057     rowSet = psDBSelectRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, NULL, 1);
    17058     if (!rowSet) {
    17059         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDIMFILE_INDEX_NAME);
    17060         psFree(rowSet);
    17061         return NULL;
    17062     }
    17063 
    17064     row = psArrayGet(rowSet, 0);
    17065     psMemIncrRefCounter(row);
    17066     if (!row) {
    17067         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    17068         return NULL;
    17069     }
    17070     psFree(rowSet);
    17071 
    17072     rowID = psMetadataLookupS32(&status, row, DETNORMALIZEDIMFILE_INDEX_NAME);
    17073     if (!status) {
    17074         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDIMFILE_INDEX_NAME);
    17075         psFree(row);
    17076         return NULL;
    17077     }
    17078 
    17079     popped = psMetadataAlloc();
    17080     psMetadataAddS32(popped, PS_LIST_TAIL, DETNORMALIZEDIMFILE_INDEX_NAME, 0, NULL, rowID);
    17081 
    17082     deleted = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, popped, 0);
    17083     if (deleted != 1) {
    17084         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    17085         psFree(popped);
    17086         psFree(row);
    17087         return NULL;
    17088     }
    17089 
    17090     psFree(popped);
    17091 
    17092     *det_id = psMetadataLookupS32(&status, row, "det_id");
    17093     if (!status) {
    17094         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    17095         psFree(row);
    17096         return false;
    17097     }
    17098     *iteration = psMetadataLookupS32(&status, row, "iteration");
    17099     if (!status) {
    17100         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    17101         psFree(row);
    17102         return false;
    17103     }
    17104     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    17105     if (!status) {
    17106         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    17107         psFree(row);
    17108         return false;
    17109     }
    17110     *uri = psMetadataLookupPtr(&status, row, "uri");
    17111     if (!status) {
    17112         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    17113         psFree(row);
    17114         return false;
    17115     }
    17116     *bg = psMetadataLookupF64(&status, row, "bg");
    17117     if (!status) {
    17118         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    17119         psFree(row);
    17120         return false;
    17121     }
    17122     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    17123     if (!status) {
    17124         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    17125         psFree(row);
    17126         return false;
    17127     }
    17128     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    17129     if (!status) {
    17130         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    17131         psFree(row);
    17132         return false;
    17133     }
    17134     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    17135     if (!status) {
    17136         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    17137         psFree(row);
    17138         return false;
    17139     }
    17140     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    17141     if (!status) {
    17142         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    17143         psFree(row);
    17144         return false;
    17145     }
    17146 
    17147     psFree(row);
    17148 
    17149     return true;
    17150 }
    17151 
    1715212340bool detNormalizedImfileInsertObject(psDB *dbh, detNormalizedImfileRow *object)
    1715312341{
    … …  
    1716412352
    1716512353    return true;
    17166 }
    17167 
    17168 detNormalizedImfileRow *detNormalizedImfilePopObject(psDB *dbh)
    17169 {
    17170     psS32           det_id;
    17171     psS32           iteration;
    17172     char            class_id[256];
    17173     char            uri[256];
    17174     psF64           bg;
    17175     psF64           bg_stdev;
    17176     psF64           bg_mean_stdev;
    17177     char            b1_uri[256];
    17178     char            b2_uri[256];
    17179 
    17180     if (!detNormalizedImfilePop(dbh, &det_id, &iteration, (char **)&class_id, (char **)&uri, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri)) {
    17181         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    17182         return NULL;
    17183     }
    17184 
    17185     return detNormalizedImfileRowAlloc(det_id, iteration, class_id, uri, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri);
    1718612354}
    1718712355
    … …  
    1722112389}
    1722212390
    17223 bool detNormalizedImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    17224 {
    17225     char            query[MAX_STRING_LENGTH];
    17226 
    17227     if (!detNormalizedImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    17228         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    17229         return false;
    17230     }
    17231 
    17232     // remove limit rows from the end of the database
    17233     if (snprintf(query, MAX_STRING_LENGTH,
    17234                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    17235                 DETNORMALIZEDIMFILE_TABLE_NAME, DETNORMALIZEDIMFILE_INDEX_NAME, limit) < 0) {
    17236         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    17237         return false;
    17238     }
    17239            
    17240     if (!p_psDBRunQuery(dbh, query)) {
    17241         psError(PS_ERR_UNKNOWN, false, "database query failed");
    17242         return false;
    17243     }
    17244 
    17245     return true;
    17246 }
    17247 
    1724812391bool detNormalizedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1724912392{
    1725012393    psArray         *rowSet;
    17251     psU64           i;
    1725212394
    1725312395    rowSet = psDBSelectRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit);
    1725412396    if (!rowSet) {
    1725512397        return false;
    17256     }
    17257 
    17258     // strip index column
    17259     for (i = 0; i < rowSet->n; i++) {
    17260         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETNORMALIZEDIMFILE_INDEX_NAME)) {
    17261             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDIMFILE_INDEX_NAME);
    17262             psFree(rowSet);
    17263             return false;
    17264         }
    1726512398    }
    1726612399
    … …  
    1740112534    if (!rowSet) {
    1740212535        return NULL;
    17403     }
    17404 
    17405     // strip index column
    17406     for (i = 0; i < rowSet->n; i++) {
    17407         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETNORMALIZEDIMFILE_INDEX_NAME)) {
    17408             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDIMFILE_INDEX_NAME);
    17409             psFree(rowSet);
    17410             return false;
    17411         }
    1741212536    }
    1741312537
    … …  
    1752912653
    1753012654    md = psMetadataAlloc();
    17531     if (!psMetadataAdd(md, PS_LIST_TAIL, DETNORMALIZEDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    17532         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETNORMALIZEDEXP_INDEX_NAME);
    17533         psFree(md);
    17534         return false;
    17535     }
    1753612655    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1753712656        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1765412773    return deleted;
    1765512774}
    17656 bool detNormalizedExpPop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri)
    17657 {
    17658     psArray         *rowSet;
    17659     psMetadata      *row;
    17660     psMetadata      *popped;
    17661     long            deleted;
    17662     bool            status;
    17663     int             rowID;
    17664 
    17665     rowSet = psDBSelectRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, NULL, 1);
    17666     if (!rowSet) {
    17667         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDEXP_INDEX_NAME);
    17668         psFree(rowSet);
    17669         return NULL;
    17670     }
    17671 
    17672     row = psArrayGet(rowSet, 0);
    17673     psMemIncrRefCounter(row);
    17674     if (!row) {
    17675         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    17676         return NULL;
    17677     }
    17678     psFree(rowSet);
    17679 
    17680     rowID = psMetadataLookupS32(&status, row, DETNORMALIZEDEXP_INDEX_NAME);
    17681     if (!status) {
    17682         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETNORMALIZEDEXP_INDEX_NAME);
    17683         psFree(row);
    17684         return NULL;
    17685     }
    17686 
    17687     popped = psMetadataAlloc();
    17688     psMetadataAddS32(popped, PS_LIST_TAIL, DETNORMALIZEDEXP_INDEX_NAME, 0, NULL, rowID);
    17689 
    17690     deleted = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, popped, 0);
    17691     if (deleted != 1) {
    17692         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    17693         psFree(popped);
    17694         psFree(row);
    17695         return NULL;
    17696     }
    17697 
    17698     psFree(popped);
    17699 
    17700     *det_id = psMetadataLookupS32(&status, row, "det_id");
    17701     if (!status) {
    17702         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    17703         psFree(row);
    17704         return false;
    17705     }
    17706     *iteration = psMetadataLookupS32(&status, row, "iteration");
    17707     if (!status) {
    17708         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    17709         psFree(row);
    17710         return false;
    17711     }
    17712     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    17713     if (!status) {
    17714         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    17715         psFree(row);
    17716         return false;
    17717     }
    17718     *bg = psMetadataLookupF64(&status, row, "bg");
    17719     if (!status) {
    17720         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    17721         psFree(row);
    17722         return false;
    17723     }
    17724     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    17725     if (!status) {
    17726         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    17727         psFree(row);
    17728         return false;
    17729     }
    17730     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    17731     if (!status) {
    17732         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    17733         psFree(row);
    17734         return false;
    17735     }
    17736     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    17737     if (!status) {
    17738         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    17739         psFree(row);
    17740         return false;
    17741     }
    17742     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    17743     if (!status) {
    17744         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    17745         psFree(row);
    17746         return false;
    17747     }
    17748 
    17749     psFree(row);
    17750 
    17751     return true;
    17752 }
    17753 
    1775412775bool detNormalizedExpInsertObject(psDB *dbh, detNormalizedExpRow *object)
    1775512776{
    … …  
    1776612787
    1776712788    return true;
    17768 }
    17769 
    17770 detNormalizedExpRow *detNormalizedExpPopObject(psDB *dbh)
    17771 {
    17772     psS32           det_id;
    17773     psS32           iteration;
    17774     char            recipe[256];
    17775     psF64           bg;
    17776     psF64           bg_stdev;
    17777     psF64           bg_mean_stdev;
    17778     char            b1_uri[256];
    17779     char            b2_uri[256];
    17780 
    17781     if (!detNormalizedExpPop(dbh, &det_id, &iteration, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri)) {
    17782         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    17783         return NULL;
    17784     }
    17785 
    17786     return detNormalizedExpRowAlloc(det_id, iteration, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri);
    1778712789}
    1778812790
    … …  
    1782212824}
    1782312825
    17824 bool detNormalizedExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    17825 {
    17826     char            query[MAX_STRING_LENGTH];
    17827 
    17828     if (!detNormalizedExpSelectRowsFits(dbh, fits, NULL, limit)) {
    17829         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    17830         return false;
    17831     }
    17832 
    17833     // remove limit rows from the end of the database
    17834     if (snprintf(query, MAX_STRING_LENGTH,
    17835                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    17836                 DETNORMALIZEDEXP_TABLE_NAME, DETNORMALIZEDEXP_INDEX_NAME, limit) < 0) {
    17837         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    17838         return false;
    17839     }
    17840            
    17841     if (!p_psDBRunQuery(dbh, query)) {
    17842         psError(PS_ERR_UNKNOWN, false, "database query failed");
    17843         return false;
    17844     }
    17845 
    17846     return true;
    17847 }
    17848 
    1784912826bool detNormalizedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1785012827{
    1785112828    psArray         *rowSet;
    17852     psU64           i;
    1785312829
    1785412830    rowSet = psDBSelectRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit);
    1785512831    if (!rowSet) {
    1785612832        return false;
    17857     }
    17858 
    17859     // strip index column
    17860     for (i = 0; i < rowSet->n; i++) {
    17861         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETNORMALIZEDEXP_INDEX_NAME)) {
    17862             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDEXP_INDEX_NAME);
    17863             psFree(rowSet);
    17864             return false;
    17865         }
    1786612833    }
    1786712834
    … …  
    1799112958    if (!rowSet) {
    1799212959        return NULL;
    17993     }
    17994 
    17995     // strip index column
    17996     for (i = 0; i < rowSet->n; i++) {
    17997         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETNORMALIZEDEXP_INDEX_NAME)) {
    17998             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETNORMALIZEDEXP_INDEX_NAME);
    17999             psFree(rowSet);
    18000             return false;
    18001         }
    1800212960    }
    1800312961
    … …  
    1811213070
    1811313071    md = psMetadataAlloc();
    18114     if (!psMetadataAdd(md, PS_LIST_TAIL, DETMASTERFRAME_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    18115         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETMASTERFRAME_INDEX_NAME);
    18116         psFree(md);
    18117         return false;
    18118     }
    1811913072    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1812013073        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1818713140    return deleted;
    1818813141}
    18189 bool detMasterFramePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **comment)
    18190 {
    18191     psArray         *rowSet;
    18192     psMetadata      *row;
    18193     psMetadata      *popped;
    18194     long            deleted;
    18195     bool            status;
    18196     int             rowID;
    18197 
    18198     rowSet = psDBSelectRows(dbh, DETMASTERFRAME_TABLE_NAME, NULL, 1);
    18199     if (!rowSet) {
    18200         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETMASTERFRAME_INDEX_NAME);
    18201         psFree(rowSet);
    18202         return NULL;
    18203     }
    18204 
    18205     row = psArrayGet(rowSet, 0);
    18206     psMemIncrRefCounter(row);
    18207     if (!row) {
    18208         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    18209         return NULL;
    18210     }
    18211     psFree(rowSet);
    18212 
    18213     rowID = psMetadataLookupS32(&status, row, DETMASTERFRAME_INDEX_NAME);
    18214     if (!status) {
    18215         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETMASTERFRAME_INDEX_NAME);
    18216         psFree(row);
    18217         return NULL;
    18218     }
    18219 
    18220     popped = psMetadataAlloc();
    18221     psMetadataAddS32(popped, PS_LIST_TAIL, DETMASTERFRAME_INDEX_NAME, 0, NULL, rowID);
    18222 
    18223     deleted = psDBDeleteRows(dbh, DETMASTERFRAME_TABLE_NAME, popped, 0);
    18224     if (deleted != 1) {
    18225         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    18226         psFree(popped);
    18227         psFree(row);
    18228         return NULL;
    18229     }
    18230 
    18231     psFree(popped);
    18232 
    18233     *det_id = psMetadataLookupS32(&status, row, "det_id");
    18234     if (!status) {
    18235         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    18236         psFree(row);
    18237         return false;
    18238     }
    18239     *iteration = psMetadataLookupS32(&status, row, "iteration");
    18240     if (!status) {
    18241         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    18242         psFree(row);
    18243         return false;
    18244     }
    18245     *comment = psMetadataLookupPtr(&status, row, "comment");
    18246     if (!status) {
    18247         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item comment");
    18248         psFree(row);
    18249         return false;
    18250     }
    18251 
    18252     psFree(row);
    18253 
    18254     return true;
    18255 }
    18256 
    1825713142bool detMasterFrameInsertObject(psDB *dbh, detMasterFrameRow *object)
    1825813143{
    … …  
    1826913154
    1827013155    return true;
    18271 }
    18272 
    18273 detMasterFrameRow *detMasterFramePopObject(psDB *dbh)
    18274 {
    18275     psS32           det_id;
    18276     psS32           iteration;
    18277     char            comment[256];
    18278 
    18279     if (!detMasterFramePop(dbh, &det_id, &iteration, (char **)&comment)) {
    18280         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    18281         return NULL;
    18282     }
    18283 
    18284     return detMasterFrameRowAlloc(det_id, iteration, comment);
    1828513156}
    1828613157
    … …  
    1832013191}
    1832113192
    18322 bool detMasterFramePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    18323 {
    18324     char            query[MAX_STRING_LENGTH];
    18325 
    18326     if (!detMasterFrameSelectRowsFits(dbh, fits, NULL, limit)) {
    18327         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    18328         return false;
    18329     }
    18330 
    18331     // remove limit rows from the end of the database
    18332     if (snprintf(query, MAX_STRING_LENGTH,
    18333                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    18334                 DETMASTERFRAME_TABLE_NAME, DETMASTERFRAME_INDEX_NAME, limit) < 0) {
    18335         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    18336         return false;
    18337     }
    18338            
    18339     if (!p_psDBRunQuery(dbh, query)) {
    18340         psError(PS_ERR_UNKNOWN, false, "database query failed");
    18341         return false;
    18342     }
    18343 
    18344     return true;
    18345 }
    18346 
    1834713193bool detMasterFrameSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1834813194{
    1834913195    psArray         *rowSet;
    18350     psU64           i;
    1835113196
    1835213197    rowSet = psDBSelectRows(dbh, DETMASTERFRAME_TABLE_NAME, where, limit);
    1835313198    if (!rowSet) {
    1835413199        return false;
    18355     }
    18356 
    18357     // strip index column
    18358     for (i = 0; i < rowSet->n; i++) {
    18359         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETMASTERFRAME_INDEX_NAME)) {
    18360             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETMASTERFRAME_INDEX_NAME);
    18361             psFree(rowSet);
    18362             return false;
    18363         }
    1836413200    }
    1836513201
    … …  
    1843413270    if (!rowSet) {
    1843513271        return NULL;
    18436     }
    18437 
    18438     // strip index column
    18439     for (i = 0; i < rowSet->n; i++) {
    18440         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETMASTERFRAME_INDEX_NAME)) {
    18441             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETMASTERFRAME_INDEX_NAME);
    18442             psFree(rowSet);
    18443             return false;
    18444         }
    1844513272    }
    1844613273
    … …  
    1855813385
    1855913386    md = psMetadataAlloc();
    18560     if (!psMetadataAdd(md, PS_LIST_TAIL, DETMASTERIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    18561         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETMASTERIMFILE_INDEX_NAME);
    18562         psFree(md);
    18563         return false;
    18564     }
    1856513387    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1856613388        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1864313465    return deleted;
    1864413466}
    18645 bool detMasterImfilePop(psDB *dbh, psS32 *det_id, char **class_id, char **uri, char **recipe)
    18646 {
    18647     psArray         *rowSet;
    18648     psMetadata      *row;
    18649     psMetadata      *popped;
    18650     long            deleted;
    18651     bool            status;
    18652     int             rowID;
    18653 
    18654     rowSet = psDBSelectRows(dbh, DETMASTERIMFILE_TABLE_NAME, NULL, 1);
    18655     if (!rowSet) {
    18656         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETMASTERIMFILE_INDEX_NAME);
    18657         psFree(rowSet);
    18658         return NULL;
    18659     }
    18660 
    18661     row = psArrayGet(rowSet, 0);
    18662     psMemIncrRefCounter(row);
    18663     if (!row) {
    18664         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    18665         return NULL;
    18666     }
    18667     psFree(rowSet);
    18668 
    18669     rowID = psMetadataLookupS32(&status, row, DETMASTERIMFILE_INDEX_NAME);
    18670     if (!status) {
    18671         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETMASTERIMFILE_INDEX_NAME);
    18672         psFree(row);
    18673         return NULL;
    18674     }
    18675 
    18676     popped = psMetadataAlloc();
    18677     psMetadataAddS32(popped, PS_LIST_TAIL, DETMASTERIMFILE_INDEX_NAME, 0, NULL, rowID);
    18678 
    18679     deleted = psDBDeleteRows(dbh, DETMASTERIMFILE_TABLE_NAME, popped, 0);
    18680     if (deleted != 1) {
    18681         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    18682         psFree(popped);
    18683         psFree(row);
    18684         return NULL;
    18685     }
    18686 
    18687     psFree(popped);
    18688 
    18689     *det_id = psMetadataLookupS32(&status, row, "det_id");
    18690     if (!status) {
    18691         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    18692         psFree(row);
    18693         return false;
    18694     }
    18695     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    18696     if (!status) {
    18697         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    18698         psFree(row);
    18699         return false;
    18700     }
    18701     *uri = psMetadataLookupPtr(&status, row, "uri");
    18702     if (!status) {
    18703         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    18704         psFree(row);
    18705         return false;
    18706     }
    18707     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    18708     if (!status) {
    18709         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    18710         psFree(row);
    18711         return false;
    18712     }
    18713 
    18714     psFree(row);
    18715 
    18716     return true;
    18717 }
    18718 
    1871913467bool detMasterImfileInsertObject(psDB *dbh, detMasterImfileRow *object)
    1872013468{
    … …  
    1873113479
    1873213480    return true;
    18733 }
    18734 
    18735 detMasterImfileRow *detMasterImfilePopObject(psDB *dbh)
    18736 {
    18737     psS32           det_id;
    18738     char            class_id[256];
    18739     char            uri[256];
    18740     char            recipe[256];
    18741 
    18742     if (!detMasterImfilePop(dbh, &det_id, (char **)&class_id, (char **)&uri, (char **)&recipe)) {
    18743         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    18744         return NULL;
    18745     }
    18746 
    18747     return detMasterImfileRowAlloc(det_id, class_id, uri, recipe);
    1874813481}
    1874913482
    … …  
    1878313516}
    1878413517
    18785 bool detMasterImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    18786 {
    18787     char            query[MAX_STRING_LENGTH];
    18788 
    18789     if (!detMasterImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    18790         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    18791         return false;
    18792     }
    18793 
    18794     // remove limit rows from the end of the database
    18795     if (snprintf(query, MAX_STRING_LENGTH,
    18796                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    18797                 DETMASTERIMFILE_TABLE_NAME, DETMASTERIMFILE_INDEX_NAME, limit) < 0) {
    18798         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    18799         return false;
    18800     }
    18801            
    18802     if (!p_psDBRunQuery(dbh, query)) {
    18803         psError(PS_ERR_UNKNOWN, false, "database query failed");
    18804         return false;
    18805     }
    18806 
    18807     return true;
    18808 }
    18809 
    1881013518bool detMasterImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1881113519{
    1881213520    psArray         *rowSet;
    18813     psU64           i;
    1881413521
    1881513522    rowSet = psDBSelectRows(dbh, DETMASTERIMFILE_TABLE_NAME, where, limit);
    1881613523    if (!rowSet) {
    1881713524        return false;
    18818     }
    18819 
    18820     // strip index column
    18821     for (i = 0; i < rowSet->n; i++) {
    18822         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETMASTERIMFILE_INDEX_NAME)) {
    18823             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETMASTERIMFILE_INDEX_NAME);
    18824             psFree(rowSet);
    18825             return false;
    18826         }
    1882713525    }
    1882813526
    … …  
    1890813606    if (!rowSet) {
    1890913607        return NULL;
    18910     }
    18911 
    18912     // strip index column
    18913     for (i = 0; i < rowSet->n; i++) {
    18914         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETMASTERIMFILE_INDEX_NAME)) {
    18915             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETMASTERIMFILE_INDEX_NAME);
    18916             psFree(rowSet);
    18917             return false;
    18918         }
    1891913608    }
    1892013609
    … …  
    1904213731
    1904313732    md = psMetadataAlloc();
    19044     if (!psMetadataAdd(md, PS_LIST_TAIL, DETRESIDIMFILE_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    19045         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETRESIDIMFILE_INDEX_NAME);
    19046         psFree(md);
    19047         return false;
    19048     }
    1904913733    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1905013734        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1919713881    return deleted;
    1919813882}
    19199 bool detResidImfilePop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **exp_tag, char **class_id, char **uri, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri)
    19200 {
    19201     psArray         *rowSet;
    19202     psMetadata      *row;
    19203     psMetadata      *popped;
    19204     long            deleted;
    19205     bool            status;
    19206     int             rowID;
    19207 
    19208     rowSet = psDBSelectRows(dbh, DETRESIDIMFILE_TABLE_NAME, NULL, 1);
    19209     if (!rowSet) {
    19210         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRESIDIMFILE_INDEX_NAME);
    19211         psFree(rowSet);
    19212         return NULL;
    19213     }
    19214 
    19215     row = psArrayGet(rowSet, 0);
    19216     psMemIncrRefCounter(row);
    19217     if (!row) {
    19218         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    19219         return NULL;
    19220     }
    19221     psFree(rowSet);
    19222 
    19223     rowID = psMetadataLookupS32(&status, row, DETRESIDIMFILE_INDEX_NAME);
    19224     if (!status) {
    19225         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRESIDIMFILE_INDEX_NAME);
    19226         psFree(row);
    19227         return NULL;
    19228     }
    19229 
    19230     popped = psMetadataAlloc();
    19231     psMetadataAddS32(popped, PS_LIST_TAIL, DETRESIDIMFILE_INDEX_NAME, 0, NULL, rowID);
    19232 
    19233     deleted = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, popped, 0);
    19234     if (deleted != 1) {
    19235         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    19236         psFree(popped);
    19237         psFree(row);
    19238         return NULL;
    19239     }
    19240 
    19241     psFree(popped);
    19242 
    19243     *det_id = psMetadataLookupS32(&status, row, "det_id");
    19244     if (!status) {
    19245         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    19246         psFree(row);
    19247         return false;
    19248     }
    19249     *iteration = psMetadataLookupS32(&status, row, "iteration");
    19250     if (!status) {
    19251         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    19252         psFree(row);
    19253         return false;
    19254     }
    19255     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    19256     if (!status) {
    19257         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    19258         psFree(row);
    19259         return false;
    19260     }
    19261     *class_id = psMetadataLookupPtr(&status, row, "class_id");
    19262     if (!status) {
    19263         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id");
    19264         psFree(row);
    19265         return false;
    19266     }
    19267     *uri = psMetadataLookupPtr(&status, row, "uri");
    19268     if (!status) {
    19269         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri");
    19270         psFree(row);
    19271         return false;
    19272     }
    19273     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    19274     if (!status) {
    19275         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    19276         psFree(row);
    19277         return false;
    19278     }
    19279     *bg = psMetadataLookupF64(&status, row, "bg");
    19280     if (!status) {
    19281         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    19282         psFree(row);
    19283         return false;
    19284     }
    19285     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    19286     if (!status) {
    19287         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    19288         psFree(row);
    19289         return false;
    19290     }
    19291     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    19292     if (!status) {
    19293         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    19294         psFree(row);
    19295         return false;
    19296     }
    19297     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    19298     if (!status) {
    19299         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    19300         psFree(row);
    19301         return false;
    19302     }
    19303     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    19304     if (!status) {
    19305         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    19306         psFree(row);
    19307         return false;
    19308     }
    19309 
    19310     psFree(row);
    19311 
    19312     return true;
    19313 }
    19314 
    1931513883bool detResidImfileInsertObject(psDB *dbh, detResidImfileRow *object)
    1931613884{
    … …  
    1932713895
    1932813896    return true;
    19329 }
    19330 
    19331 detResidImfileRow *detResidImfilePopObject(psDB *dbh)
    19332 {
    19333     psS32           det_id;
    19334     psS32           iteration;
    19335     char            exp_tag[256];
    19336     char            class_id[256];
    19337     char            uri[256];
    19338     char            recipe[256];
    19339     psF64           bg;
    19340     psF64           bg_stdev;
    19341     psF64           bg_mean_stdev;
    19342     char            b1_uri[256];
    19343     char            b2_uri[256];
    19344 
    19345     if (!detResidImfilePop(dbh, &det_id, &iteration, (char **)&exp_tag, (char **)&class_id, (char **)&uri, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri)) {
    19346         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    19347         return NULL;
    19348     }
    19349 
    19350     return detResidImfileRowAlloc(det_id, iteration, exp_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri);
    1935113897}
    1935213898
    … …  
    1938613932}
    1938713933
    19388 bool detResidImfilePopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    19389 {
    19390     char            query[MAX_STRING_LENGTH];
    19391 
    19392     if (!detResidImfileSelectRowsFits(dbh, fits, NULL, limit)) {
    19393         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    19394         return false;
    19395     }
    19396 
    19397     // remove limit rows from the end of the database
    19398     if (snprintf(query, MAX_STRING_LENGTH,
    19399                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    19400                 DETRESIDIMFILE_TABLE_NAME, DETRESIDIMFILE_INDEX_NAME, limit) < 0) {
    19401         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    19402         return false;
    19403     }
    19404            
    19405     if (!p_psDBRunQuery(dbh, query)) {
    19406         psError(PS_ERR_UNKNOWN, false, "database query failed");
    19407         return false;
    19408     }
    19409 
    19410     return true;
    19411 }
    19412 
    1941313934bool detResidImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    1941413935{
    1941513936    psArray         *rowSet;
    19416     psU64           i;
    1941713937
    1941813938    rowSet = psDBSelectRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit);
    1941913939    if (!rowSet) {
    1942013940        return false;
    19421     }
    19422 
    19423     // strip index column
    19424     for (i = 0; i < rowSet->n; i++) {
    19425         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETRESIDIMFILE_INDEX_NAME)) {
    19426             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRESIDIMFILE_INDEX_NAME);
    19427             psFree(rowSet);
    19428             return false;
    19429         }
    1943013941    }
    1943113942
    … …  
    1958814099    if (!rowSet) {
    1958914100        return NULL;
    19590     }
    19591 
    19592     // strip index column
    19593     for (i = 0; i < rowSet->n; i++) {
    19594         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETRESIDIMFILE_INDEX_NAME)) {
    19595             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRESIDIMFILE_INDEX_NAME);
    19596             psFree(rowSet);
    19597             return false;
    19598         }
    1959914101    }
    1960014102
    … …  
    1971914221
    1972014222    md = psMetadataAlloc();
    19721     if (!psMetadataAdd(md, PS_LIST_TAIL, DETRESIDEXP_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    19722         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETRESIDEXP_INDEX_NAME);
    19723         psFree(md);
    19724         return false;
    19725     }
    1972614223    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    1972714224        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    1986414361    return deleted;
    1986514362}
    19866 bool detResidExpPop(psDB *dbh, psS32 *det_id, psS32 *iteration, char **exp_tag, char **recipe, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, char **b1_uri, char **b2_uri, bool *accept)
    19867 {
    19868     psArray         *rowSet;
    19869     psMetadata      *row;
    19870     psMetadata      *popped;
    19871     long            deleted;
    19872     bool            status;
    19873     int             rowID;
    19874 
    19875     rowSet = psDBSelectRows(dbh, DETRESIDEXP_TABLE_NAME, NULL, 1);
    19876     if (!rowSet) {
    19877         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRESIDEXP_INDEX_NAME);
    19878         psFree(rowSet);
    19879         return NULL;
    19880     }
    19881 
    19882     row = psArrayGet(rowSet, 0);
    19883     psMemIncrRefCounter(row);
    19884     if (!row) {
    19885         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    19886         return NULL;
    19887     }
    19888     psFree(rowSet);
    19889 
    19890     rowID = psMetadataLookupS32(&status, row, DETRESIDEXP_INDEX_NAME);
    19891     if (!status) {
    19892         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRESIDEXP_INDEX_NAME);
    19893         psFree(row);
    19894         return NULL;
    19895     }
    19896 
    19897     popped = psMetadataAlloc();
    19898     psMetadataAddS32(popped, PS_LIST_TAIL, DETRESIDEXP_INDEX_NAME, 0, NULL, rowID);
    19899 
    19900     deleted = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, popped, 0);
    19901     if (deleted != 1) {
    19902         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    19903         psFree(popped);
    19904         psFree(row);
    19905         return NULL;
    19906     }
    19907 
    19908     psFree(popped);
    19909 
    19910     *det_id = psMetadataLookupS32(&status, row, "det_id");
    19911     if (!status) {
    19912         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    19913         psFree(row);
    19914         return false;
    19915     }
    19916     *iteration = psMetadataLookupS32(&status, row, "iteration");
    19917     if (!status) {
    19918         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    19919         psFree(row);
    19920         return false;
    19921     }
    19922     *exp_tag = psMetadataLookupPtr(&status, row, "exp_tag");
    19923     if (!status) {
    19924         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag");
    19925         psFree(row);
    19926         return false;
    19927     }
    19928     *recipe = psMetadataLookupPtr(&status, row, "recipe");
    19929     if (!status) {
    19930         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe");
    19931         psFree(row);
    19932         return false;
    19933     }
    19934     *bg = psMetadataLookupF64(&status, row, "bg");
    19935     if (!status) {
    19936         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    19937         psFree(row);
    19938         return false;
    19939     }
    19940     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    19941     if (!status) {
    19942         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    19943         psFree(row);
    19944         return false;
    19945     }
    19946     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    19947     if (!status) {
    19948         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    19949         psFree(row);
    19950         return false;
    19951     }
    19952     *b1_uri = psMetadataLookupPtr(&status, row, "b1_uri");
    19953     if (!status) {
    19954         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri");
    19955         psFree(row);
    19956         return false;
    19957     }
    19958     *b2_uri = psMetadataLookupPtr(&status, row, "b2_uri");
    19959     if (!status) {
    19960         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri");
    19961         psFree(row);
    19962         return false;
    19963     }
    19964     *accept = psMetadataLookupBool(&status, row, "accept");
    19965     if (!status) {
    19966         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item accept");
    19967         psFree(row);
    19968         return false;
    19969     }
    19970 
    19971     psFree(row);
    19972 
    19973     return true;
    19974 }
    19975 
    1997614363bool detResidExpInsertObject(psDB *dbh, detResidExpRow *object)
    1997714364{
    … …  
    1998814375
    1998914376    return true;
    19990 }
    19991 
    19992 detResidExpRow *detResidExpPopObject(psDB *dbh)
    19993 {
    19994     psS32           det_id;
    19995     psS32           iteration;
    19996     char            exp_tag[256];
    19997     char            recipe[256];
    19998     psF64           bg;
    19999     psF64           bg_stdev;
    20000     psF64           bg_mean_stdev;
    20001     char            b1_uri[256];
    20002     char            b2_uri[256];
    20003     bool            accept;
    20004 
    20005     if (!detResidExpPop(dbh, &det_id, &iteration, (char **)&exp_tag, (char **)&recipe, &bg, &bg_stdev, &bg_mean_stdev, (char **)&b1_uri, (char **)&b2_uri, &accept)) {
    20006         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    20007         return NULL;
    20008     }
    20009 
    20010     return detResidExpRowAlloc(det_id, iteration, exp_tag, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, accept);
    2001114377}
    2001214378
    … …  
    2004614412}
    2004714413
    20048 bool detResidExpPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    20049 {
    20050     char            query[MAX_STRING_LENGTH];
    20051 
    20052     if (!detResidExpSelectRowsFits(dbh, fits, NULL, limit)) {
    20053         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    20054         return false;
    20055     }
    20056 
    20057     // remove limit rows from the end of the database
    20058     if (snprintf(query, MAX_STRING_LENGTH,
    20059                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    20060                 DETRESIDEXP_TABLE_NAME, DETRESIDEXP_INDEX_NAME, limit) < 0) {
    20061         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    20062         return false;
    20063     }
    20064            
    20065     if (!p_psDBRunQuery(dbh, query)) {
    20066         psError(PS_ERR_UNKNOWN, false, "database query failed");
    20067         return false;
    20068     }
    20069 
    20070     return true;
    20071 }
    20072 
    2007314414bool detResidExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    2007414415{
    2007514416    psArray         *rowSet;
    20076     psU64           i;
    2007714417
    2007814418    rowSet = psDBSelectRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit);
    2007914419    if (!rowSet) {
    2008014420        return false;
    20081     }
    20082 
    20083     // strip index column
    20084     for (i = 0; i < rowSet->n; i++) {
    20085         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETRESIDEXP_INDEX_NAME)) {
    20086             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRESIDEXP_INDEX_NAME);
    20087             psFree(rowSet);
    20088             return false;
    20089         }
    2009014421    }
    2009114422
    … …  
    2023714568    if (!rowSet) {
    2023814569        return NULL;
    20239     }
    20240 
    20241     // strip index column
    20242     for (i = 0; i < rowSet->n; i++) {
    20243         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETRESIDEXP_INDEX_NAME)) {
    20244             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRESIDEXP_INDEX_NAME);
    20245             psFree(rowSet);
    20246             return false;
    20247         }
    2024814570    }
    2024914571
    … …  
    2036014682
    2036114683    md = psMetadataAlloc();
    20362     if (!psMetadataAdd(md, PS_LIST_TAIL, DETRUNSUMMARY_INDEX_NAME, PS_DATA_S32, "AUTO_INCREMENT", 0.0)) {
    20363         psError(PS_ERR_UNKNOWN, false, "failed to add item %s", DETRUNSUMMARY_INDEX_NAME);
    20364         psFree(md);
    20365         return false;
    20366     }
    2036714684    if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, "Primary Key", 0)) {
    2036814685        psError(PS_ERR_UNKNOWN, false, "failed to add item det_id");
    … …  
    2046514782    return deleted;
    2046614783}
    20467 bool detRunSummaryPop(psDB *dbh, psS32 *det_id, psS32 *iteration, psF64 *bg, psF64 *bg_stdev, psF64 *bg_mean_stdev, bool *accept)
    20468 {
    20469     psArray         *rowSet;
    20470     psMetadata      *row;
    20471     psMetadata      *popped;
    20472     long            deleted;
    20473     bool            status;
    20474     int             rowID;
    20475 
    20476     rowSet = psDBSelectRows(dbh, DETRUNSUMMARY_TABLE_NAME, NULL, 1);
    20477     if (!rowSet) {
    20478         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRUNSUMMARY_INDEX_NAME);
    20479         psFree(rowSet);
    20480         return NULL;
    20481     }
    20482 
    20483     row = psArrayGet(rowSet, 0);
    20484     psMemIncrRefCounter(row);
    20485     if (!row) {
    20486         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    20487         return NULL;
    20488     }
    20489     psFree(rowSet);
    20490 
    20491     rowID = psMetadataLookupS32(&status, row, DETRUNSUMMARY_INDEX_NAME);
    20492     if (!status) {
    20493         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item %s", DETRUNSUMMARY_INDEX_NAME);
    20494         psFree(row);
    20495         return NULL;
    20496     }
    20497 
    20498     popped = psMetadataAlloc();
    20499     psMetadataAddS32(popped, PS_LIST_TAIL, DETRUNSUMMARY_INDEX_NAME, 0, NULL, rowID);
    20500 
    20501     deleted = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, popped, 0);
    20502     if (deleted != 1) {
    20503         psError(PS_ERR_UNKNOWN, false, "database failed to delete row");
    20504         psFree(popped);
    20505         psFree(row);
    20506         return NULL;
    20507     }
    20508 
    20509     psFree(popped);
    20510 
    20511     *det_id = psMetadataLookupS32(&status, row, "det_id");
    20512     if (!status) {
    20513         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id");
    20514         psFree(row);
    20515         return false;
    20516     }
    20517     *iteration = psMetadataLookupS32(&status, row, "iteration");
    20518     if (!status) {
    20519         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration");
    20520         psFree(row);
    20521         return false;
    20522     }
    20523     *bg = psMetadataLookupF64(&status, row, "bg");
    20524     if (!status) {
    20525         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg");
    20526         psFree(row);
    20527         return false;
    20528     }
    20529     *bg_stdev = psMetadataLookupF64(&status, row, "bg_stdev");
    20530     if (!status) {
    20531         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev");
    20532         psFree(row);
    20533         return false;
    20534     }
    20535     *bg_mean_stdev = psMetadataLookupF64(&status, row, "bg_mean_stdev");
    20536     if (!status) {
    20537         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev");
    20538         psFree(row);
    20539         return false;
    20540     }
    20541     *accept = psMetadataLookupBool(&status, row, "accept");
    20542     if (!status) {
    20543         psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item accept");
    20544         psFree(row);
    20545         return false;
    20546     }
    20547 
    20548     psFree(row);
    20549 
    20550     return true;
    20551 }
    20552 
    2055314784bool detRunSummaryInsertObject(psDB *dbh, detRunSummaryRow *object)
    2055414785{
    … …  
    2056514796
    2056614797    return true;
    20567 }
    20568 
    20569 detRunSummaryRow *detRunSummaryPopObject(psDB *dbh)
    20570 {
    20571     psS32           det_id;
    20572     psS32           iteration;
    20573     psF64           bg;
    20574     psF64           bg_stdev;
    20575     psF64           bg_mean_stdev;
    20576     bool            accept;
    20577 
    20578     if (!detRunSummaryPop(dbh, &det_id, &iteration, &bg, &bg_stdev, &bg_mean_stdev, &accept)) {
    20579         psError(PS_ERR_UNKNOWN, false, "failed to pop a database row");
    20580         return NULL;
    20581     }
    20582 
    20583     return detRunSummaryRowAlloc(det_id, iteration, bg, bg_stdev, bg_mean_stdev, accept);
    2058414798}
    2058514799
    … …  
    2061914833}
    2062014834
    20621 bool detRunSummaryPopFits(psDB *dbh, psFits *fits, unsigned long long limit)
    20622 {
    20623     char            query[MAX_STRING_LENGTH];
    20624 
    20625     if (!detRunSummarySelectRowsFits(dbh, fits, NULL, limit)) {
    20626         psError(PS_ERR_UNKNOWN, true, "database error or table is empty");
    20627         return false;
    20628     }
    20629 
    20630     // remove limit rows from the end of the database
    20631     if (snprintf(query, MAX_STRING_LENGTH,
    20632                 "DELETE FROM %s ORDER BY %s DESC LIMIT %lld",
    20633                 DETRUNSUMMARY_TABLE_NAME, DETRUNSUMMARY_INDEX_NAME, limit) < 0) {
    20634         psError(PS_ERR_UNKNOWN, true, "query value attempted to exceed %d bytes", MAX_STRING_LENGTH);
    20635         return false;
    20636     }
    20637            
    20638     if (!p_psDBRunQuery(dbh, query)) {
    20639         psError(PS_ERR_UNKNOWN, false, "database query failed");
    20640         return false;
    20641     }
    20642 
    20643     return true;
    20644 }
    20645 
    2064614835bool detRunSummarySelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit)
    2064714836{
    2064814837    psArray         *rowSet;
    20649     psU64           i;
    2065014838
    2065114839    rowSet = psDBSelectRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit);
    2065214840    if (!rowSet) {
    2065314841        return false;
    20654     }
    20655 
    20656     // strip index column
    20657     for (i = 0; i < rowSet->n; i++) {
    20658         if (!psMetadataRemove((psMetadata *)rowSet->data[i], 0, DETRUNSUMMARY_INDEX_NAME)) {
    20659             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRUNSUMMARY_INDEX_NAME);
    20660             psFree(rowSet);
    20661             return false;
    20662         }
    2066314842    }
    2066414843
    … …  
    2076614945    if (!rowSet) {
    2076714946        return NULL;
    20768     }
    20769 
    20770     // strip index column
    20771     for (i = 0; i < rowSet->n; i++) {
    20772         if (!psMetadataRemove((psMetadata *)(rowSet->data[i]), 0, DETRUNSUMMARY_INDEX_NAME)) {
    20773             psError(PS_ERR_UNKNOWN, true, "failed to remove item %s", DETRUNSUMMARY_INDEX_NAME);
    20774             psFree(rowSet);
    20775             return false;
    20776         }
    2077714947    }
    2077814948

  • trunk/ippdb/src/ippdb.h

    r9307 r9423  
    11/*
    2  *
    3  * This file was generated by glueforge 0.25
     2 * header.c
     3 *
     4 * Copyright (C) 2006  Joshua Hoblitt
     5 *
     6 * This program is free software; you can redistribute it and/or modify it
     7 * under the terms of the GNU General Public License as published by the Free
     8 * Software Foundation; version 2 of the License.
     9 *
     10 * This program is distributed in the hope that it will be useful, but WITHOUT
     11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
     13 * more details.
     14 *
     15 * You should have received a copy of the GNU General Public License along with
     16 * program; see the file COPYING. If not, write to the Free Software
     17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
     18 */
     19
     20/*
     21 *
     22 * This file was generated by glueforge 0.29
    423 *
    524 * Do NOT directly edit this file.
    … …  
    2948    const char      *user,              ///< Database username
    3049    const char      *passwd,            ///< Database password
    31     const char      *dbname             ///< Database table.namespace
     50    const char      *dbname,            ///< Database table.namespace
     51    unsigned int    port                ///< Database port
    3252);
    3353
    … …  
    182202);
    183203
    184 /** Removes the last row from the database and returns it
    185  *
    186  * @return true on success
    187  */
    188 
    189 bool weatherPop(
    190     psDB            *dbh,               ///< Database handle
    191     psF32           *temp01,
    192     psF32           *humi01,
    193     psF32           *temp02,
    194     psF32           *humi02,
    195     psF32           *temp03,
    196     psF32           *humi03,
    197     psF32           *pressure
    198 );
    199 
    200204/** Insert a single weatherRow object into a table
    201205 *
    … …  
    220224    psDB            *dbh,               ///< Database handle
    221225    psArray         *objects            ///< array of weatherRow objects
    222 );
    223 
    224 /** Removes the last row from the database and returns it
    225  *
    226  * @return A new weatherRow on success or NULL on failure.
    227  */
    228 
    229 weatherRow *weatherPopObject(
    230     psDB            *dbh                ///< Database handle
    231226);
    232227
    … …  
    244239    psDB            *dbh,               ///< Database handle
    245240    const psFits    *fits               ///< psFits object
    246 );
    247 
    248 /** Removes the last limit row from the database and returns them in a binary FITS table.
    249  *
    250  * This function assumes an empty psFits object and will create a FITS table as
    251  * the first extension.
    252  *
    253  * @return true on success
    254  */
    255 
    256 bool weatherPopFits(
    257     psDB            *dbh,               ///< Database handle
    258     psFits          *fits,              ///< psFits object
    259     unsigned long long limit            ///< Maximum number of elements to return
    260241);
    261242
    … …  
    421402);
    422403
    423 /** Removes the last row from the database and returns it
    424  *
    425  * @return true on success
    426  */
    427 
    428 bool skyp_transparencyPop(
    429     psDB            *dbh,               ///< Database handle
    430     char            **filter,
    431     psF64           *trans,
    432     psS32           *nstars,
    433     psF64           *ra,
    434     psF64           *decl,
    435     psF32           *exptime,
    436     psF64           *sky_bright
    437 );
    438 
    439404/** Insert a single skyp_transparencyRow object into a table
    440405 *
    … …  
    459424    psDB            *dbh,               ///< Database handle
    460425    psArray         *objects            ///< array of skyp_transparencyRow objects
    461 );
    462 
    463 /** Removes the last row from the database and returns it
    464  *
    465  * @return A new skyp_transparencyRow on success or NULL on failure.
    466  */
    467 
    468 skyp_transparencyRow *skyp_transparencyPopObject(
    469     psDB            *dbh                ///< Database handle
    470426);
    471427
    … …  
    483439    psDB            *dbh,               ///< Database handle
    484440    const psFits    *fits               ///< psFits object
    485 );
    486 
    487 /** Removes the last limit row from the database and returns them in a binary FITS table.
    488  *
    489  * This function assumes an empty psFits object and will create a FITS table as
    490  * the first extension.
    491  *
    492  * @return true on success
    493  */
    494 
    495 bool skyp_transparencyPopFits(
    496     psDB            *dbh,               ///< Database handle
    497     psFits          *fits,              ///< psFits object
    498     unsigned long long limit            ///< Maximum number of elements to return
    499441);
    500442
    … …  
    666608);
    667609
    668 /** Removes the last row from the database and returns it
    669  *
    670  * @return true on success
    671  */
    672 
    673 bool skyp_absorptionPop(
    674     psDB            *dbh,               ///< Database handle
    675     char            **disperser_id,
    676     psF32           *atmcomp1,
    677     psF32           *atmcomp2,
    678     psF32           *atmcomp3,
    679     psS32           *nstars,
    680     psF64           *ra,
    681     psF64           *decl,
    682     psF32           *exptime,
    683     psF64           *sky_bright
    684 );
    685 
    686610/** Insert a single skyp_absorptionRow object into a table
    687611 *
    … …  
    706630    psDB            *dbh,               ///< Database handle
    707631    psArray         *objects            ///< array of skyp_absorptionRow objects
    708 );
    709 
    710 /** Removes the last row from the database and returns it
    711  *
    712  * @return A new skyp_absorptionRow on success or NULL on failure.
    713  */
    714 
    715 skyp_absorptionRow *skyp_absorptionPopObject(
    716     psDB            *dbh                ///< Database handle
    717632);
    718633
    … …  
    730645    psDB            *dbh,               ///< Database handle
    731646    const psFits    *fits               ///< psFits object
    732 );
    733 
    734 /** Removes the last limit row from the database and returns them in a binary FITS table.
    735  *
    736  * This function assumes an empty psFits object and will create a FITS table as
    737  * the first extension.
    738  *
    739  * @return true on success
    740  */
    741 
    742 bool skyp_absorptionPopFits(
    743     psDB            *dbh,               ///< Database handle
    744     psFits          *fits,              ///< psFits object
    745     unsigned long long limit            ///< Maximum number of elements to return
    746647);
    747648
    … …  
    904805);
    905806
    906 /** Removes the last row from the database and returns it
    907  *
    908  * @return true on success
    909  */
    910 
    911 bool skyp_emissionPop(
    912     psDB            *dbh,               ///< Database handle
    913     char            **disperser_id,
    914     psF32           *atmcomp1,
    915     psF32           *atmcomp2,
    916     psF32           *atmcomp3,
    917     psF32           *continuum,
    918     psF32           *exptime
    919 );
    920 
    921807/** Insert a single skyp_emissionRow object into a table
    922808 *
    … …  
    941827    psDB            *dbh,               ///< Database handle
    942828    psArray         *objects            ///< array of skyp_emissionRow objects
    943 );
    944 
    945 /** Removes the last row from the database and returns it
    946  *
    947  * @return A new skyp_emissionRow on success or NULL on failure.
    948  */
    949 
    950 skyp_emissionRow *skyp_emissionPopObject(
    951     psDB            *dbh                ///< Database handle
    952829);
    953830
    … …  
    965842    psDB            *dbh,               ///< Database handle
    966843    const psFits    *fits               ///< psFits object
    967 );
    968 
    969 /** Removes the last limit row from the database and returns them in a binary FITS table.
    970  *
    971  * This function assumes an empty psFits object and will create a FITS table as
    972  * the first extension.
    973  *
    974  * @return true on success
    975  */
    976 
    977 bool skyp_emissionPopFits(
    978     psDB            *dbh,               ///< Database handle
    979     psFits          *fits,              ///< psFits object
    980     unsigned long long limit            ///< Maximum number of elements to return
    981844);
    982845
    … …  
    11421005);
    11431006
    1144 /** Removes the last row from the database and returns it
    1145  *
    1146  * @return true on success
    1147  */
    1148 
    1149 bool dimmPop(
    1150     psDB            *dbh,               ///< Database handle
    1151     psF32           *sigmax,
    1152     psF32           *sigmay,
    1153     psF32           *fwhm,
    1154     psF64           *ra,
    1155     psF64           *decl,
    1156     psF32           *expttime,
    1157     char            **telescope_id
    1158 );
    1159 
    11601007/** Insert a single dimmRow object into a table
    11611008 *
    … …  
    11801027    psDB            *dbh,               ///< Database handle
    11811028    psArray         *objects            ///< array of dimmRow objects
    1182 );
    1183 
    1184 /** Removes the last row from the database and returns it
    1185  *
    1186  * @return A new dimmRow on success or NULL on failure.
    1187  */
    1188 
    1189 dimmRow *dimmPopObject(
    1190     psDB            *dbh                ///< Database handle
    11911029);
    11921030
    … …  
    12041042    psDB            *dbh,               ///< Database handle
    12051043    const psFits    *fits               ///< psFits object
    1206 );
    1207 
    1208 /** Removes the last limit row from the database and returns them in a binary FITS table.
    1209  *
    1210  * This function assumes an empty psFits object and will create a FITS table as
    1211  * the first extension.
    1212  *
    1213  * @return true on success
    1214  */
    1215 
    1216 bool dimmPopFits(
    1217     psDB            *dbh,               ///< Database handle
    1218     psFits          *fits,              ///< psFits object
    1219     unsigned long long limit            ///< Maximum number of elements to return
    12201044);
    12211045
    … …  
    13781202);
    13791203
    1380 /** Removes the last row from the database and returns it
    1381  *
    1382  * @return true on success
    1383  */
    1384 
    1385 bool skyp_irPop(
    1386     psDB            *dbh,               ///< Database handle
    1387     psF64           *sky_bright,
    1388     psF64           *sky_var,
    1389     psF64           *ra,
    1390     psF64           *decl,
    1391     psF32           *fov_x,
    1392     psF32           *fov_y
    1393 );
    1394 
    13951204/** Insert a single skyp_irRow object into a table
    13961205 *
    … …  
    14151224    psDB            *dbh,               ///< Database handle
    14161225    psArray         *objects            ///< array of skyp_irRow objects
    1417 );
    1418 
    1419 /** Removes the last row from the database and returns it
    1420  *
    1421  * @return A new skyp_irRow on success or NULL on failure.
    1422  */
    1423 
    1424 skyp_irRow *skyp_irPopObject(
    1425     psDB            *dbh                ///< Database handle
    14261226);
    14271227
    … …  
    14391239    psDB            *dbh,               ///< Database handle
    14401240    const psFits    *fits               ///< psFits object
    1441 );
    1442 
    1443 /** Removes the last limit row from the database and returns them in a binary FITS table.
    1444  *
    1445  * This function assumes an empty psFits object and will create a FITS table as
    1446  * the first extension.
    1447  *
    1448  * @return true on success
    1449  */
    1450 
    1451 bool skyp_irPopFits(
    1452     psDB            *dbh,               ///< Database handle
    1453     psFits          *fits,              ///< psFits object
    1454     unsigned long long limit            ///< Maximum number of elements to return
    14551241);
    14561242
    … …  
    16071393);
    16081394
    1609 /** Removes the last row from the database and returns it
    1610  *
    1611  * @return true on success
    1612  */
    1613 
    1614 bool domePop(
    1615     psDB            *dbh,               ///< Database handle
    1616     psF32           *az,
    1617     bool            *open,
    1618     bool            *light,
    1619     bool            *track
    1620 );
    1621 
    16221395/** Insert a single domeRow object into a table
    16231396 *
    … …  
    16421415    psDB            *dbh,               ///< Database handle
    16431416    psArray         *objects            ///< array of domeRow objects
    1644 );
    1645 
    1646 /** Removes the last row from the database and returns it
    1647  *
    1648  * @return A new domeRow on success or NULL on failure.
    1649  */
    1650 
    1651 domeRow *domePopObject(
    1652     psDB            *dbh                ///< Database handle
    16531417);
    16541418
    … …  
    16661430    psDB            *dbh,               ///< Database handle
    16671431    const psFits    *fits               ///< psFits object
    1668 );
    1669 
    1670 /** Removes the last limit row from the database and returns them in a binary FITS table.
    1671  *
    1672  * This function assumes an empty psFits object and will create a FITS table as
    1673  * the first extension.
    1674  *
    1675  * @return true on success
    1676  */
    1677 
    1678 bool domePopFits(
    1679     psDB            *dbh,               ///< Database handle
    1680     psFits          *fits,              ///< psFits object
    1681     unsigned long long limit            ///< Maximum number of elements to return
    16821432);
    16831433
    … …  
    18371587);
    18381588
    1839 /** Removes the last row from the database and returns it
    1840  *
    1841  * @return true on success
    1842  */
    1843 
    1844 bool telescopePop(
    1845     psDB            *dbh,               ///< Database handle
    1846     char            **guide,
    1847     psF32           *alt,
    1848     psF32           *az,
    1849     psF64           *ra,
    1850     psF64           *decl
    1851 );
    1852 
    18531589/** Insert a single telescopeRow object into a table
    18541590 *
    … …  
    18731609    psDB            *dbh,               ///< Database handle
    18741610    psArray         *objects            ///< array of telescopeRow objects
    1875 );
    1876 
    1877 /** Removes the last row from the database and returns it
    1878  *
    1879  * @return A new telescopeRow on success or NULL on failure.
    1880  */
    1881 
    1882 telescopeRow *telescopePopObject(
    1883     psDB            *dbh                ///< Database handle
    18841611);
    18851612
    … …  
    18971624    psDB            *dbh,               ///< Database handle
    18981625    const psFits    *fits               ///< psFits object
    1899 );
    1900 
    1901 /** Removes the last limit row from the database and returns them in a binary FITS table.
    1902  *
    1903  * This function assumes an empty psFits object and will create a FITS table as
    1904  * the first extension.
    1905  *
    1906  * @return true on success
    1907  */
    1908 
    1909 bool telescopePopFits(
    1910     psDB            *dbh,               ///< Database handle
    1911     psFits          *fits,              ///< psFits object
    1912     unsigned long long limit            ///< Maximum number of elements to return
    19131626);
    19141627
    … …  
    20681781);
    20691782
    2070 /** Removes the last row from the database and returns it
    2071  *
    2072  * @return true on success
    2073  */
    2074 
    2075 bool summitExpPop(
    2076     psDB            *dbh,               ///< Database handle
    2077     char            **exp_id,
    2078     char            **camera,
    2079     char            **telescope,
    2080     char            **exp_type,
    2081     char            **uri
    2082 );
    2083 
    20841783/** Insert a single summitExpRow object into a table
    20851784 *
    … …  
    21041803    psDB            *dbh,               ///< Database handle
    21051804    psArray         *objects            ///< array of summitExpRow objects
    2106 );
    2107 
    2108 /** Removes the last row from the database and returns it
    2109  *
    2110  * @return A new summitExpRow on success or NULL on failure.
    2111  */
    2112 
    2113 summitExpRow *summitExpPopObject(
    2114     psDB            *dbh                ///< Database handle
    21151805);
    21161806
    … …  
    21281818    psDB            *dbh,               ///< Database handle
    21291819    const psFits    *fits               ///< psFits object
    2130 );
    2131 
    2132 /** Removes the last limit row from the database and returns them in a binary FITS table.
    2133  *
    2134  * This function assumes an empty psFits object and will create a FITS table as
    2135  * the first extension.
    2136  *
    2137  * @return true on success
    2138  */
    2139 
    2140 bool summitExpPopFits(
    2141     psDB            *dbh,               ///< Database handle
    2142     psFits          *fits,              ///< psFits object
    2143     unsigned long long limit            ///< Maximum number of elements to return
    21441820);
    21451821
    … …  
    22991975);
    23001976
    2301 /** Removes the last row from the database and returns it
    2302  *
    2303  * @return true on success
    2304  */
    2305 
    2306 bool pzPendingExpPop(
    2307     psDB            *dbh,               ///< Database handle
    2308     char            **exp_id,
    2309     char            **camera,
    2310     char            **telescope,
    2311     char            **exp_type,
    2312     psS32           *imfiles
    2313 );
    2314 
    23151977/** Insert a single pzPendingExpRow object into a table
    23161978 *
    … …  
    23351997    psDB            *dbh,               ///< Database handle
    23361998    psArray         *objects            ///< array of pzPendingExpRow objects
    2337 );
    2338 
    2339 /** Removes the last row from the database and returns it
    2340  *
    2341  * @return A new pzPendingExpRow on success or NULL on failure.
    2342  */
    2343 
    2344 pzPendingExpRow *pzPendingExpPopObject(
    2345     psDB            *dbh                ///< Database handle
    23461999);
    23472000
    … …  
    23592012    psDB            *dbh,               ///< Database handle
    23602013    const psFits    *fits               ///< psFits object
    2361 );
    2362 
    2363 /** Removes the last limit row from the database and returns them in a binary FITS table.
    2364  *
    2365  * This function assumes an empty psFits object and will create a FITS table as
    2366  * the first extension.
    2367  *
    2368  * @return true on success
    2369  */
    2370 
    2371 bool pzPendingExpPopFits(
    2372     psDB            *dbh,               ///< Database handle
    2373     psFits          *fits,              ///< psFits object
    2374     unsigned long long limit            ///< Maximum number of elements to return
    23752014);
    23762015
    … …  
    25392178);
    25402179
    2541 /** Removes the last row from the database and returns it
    2542  *
    2543  * @return true on success
    2544  */
    2545 
    2546 bool pzPendingImfilePop(
    2547     psDB            *dbh,               ///< Database handle
    2548     char            **exp_id,
    2549     char            **camera,
    2550     char            **telescope,
    2551     psS32           *bytes,
    2552     char            **md5sum,
    2553     char            **class,
    2554     char            **class_id,
    2555     char            **uri
    2556 );
    2557 
    25582180/** Insert a single pzPendingImfileRow object into a table
    25592181 *
    … …  
    25782200    psDB            *dbh,               ///< Database handle
    25792201    psArray         *objects            ///< array of pzPendingImfileRow objects
    2580 );
    2581 
    2582 /** Removes the last row from the database and returns it
    2583  *
    2584  * @return A new pzPendingImfileRow on success or NULL on failure.
    2585  */
    2586 
    2587 pzPendingImfileRow *pzPendingImfilePopObject(
    2588     psDB            *dbh                ///< Database handle
    25892202);
    25902203
    … …  
    26022215    psDB            *dbh,               ///< Database handle
    26032216    const psFits    *fits               ///< psFits object
    2604 );
    2605 
    2606 /** Removes the last limit row from the database and returns them in a binary FITS table.
    2607  *
    2608  * This function assumes an empty psFits object and will create a FITS table as
    2609  * the first extension.
    2610  *
    2611  * @return true on success
    2612  */
    2613 
    2614 bool pzPendingImfilePopFits(
    2615     psDB            *dbh,               ///< Database handle
    2616     psFits          *fits,              ///< psFits object
    2617     unsigned long long limit            ///< Maximum number of elements to return
    26182217);
    26192218
    … …  
    27762375);
    27772376
    2778 /** Removes the last row from the database and returns it
    2779  *
    2780  * @return true on success
    2781  */
    2782 
    2783 bool newExpPop(
    2784     psDB            *dbh,               ///< Database handle
    2785     char            **exp_tag,
    2786     char            **exp_id,
    2787     char            **camera,
    2788     char            **telescope,
    2789     char            **exp_type,
    2790     psS32           *imfiles
    2791 );
    2792 
    27932377/** Insert a single newExpRow object into a table
    27942378 *
    … …  
    28132397    psDB            *dbh,               ///< Database handle
    28142398    psArray         *objects            ///< array of newExpRow objects
    2815 );
    2816 
    2817 /** Removes the last row from the database and returns it
    2818  *
    2819  * @return A new newExpRow on success or NULL on failure.
    2820  */
    2821 
    2822 newExpRow *newExpPopObject(
    2823     psDB            *dbh                ///< Database handle
    28242399);
    28252400
    … …  
    28372412    psDB            *dbh,               ///< Database handle
    28382413    const psFits    *fits               ///< psFits object
    2839 );
    2840 
    2841 /** Removes the last limit row from the database and returns them in a binary FITS table.
    2842  *
    2843  * This function assumes an empty psFits object and will create a FITS table as
    2844  * the first extension.
    2845  *
    2846  * @return true on success
    2847  */
    2848 
    2849 bool newExpPopFits(
    2850     psDB            *dbh,               ///< Database handle
    2851     psFits          *fits,              ///< psFits object
    2852     unsigned long long limit            ///< Maximum number of elements to return
    28532414);
    28542415
    … …  
    30052566);
    30062567
    3007 /** Removes the last row from the database and returns it
    3008  *
    3009  * @return true on success
    3010  */
    3011 
    3012 bool newImfilePop(
    3013     psDB            *dbh,               ///< Database handle
    3014     char            **exp_tag,
    3015     char            **class,
    3016     char            **class_id,
    3017     char            **uri
    3018 );
    3019 
    30202568/** Insert a single newImfileRow object into a table
    30212569 *
    … …  
    30402588    psDB            *dbh,               ///< Database handle
    30412589    psArray         *objects            ///< array of newImfileRow objects
    3042 );
    3043 
    3044 /** Removes the last row from the database and returns it
    3045  *
    3046  * @return A new newImfileRow on success or NULL on failure.
    3047  */
    3048 
    3049 newImfileRow *newImfilePopObject(
    3050     psDB            *dbh                ///< Database handle
    30512590);
    30522591
    … …  
    30642603    psDB            *dbh,               ///< Database handle
    30652604    const psFits    *fits               ///< psFits object
    3066 );
    3067 
    3068 /** Removes the last limit row from the database and returns them in a binary FITS table.
    3069  *
    3070  * This function assumes an empty psFits object and will create a FITS table as
    3071  * the first extension.
    3072  *
    3073  * @return true on success
    3074  */
    3075 
    3076 bool newImfilePopFits(
    3077     psDB            *dbh,               ///< Database handle
    3078     psFits          *fits,              ///< psFits object
    3079     unsigned long long limit            ///< Maximum number of elements to return
    30802605);
    30812606
    … …  
    32742799);
    32752800
    3276 /** Removes the last row from the database and returns it
    3277  *
    3278  * @return true on success
    3279  */
    3280 
    3281 bool rawDetrendExpPop(
    3282     psDB            *dbh,               ///< Database handle
    3283     char            **exp_tag,
    3284     char            **camera,
    3285     char            **telescope,
    3286     char            **exp_type,
    3287     psS32           *imfiles,
    3288     char            **filter,
    3289     psF32           *airmass,
    3290     psF64           *ra,
    3291     psF64           *decl,
    3292     psF32           *exp_time,
    3293     psF64           *bg,
    3294     psF64           *bg_stdev,
    3295     psF64           *bg_mean_stdev,
    3296     psF64           *alt,
    3297     psF64           *az,
    3298     psF32           *ccd_temp,
    3299     psF64           *posang,
    3300     char            **object
    3301 );
    3302 
    33032801/** Insert a single rawDetrendExpRow object into a table
    33042802 *
    … …  
    33232821    psDB            *dbh,               ///< Database handle
    33242822    psArray         *objects            ///< array of rawDetrendExpRow objects
    3325 );
    3326 
    3327 /** Removes the last row from the database and returns it
    3328  *
    3329  * @return A new rawDetrendExpRow on success or NULL on failure.
    3330  */
    3331 
    3332 rawDetrendExpRow *rawDetrendExpPopObject(
    3333     psDB            *dbh                ///< Database handle
    33342823);
    33352824
    … …  
    33472836    psDB            *dbh,               ///< Database handle
    33482837    const psFits    *fits               ///< psFits object
    3349 );
    3350 
    3351 /** Removes the last limit row from the database and returns them in a binary FITS table.
    3352  *
    3353  * This function assumes an empty psFits object and will create a FITS table as
    3354  * the first extension.
    3355  *
    3356  * @return true on success
    3357  */
    3358 
    3359 bool rawDetrendExpPopFits(
    3360     psDB            *dbh,               ///< Database handle
    3361     psFits          *fits,              ///< psFits object
    3362     unsigned long long limit            ///< Maximum number of elements to return
    33632838);
    33642839
    … …  
    35573032);
    35583033
    3559 /** Removes the last row from the database and returns it
    3560  *
    3561  * @return true on success
    3562  */
    3563 
    3564 bool rawScienceExpPop(
    3565     psDB            *dbh,               ///< Database handle
    3566     char            **exp_tag,
    3567     char            **camera,
    3568     char            **telescope,
    3569     char            **exp_type,
    3570     psS32           *imfiles,
    3571     char            **filter,
    3572     psF32           *airmass,
    3573     psF64           *ra,
    3574     psF64           *decl,
    3575     psF32           *exp_time,
    3576     psF64           *bg,
    3577     psF64           *bg_stdev,
    3578     psF64           *bg_mean_stdev,
    3579     psF64           *alt,
    3580     psF64           *az,
    3581     psF32           *ccd_temp,
    3582     psF64           *posang,
    3583     char            **object
    3584 );
    3585 
    35863034/** Insert a single rawScienceExpRow object into a table
    35873035 *
    … …  
    36063054    psDB            *dbh,               ///< Database handle
    36073055    psArray         *objects            ///< array of rawScienceExpRow objects
    3608 );
    3609 
    3610 /** Removes the last row from the database and returns it
    3611  *
    3612  * @return A new rawScienceExpRow on success or NULL on failure.
    3613  */
    3614 
    3615 rawScienceExpRow *rawScienceExpPopObject(
    3616     psDB            *dbh                ///< Database handle
    36173056);
    36183057
    … …  
    36303069    psDB            *dbh,               ///< Database handle
    36313070    const psFits    *fits               ///< psFits object
    3632 );
    3633 
    3634 /** Removes the last limit row from the database and returns them in a binary FITS table.
    3635  *
    3636  * This function assumes an empty psFits object and will create a FITS table as
    3637  * the first extension.
    3638  *
    3639  * @return true on success
    3640  */
    3641 
    3642 bool rawScienceExpPopFits(
    3643     psDB            *dbh,               ///< Database handle
    3644     psFits          *fits,              ///< psFits object
    3645     unsigned long long limit            ///< Maximum number of elements to return
    36463071);
    36473072
    … …  
    38403265);
    38413266
    3842 /** Removes the last row from the database and returns it
    3843  *
    3844  * @return true on success
    3845  */
    3846 
    3847 bool rawImfilePop(
    3848     psDB            *dbh,               ///< Database handle
    3849     char            **exp_tag,
    3850     char            **class,
    3851     char            **class_id,
    3852     char            **uri,
    3853     char            **exp_type,
    3854     char            **filter,
    3855     psF32           *airmass,
    3856     psF64           *ra,
    3857     psF64           *decl,
    3858     psF32           *exp_time,
    3859     psF64           *bg,
    3860     psF64           *bg_stdev,
    3861     psF64           *bg_mean_stdev,
    3862     psF64           *alt,
    3863     psF64           *az,
    3864     psF32           *ccd_temp,
    3865     psF64           *posang,
    3866     char            **object
    3867 );
    3868 
    38693267/** Insert a single rawImfileRow object into a table
    38703268 *
    … …  
    38893287    psDB            *dbh,               ///< Database handle
    38903288    psArray         *objects            ///< array of rawImfileRow objects
    3891 );
    3892 
    3893 /** Removes the last row from the database and returns it
    3894  *
    3895  * @return A new rawImfileRow on success or NULL on failure.
    3896  */
    3897 
    3898 rawImfileRow *rawImfilePopObject(
    3899     psDB            *dbh                ///< Database handle
    39003289);
    39013290
    … …  
    39133302    psDB            *dbh,               ///< Database handle
    39143303    const psFits    *fits               ///< psFits object
    3915 );
    3916 
    3917 /** Removes the last limit row from the database and returns them in a binary FITS table.
    3918  *
    3919  * This function assumes an empty psFits object and will create a FITS table as
    3920  * the first extension.
    3921  *
    3922  * @return true on success
    3923  */
    3924 
    3925 bool rawImfilePopFits(
    3926     psDB            *dbh,               ///< Database handle
    3927     psFits          *fits,              ///< psFits object
    3928     unsigned long long limit            ///< Maximum number of elements to return
    39293304);
    39303305
    … …  
    40783453);
    40793454
    4080 /** Removes the last row from the database and returns it
    4081  *
    4082  * @return true on success
    4083  */
    4084 
    4085 bool p1PendingExpPop(
    4086     psDB            *dbh,               ///< Database handle
    4087     char            **exp_tag,
    4088     char            **recipe,
    4089     psS32           *p1_version
    4090 );
    4091 
    40923455/** Insert a single p1PendingExpRow object into a table
    40933456 *
    … …  
    41123475    psDB            *dbh,               ///< Database handle
    41133476    psArray         *objects            ///< array of p1PendingExpRow objects
    4114 );
    4115 
    4116 /** Removes the last row from the database and returns it
    4117  *
    4118  * @return A new p1PendingExpRow on success or NULL on failure.
    4119  */
    4120 
    4121 p1PendingExpRow *p1PendingExpPopObject(
    4122     psDB            *dbh                ///< Database handle
    41233477);
    41243478
    … …  
    41363490    psDB            *dbh,               ///< Database handle
    41373491    const psFits    *fits               ///< psFits object
    4138 );
    4139 
    4140 /** Removes the last limit row from the database and returns them in a binary FITS table.
    4141  *
    4142  * This function assumes an empty psFits object and will create a FITS table as
    4143  * the first extension.
    4144  *
    4145  * @return true on success
    4146  */
    4147 
    4148 bool p1PendingExpPopFits(
    4149     psDB            *dbh,               ///< Database handle
    4150     psFits          *fits,              ///< psFits object
    4151     unsigned long long limit            ///< Maximum number of elements to return
    41523492);
    41533493
    … …  
    43043644);
    43053645
    4306 /** Removes the last row from the database and returns it
    4307  *
    4308  * @return true on success
    4309  */
    4310 
    4311 bool p2PendingExpPop(
    4312     psDB            *dbh,               ///< Database handle
    4313     char            **exp_tag,
    4314     char            **recipe,
    4315     psS32           *p1_version,
    4316     psS32           *p2_version
    4317 );
    4318 
    43193646/** Insert a single p2PendingExpRow object into a table
    43203647 *
    … …  
    43393666    psDB            *dbh,               ///< Database handle
    43403667    psArray         *objects            ///< array of p2PendingExpRow objects
    4341 );
    4342 
    4343 /** Removes the last row from the database and returns it
    4344  *
    4345  * @return A new p2PendingExpRow on success or NULL on failure.
    4346  */
    4347 
    4348 p2PendingExpRow *p2PendingExpPopObject(
    4349     psDB            *dbh                ///< Database handle
    43503668);
    43513669
    … …  
    43633681    psDB            *dbh,               ///< Database handle
    43643682    const psFits    *fits               ///< psFits object
    4365 );
    4366 
    4367 /** Removes the last limit row from the database and returns them in a binary FITS table.
    4368  *
    4369  * This function assumes an empty psFits object and will create a FITS table as
    4370  * the first extension.
    4371  *
    4372  * @return true on success
    4373  */
    4374 
    4375 bool p2PendingExpPopFits(
    4376     psDB            *dbh,               ///< Database handle
    4377     psFits          *fits,              ///< psFits object
    4378     unsigned long long limit            ///< Maximum number of elements to return
    43793683);
    43803684
    … …  
    45373841);
    45383842
    4539 /** Removes the last row from the database and returns it
    4540  *
    4541  * @return true on success
    4542  */
    4543 
    4544 bool p2PendingImfilePop(
    4545     psDB            *dbh,               ///< Database handle
    4546     char            **exp_tag,
    4547     char            **class_id,
    4548     char            **uri,
    4549     char            **recipe,
    4550     psS32           *p1_version,
    4551     psS32           *p2_version
    4552 );
    4553 
    45543843/** Insert a single p2PendingImfileRow object into a table
    45553844 *
    … …  
    45743863    psDB            *dbh,               ///< Database handle
    45753864    psArray         *objects            ///< array of p2PendingImfileRow objects
    4576 );
    4577 
    4578 /** Removes the last row from the database and returns it
    4579  *
    4580  * @return A new p2PendingImfileRow on success or NULL on failure.
    4581  */
    4582 
    4583 p2PendingImfileRow *p2PendingImfilePopObject(
    4584     psDB            *dbh                ///< Database handle
    45853865);
    45863866
    … …  
    45983878    psDB            *dbh,               ///< Database handle
    45993879    const psFits    *fits               ///< psFits object
    4600 );
    4601 
    4602 /** Removes the last limit row from the database and returns them in a binary FITS table.
    4603  *
    4604  * This function assumes an empty psFits object and will create a FITS table as
    4605  * the first extension.
    4606  *
    4607  * @return true on success
    4608  */
    4609 
    4610 bool p2PendingImfilePopFits(
    4611     psDB            *dbh,               ///< Database handle
    4612     psFits          *fits,              ///< psFits object
    4613     unsigned long long limit            ///< Maximum number of elements to return
    46143880);
    46153881
    … …  
    47634029);
    47644030
    4765 /** Removes the last row from the database and returns it
    4766  *
    4767  * @return true on success
    4768  */
    4769 
    4770 bool p2ProcessedExpPop(
    4771     psDB            *dbh,               ///< Database handle
    4772     char            **exp_tag,
    4773     psS32           *p1_version,
    4774     psS32           *p2_version
    4775 );
    4776 
    47774031/** Insert a single p2ProcessedExpRow object into a table
    47784032 *
    … …  
    47974051    psDB            *dbh,               ///< Database handle
    47984052    psArray         *objects            ///< array of p2ProcessedExpRow objects
    4799 );
    4800 
    4801 /** Removes the last row from the database and returns it
    4802  *
    4803  * @return A new p2ProcessedExpRow on success or NULL on failure.
    4804  */
    4805 
    4806 p2ProcessedExpRow *p2ProcessedExpPopObject(
    4807     psDB            *dbh                ///< Database handle
    48084053);
    48094054
    … …  
    48214066    psDB            *dbh,               ///< Database handle
    48224067    const psFits    *fits               ///< psFits object
    4823 );
    4824 
    4825 /** Removes the last limit row from the database and returns them in a binary FITS table.
    4826  *
    4827  * This function assumes an empty psFits object and will create a FITS table as
    4828  * the first extension.
    4829  *
    4830  * @return true on success
    4831  */
    4832 
    4833 bool p2ProcessedExpPopFits(
    4834     psDB            *dbh,               ///< Database handle
    4835     psFits          *fits,              ///< psFits object
    4836     unsigned long long limit            ///< Maximum number of elements to return
    48374068);
    48384069
    … …  
    50104241);
    50114242
    5012 /** Removes the last row from the database and returns it
    5013  *
    5014  * @return true on success
    5015  */
    5016 
    5017 bool p2ProcessedImfilePop(
    5018     psDB            *dbh,               ///< Database handle
    5019     char            **exp_tag,
    5020     char            **class_id,
    5021     char            **uri,
    5022     char            **recipe,
    5023     psF64           *bg,
    5024     psF64           *bg_stdev,
    5025     psF64           *bg_mean_stdev,
    5026     char            **b1_uri,
    5027     char            **b2_uri,
    5028     psS32           *p1_version,
    5029     psS32           *p2_version
    5030 );
    5031 
    50324243/** Insert a single p2ProcessedImfileRow object into a table
    50334244 *
    … …  
    50524263    psDB            *dbh,               ///< Database handle
    50534264    psArray         *objects            ///< array of p2ProcessedImfileRow objects
    5054 );
    5055 
    5056 /** Removes the last row from the database and returns it
    5057  *
    5058  * @return A new p2ProcessedImfileRow on success or NULL on failure.
    5059  */
    5060 
    5061 p2ProcessedImfileRow *p2ProcessedImfilePopObject(
    5062     psDB            *dbh                ///< Database handle
    50634265);
    50644266
    … …  
    50764278    psDB            *dbh,               ///< Database handle
    50774279    const psFits    *fits               ///< psFits object
    5078 );
    5079 
    5080 /** Removes the last limit row from the database and returns them in a binary FITS table.
    5081  *
    5082  * This function assumes an empty psFits object and will create a FITS table as
    5083  * the first extension.
    5084  *
    5085  * @return true on success
    5086  */
    5087 
    5088 bool p2ProcessedImfilePopFits(
    5089     psDB            *dbh,               ///< Database handle
    5090     psFits          *fits,              ///< psFits object
    5091     unsigned long long limit            ///< Maximum number of elements to return
    50924280);
    50934281
    … …  
    52414429);
    52424430
    5243 /** Removes the last row from the database and returns it
    5244  *
    5245  * @return true on success
    5246  */
    5247 
    5248 bool p3PendingExpPop(
    5249     psDB            *dbh,               ///< Database handle
    5250     char            **exp_tag,
    5251     psS32           *p2_version,
    5252     psS32           *p3_version
    5253 );
    5254 
    52554431/** Insert a single p3PendingExpRow object into a table
    52564432 *
    … …  
    52754451    psDB            *dbh,               ///< Database handle
    52764452    psArray         *objects            ///< array of p3PendingExpRow objects
    5277 );
    5278 
    5279 /** Removes the last row from the database and returns it
    5280  *
    5281  * @return A new p3PendingExpRow on success or NULL on failure.
    5282  */
    5283 
    5284 p3PendingExpRow *p3PendingExpPopObject(
    5285     psDB            *dbh                ///< Database handle
    52864453);
    52874454
    … …  
    52994466    psDB            *dbh,               ///< Database handle
    53004467    const psFits    *fits               ///< psFits object
    5301 );
    5302 
    5303 /** Removes the last limit row from the database and returns them in a binary FITS table.
    5304  *
    5305  * This function assumes an empty psFits object and will create a FITS table as
    5306  * the first extension.
    5307  *
    5308  * @return true on success
    5309  */
    5310 
    5311 bool p3PendingExpPopFits(
    5312     psDB            *dbh,               ///< Database handle
    5313     psFits          *fits,              ///< psFits object
    5314     unsigned long long limit            ///< Maximum number of elements to return
    53154468);
    53164469
    … …  
    55004653);
    55014654
    5502 /** Removes the last row from the database and returns it
    5503  *
    5504  * @return true on success
    5505  */
    5506 
    5507 bool p3ProcessedExpPop(
    5508     psDB            *dbh,               ///< Database handle
    5509     char            **exp_tag,
    5510     char            **uri,
    5511     char            **recipe,
    5512     psF64           *bg,
    5513     psF64           *bg_stdev,
    5514     psF64           *bg_mean_stdev,
    5515     psF32           *sigma_ra,
    5516     psF32           *sigma_dec,
    5517     psS32           *nastro,
    5518     char            **b1_uri,
    5519     char            **b2_uri,
    5520     psF32           *zp_mean,
    5521     psF32           *zp_stdev,
    5522     psS32           *p2_version,
    5523     psS32           *p3_version
    5524 );
    5525 
    55264655/** Insert a single p3ProcessedExpRow object into a table
    55274656 *
    … …  
    55464675    psDB            *dbh,               ///< Database handle
    55474676    psArray         *objects            ///< array of p3ProcessedExpRow objects
    5548 );
    5549 
    5550 /** Removes the last row from the database and returns it
    5551  *
    5552  * @return A new p3ProcessedExpRow on success or NULL on failure.
    5553  */
    5554 
    5555 p3ProcessedExpRow *p3ProcessedExpPopObject(
    5556     psDB            *dbh                ///< Database handle
    55574677);
    55584678
    … …  
    55724692);
    55734693
    5574 /** Removes the last limit row from the database and returns them in a binary FITS table.
    5575  *
    5576  * This function assumes an empty psFits object and will create a FITS table as
    5577  * the first extension.
    5578  *
    5579  * @return true on success
    5580  */
    5581 
    5582 bool p3ProcessedExpPopFits(
    5583     psDB            *dbh,               ///< Database handle
    5584     psFits          *fits,              ///< psFits object
    5585     unsigned long long limit            ///< Maximum number of elements to return
    5586 );
    5587 
    55884694/** Selects up to limit from the database and returns them in a binary FITS table
    55894695 *
    … …  
    56764782
    56774783typedef struct {
     4784    psS32           det_id;
    56784785    psS32           iteration;
    56794786    char            *det_type;
    … …  
    56874794
    56884795detRunRow *detRunRowAlloc(
     4796    psS32           det_id,
    56894797    psS32           iteration,
    56904798    const char      *det_type,
    … …  
    57194827bool detRunInsert(
    57204828    psDB            *dbh,               ///< Database handle
     4829    psS32           det_id,
    57214830    psS32           iteration,
    57224831    const char      *det_type,
    … …  
    57354844);
    57364845
    5737 /** Removes the last row from the database and returns it
    5738  *
    5739  * @return true on success
    5740  */
    5741 
    5742 bool detRunPop(
    5743     psDB            *dbh,               ///< Database handle
    5744     psS32           *iteration,
    5745     char            **det_type,
    5746     char            **state
    5747 );
    5748 
    57494846/** Insert a single detRunRow object into a table
    57504847 *
    … …  
    57694866    psDB            *dbh,               ///< Database handle
    57704867    psArray         *objects            ///< array of detRunRow objects
    5771 );
    5772 
    5773 /** Removes the last row from the database and returns it
    5774  *
    5775  * @return A new detRunRow on success or NULL on failure.
    5776  */
    5777 
    5778 detRunRow *detRunPopObject(
    5779     psDB            *dbh                ///< Database handle
    57804868);
    57814869
    … …  
    57934881    psDB            *dbh,               ///< Database handle
    57944882    const psFits    *fits               ///< psFits object
    5795 );
    5796 
    5797 /** Removes the last limit row from the database and returns them in a binary FITS table.
    5798  *
    5799  * This function assumes an empty psFits object and will create a FITS table as
    5800  * the first extension.
    5801  *
    5802  * @return true on success
    5803  */
    5804 
    5805 bool detRunPopFits(
    5806     psDB            *dbh,               ///< Database handle
    5807     psFits          *fits,              ///< psFits object
    5808     unsigned long long limit            ///< Maximum number of elements to return
    58094883);
    58104884
    … …  
    59615035);
    59625036
    5963 /** Removes the last row from the database and returns it
    5964  *
    5965  * @return true on success
    5966  */
    5967 
    5968 bool detInputExpPop(
    5969     psDB            *dbh,               ///< Database handle
    5970     psS32           *det_id,
    5971     psS32           *iteration,
    5972     char            **exp_tag,
    5973     bool            *include
    5974 );
    5975 
    59765037/** Insert a single detInputExpRow object into a table
    59775038 *
    … …  
    59965057    psDB            *dbh,               ///< Database handle
    59975058    psArray         *objects            ///< array of detInputExpRow objects
    5998 );
    5999 
    6000 /** Removes the last row from the database and returns it
    6001  *
    6002  * @return A new detInputExpRow on success or NULL on failure.
    6003  */
    6004 
    6005 detInputExpRow *detInputExpPopObject(
    6006     psDB            *dbh                ///< Database handle
    60075059);
    60085060
    … …  
    60205072    psDB            *dbh,               ///< Database handle
    60215073    const psFits    *fits               ///< psFits object
    6022 );
    6023 
    6024 /** Removes the last limit row from the database and returns them in a binary FITS table.
    6025  *
    6026  * This function assumes an empty psFits object and will create a FITS table as
    6027  * the first extension.
    6028  *
    6029  * @return true on success
    6030  */
    6031 
    6032 bool detInputExpPopFits(
    6033     psDB            *dbh,               ///< Database handle
    6034     psFits          *fits,              ///< psFits object
    6035     unsigned long long limit            ///< Maximum number of elements to return
    60365074);
    60375075
    … …  
    62065244);
    62075245
    6208 /** Removes the last row from the database and returns it
    6209  *
    6210  * @return true on success
    6211  */
    6212 
    6213 bool detProcessedImfilePop(
    6214     psDB            *dbh,               ///< Database handle
    6215     psS32           *det_id,
    6216     char            **exp_tag,
    6217     char            **class_id,
    6218     char            **uri,
    6219     char            **recipe,
    6220     psF64           *bg,
    6221     psF64           *bg_stdev,
    6222     psF64           *bg_mean_stdev,
    6223     char            **b1_uri,
    6224     char            **b2_uri
    6225 );
    6226 
    62275246/** Insert a single detProcessedImfileRow object into a table
    62285247 *
    … …  
    62475266    psDB            *dbh,               ///< Database handle
    62485267    psArray         *objects            ///< array of detProcessedImfileRow objects
    6249 );
    6250 
    6251 /** Removes the last row from the database and returns it
    6252  *
    6253  * @return A new detProcessedImfileRow on success or NULL on failure.
    6254  */
    6255 
    6256 detProcessedImfileRow *detProcessedImfilePopObject(
    6257     psDB            *dbh                ///< Database handle
    62585268);
    62595269
    … …  
    62715281    psDB            *dbh,               ///< Database handle
    62725282    const psFits    *fits               ///< psFits object
    6273 );
    6274 
    6275 /** Removes the last limit row from the database and returns them in a binary FITS table.
    6276  *
    6277  * This function assumes an empty psFits object and will create a FITS table as
    6278  * the first extension.
    6279  *
    6280  * @return true on success
    6281  */
    6282 
    6283 bool detProcessedImfilePopFits(
    6284     psDB            *dbh,               ///< Database handle
    6285     psFits          *fits,              ///< psFits object
    6286     unsigned long long limit            ///< Maximum number of elements to return
    62875283);
    62885284
    … …  
    64515447);
    64525448
    6453 /** Removes the last row from the database and returns it
    6454  *
    6455  * @return true on success
    6456  */
    6457 
    6458 bool detProcessedExpPop(
    6459     psDB            *dbh,               ///< Database handle
    6460     psS32           *det_id,
    6461     char            **exp_tag,
    6462     char            **recipe,
    6463     psF64           *bg,
    6464     psF64           *bg_stdev,
    6465     psF64           *bg_mean_stdev,
    6466     char            **b1_uri,
    6467     char            **b2_uri
    6468 );
    6469 
    64705449/** Insert a single detProcessedExpRow object into a table
    64715450 *
    … …  
    64905469    psDB            *dbh,               ///< Database handle
    64915470    psArray         *objects            ///< array of detProcessedExpRow objects
    6492 );
    6493 
    6494 /** Removes the last row from the database and returns it
    6495  *
    6496  * @return A new detProcessedExpRow on success or NULL on failure.
    6497  */
    6498 
    6499 detProcessedExpRow *detProcessedExpPopObject(
    6500     psDB            *dbh                ///< Database handle
    65015471);
    65025472
    … …  
    65145484    psDB            *dbh,               ///< Database handle
    65155485    const psFits    *fits               ///< psFits object
    6516 );
    6517 
    6518 /** Removes the last limit row from the database and returns them in a binary FITS table.
    6519  *
    6520  * This function assumes an empty psFits object and will create a FITS table as
    6521  * the first extension.
    6522  *
    6523  * @return true on success
    6524  */
    6525 
    6526 bool detProcessedExpPopFits(
    6527     psDB            *dbh,               ///< Database handle
    6528     psFits          *fits,              ///< psFits object
    6529     unsigned long long limit            ///< Maximum number of elements to return
    65305486);
    65315487
    … …  
    66945650);
    66955651
    6696 /** Removes the last row from the database and returns it
    6697  *
    6698  * @return true on success
    6699  */
    6700 
    6701 bool detStackedImfilePop(
    6702     psDB            *dbh,               ///< Database handle
    6703     psS32           *det_id,
    6704     psS32           *iteration,
    6705     char            **class_id,
    6706     char            **uri,
    6707     char            **recipe,
    6708     psF64           *bg,
    6709     psF64           *bg_stdev,
    6710     psF64           *bg_mean_stdev
    6711 );
    6712 
    67135652/** Insert a single detStackedImfileRow object into a table
    67145653 *
    … …  
    67335672    psDB            *dbh,               ///< Database handle
    67345673    psArray         *objects            ///< array of detStackedImfileRow objects
    6735 );
    6736 
    6737 /** Removes the last row from the database and returns it
    6738  *
    6739  * @return A new detStackedImfileRow on success or NULL on failure.
    6740  */
    6741 
    6742 detStackedImfileRow *detStackedImfilePopObject(
    6743     psDB            *dbh                ///< Database handle
    67445674);
    67455675
    … …  
    67575687    psDB            *dbh,               ///< Database handle
    67585688    const psFits    *fits               ///< psFits object
    6759 );
    6760 
    6761 /** Removes the last limit row from the database and returns them in a binary FITS table.
    6762  *
    6763  * This function assumes an empty psFits object and will create a FITS table as
    6764  * the first extension.
    6765  *
    6766  * @return true on success
    6767  */
    6768 
    6769 bool detStackedImfilePopFits(
    6770     psDB            *dbh,               ///< Database handle
    6771     psFits          *fits,              ///< psFits object
    6772     unsigned long long limit            ///< Maximum number of elements to return
    67735689);
    67745690
    … …  
    69255841);
    69265842
    6927 /** Removes the last row from the database and returns it
    6928  *
    6929  * @return true on success
    6930  */
    6931 
    6932 bool detNormalizedStatImfilePop(
    6933     psDB            *dbh,               ///< Database handle
    6934     psS32           *det_id,
    6935     psS32           *iteration,
    6936     char            **class_id,
    6937     psF32           *norm
    6938 );
    6939 
    69405843/** Insert a single detNormalizedStatImfileRow object into a table
    69415844 *
    … …  
    69605863    psDB            *dbh,               ///< Database handle
    69615864    psArray         *objects            ///< array of detNormalizedStatImfileRow objects
    6962 );
    6963 
    6964 /** Removes the last row from the database and returns it
    6965  *
    6966  * @return A new detNormalizedStatImfileRow on success or NULL on failure.
    6967  */
    6968 
    6969 detNormalizedStatImfileRow *detNormalizedStatImfilePopObject(
    6970     psDB            *dbh                ///< Database handle
    69715865);
    69725866
    … …  
    69845878    psDB            *dbh,               ///< Database handle
    69855879    const psFits    *fits               ///< psFits object
    6986 );
    6987 
    6988 /** Removes the last limit row from the database and returns them in a binary FITS table.
    6989  *
    6990  * This function assumes an empty psFits object and will create a FITS table as
    6991  * the first extension.
    6992  *
    6993  * @return true on success
    6994  */
    6995 
    6996 bool detNormalizedStatImfilePopFits(
    6997     psDB            *dbh,               ///< Database handle
    6998     psFits          *fits,              ///< psFits object
    6999     unsigned long long limit            ///< Maximum number of elements to return
    70005880);
    70015881
    … …  
    71676047);
    71686048
    7169 /** Removes the last row from the database and returns it
    7170  *
    7171  * @return true on success
    7172  */
    7173 
    7174 bool detNormalizedImfilePop(
    7175     psDB            *dbh,               ///< Database handle
    7176     psS32           *det_id,
    7177     psS32           *iteration,
    7178     char            **class_id,
    7179     char            **uri,
    7180     psF64           *bg,
    7181     psF64           *bg_stdev,
    7182     psF64           *bg_mean_stdev,
    7183     char            **b1_uri,
    7184     char            **b2_uri
    7185 );
    7186 
    71876049/** Insert a single detNormalizedImfileRow object into a table
    71886050 *
    … …  
    72076069    psDB            *dbh,               ///< Database handle
    72086070    psArray         *objects            ///< array of detNormalizedImfileRow objects
    7209 );
    7210 
    7211 /** Removes the last row from the database and returns it
    7212  *
    7213  * @return A new detNormalizedImfileRow on success or NULL on failure.
    7214  */
    7215 
    7216 detNormalizedImfileRow *detNormalizedImfilePopObject(
    7217     psDB            *dbh                ///< Database handle
    72186071);
    72196072
    … …  
    72316084    psDB            *dbh,               ///< Database handle
    72326085    const psFits    *fits               ///< psFits object
    7233 );
    7234 
    7235 /** Removes the last limit row from the database and returns them in a binary FITS table.
    7236  *
    7237  * This function assumes an empty psFits object and will create a FITS table as
    7238  * the first extension.
    7239  *
    7240  * @return true on success
    7241  */
    7242 
    7243 bool detNormalizedImfilePopFits(
    7244     psDB            *dbh,               ///< Database handle
    7245     psFits          *fits,              ///< psFits object
    7246     unsigned long long limit            ///< Maximum number of elements to return
    72476086);
    72486087
    … …  
    74116250);
    74126251
    7413 /** Removes the last row from the database and returns it
    7414  *
    7415  * @return true on success
    7416  */
    7417 
    7418 bool detNormalizedExpPop(
    7419     psDB            *dbh,               ///< Database handle
    7420     psS32           *det_id,
    7421     psS32           *iteration,
    7422     char            **recipe,
    7423     psF64           *bg,
    7424     psF64           *bg_stdev,
    7425     psF64           *bg_mean_stdev,
    7426     char            **b1_uri,
    7427     char            **b2_uri
    7428 );
    7429 
    74306252/** Insert a single detNormalizedExpRow object into a table
    74316253 *
    … …  
    74506272    psDB            *dbh,               ///< Database handle
    74516273    psArray         *objects            ///< array of detNormalizedExpRow objects
    7452 );
    7453 
    7454 /** Removes the last row from the database and returns it
    7455  *
    7456  * @return A new detNormalizedExpRow on success or NULL on failure.
    7457  */
    7458 
    7459 detNormalizedExpRow *detNormalizedExpPopObject(
    7460     psDB            *dbh                ///< Database handle
    74616274);
    74626275
    … …  
    74746287    psDB            *dbh,               ///< Database handle
    74756288    const psFits    *fits               ///< psFits object
    7476 );
    7477 
    7478 /** Removes the last limit row from the database and returns them in a binary FITS table.
    7479  *
    7480  * This function assumes an empty psFits object and will create a FITS table as
    7481  * the first extension.
    7482  *
    7483  * @return true on success
    7484  */
    7485 
    7486 bool detNormalizedExpPopFits(
    7487     psDB            *dbh,               ///< Database handle
    7488     psFits          *fits,              ///< psFits object
    7489     unsigned long long limit            ///< Maximum number of elements to return
    74906289);
    74916290
    … …  
    76396438);
    76406439
    7641 /** Removes the last row from the database and returns it
    7642  *
    7643  * @return true on success
    7644  */
    7645 
    7646 bool detMasterFramePop(
    7647     psDB            *dbh,               ///< Database handle
    7648     psS32           *det_id,
    7649     psS32           *iteration,
    7650     char            **comment
    7651 );
    7652 
    76536440/** Insert a single detMasterFrameRow object into a table
    76546441 *
    … …  
    76736460    psDB            *dbh,               ///< Database handle
    76746461    psArray         *objects            ///< array of detMasterFrameRow objects
    7675 );
    7676 
    7677 /** Removes the last row from the database and returns it
    7678  *
    7679  * @return A new detMasterFrameRow on success or NULL on failure.
    7680  */
    7681 
    7682 detMasterFrameRow *detMasterFramePopObject(
    7683     psDB            *dbh                ///< Database handle
    76846462);
    76856463
    … …  
    76976475    psDB            *dbh,               ///< Database handle
    76986476    const psFits    *fits               ///< psFits object
    7699 );
    7700 
    7701 /** Removes the last limit row from the database and returns them in a binary FITS table.
    7702  *
    7703  * This function assumes an empty psFits object and will create a FITS table as
    7704  * the first extension.
    7705  *
    7706  * @return true on success
    7707  */
    7708 
    7709 bool detMasterFramePopFits(
    7710     psDB            *dbh,               ///< Database handle
    7711     psFits          *fits,              ///< psFits object
    7712     unsigned long long limit            ///< Maximum number of elements to return
    77136477);
    77146478
    … …  
    78656629);
    78666630
    7867 /** Removes the last row from the database and returns it
    7868  *
    7869  * @return true on success
    7870  */
    7871 
    7872 bool detMasterImfilePop(
    7873     psDB            *dbh,               ///< Database handle
    7874     psS32           *det_id,
    7875     char            **class_id,
    7876     char            **uri,
    7877     char            **recipe
    7878 );
    7879 
    78806631/** Insert a single detMasterImfileRow object into a table
    78816632 *
    … …  
    79006651    psDB            *dbh,               ///< Database handle
    79016652    psArray         *objects            ///< array of detMasterImfileRow objects
    7902 );
    7903 
    7904 /** Removes the last row from the database and returns it
    7905  *
    7906  * @return A new detMasterImfileRow on success or NULL on failure.
    7907  */
    7908 
    7909 detMasterImfileRow *detMasterImfilePopObject(
    7910     psDB            *dbh                ///< Database handle
    79116653);
    79126654
    … …  
    79246666    psDB            *dbh,               ///< Database handle
    79256667    const psFits    *fits               ///< psFits object
    7926 );
    7927 
    7928 /** Removes the last limit row from the database and returns them in a binary FITS table.
    7929  *
    7930  * This function assumes an empty psFits object and will create a FITS table as
    7931  * the first extension.
    7932  *
    7933  * @return true on success
    7934  */
    7935 
    7936 bool detMasterImfilePopFits(
    7937     psDB            *dbh,               ///< Database handle
    7938     psFits          *fits,              ///< psFits object
    7939     unsigned long long limit            ///< Maximum number of elements to return
    79406668);
    79416669
    … …  
    81136841);
    81146842
    8115 /** Removes the last row from the database and returns it
    8116  *
    8117  * @return true on success
    8118  */
    8119 
    8120 bool detResidImfilePop(
    8121     psDB            *dbh,               ///< Database handle
    8122     psS32           *det_id,
    8123     psS32           *iteration,
    8124     char            **exp_tag,
    8125     char            **class_id,
    8126     char            **uri,
    8127     char            **recipe,
    8128     psF64           *bg,
    8129     psF64           *bg_stdev,
    8130     psF64           *bg_mean_stdev,
    8131     char            **b1_uri,
    8132     char            **b2_uri
    8133 );
    8134 
    81356843/** Insert a single detResidImfileRow object into a table
    81366844 *
    … …  
    81556863    psDB            *dbh,               ///< Database handle
    81566864    psArray         *objects            ///< array of detResidImfileRow objects
    8157 );
    8158 
    8159 /** Removes the last row from the database and returns it
    8160  *
    8161  * @return A new detResidImfileRow on success or NULL on failure.
    8162  */
    8163 
    8164 detResidImfileRow *detResidImfilePopObject(
    8165     psDB            *dbh                ///< Database handle
    81666865);
    81676866
    … …  
    81796878    psDB            *dbh,               ///< Database handle
    81806879    const psFits    *fits               ///< psFits object
    8181 );
    8182 
    8183 /** Removes the last limit row from the database and returns them in a binary FITS table.
    8184  *
    8185  * This function assumes an empty psFits object and will create a FITS table as
    8186  * the first extension.
    8187  *
    8188  * @return true on success
    8189  */
    8190 
    8191 bool detResidImfilePopFits(
    8192     psDB            *dbh,               ///< Database handle
    8193     psFits          *fits,              ///< psFits object
    8194     unsigned long long limit            ///< Maximum number of elements to return
    81956880);
    81966881
    … …  
    83657050);
    83667051
    8367 /** Removes the last row from the database and returns it
    8368  *
    8369  * @return true on success
    8370  */
    8371 
    8372 bool detResidExpPop(
    8373     psDB            *dbh,               ///< Database handle
    8374     psS32           *det_id,
    8375     psS32           *iteration,
    8376     char            **exp_tag,
    8377     char            **recipe,
    8378     psF64           *bg,
    8379     psF64           *bg_stdev,
    8380     psF64           *bg_mean_stdev,
    8381     char            **b1_uri,
    8382     char            **b2_uri,
    8383     bool            *accept
    8384 );
    8385 
    83867052/** Insert a single detResidExpRow object into a table
    83877053 *
    … …  
    84067072    psDB            *dbh,               ///< Database handle
    84077073    psArray         *objects            ///< array of detResidExpRow objects
    8408 );
    8409 
    8410 /** Removes the last row from the database and returns it
    8411  *
    8412  * @return A new detResidExpRow on success or NULL on failure.
    8413  */
    8414 
    8415 detResidExpRow *detResidExpPopObject(
    8416     psDB            *dbh                ///< Database handle
    84177074);
    84187075
    … …  
    84307087    psDB            *dbh,               ///< Database handle
    84317088    const psFits    *fits               ///< psFits object
    8432 );
    8433 
    8434 /** Removes the last limit row from the database and returns them in a binary FITS table.
    8435  *
    8436  * This function assumes an empty psFits object and will create a FITS table as
    8437  * the first extension.
    8438  *
    8439  * @return true on success
    8440  */
    8441 
    8442 bool detResidExpPopFits(
    8443     psDB            *dbh,               ///< Database handle
    8444     psFits          *fits,              ///< psFits object
    8445     unsigned long long limit            ///< Maximum number of elements to return
    84467089);
    84477090
    … …  
    86047247);
    86057248
    8606 /** Removes the last row from the database and returns it
    8607  *
    8608  * @return true on success
    8609  */
    8610 
    8611 bool detRunSummaryPop(
    8612     psDB            *dbh,               ///< Database handle
    8613     psS32           *det_id,
    8614     psS32           *iteration,
    8615     psF64           *bg,
    8616     psF64           *bg_stdev,
    8617     psF64           *bg_mean_stdev,
    8618     bool            *accept
    8619 );
    8620 
    86217249/** Insert a single detRunSummaryRow object into a table
    86227250 *
    … …  
    86417269    psDB            *dbh,               ///< Database handle
    86427270    psArray         *objects            ///< array of detRunSummaryRow objects
    8643 );
    8644 
    8645 /** Removes the last row from the database and returns it
    8646  *
    8647  * @return A new detRunSummaryRow on success or NULL on failure.
    8648  */
    8649 
    8650 detRunSummaryRow *detRunSummaryPopObject(
    8651     psDB            *dbh                ///< Database handle
    86527271);
    86537272
    … …  
    86677286);
    86687287
    8669 /** Removes the last limit row from the database and returns them in a binary FITS table.
    8670  *
    8671  * This function assumes an empty psFits object and will create a FITS table as
    8672  * the first extension.
    8673  *
    8674  * @return true on success
    8675  */
    8676 
    8677 bool detRunSummaryPopFits(
    8678     psDB            *dbh,               ///< Database handle
    8679     psFits          *fits,              ///< psFits object
    8680     unsigned long long limit            ///< Maximum number of elements to return
    8681 );
    8682 
    86837288/** Selects up to limit from the database and returns them in a binary FITS table
    86847289 *

  • trunk/ippdb/tests/Makefile.am

    r7461 r9423  
    5151    droptable \
    5252    insert \
    53     pop \
    5453    insertobject \
    55     popobject \
    5654    insertfits \
    57     popfits \
    5855    selectrowsfits \
    5956    metadatafromobject \

  • trunk/ippdb/tests/alloc.c

    r9307 r9423  
    10221022        detRunRow       *object;
    10231023
    1024         object = detRunRowAlloc(-32, "a string", "a string"    );
    1025 
    1026         if (!object) {
    1027             exit(EXIT_FAILURE);
    1028         }
    1029 
     1024        object = detRunRowAlloc(-32, -32, "a string", "a string"    );
     1025
     1026        if (!object) {
     1027            exit(EXIT_FAILURE);
     1028        }
     1029
     1030        if (!object->det_id == -32) {
     1031            psFree(object);
     1032            exit(EXIT_FAILURE);
     1033        }
    10301034        if (!object->iteration == -32) {
    10311035            psFree(object);

  • trunk/ippdb/tests/insert.c

    r9307 r9423  
    358358        }
    359359
    360         if (!detRunInsert(dbh, -32, "a string", "a string")) {
     360        if (!detRunInsert(dbh, -32, -32, "a string", "a string")) {
    361361            exit(EXIT_FAILURE);
    362362        }

  • trunk/ippdb/tests/insertobject.c

    r9307 r9423  
    520520        }
    521521
    522         object = detRunRowAlloc(-32, "a string", "a string");
     522        object = detRunRowAlloc(-32, -32, "a string", "a string");
    523523        if (!object) {
    524524            exit(EXIT_FAILURE);

  • trunk/ippdb/tests/metadatafromobject.c

    r9307 r9423  
    12081208        bool            status;
    12091209
    1210         object = detRunRowAlloc(-32, "a string", "a string");
     1210        object = detRunRowAlloc(-32, -32, "a string", "a string");
    12111211        if (!object) {
    12121212            exit(EXIT_FAILURE);
    … …  
    12201220        psFree(object);
    12211221
     1222        if (!psMetadataLookupS32(&status, md, "det_id") == -32) {
     1223            psFree(md);
     1224            exit(EXIT_FAILURE);
     1225        }
    12221226        if (!psMetadataLookupS32(&status, md, "iteration") == -32) {
    12231227            psFree(md);

  • trunk/ippdb/tests/objectfrommetadata.c

    r9307 r9423  
    18511851
    18521852        md = psMetadataAlloc();
     1853        if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) {
     1854            psFree(md);
     1855            exit(EXIT_FAILURE);
     1856        }
    18531857        if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) {
    18541858            psFree(md);
    … …  
    18721876        psFree(md);
    18731877
     1878        if (!object->det_id == -32) {
     1879            psFree(object);
     1880            exit(EXIT_FAILURE);
     1881        }
    18741882        if (!object->iteration == -32) {
    18751883            psFree(object);

  • trunk/ippdb/tests/testsuite.at

    r7461 r9423  
    6060
    6161###
    62 AT_SETUP([Pop()])
    63 AT_KEYWORDS([Pop])
    64 
    65 AT_CHECK([dbsetup])
    66 # run insert so there is a row in the table
    67 AT_CHECK([insert])
    68 AT_CHECK([pop])
    69 AT_CHECK([dbcleanup])
    70 
    71 AT_CLEANUP
    72 
    73 ###
    7462AT_SETUP([InsertObject()])
    7563AT_KEYWORDS([InsertObject])
    … …  
    7765AT_CHECK([dbsetup])
    7866AT_CHECK([insertobject])
    79 AT_CHECK([dbcleanup])
    80 
    81 AT_CLEANUP
    82 
    83 ###
    84 AT_SETUP([PopObject()])
    85 AT_KEYWORDS([PopObject])
    86 
    87 AT_CHECK([dbsetup])
    88 # run insert so there is a row in the table
    89 AT_CHECK([insert])
    90 AT_CHECK([popobject])
    9167AT_CHECK([dbcleanup])
    9268
    … …  
    10177AT_CHECK([insert])
    10278# run popfis so there is afits file to read
    103 AT_CHECK([popfits])
     79AT_CHECK([selectrowsfits])
    10480AT_CHECK([insertfits])
    105 AT_CHECK([dbcleanup])
    106 if [ test -f "blargh" ] ; then
    107     rm -f "blargh"
    108 fi
    109 
    110 AT_CLEANUP
    111 
    112 ###
    113 AT_SETUP([PopFits()])
    114 AT_KEYWORDS([PopFits])
    115 
    116 AT_CHECK([dbsetup])
    117 # run insert so there is a row in the table
    118 AT_CHECK([insert])
    119 AT_CHECK([popfits])
    12081AT_CHECK([dbcleanup])
    12182if [ test -f "blargh" ] ; then
Note: See TracChangeset for help on using the changeset viewer.