Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/.cvsignore (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/.cvsignore (revision 22077) @@ -0,0 +1,2 @@ +ippdb.m4 +ippdb.mdc Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/Makefile =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/Makefile (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/Makefile (revision 22077) @@ -0,0 +1,26 @@ +SHELL=/bin/sh +GLUEFORGE=`which glueforge` + +all: ippdb.mdc + +ippdb.mdc : ipp.m4 *.md + m4 ipp.m4 > ippdb.mdc + +## please leave the output target as ippdb.src and +## move to ippdb by hand for cvs import +install: ippdb.mdc + rm -rf ../ippdb.src + $(GLUEFORGE) -i ippdb.mdc --output ../ippdb.src + chmod +x ../ippdb.src/autogen.sh + +src: ippdb.mdc + $(GLUEFORGE) -i ippdb.mdc --output ../ippdb + chmod +x ../ippdb/autogen.sh + +foo: src + $(MAKE) -C ../ippdb install + +build : ippdb ippdb.mdc + +clean: + @rm -f *~ Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/cam.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/cam.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/cam.md (revision 22077) @@ -0,0 +1,37 @@ +camRun METADATA + cam_id S64 0 # Primary Key AUTO_INCREMENT + chip_id S64 0 # Key INDEX(cam_id, chip_id) fkey(chip_id) ref chipRun(chip_id) + state STR 64 # key + workdir STR 255 + workdir_state STR 64 # key + label STR 64 # key + reduction STR 64 + expgroup STR 64 # key + dvodb STR 255 +END + +camProcessedExp METADATA +# the camPendingExp row gets deleted so we can not put a fkey on cam_id + cam_id S64 0 # Primary Key + chip_id S64 0 # Primary Key fkey(cam_id, chip_id) ref camRun(cam_id, chip_id) + uri STR 255 + bg F32 0.0 + bg_stdev F32 0.0 + bg_mean_stdev F32 0.0 + sigma_ra F32 0.0 + sigma_dec F32 0.0 + zp_mean F32 0.0 + zp_stdev F32 0.0 + fwhm F32 0.0 + fwhm_range F32 0.0 + n_stars S32 0 + n_extended S32 0 + n_cr S32 0 + n_astrom S32 0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +camMask METADATA + label STR 64 # Primary Key +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/changes.txt =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/changes.txt (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/changes.txt (revision 22077) @@ -0,0 +1,25 @@ +How to manually change the database between versions via mySQL commands. + +This file is generated manually, and may not be complete. + + +Version 1.1.20 --> 1.1.21: + +alter table camProcessedExp drop nastro; +alter table camProcessedExp add (fwhm double, fwhm_range double, n_stars int(11), n_extended int(11), n_cr int(11), n_astrom int(11)); +alter table chipProcessedImfile add column (bias double, bias_stdev double, fringe_0 double, fringe_1 double, fringe_2 double, sigma_ra double, sigma_dec double, ap_resid double, ap_resid_stdev double, fwhm double, fwhm_range double, n_stars int(11), n_extended int(11), n_cr int(11), n_astrom int(11)); +alter table warpSkyfile add column path_base varchar(255) NULL DEFAULT NULL after uri; +alter table diffSkyfile add column path_base varchar(255) NULL DEFAULT NULL after uri; +alter table stackSumSkyfile add column path_base varchar(255) NULL DEFAULT NULL after uri; + + +Version 1.1.22 --> 1.1.23 +# Adding support for reduction classes (which are used to specify recipes for parts of the pipeline). +# Adding 'reduction' to detRun +# Renaming 'recipe' in {chip,cam}{Pending,Processed}Exp to 'reduction' + +alter table detRun add column reduction varchar(64) NULL DEFAULT NULL after exp_type; +alter table chipPendingExp change column recipe reduction varchar(64); +alter table chipProcessedExp change column recipe reduction varchar(64); +alter table camPendingExp change column recipe reduction varchar(64); +alter table camProcessedExp change column recipe reduction varchar(64); Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/chip.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/chip.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/chip.md (revision 22077) @@ -0,0 +1,42 @@ +chipRun METADATA + chip_id S64 0 # Primary Key AUTO_INCREMENT + exp_id S64 64 # Key INDEX(chip_id, exp_id) fkey (exp_id) ref rawExp(exp_id) + state STR 64 # Key + workdir STR 255 + workdir_state STR 64 # Key + label STR 64 # Key + reduction STR 64 # Reduction class + expgroup STR 64 # Key + dvodb STR 255 +END + +chipProcessedImfile METADATA + chip_id S64 0 # Primary Key fkey (chip_id, exp_id) ref chipRun(chip_id, exp_id) + exp_id S64 64 # Primary Key fkey (exp_id, class_id) ref rawImfile(exp_id, class_id) + class_id STR 64 # Primary Key + uri STR 255 + bg F32 0.0 + bg_stdev F32 0.0 + bg_mean_stdev F32 0.0 + bias F32 0.0 + bias_stdev F32 0.0 + fringe_0 F32 0.0 + fringe_1 F32 0.0 + fringe_2 F32 0.0 + sigma_ra F32 0.0 + sigma_dec F32 0.0 + ap_resid F32 0.0 + ap_resid_stdev F32 0.0 + fwhm F32 0.0 ## replace this with fwhm_major + fwhm_range F32 0.0 ## replace this with fwhm_minor + n_stars S32 0 + n_extended S32 0 + n_cr S32 0 + n_astrom S32 0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +chipMask METADATA + label STR 64 # Primary Key +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/config.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/config.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/config.md (revision 22077) @@ -0,0 +1,5 @@ +glueforge METADATA + pkg_name STR ippdb + pkg_namespace STR ippdb + pkg_version STR 1.1.27 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/det.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/det.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/det.md (revision 22077) @@ -0,0 +1,240 @@ +detRun METADATA + det_id S64 0 # Primary Key AUTO_INCREMENT + iteration S32 0 # Key INDEX(det_id, iteration) + det_type STR 64 # Key + mode STR 64 # Key + state STR 64 # Key + filelevel STR 64 + workdir STR 255 # destination for output files + camera STR 64 + telescope STR 64 + exp_type STR 64 # XXX this should be dropped + reduction STR 64 # Reduction clas + filter STR 64 + airmass_min F32 0.0 + airmass_max F32 0.0 + exp_time_min F32 0.0 + exp_time_max F32 0.0 + ccd_temp_min F32 0.0 + ccd_temp_max F32 0.0 + posang_min F64 0.0 + posang_max F64 0.0 + registered TAI 0001-01-01T00:00:00Z + time_begin TAI 0001-01-01T00:00:00Z + time_end TAI 0001-01-01T00:00:00Z + use_begin TAI 0001-01-01T00:00:00Z + use_end TAI 0001-01-01T00:00:00Z + solang_min F32 0.0 + solang_max F32 0.0 + label STR 64 # key + parent S32 0 # Key +END + +detInputExp METADATA + det_id S64 0 # Primary Key fkey(det_id) ref detRun(det_id) + iteration S32 0 # Primary Key fkey(exp_id) ref rawExp(exp_id) + exp_id S64 64 # Primary Key INDEX(det_id, exp_id) + include BOOL f # INDEX(det_id, iteration) +END + +detProcessedImfile METADATA + det_id S64 0 # Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id) + exp_id S64 64 # Primary Key fkey(exp_id, class_id) ref rawImfile(exp_id, class_id) + class_id STR 64 # Primary Key INDEX(det_id, class_id) + uri STR 255 # INDEX(det_id, exp_id) + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + fringe_0 F64 0.0 + fringe_1 F64 0.0 + fringe_2 F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +detProcessedExp METADATA + det_id S64 0 # Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id) + exp_id S64 64 # Primary Key fkey(det_id, exp_id) ref detProcessedImfile(det_id, exp_id) + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + fringe_0 F64 0.0 + fringe_1 F64 0.0 + fringe_2 F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +# +# detStackedImfile does not depend on detProcessedExp. detProcesedExp is purely +# FYI values and can be calculated in parellel +# +detStackedImfile METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration) + iteration S32 0 # Primary Key fkey(det_id, class_id) ref detProcessedImfile(det_id, class_id) + class_id STR 64 # Primary Key + uri STR 255 + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + fault S16 0 # Key NOT NULL +END + +detNormalizedStatImfile METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration) + iteration S32 0 # Primary Key fkey(det_id, iteration, class_id) ref detStackedImfile(det_id, iteration, class_id) + class_id STR 64 # Primary Key + norm F32 0.0 + fault S16 0 # Key NOT NULL +END + +detNormalizedImfile METADATA + det_id S64 0 # Primary Key fkey(det_id) ref detInputExp(det_id) + iteration S32 0 # Primary Key fkey(det_id, iteration, class_id) ref detNormalizedStatImfile(det_id, iteration, class_id) + class_id STR 64 # Primary Key INDEX(det_id, iteration) + uri STR 255 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +detNormalizedExp METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration) + iteration S32 0 # Primary Key fkey(det_id, iteration) ref detNormalizedImfile(det_id, iteration) + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +#detMasterFrame METADATA +# det_id S64 0 # Primary Key +# iteration S32 0 # Primary Key +# comment STR 255 +#END +# +## drop? +#detMasterImfile METADATA +# det_id S64 0 # Primary Key +# class_id STR 64 # Primary Key +# uri STR 255 +# recipe STR 64 +#END + +detResidImfile METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration, exp_id) ref detInputExp(det_id, iteration, exp_id) + iteration S32 0 # Primary Key fkey(det_id, exp_id, class_id) ref detProcessedImfile(det_id, exp_id, class_id) + exp_id S64 64 # Primary Key fkey(det_id, iteration) ref detNormalizedExp(det_id, iteration) + class_id STR 64 # Primary Key INDEX(det_id, iteration, exp_id) + uri STR 255 + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + bg_skewness F64 0.0 + bg_kurtosis F64 0.0 + bin_stdev F64 0.0 + fringe_0 F64 0.0 + fringe_1 F64 0.0 + fringe_2 F64 0.0 + fringe_resid_0 F64 0.0 + fringe_resid_1 F64 0.0 + fringe_resid_2 F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END + +detResidExp METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration, exp_id) ref detInputExp(det_id, iteration, exp_id) + iteration S32 0 # Primary Key fkey(det_id, iteration, exp_id) ref detResidImfile(det_id, iteration, exp_id) + exp_id S64 64 # Primary Key INDEX(det_id, iteration) + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + bg_skewness F64 0.0 + bg_kurtosis F64 0.0 + bin_stdev F64 0.0 + fringe_0 F64 0.0 + fringe_1 F64 0.0 + fringe_2 F64 0.0 + fringe_resid_0 F64 0.0 + fringe_resid_1 F64 0.0 + fringe_resid_2 F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + accept BOOL f + fault S16 0 # Key NOT NULL +END + +detRunSummary METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration) + iteration S32 0 # Primary Key fkey(det_id, iteration) ref detResidExp(det_id, iteration) + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + accept BOOL f + fault S16 0 # Key NOT NULL +END + +# +# Note: This table needs to stay more or less identical to detNormalizedImfile. +# It only exists as a seperate entity so they it can have different fkeys +# +detRegisteredImfile METADATA + det_id S64 0 # Primary Key fkey(det_id, iteration) ref detRun(det_id, iteration) + iteration S32 0 # Primary Key + class_id STR 64 # Primary Key + uri STR 255 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + path_base STR 255 + fault S16 0 # Key NOT NULL +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/diff.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/diff.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/diff.md (revision 22077) @@ -0,0 +1,36 @@ +# $Id: diff.md,v 1.5 2007-07-17 03:10:08 jhoblitt Exp $ + +diffRun METADATA + diff_id S64 0 # Primary Key AUTO_INCREMENT + state STR 64 # Key + workdir STR 255 + dvodb STR 255 + registered TAI NULL + skycell_id STR 64 # Key + tess_id STR 64 # Key +END + +# +# Diff Sky Cells Mode +# + +# only ever 2 per run - one template / one not +diffInputSkyfile METADATA + diff_id S64 0 # Primary Key fkey(diff_id) ref diffRun(diff_id) + template BOOL f # Primary Key + stack_id S64 0 # fkey(stack_id) ref stackSumSkyfile(stack_id) + warp_id S64 0 # fkey(warp_id, skycell_id, tess_id) ref warpSkyfile(warp_id, skycell_id, tess_id) + skycell_id STR 64 # Key + tess_id STR 64 # Key +# either a input or a template + kind STR 64 # Key +END + +diffSkyfile METADATA + diff_id S64 0 # Primary Key fkey(diff_id) ref diffRun(diff_id) + uri STR 255 + path_base STR 255 + bg F64 0.0 + bg_stdev F64 0.0 + fault S16 0 # Key +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/dimm.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/dimm.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/dimm.md (revision 22077) @@ -0,0 +1,21 @@ +# Table 13: DIMM Measurements Table +# Column Name Datatype Description +# Time date/time The time the DIMM observation was taken. +# sigmax float Raw dispersion in x. +# sigmay float Raw dispersion in y. +# FWHM float Dervied seeing full width at half maximum. +# RA float The coordinates of the measured star. +# DEC float The coordinates of the measured star. +# Exposure time float The exposure time of the DIMM observation. +# Telescope ID string source of the DIMM data + +dimm METADATA +# time DATETIME 2006-01-11T00:00:00 + sigmax F32 0.0 + sigmay F32 0.0 + fwhm F32 0.0 + ra F64 0.0 + decl F64 0.0 + expttime F32 0.0 + telescope_id STR 255 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/dome.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/dome.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/dome.md (revision 22077) @@ -0,0 +1,16 @@ +# Table 15: Dome Status Table +# Column Name Datatype Description +# Time date/time The time for which the dome status is valid. +# Azimuth float The azimuth of the dome. +# Open status boolean Whether the dome is open or not. +# Lights status boolean Whether lights are on in the dome or not. +# Track status boolean Whether dome is tracking telescope or not. + +dome METADATA +# time DATETIME 2006-01-11T00:00:00 + az F32 0.0 + open BOOL t + light BOOL t + # XXX is it possible for the dome slit to not track the telescope? ;) + track BOOL t +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/guide.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/guide.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/guide.md (revision 22077) @@ -0,0 +1,5 @@ +guidePendingExp METADATA + guide_id S64 0 # Primary Key AUTO_INCREMENT + exp_id S64 64 # Key + recipe STR 64 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/ipp.m4 =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/ipp.m4 (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/ipp.m4 (revision 22077) @@ -0,0 +1,19 @@ +include(config.md) +dnl include(weather.md) +dnl include(skyp_transparency.md) +dnl include(skyp_absorption.md) +dnl include(skyp_emission.md) +dnl include(dimm.md) +dnl include(skyp_ir.md) +dnl include(dome.md) +dnl include(telescope.md) +include(tasks.md) +include(guide.md) +include(chip.md) +include(cam.md) +include(warp.md) +include(diff.md) +include(stack.md) +include(det.md) +include(magic.md) +dnl include(skycell.md) Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/magic.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/magic.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/magic.md (revision 22077) @@ -0,0 +1,35 @@ +# $Id: magic.md,v 1.4 2007-08-22 02:25:06 jhoblitt Exp $ + +magicRun METADATA + magic_id S64 0 # Primary Key AUTO_INCREMENT + state STR 64 # Key + workdir STR 255 + workdir_state STR 255 # Key + label STR 64 # key + dvodb STR 255 + registered TAI NULL +END + +magicInputSkyfile METADATA + magic_id S64 0 # Primary Key fkey(magic_id) ref magicRun(magic_id) + diff_id S64 0 # Key fkey(diff_id) ref diffRun(diff_id) + node S32 0 # AUTO_INCREMENT INDEX(magic_id, node) +END + +magicTree METADATA + magic_id S64 0 # Primary Key fkey(magic_id) ref magicRun(magic_id) + node STR 64 # Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node) + dep STR 64 # fkey(magic_id, dep) ref magicInputSkyfile(magic_id, node) + +END + +magicNodeResult METADATA + magic_id S64 0 # Primary Key fkey(magic_id) ref magicRun(magic_id) + node STR 64 # Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node) + uri STR 255 +END + +magicMask METADATA + magic_id S64 0 # Primary Key fkey(magic_id) ref magicRun(magic_id) + uri STR 255 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/notes.txt =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/notes.txt (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/notes.txt (revision 22077) @@ -0,0 +1,41 @@ + +2007.06.08 : EAM + + * when changing the database schema: + * increment the pkg_version number on dbconfig/config.md + * increment the ippdb version number in ippTools/configure.ac (to match) + * increment the ippTools version number in ippTools/configure.ac + * build ippbd ('make src' in dbconfig) + * check in dbconfig, ippdb, and ippTools + +2007.06.04 : EAM + +I am adding additional fields which we will need for selecting the +input detrend images: + +rawExp : + user stat 1 + user stat 2 + user stat 3 + user stat 4 + user stat 5 + +detProcessedImfile, detProcessedExp: + fringe amplitude + user stat 1 + user stat 2 + user stat 3 + user stat 4 + user stat 5 + +detResidImfile, detResidExp: + binned stdev + fringe_0 + fringe_1 + fringe_2 + user stat 1 + user stat 2 + user stat 3 + user stat 4 + user stat 5 + Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/skycell.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/skycell.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/skycell.md (revision 22077) @@ -0,0 +1,25 @@ +# $Id: skycell.md,v 1.4 2007-07-06 01:16:08 jhoblitt Exp $ + +skyCell METADATA + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key + ra1 F64 0.0 + decl1 F64 0.0 + ra2 F64 0.0 + decl2 F64 0.0 + ra3 F64 0.0 + decl3 F64 0.0 + ra4 F64 0.0 + decl4 F64 0.0 +END + +skyCellMap METADATA + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key + exp_id S64 64 # Primary Key + p3_version S32 0 # Primary Key +# class is not yet consistently carried through pXtools +# class STR 64 # Primary Key + class_id STR 64 # Primary Key +END + Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_absorption.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_absorption.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_absorption.md (revision 22077) @@ -0,0 +1,25 @@ +# Table 11: Skyprobe Line Absorption Table (sample entries) +# Column Name Datatype Description +# Time date/time The time the LRProbe observation was taken. +# Disperser ID string ID of the dispersing element +# Atm Component 1 float The strength of the 1st atmospheric component. +# Atm Component 2 float The strength of the 2nd atmospheric component. +# Atm Component 3 float The strength of the 3rd atmospheric component. +# Disperser ID string ID of the dispersing element +# Number of stars int Number of stars used to measure the absorptions. +# Astrometry coords The astrometry used on the LRProbe image. +# Exposure time float The exposure time of the LRProbe image. +# Sky brightness float The measured sky (surface) brightness, in physical units. + +skyp_absorption METADATA +# time DATETIME 2006-01-10T00:00:00 + disperser_id STR 255 + atmcomp1 F32 0.0 + atmcomp2 F32 0.0 + atmcomp3 F32 0.0 + nstars S32 0 + ra F64 0.0 + decl F64 0.0 + exptime F32 0.0 + sky_bright F64 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_emission.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_emission.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_emission.md (revision 22077) @@ -0,0 +1,20 @@ +# Table 12: Skyprobe Line Emission Table (sample entries) +# Column Name Datatype Description +# Time date/time The time the LRProbe observation was taken. +# Disperser ID string ID of the dispersing element +# Atm Component 1 float The strength of the 1st atmospheric component. +# Atm Component 2 float The strength of the 2nd atmospheric component. +# Atm Component 3 float The strength of the 3rd atmospheric component. +# Continuum float The strength of the continuum emission. +# Disperser ID string ID of the dispersing element +# Exposure time float The exposure time of the LRProbe image. + +skyp_emission METADATA +# time DATETIME 2006-01-11T00:00:00 + disperser_id STR 255 + atmcomp1 F32 0.0 + atmcomp2 F32 0.0 + atmcomp3 F32 0.0 + continuum F32 0.0 + exptime F32 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_ir.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_ir.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_ir.md (revision 22077) @@ -0,0 +1,18 @@ +# Table 14: Near IR Wide-field Camera Results Table +# Column Name Datatype Description +# Time date/time The time the NIR observation was taken. +# Sky brightness float The sky (surface) brightness in the NIR observation. +# Sky variance float The variance in the sky (surface) brightness. +# Astrometry coords The astrometry used on the NIR image. +# FOV X float field width +# FOV Y float field height + +skyp_ir METADATA +# time DATETIME 2006-01-11T00:00:00 + sky_bright F64 0.0 + sky_var F64 0.0 + ra F64 0.0 + decl F64 0.0 + fov_x F32 0.0 + fov_y F32 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_transparency.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_transparency.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/skyp_transparency.md (revision 22077) @@ -0,0 +1,21 @@ +# Table 10: SkyProbe Transparency Table (sample entries) +# Column Name Datatype Description +# Time date/time The time the SkyProbe image was taken. +# Filter string Filter used for SkyProbe image. +# Transparency float The derived transparency. +# Number of stars int The number of stars used to measure the transparency. +# Astrometry coords The astrometry used on the SkyProbe image. +# Exposure time float The exposure time of the SkyProbe image. +# Sky brightness float The measured sky (surface) brightness, counts / second + +skyp_transparency METADATA +# time DATETIME 2006-01-10T00:00:00 # Primary Key + filter STR 255 + trans F64 0.0 + nstars S32 0 +# astrom + ra F64 0.0 + decl F64 0.0 + exptime F32 0.0 + sky_bright F64 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/stack.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/stack.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/stack.md (revision 22077) @@ -0,0 +1,25 @@ +# $Id: stack.md,v 1.4 2007-07-11 00:24:29 jhoblitt Exp $ + +stackRun METADATA + stack_id S64 0 # Primary Key AUTO_INCREMENT + state STR 64 # Key + workdir STR 255 + dvodb STR 255 + registered TAI NULL + skycell_id STR 64 # Key + tess_id STR 64 # Key +END + +stackInputSkyfile METADATA + stack_id S64 0 # Primary Key fkey(stack_id) ref stackRun(stack_id) + warp_id S64 0 # Primary Key fkey(warp_id) ref warpSkyfile(warp_id) +END + +stackSumSkyfile METADATA + stack_id S64 0 # Primary Key fkey(stack_id) ref stackRun(stack_id) + uri STR 255 + path_base STR 255 + bg F64 0.0 + bg_stdev F64 0.0 + fault S16 0 # Key +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/tasks.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/tasks.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/tasks.md (revision 22077) @@ -0,0 +1,170 @@ +# $Id: tasks.md,v 1.140 2007-08-22 02:25:06 jhoblitt Exp $ + +# this table records all exposure ID ever seen from the summit +# exp_name == fileset + +# note that dec is a MySQL reserved word +# note that use is a MySQL reserved word +# note that exp is a MySQL reserved word + +# for use with this stored procedure to generate exp_ids under Mysql 5+ +# +#CREATE FUNCTION genTag (exp_name varchar(64)) RETURNS VARCHAR(64) +#BEGIN +# UPDATE expTagCounter SET counter = LAST_INSERT_ID(counter + 1); +# RETURN CONCAT(exp_name, '.', LAST_INSERT_ID()); +#END +# +#expTagCounter METADATA +# counter U64 0 +#END + +# list of source exposures -- updated as exposures are seen +# summitExp.imfiles is updated as filesets are queried default value should be +# -1 as NULL or 0 might be a valid value (empty fileset) +summitExp METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key + dateobs UTC NULL + exp_type STR 64 + uri STR 255 + imfiles S32 0 +END + +# class == type of file +# class_id == type set id +# list of source images -- updated as exposures/filesets are queried +summitImfile METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key + file_id STR 64 # Key + bytes S32 0 + md5sum STR 32 + class STR 64 # Primary Key + class_id STR 64 # Primary Key + uri STR 255 +END + +# list of exposures that have had their imfiles/files registered (but not +# downloaded) +pzPendingExp METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key +END + +pzPendingImfile METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key + class STR 64 # Primary Key + class_id STR 64 # Primary Key +END + +# list of exposures that have had all of their imfiles downloaded +pzDoneExp METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key +END + +pzDoneImfile METADATA + exp_name STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key + class STR 64 # Primary Key + class_id STR 64 # Primary Key + uri STR 255 +END + +newExp METADATA + exp_id S64 0 # Primary Key AUTO_INCREMENT + tmp_exp_name STR 64 # Key + tmp_camera STR 64 # Key + tmp_telescope STR 64 # Key + state STR 64 # Key + workdir STR 255 # destination for output files + workdir_state STR 64 # key + reduction STR 64 # Reduction class +END + +# class needs to be carried here so it can go into rawImfile and be normalized +# from there +newImfile METADATA + exp_id S64 64 # Primary Key fkey(exp_id) ref newExp(exp_id) + tmp_class_id STR 64 # Primary Key + uri STR 255 +END + +# paired with rawImfile +rawExp METADATA + exp_id S64 64 # Primary Key fkey(exp_id) ref newExp(exp_id) + exp_name STR 64 + camera STR 64 + telescope STR 64 + dateobs UTC 0001-01-01T00:00:00Z + exp_tag STR 255 + exp_type STR 64 + filelevel STR 64 + workdir STR 255 # destination for output files + reduction STR 64 # Reduction class + filter STR 64 + airmass F32 0.0 + ra F64 0.0 + decl F64 0.0 + exp_time F32 0.0 + sat_pixel_frac F32 0.0 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + alt F64 0.0 + az F64 0.0 + ccd_temp F32 0.0 + posang F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + object STR 64 + solang F32 0.0 + fault S16 0 # Key NOT NULL +END + +rawImfile METADATA + exp_id S64 64 # Primary Key fkey(exp_id, tmp_class_id) ref newImfile(exp_id, tmp_class_id) + exp_name STR 64 + camera STR 64 + telescope STR 64 + dateobs UTC 0001-01-01T00:00:00Z + tmp_class_id STR 64 # Key + class_id STR 64 # Primary Key + uri STR 255 + exp_type STR 64 +# This field is used to set the per exp filelevel. Thus the values for all of +# the imfiles in an exposure need to be sanity checked to make sure that this +# value is in argeement. + filelevel STR 64 + filter STR 64 + airmass F32 0.0 + ra F64 0.0 + decl F64 0.0 + exp_time F32 0.0 + sat_pixel_frac F32 0.0 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + alt F64 0.0 + az F64 0.0 + ccd_temp F32 0.0 + posang F64 0.0 + user_1 F64 0.0 + user_2 F64 0.0 + user_3 F64 0.0 + user_4 F64 0.0 + user_5 F64 0.0 + object STR 64 + fault S16 0 # Key NOT NULL +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/telescope.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/telescope.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/telescope.md (revision 22077) @@ -0,0 +1,18 @@ +# Table 16: Telescope Status +# Column Name Datatype Description +# Time date/time The time for which the telescope status is valid. +# Guide status enum The status of the guiding. +# Altitude float The telescope altitude. +# Azimuth float The telescope azimuth. +# RA float The telescope Right Ascension (ICRS ~ J2000). +# Dec float The telescope Declination (ICRS ~ J2000). + +telescope METADATA +# time DATETIME 2006-01-11T00:00:00 # Primary Key +# XXX there is currently no way to declare an enum - use str or int instead? + guide STR 255 + alt F32 0.0 + az F32 0.0 + ra F64 0.0 + decl F64 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/warp.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/warp.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/warp.md (revision 22077) @@ -0,0 +1,55 @@ +# $Id: warp.md,v 1.6 2007-08-14 02:13:56 jhoblitt Exp $ + +# +# We have at least 3 different run types +# a) single epoch differing +# b) magic run operates on "complete" exposures +# c) multiple epoch differing/stacking operations +# + +# define a new warprun for a single skycell +warpRun METADATA + warp_id S64 0 # Primary Key AUTO_INCREMENT + mode STR 64 # Key + state STR 64 # Key + workdir STR 255 + dvodb STR 255 + registered TAI NULL +END + +# +# Warp to Sky Cell Mode +# + +# the list of imfiles in our skycell keyed against phase 3 +# only allow one cam_version of an exp_id per warpRun +warpInputExp METADATA + warp_id S64 0 # Primary Key fkey(warp_id) ref warpRun(warp_id) + cam_id S64 0 # Primary Key fkey(cam_id) ref camProcessedExp(cam_id) +# if magic is T then look for the exp_id in the magic output tables + magiced BOOL f # Key +END + +warpSkyCellMap METADATA + warp_id S64 0 # Primary Key fkey(warp_id, cam_id) ref warpInputExp(warp_id, cam_id) + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key + cam_id S64 0 # Primary Key +# class is not yet consistently carried through pXtools +# class STR 64 # Primary Key + class_id STR 64 # Primary Key + fault S16 0 # Key +END + +warpSkyfile METADATA + warp_id S64 0 # Primary Key fkey(warp_id, skycell_id, tess_id) ref warpSkyCellMap(warp_id, skycell_id, tess_id) + skycell_id STR 64 # Primary Key + tess_id STR 64 # Primary Key + uri STR 255 + path_base STR 255 + bg F64 0.0 + bg_stdev F64 0.0 + pixel_fill F64 0.0 # Key + fault S16 0 # Key +END + Index: /tags/ipp-1-X/rel-1_1_27/dbconfig/weather.md =================================================================== --- /tags/ipp-1-X/rel-1_1_27/dbconfig/weather.md (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/dbconfig/weather.md (revision 22077) @@ -0,0 +1,19 @@ +# Table 9: Weather Table: some sample weather points +# Column Name Datatype Description +# Time date/time The time the weather information was measured. +# Temperature 01 float The external temperature +# Temperature 02 float The temperature at top of the dome +# Temperature 03 float The temperature on the primary mirror +# Humidity float The relative humidity. +# Pressure float The (external) atmospheric pressure. + +weather METADATA +# time DATETIME 2006-01-10T00:00:00 # Primary Key + temp01 F32 0.0 + humi01 F32 0.0 + temp02 F32 0.0 + humi02 F32 0.0 + temp03 F32 0.0 + humi03 F32 0.0 + pressure F32 0.0 +END Index: /tags/ipp-1-X/rel-1_1_27/ippdb/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/.cvsignore (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/.cvsignore (revision 22077) @@ -0,0 +1,21 @@ +Doxyfile +Makefile +Makefile.in +aclocal.m4 +autom4te.cache +compile +config.guess +config.h +config.h.in +config.log +config.status +config.sub +configure +depcomp +install-sh +ippdb.pc +libtool +ltmain.sh +missing +stamp-h1 +docs Index: /tags/ipp-1-X/rel-1_1_27/ippdb/COPYING =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/COPYING (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/COPYING (revision 22077) @@ -0,0 +1,345 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. Index: /tags/ipp-1-X/rel-1_1_27/ippdb/Doxyfile.in =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/Doxyfile.in (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/Doxyfile.in (revision 22077) @@ -0,0 +1,1219 @@ +# Doxyfile 1.4.2 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = @PACKAGE_NAME@ + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = @PACKAGE_VERSION@ + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +# @top_builddir@ doesn't work for some reason +OUTPUT_DIRECTORY = @builddir@/docs + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create +# 4096 sub-directories (in 2 levels) under the output directory of each output +# format and will distribute the generated files over these directories. +# Enabling this option can be useful when feeding doxygen a huge amount of +# source files, where putting all generated files in the same directory would +# otherwise cause performance problems for the file system. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, +# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, +# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, +# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, +# Swedish, and Ukrainian. + +OUTPUT_LANGUAGE = English + +# This tag can be used to specify the encoding used in the generated output. +# The encoding is not always determined by the language that is chosen, +# but also whether or not the output is meant for Windows or non-Windows users. +# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES +# forces the Windows encoding (this is the default for the Windows binary), +# whereas setting the tag to NO uses a Unix-style encoding (the default for +# all platforms other than Windows). + +USE_WINDOWS_ENCODING = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator +# that is used to form the text in various listings. Each string +# in this list, if found as the leading text of the brief description, will be +# stripped from the text and the result after processing the whole list, is +# used as the annotated text. Otherwise, the brief description is used as-is. +# If left blank, the following values are used ("$name" is automatically +# replaced with the name of the entity): "The $name class" "The $name widget" +# "The $name file" "is" "provides" "specifies" "contains" +# "represents" "a" "an" "the" + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user-defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the +# path to strip. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of +# the path mentioned in the documentation of a class, which tells +# the reader which header file to include in order to use a class. +# If left blank only the name of the header file containing the class +# definition is used. Otherwise one should specify the include paths that +# are normally passed to the compiler using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter +# (but less readable) file names. This can be useful is your file systems +# doesn't support long names like on DOS, Mac, or CD-ROM. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the JavaDoc +# comments will behave just like the Qt-style comments (thus requiring an +# explicit @brief command for a brief description. + +JAVADOC_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen +# treat a multi-line C++ special comment block (i.e. a block of //! or /// +# comments) as a brief description. This used to be the default behaviour. +# The new default is to treat a multi-line C++ comment block as a detailed +# description. Set this tag to YES if you prefer the old behaviour instead. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the DETAILS_AT_TOP tag is set to YES then Doxygen +# will output the detailed description near the top, like JavaDoc. +# If set to NO, the detailed description appears after the member +# documentation. + +DETAILS_AT_TOP = NO + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# re-implements. + +INHERIT_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce +# a new page for each member. If set to NO, the documentation of a member will +# be part of the file/class/namespace that contains it. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user-defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C +# sources only. Doxygen will then generate output that is more tailored for C. +# For instance, some of the names that are used will be different. The list +# of all members will be omitted, etc. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources +# only. Doxygen will then generate output that is more tailored for Java. +# For instance, namespaces will be presented as packages, qualified scopes +# will look different, etc. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the SUBGROUPING tag to YES (the default) to allow class member groups of +# the same type (for instance a group of public functions) to be put as a +# subgroup of that type (e.g. under the Public Functions section). Set it to +# NO to prevent subgrouping. Alternatively, this can be done per class using +# the \nosubgrouping command. + +SUBGROUPING = YES + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) +# defined locally in source files will be included in the documentation. +# If set to NO only classes defined in header files are included. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local +# methods, which are defined in the implementation section but not in +# the interface are included in the documentation. +# If set to NO (the default) only methods in the interface are included. + +EXTRACT_LOCAL_METHODS = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these classes will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all +# friend (class|struct|union) declarations. +# If set to NO (the default) these declarations will be included in the +# documentation. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any +# documentation blocks found inside the body of a function. +# If set to NO (the default) these blocks will be appended to the +# function's detailed documentation block. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put a list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the +# brief documentation of file, namespace and class members alphabetically +# by member name. If set to NO (the default) the members will appear in +# declaration order. + +SORT_BRIEF_DOCS = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be +# sorted by fully-qualified names, including namespaces. If set to +# NO (the default), the class list will be sorted only by class name, +# not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the +# alphabetical list. + +SORT_BY_SCOPE_NAME = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or +# disable (NO) the bug list. This list is created by putting \bug +# commands in the documentation. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or +# disable (NO) the deprecated list. This list is created by putting +# \deprecated commands in the documentation. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines +# the initial value of a variable or define consists of for it to appear in +# the documentation. If the initializer consists of more lines than specified +# here it will be hidden. Use a value of 0 to hide initializers completely. +# The appearance of the initializer of individual variables and defines in the +# documentation can be controlled using \showinitializer or \hideinitializer +# command in the documentation regardless of this setting. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated +# at the bottom of the documentation of classes and structs. If set to YES the +# list will mention the files that were used to generate the documentation. + +SHOW_USED_FILES = YES + +# If the sources in your project are distributed over multiple directories +# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy +# in the documentation. + +SHOW_DIRECTORIES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from the +# version control system). Doxygen will invoke the program by executing (via +# popen()) the command , where is the value of +# the FILE_VERSION_FILTER tag, and is the name of an input file +# provided by doxygen. Whatever the progam writes to standard output +# is used as the file version. See the manual for examples. + +FILE_VERSION_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some +# parameters in a documented function, or documenting parameters that +# don't exist or using markup commands wrongly. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be abled to get warnings for +# functions that are documented, but have no documentation for their parameters +# or return value. If set to NO (the default) doxygen will only warn about +# wrong or incomplete parameter documentation, but not about the absence of +# documentation. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. Optionally the format may contain +# $version, which will be replaced by the version of the file (if it could +# be obtained via FILE_VERSION_FILTER) + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning +# and error messages should be written. If left blank the output is written +# to stderr. + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = @top_srcdir@/src + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank the following patterns are tested: +# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx +# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm + +FILE_PATTERNS = *.h + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used select whether or not files or +# directories that are symbolic links (a Unix filesystem feature) are excluded +# from the input. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude +# commands irrespective of the value of the RECURSIVE tag. +# Possible values are YES and NO. If left blank NO is used. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. If FILTER_PATTERNS is specified, this tag will be +# ignored. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: +# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further +# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER +# is applied to all files. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will be used to filter the input files when producing source +# files to browse (i.e. when SOURCE_BROWSER is set to YES). + +FILTER_SOURCE_FILES = NO + +#--------------------------------------------------------------------------- +# configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. +# Note: To get rid of all source code in the generated output, make sure also +# VERBATIM_HEADERS is set to NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES (the default) +# then for each documented function all documented +# functions referencing it will be listed. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES (the default) +# then for each documented function all documented entities +# called/used by that function will be listed. + +REFERENCES_RELATION = YES + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = NO + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for +# each generated HTML page (for example: .htm,.php,.asp). If it is left blank +# doxygen will generate files with .html extension. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet. Note that doxygen will try to copy +# the style sheet file to the HTML output directory, so don't put your own +# stylesheet in the HTML output directory as well, or it will be erased! + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can +# be used to specify the file name of the resulting .chm file. You +# can add a path in front of the file if the result should not be +# written to the html output directory. + +CHM_FILE = + +# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can +# be used to specify the location (absolute path including file name) of +# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run +# the HTML help compiler on the generated index.hhp. + +HHC_LOCATION = + +# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag +# controls if a separate .chi index file is generated (YES) or that +# it should be included in the master .chm file (NO). + +GENERATE_CHI = NO + +# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag +# controls whether a binary table of contents is generated (YES) or a +# normal table of contents (NO) in the .chm file. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members +# to the contents of the HTML help documentation and to the tree view. + +TOC_EXPAND = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +# This tag can be used to set the number of enum values (range [1..20]) +# that doxygen will group on one line in the generated HTML documentation. + +ENUM_VALUES_PER_LINE = 4 + +# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be +# generated containing a tree-like index structure (just like the one that +# is generated for HTML Help). For this to work a browser that supports +# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, +# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are +# probably better off using the HTML help feature. + +GENERATE_TREEVIEW = NO + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be +# used to set the initial width (in pixels) of the frame in which the tree +# is shown. + +TREEVIEW_WIDTH = 250 + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. If left blank `latex' will be used as the default command name. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to +# generate index for LaTeX. If left blank `makeindex' will be used as the +# default command name. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +# If LATEX_HIDE_INDICES is set to YES then doxygen will not +# include the index chapters (such as File Index, Compound Index, etc.) +# in the output. + +LATEX_HIDE_INDICES = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimized for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using WORD or other +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assignments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an rtf document. +# Syntax is similar to doxygen's config file. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = YES + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +# If the MAN_LINKS tag is set to YES and Doxygen generates man output, +# then it will generate one additional man file for each entity +# documented in the real man page(s). These additional files +# only source the real man page, but without them the man command +# would be unable to find the correct page. The default is NO. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `xml' will be used as the default path. + +XML_OUTPUT = xml + +# The XML_SCHEMA tag can be used to specify an XML schema, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_SCHEMA = + +# The XML_DTD tag can be used to specify an XML DTD, +# which can be used by a validating XML parser to check the +# syntax of the XML files. + +XML_DTD = + +# If the XML_PROGRAMLISTING tag is set to YES Doxygen will +# dump the program listings (including syntax highlighting +# and cross-referencing information) to the XML output. Note that +# enabling this will significantly increase the size of the XML output. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will +# generate an AutoGen Definitions (see autogen.sf.net) file +# that captures the structure of the code including all +# documentation. Note that this feature is still experimental +# and incomplete at the moment. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES Doxygen will +# generate a Perl module file that captures the structure of +# the code including all documentation. Note that this +# feature is still experimental and incomplete at the +# moment. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES Doxygen will generate +# the necessary Makefile rules, Perl scripts and LaTeX code to be able +# to generate PDF and DVI output from the Perl module output. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be +# nicely formatted so it can be parsed by a human reader. This is useful +# if you want to understand what is going on. On the other hand, if this +# tag is set to NO the size of the Perl module output will be much smaller +# and Perl will parse it just the same. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file +# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. +# This is useful so different doxyrules.make files included by the same +# Makefile don't overwrite each other's variables. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. To prevent a macro definition from being +# undefined via #undef or recursively expanded use the := operator +# instead of the = operator. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then +# doxygen's preprocessor will remove all function-like macros that are alone +# on a line, have an all uppercase name, and do not end with a semicolon. Such +# function macros are typically used for boiler-plate code, and will confuse +# the parser if not removed. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES option can be used to specify one or more tagfiles. +# Optionally an initial location of the external documentation +# can be added for each tagfile. The format of a tag file without +# this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where "loc1" and "loc2" can be relative or absolute paths or +# URLs. If a location is present for each tag, the installdox tool +# does not have to be run to correct the links. +# Note that each tag file must have a unique name +# (where the name does NOT include the path) +# If a tag file is not located in the directory in which doxygen +# is run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed +# in the modules index. If set to NO, only the current project's groups will +# be listed. + +EXTERNAL_GROUPS = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = @PERL@ + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base +# or super classes. Setting the tag to NO turns the diagrams off. Note that +# this option is superseded by the HAVE_DOT option below. This is only a +# fallback. It is recommended to install and use dot, since it yields more +# powerful graphs. + +CLASS_DIAGRAMS = YES + +# If set to YES, the inheritance and collaboration graphs will hide +# inheritance and usage relations if the target is undocumented +# or is not a class. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = NO + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for groups, showing the direct groups dependencies + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. + +UML_LOOK = NO + +# If set to YES, the inheritance and collaboration graphs will show the +# relations between templates and their instances. + +TEMPLATE_RELATIONS = NO + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT +# tags are set to YES then doxygen will generate a graph for each documented +# file showing the direct and indirect include dependencies of the file with +# other documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and +# HAVE_DOT tags are set to YES then doxygen will generate a graph for each +# documented header file showing the documented files that directly or +# indirectly include this file. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will +# generate a call dependency graph for every global function or class method. +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. + +CALL_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES +# then doxygen will show the dependencies a directory has on other directories +# in a graphical way. The dependency relations are determined by the #include +# relations between the files in the directories. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. Possible values are png, jpg, or gif +# If left blank png will be used. + +DOT_IMAGE_FORMAT = png + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the +# \dotfile command). + +DOTFILE_DIRS = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the +# graphs generated by dot. A depth value of 3 means that only nodes reachable +# from the root by following a path via at most 3 edges will be shown. Nodes +# that lay further from the root node will be omitted. Note that setting this +# option to 1 or 2 may greatly reduce the computation time needed for large +# code bases. Also note that a graph may be further truncated if the graph's +# image dimensions are not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH +# and MAX_DOT_GRAPH_HEIGHT). If 0 is used for the depth value (the default), +# the graph is not depth-constrained. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, which results in a white background. +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) +# support this, this feature is disabled by default. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will +# generate a legend page explaining the meaning of the various boxes and +# arrows in the dot generated graphs. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will +# remove the intermediate dot files that are used to generate +# the various graphs. + +DOT_CLEANUP = YES + +#--------------------------------------------------------------------------- +# Configuration::additions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO Index: /tags/ipp-1-X/rel-1_1_27/ippdb/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/Makefile.am (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/Makefile.am (revision 22077) @@ -0,0 +1,64 @@ +SUBDIRS = src tests + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA= ippdb.pc + +EXTRA_DIST = ippdb.pc.in Doxyfile.in + +if HAVE_DOXYGEN + +man_MANS = \ + $(top_builddir)/docs/man/man3/ippdb.3 \ + $(top_builddir)/docs/man/man3/summitExpRow.3 \ + $(top_builddir)/docs/man/man3/summitImfileRow.3 \ + $(top_builddir)/docs/man/man3/pzPendingExpRow.3 \ + $(top_builddir)/docs/man/man3/pzPendingImfileRow.3 \ + $(top_builddir)/docs/man/man3/pzDoneExpRow.3 \ + $(top_builddir)/docs/man/man3/pzDoneImfileRow.3 \ + $(top_builddir)/docs/man/man3/newExpRow.3 \ + $(top_builddir)/docs/man/man3/newImfileRow.3 \ + $(top_builddir)/docs/man/man3/rawExpRow.3 \ + $(top_builddir)/docs/man/man3/rawImfileRow.3 \ + $(top_builddir)/docs/man/man3/guidePendingExpRow.3 \ + $(top_builddir)/docs/man/man3/chipRunRow.3 \ + $(top_builddir)/docs/man/man3/chipProcessedImfileRow.3 \ + $(top_builddir)/docs/man/man3/chipMaskRow.3 \ + $(top_builddir)/docs/man/man3/camRunRow.3 \ + $(top_builddir)/docs/man/man3/camProcessedExpRow.3 \ + $(top_builddir)/docs/man/man3/camMaskRow.3 \ + $(top_builddir)/docs/man/man3/warpRunRow.3 \ + $(top_builddir)/docs/man/man3/warpInputExpRow.3 \ + $(top_builddir)/docs/man/man3/warpSkyCellMapRow.3 \ + $(top_builddir)/docs/man/man3/warpSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/diffRunRow.3 \ + $(top_builddir)/docs/man/man3/diffInputSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/diffSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/stackRunRow.3 \ + $(top_builddir)/docs/man/man3/stackInputSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/stackSumSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/detRunRow.3 \ + $(top_builddir)/docs/man/man3/detInputExpRow.3 \ + $(top_builddir)/docs/man/man3/detProcessedImfileRow.3 \ + $(top_builddir)/docs/man/man3/detProcessedExpRow.3 \ + $(top_builddir)/docs/man/man3/detStackedImfileRow.3 \ + $(top_builddir)/docs/man/man3/detNormalizedStatImfileRow.3 \ + $(top_builddir)/docs/man/man3/detNormalizedImfileRow.3 \ + $(top_builddir)/docs/man/man3/detNormalizedExpRow.3 \ + $(top_builddir)/docs/man/man3/detResidImfileRow.3 \ + $(top_builddir)/docs/man/man3/detResidExpRow.3 \ + $(top_builddir)/docs/man/man3/detRunSummaryRow.3 \ + $(top_builddir)/docs/man/man3/detRegisteredImfileRow.3 \ + $(top_builddir)/docs/man/man3/magicRunRow.3 \ + $(top_builddir)/docs/man/man3/magicInputSkyfileRow.3 \ + $(top_builddir)/docs/man/man3/magicTreeRow.3 \ + $(top_builddir)/docs/man/man3/magicNodeResultRow.3 \ + $(top_builddir)/docs/man/man3/magicMaskRow.3 + + +docs/man/man3/ippdb.3 docs/man/man3/summitExpRow.3 docs/man/man3/summitImfileRow.3 docs/man/man3/pzPendingExpRow.3 docs/man/man3/pzPendingImfileRow.3 docs/man/man3/pzDoneExpRow.3 docs/man/man3/pzDoneImfileRow.3 docs/man/man3/newExpRow.3 docs/man/man3/newImfileRow.3 docs/man/man3/rawExpRow.3 docs/man/man3/rawImfileRow.3 docs/man/man3/guidePendingExpRow.3 docs/man/man3/chipRunRow.3 docs/man/man3/chipProcessedImfileRow.3 docs/man/man3/chipMaskRow.3 docs/man/man3/camRunRow.3 docs/man/man3/camProcessedExpRow.3 docs/man/man3/camMaskRow.3 docs/man/man3/warpRunRow.3 docs/man/man3/warpInputExpRow.3 docs/man/man3/warpSkyCellMapRow.3 docs/man/man3/warpSkyfileRow.3 docs/man/man3/diffRunRow.3 docs/man/man3/diffInputSkyfileRow.3 docs/man/man3/diffSkyfileRow.3 docs/man/man3/stackRunRow.3 docs/man/man3/stackInputSkyfileRow.3 docs/man/man3/stackSumSkyfileRow.3 docs/man/man3/detRunRow.3 docs/man/man3/detInputExpRow.3 docs/man/man3/detProcessedImfileRow.3 docs/man/man3/detProcessedExpRow.3 docs/man/man3/detStackedImfileRow.3 docs/man/man3/detNormalizedStatImfileRow.3 docs/man/man3/detNormalizedImfileRow.3 docs/man/man3/detNormalizedExpRow.3 docs/man/man3/detResidImfileRow.3 docs/man/man3/detResidExpRow.3 docs/man/man3/detRunSummaryRow.3 docs/man/man3/detRegisteredImfileRow.3 docs/man/man3/magicRunRow.3 docs/man/man3/magicInputSkyfileRow.3 docs/man/man3/magicTreeRow.3 docs/man/man3/magicNodeResultRow.3 docs/man/man3/magicMaskRow.3: + $(DOXYGEN) + +endif + +clean-local: + -rm -rf docs Index: /tags/ipp-1-X/rel-1_1_27/ippdb/autogen.sh =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/autogen.sh (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/autogen.sh (revision 22077) @@ -0,0 +1,103 @@ +#!/bin/sh +# Run this to generate all the initial makefiles, etc. + +srcdir=`dirname $0` +test -z "$srcdir" && srcdir=. + +ORIGDIR=`pwd` +cd $srcdir + +PROJECT=ippdb +TEST_TYPE=-f +# change this to be a unique filename in the top level dir +FILE=autogen.sh + +DIE=0 + +LIBTOOLIZE=libtoolize +ACLOCAL="aclocal $ACLOCAL_FLAGS" +AUTOHEADER=autoheader +AUTOMAKE=automake +AUTOCONF=autoconf + +($LIBTOOLIZE --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $LIBTOOlIZE installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/libtool/" + DIE=1 +} + +($ACLOCAL --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $ACLOCAL installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/automake/" + DIE=1 +} + +($AUTOHEADER --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOHEADER installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/autoconf/" + DIE=1 +} + +($AUTOMAKE --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOMAKE installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/automake/" + DIE=1 +} + +($AUTOCONF --version) < /dev/null > /dev/null 2>&1 || { + echo + echo "You must have $AUTOCONF installed to compile $PROJECT." + echo "Download the appropriate package for your distribution," + echo "or get the source tarball at http://ftp.gnu.org/gnu/autoconf/" + DIE=1 +} + +if test "$DIE" -eq 1; then + exit 1 +fi + +test $TEST_TYPE $FILE || { + echo "You must run this script in the top-level $PROJECT directory" + exit 1 +} + +if test -z "$*"; then + echo "I am going to run ./configure with no arguments - if you wish " + echo "to pass any to it, please specify them on the $0 command line." +fi + +$LIBTOOLIZE --copy --force || echo "$LIBTOOlIZE failed" +$ACLOCAL || echo "$ACLOCAL failed" +$AUTOHEADER || echo "$AUTOHEADER failed" +$AUTOMAKE --add-missing --force-missing --copy || echo "$AUTOMAKE failed" +$AUTOCONF || echo "$AUTOCONF failed" + +cd $ORIGDIR + +run_configure=true +for arg in $*; do + case $arg in + --no-configure) + run_configure=false + ;; + *) + ;; + esac +done + +if $run_configure; then + $srcdir/configure --enable-maintainer-mode "$@" + echo + echo "Now type 'make' to compile $PROJECT." +else + echo + echo "Now run 'configure' and 'make' to compile $PROJECT." +fi Index: /tags/ipp-1-X/rel-1_1_27/ippdb/configure.ac =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/configure.ac (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/configure.ac (revision 22077) @@ -0,0 +1,63 @@ +dnl +dnl This file was generated by glueforge 1.01 +dnl +dnl Do NOT directly edit this file. +dnl + +AC_PREREQ(2.61) + +AC_INIT([ippdb], [1.1.27], [pan-starrs.ifa.hawaii.edu]) +AC_CONFIG_SRCDIR([ippdb.pc.in]) + +AM_INIT_AUTOMAKE([1.6 foreign dist-bzip2]) +AM_CONFIG_HEADER([config.h]) +AM_MAINTAINER_MODE + +AC_CONFIG_TESTDIR([tests]) +AC_CONFIG_FILES([tests/Makefile]) +AM_MISSING_PROG([AUTOM4TE], [autom4te]) + +AC_LANG(C) +AC_PROG_CC_C99 +AC_PROG_INSTALL +AC_PROG_LIBTOOL + +PKG_CHECK_MODULES([PSLIB], [pslib >= 0.9.0]) + +dnl check to make sure that pslib declares HAVE_PSDB +TMP_CFLAGS=${CFLAGS} +CFLAGS="${CFLAGS=} ${PSLIB_CFLAGS}" + +AC_MSG_CHECKING([pslib's psDB support]) +AC_RUN_IFELSE( + [AC_LANG_PROGRAM([], [dnl +#ifndef HAVE_PSDB + return 1; +#endif])], + [AC_MSG_RESULT([yes])], + [AC_MSG_FAILURE([pslib was built without psDB support (HAVE_PSDB)])]) + +CFLAGS=${TMP_CFLAGS} + + +AC_PATH_PROG([PERL], [perl], [missing]) +if test "$PERL" = "missing" ; then + AC_MSG_ERROR([perl is required]) +fi + +AC_PATH_PROG([DOXYGEN], [doxygen], []) +AM_CONDITIONAL([HAVE_DOXYGEN], [test -n "$DOXYGEN"]) + +dnl is this the best was to setup recursive CFLAGS? +IPP_STDOPTS +dnl -Werror causes problems on OSX as inttypes.h uses some non standard C types +ippdb_CFLAGS="-Wall -pedantic -fno-strict-aliasing" +AC_SUBST([ippdb_CFLAGS]) + +AC_CONFIG_FILES([ + Makefile + src/Makefile + ippdb.pc + Doxyfile +]) +AC_OUTPUT Index: /tags/ipp-1-X/rel-1_1_27/ippdb/ippdb.pc.in =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/ippdb.pc.in (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/ippdb.pc.in (revision 22077) @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: @PACKAGE@ +Description: some library +Version: @VERSION@ +Requires: pslib +Libs: -L${libdir} -l@PACKAGE@ +Cflags: -I${includedir} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/src/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/src/.cvsignore (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/src/.cvsignore (revision 22077) @@ -0,0 +1,6 @@ +.deps +Makefile +Makefile.in +.libs +libippdb.la +libippdb_la-ippdb.lo Index: /tags/ipp-1-X/rel-1_1_27/ippdb/src/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/src/Makefile.am (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/src/Makefile.am (revision 22077) @@ -0,0 +1,10 @@ +AM_CFLAGS = @ippdb_CFLAGS@ + +include_HEADERS = ippdb.h +lib_LTLIBRARIES = libippdb.la +libippdb_la_CFLAGS = $(PSLIB_CFLAGS) $(AM_CFLAGS) +libippdb_la_LIBS = $(PSLIB_LIBS) $(AM_LIBS) +libippdb_la_LDFLAGS = -release $(PACKAGE_VERSION) +libippdb_la_SOURCES = \ + ippdb.h \ + ippdb.c Index: /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.c (revision 22077) @@ -0,0 +1,20536 @@ +/* + * code.c + * + * Copyright (C) 2006 Joshua Hoblitt + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * program; see the file COPYING. If not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/* + * + * This file was generated by glueforge 1.01 + * + * Do NOT directly edit this file. + * + */ + +#include +#include + +#include "ippdb.h" + +#define SUMMITEXP_TABLE_NAME "summitExp" +#define SUMMITIMFILE_TABLE_NAME "summitImfile" +#define PZPENDINGEXP_TABLE_NAME "pzPendingExp" +#define PZPENDINGIMFILE_TABLE_NAME "pzPendingImfile" +#define PZDONEEXP_TABLE_NAME "pzDoneExp" +#define PZDONEIMFILE_TABLE_NAME "pzDoneImfile" +#define NEWEXP_TABLE_NAME "newExp" +#define NEWIMFILE_TABLE_NAME "newImfile" +#define RAWEXP_TABLE_NAME "rawExp" +#define RAWIMFILE_TABLE_NAME "rawImfile" +#define GUIDEPENDINGEXP_TABLE_NAME "guidePendingExp" +#define CHIPRUN_TABLE_NAME "chipRun" +#define CHIPPROCESSEDIMFILE_TABLE_NAME "chipProcessedImfile" +#define CHIPMASK_TABLE_NAME "chipMask" +#define CAMRUN_TABLE_NAME "camRun" +#define CAMPROCESSEDEXP_TABLE_NAME "camProcessedExp" +#define CAMMASK_TABLE_NAME "camMask" +#define WARPRUN_TABLE_NAME "warpRun" +#define WARPINPUTEXP_TABLE_NAME "warpInputExp" +#define WARPSKYCELLMAP_TABLE_NAME "warpSkyCellMap" +#define WARPSKYFILE_TABLE_NAME "warpSkyfile" +#define DIFFRUN_TABLE_NAME "diffRun" +#define DIFFINPUTSKYFILE_TABLE_NAME "diffInputSkyfile" +#define DIFFSKYFILE_TABLE_NAME "diffSkyfile" +#define STACKRUN_TABLE_NAME "stackRun" +#define STACKINPUTSKYFILE_TABLE_NAME "stackInputSkyfile" +#define STACKSUMSKYFILE_TABLE_NAME "stackSumSkyfile" +#define DETRUN_TABLE_NAME "detRun" +#define DETINPUTEXP_TABLE_NAME "detInputExp" +#define DETPROCESSEDIMFILE_TABLE_NAME "detProcessedImfile" +#define DETPROCESSEDEXP_TABLE_NAME "detProcessedExp" +#define DETSTACKEDIMFILE_TABLE_NAME "detStackedImfile" +#define DETNORMALIZEDSTATIMFILE_TABLE_NAME "detNormalizedStatImfile" +#define DETNORMALIZEDIMFILE_TABLE_NAME "detNormalizedImfile" +#define DETNORMALIZEDEXP_TABLE_NAME "detNormalizedExp" +#define DETRESIDIMFILE_TABLE_NAME "detResidImfile" +#define DETRESIDEXP_TABLE_NAME "detResidExp" +#define DETRUNSUMMARY_TABLE_NAME "detRunSummary" +#define DETREGISTEREDIMFILE_TABLE_NAME "detRegisteredImfile" +#define MAGICRUN_TABLE_NAME "magicRun" +#define MAGICINPUTSKYFILE_TABLE_NAME "magicInputSkyfile" +#define MAGICTREE_TABLE_NAME "magicTree" +#define MAGICNODERESULT_TABLE_NAME "magicNodeResult" +#define MAGICMASK_TABLE_NAME "magicMask" +#define MAX_STRING_LENGTH 1024 + +psDB *ippdbInit(const char *host, const char *user, const char *passwd, const char *dbname, unsigned int port) +{ + return psDBInit(host, user, passwd, dbname, port); +} + +void ippdbCleanup(psDB *dbh) +{ + psDBCleanup(dbh); +} + +bool ippdbPrintMetadata(FILE *stream, psMetadata *md, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(md, false); + + psMetadata *clean = psMetadataCopy(NULL, md); + + if (!ippdbPrintMetadataRaw(stream, clean, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(clean); + return false; + } + psFree(clean); + + return true; +} + +bool ippdbPrintMetadataRaw(FILE *stream, psMetadata *md, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(md, false); + + if (mdcf) { + psString str = psMetadataConfigFormat(md); + if (!str) { + psError(PS_ERR_UNKNOWN, false, "failed to format data into a string"); + psFree(str); + return false; + } + fprintf(stream, "%s\n", str); + psFree(str); + + return true; + } + +#define METADATAITEM_STRIFY_CASE(ptype, format, type) \ +case ptype: \ + psStringAppend(&str, format, item->data.type); \ + break; + + // else + // flatten the metadata into | separated values + psString str = NULL; + psMetadataItem *item = NULL; + psMetadataIterator *iter = psMetadataIteratorAlloc(md, 0, NULL); + while ((item = psMetadataGetAndIncrement(iter))) { + switch (item->type) { + METADATAITEM_STRIFY_CASE(PS_DATA_S8, "%hhd", S8); + METADATAITEM_STRIFY_CASE(PS_DATA_S16, "%hd", S16); + METADATAITEM_STRIFY_CASE(PS_DATA_S32, "%d", S32); + METADATAITEM_STRIFY_CASE(PS_DATA_S64, "%" PRId64, S64); + METADATAITEM_STRIFY_CASE(PS_DATA_U8, "%hhu", U8); + METADATAITEM_STRIFY_CASE(PS_DATA_U16, "%hu", U16); + METADATAITEM_STRIFY_CASE(PS_DATA_U32, "%u", U32); + METADATAITEM_STRIFY_CASE(PS_DATA_U64, "%" PRIu64, U64); + METADATAITEM_STRIFY_CASE(PS_DATA_F32, "%f", F32); + METADATAITEM_STRIFY_CASE(PS_DATA_F64, "%f", F64); + case PS_DATA_STRING: + if (item->data.str) { + psString tmpStr = psStringCopy(item->data.str); + psStringSubstitute(&tmpStr, "_", " "); + psStringAppend(&str, "%s", tmpStr); + psFree(tmpStr); + } + break; + case PS_DATA_BOOL: + if (item->data.B) { + psStringAppend(&str, "T"); + } else { + psStringAppend(&str, "F"); + } + break; + case PS_DATA_METADATA: + if (!ippdbPrintMetadataRaw(stream, item->data.md, mdcf)) { + psError(PS_ERR_UNKNOWN, false ,"failed to print nested metadata"); + } + // a metadata is a special case. We don't want a | seperating + // the metadata from any other output so we need to skip the + // !->offEnd test + continue; + case PS_DATA_TIME: + // pass through NULLs as "NULL" + if (item->data.V) { + psString time = psTimeToISO(item->data.V); + psStringAppend(&str, "%s", time); + psFree(time); + } else { + psStringAppend(&str, "NULL"); + } + break; + default: + psError(PS_ERR_UNKNOWN, true,"unsupported psMetadataItem type"); + psFree(iter); + psFree(str); + return false; + } + if (!iter->iter->offEnd) { + psStringAppend(&str, " "); + } + } + psFree(iter); + + // if we did nothing but handle recursive metadatas str will be NULL + if (str) { + fprintf(stream, "%s\n", str); + psFree(str); + } + + return true; +} + +bool ippdbPrintMetadatas(FILE *stream, psArray *mds, const char *mdname, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(mds, false); + PS_ASSERT_PTR_NON_NULL(mdname, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(mds); i++) { + psMetadata *md = psMetadataCopy(NULL, mds->data[i]); + if (!psMetadataAddMetadata(output, PS_LIST_TAIL, mdname, PS_META_DUPLICATE_OK, NULL, md)) { + psError(PS_ERR_UNKNOWN, false, "failed to add a metadata item"); + psFree(md); + psFree(output); + return false; + } + + psFree(md); + } + + if (!ippdbPrintMetadata(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + +bool ippdbPrintMetadatasRaw(FILE *stream, psArray *mds, const char *mdname, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(mds, false); + PS_ASSERT_PTR_NON_NULL(mdname, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(mds); i++) { + psMetadata *md = mds->data[i]; + if (!psMetadataAddMetadata(output, PS_LIST_TAIL, mdname, PS_META_DUPLICATE_OK, NULL, md)) { + psError(PS_ERR_UNKNOWN, false, "failed to add a metadata item"); + psFree(output); + return false; + } + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + return false; + } + + psFree(output); + + return true; +} + +static void summitExpRowFree(summitExpRow *object); + +summitExpRow *summitExpRowAlloc(const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, const char *uri, psS32 imfiles) +{ + summitExpRow *_object; + + _object = psAlloc(sizeof(summitExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)summitExpRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->dateobs = psTimeCopy(dateobs); + _object->exp_type = psStringCopy(exp_type); + _object->uri = psStringCopy(uri); + _object->imfiles = imfiles; + + return _object; +} + +static void summitExpRowFree(summitExpRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->dateobs); + psFree(object->exp_type); + psFree(object->uri); +} + +bool summitExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, SUMMITEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool summitExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, SUMMITEXP_TABLE_NAME); +} + +bool summitExpInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, const char *uri, psS32 imfiles) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, SUMMITEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long summitExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool summitExpInsertObject(psDB *dbh, summitExpRow *object) +{ + return summitExpInsert(dbh, object->exp_name, object->camera, object->telescope, object->dateobs, object->exp_type, object->uri, object->imfiles); +} + +bool summitExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!summitExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool summitExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named SUMMITEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, SUMMITEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", SUMMITEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, SUMMITEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool summitExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, SUMMITEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, SUMMITEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *summitExpMetadataFromObject(const summitExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "imfiles", PS_DATA_S32, NULL, object->imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + psFree(md); + return false; + } + + + return md; +} + +summitExpRow *summitExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs"); + return false; + } + char* exp_type = psMetadataLookupPtr(&status, md, "exp_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles"); + return false; + } + + return summitExpRowAlloc(exp_name, camera, telescope, dateobs, exp_type, uri, imfiles); +} +psArray *summitExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, SUMMITEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + summitExpRow *object = summitExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool summitExpDeleteObject(psDB *dbh, const summitExpRow *object) +{ + psMetadata *where = summitExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "summitExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long summitExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + summitExpRow *object = objects->data[i]; + psMetadata *where = summitExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, SUMMITEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool summitExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = summitExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + SUMMITEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool summitExpPrintObject(FILE *stream, summitExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = summitExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void summitImfileRowFree(summitImfileRow *object); + +summitImfileRow *summitImfileRowAlloc(const char *exp_name, const char *camera, const char *telescope, const char *file_id, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri) +{ + summitImfileRow *_object; + + _object = psAlloc(sizeof(summitImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)summitImfileRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->file_id = psStringCopy(file_id); + _object->bytes = bytes; + _object->md5sum = psStringCopy(md5sum); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void summitImfileRowFree(summitImfileRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->file_id); + psFree(object->md5sum); + psFree(object->class); + psFree(object->class_id); + psFree(object->uri); +} + +bool summitImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "file_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item file_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bytes"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, "32")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, SUMMITIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool summitImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, SUMMITIMFILE_TABLE_NAME); +} + +bool summitImfileInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope, const char *file_id, psS32 bytes, const char *md5sum, const char *class, const char *class_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "file_id", PS_DATA_STRING, NULL, file_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item file_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, bytes)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bytes"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, md5sum)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, SUMMITIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long summitImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool summitImfileInsertObject(psDB *dbh, summitImfileRow *object) +{ + return summitImfileInsert(dbh, object->exp_name, object->camera, object->telescope, object->file_id, object->bytes, object->md5sum, object->class, object->class_id, object->uri); +} + +bool summitImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!summitImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool summitImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named SUMMITIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, SUMMITIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", SUMMITIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, SUMMITIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool summitImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, SUMMITIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *summitImfileMetadataFromObject(const summitImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "file_id", PS_DATA_STRING, NULL, object->file_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item file_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bytes", PS_DATA_S32, NULL, object->bytes)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bytes"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "md5sum", PS_DATA_STRING, NULL, object->md5sum)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item md5sum"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +summitImfileRow *summitImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + char* file_id = psMetadataLookupPtr(&status, md, "file_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item file_id"); + return false; + } + psS32 bytes = psMetadataLookupS32(&status, md, "bytes"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bytes"); + return false; + } + char* md5sum = psMetadataLookupPtr(&status, md, "md5sum"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item md5sum"); + return false; + } + char* class = psMetadataLookupPtr(&status, md, "class"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return summitImfileRowAlloc(exp_name, camera, telescope, file_id, bytes, md5sum, class, class_id, uri); +} +psArray *summitImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + summitImfileRow *object = summitImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool summitImfileDeleteObject(psDB *dbh, const summitImfileRow *object) +{ + psMetadata *where = summitImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "summitImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long summitImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + summitImfileRow *object = objects->data[i]; + psMetadata *where = summitImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, SUMMITIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from summitImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool summitImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = summitImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + SUMMITIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool summitImfilePrintObject(FILE *stream, summitImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = summitImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void pzPendingExpRowFree(pzPendingExpRow *object); + +pzPendingExpRow *pzPendingExpRowAlloc(const char *exp_name, const char *camera, const char *telescope) +{ + pzPendingExpRow *_object; + + _object = psAlloc(sizeof(pzPendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzPendingExpRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + + return _object; +} + +static void pzPendingExpRowFree(pzPendingExpRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); +} + +bool pzPendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, PZPENDINGEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool pzPendingExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, PZPENDINGEXP_TABLE_NAME); +} + +bool pzPendingExpInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, PZPENDINGEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long pzPendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool pzPendingExpInsertObject(psDB *dbh, pzPendingExpRow *object) +{ + return pzPendingExpInsert(dbh, object->exp_name, object->camera, object->telescope); +} + +bool pzPendingExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!pzPendingExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool pzPendingExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named PZPENDINGEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, PZPENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZPENDINGEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, PZPENDINGEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool pzPendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, PZPENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *pzPendingExpMetadataFromObject(const pzPendingExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + + return md; +} + +pzPendingExpRow *pzPendingExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + + return pzPendingExpRowAlloc(exp_name, camera, telescope); +} +psArray *pzPendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + pzPendingExpRow *object = pzPendingExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool pzPendingExpDeleteObject(psDB *dbh, const pzPendingExpRow *object) +{ + psMetadata *where = pzPendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "pzPendingExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long pzPendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + pzPendingExpRow *object = objects->data[i]; + psMetadata *where = pzPendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZPENDINGEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool pzPendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = pzPendingExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + PZPENDINGEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool pzPendingExpPrintObject(FILE *stream, pzPendingExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = pzPendingExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void pzPendingImfileRowFree(pzPendingImfileRow *object); + +pzPendingImfileRow *pzPendingImfileRowAlloc(const char *exp_name, const char *camera, const char *telescope, const char *class, const char *class_id) +{ + pzPendingImfileRow *_object; + + _object = psAlloc(sizeof(pzPendingImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzPendingImfileRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + + return _object; +} + +static void pzPendingImfileRowFree(pzPendingImfileRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->class); + psFree(object->class_id); +} + +bool pzPendingImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, PZPENDINGIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool pzPendingImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, PZPENDINGIMFILE_TABLE_NAME); +} + +bool pzPendingImfileInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope, const char *class, const char *class_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, PZPENDINGIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long pzPendingImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool pzPendingImfileInsertObject(psDB *dbh, pzPendingImfileRow *object) +{ + return pzPendingImfileInsert(dbh, object->exp_name, object->camera, object->telescope, object->class, object->class_id); +} + +bool pzPendingImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!pzPendingImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool pzPendingImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named PZPENDINGIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, PZPENDINGIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZPENDINGIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, PZPENDINGIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool pzPendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, PZPENDINGIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *pzPendingImfileMetadataFromObject(const pzPendingImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + + + return md; +} + +pzPendingImfileRow *pzPendingImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + char* class = psMetadataLookupPtr(&status, md, "class"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + + return pzPendingImfileRowAlloc(exp_name, camera, telescope, class, class_id); +} +psArray *pzPendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + pzPendingImfileRow *object = pzPendingImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool pzPendingImfileDeleteObject(psDB *dbh, const pzPendingImfileRow *object) +{ + psMetadata *where = pzPendingImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "pzPendingImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long pzPendingImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + pzPendingImfileRow *object = objects->data[i]; + psMetadata *where = pzPendingImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZPENDINGIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzPendingImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool pzPendingImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = pzPendingImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + PZPENDINGIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool pzPendingImfilePrintObject(FILE *stream, pzPendingImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = pzPendingImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void pzDoneExpRowFree(pzDoneExpRow *object); + +pzDoneExpRow *pzDoneExpRowAlloc(const char *exp_name, const char *camera, const char *telescope) +{ + pzDoneExpRow *_object; + + _object = psAlloc(sizeof(pzDoneExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzDoneExpRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + + return _object; +} + +static void pzDoneExpRowFree(pzDoneExpRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); +} + +bool pzDoneExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, PZDONEEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool pzDoneExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, PZDONEEXP_TABLE_NAME); +} + +bool pzDoneExpInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, PZDONEEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long pzDoneExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool pzDoneExpInsertObject(psDB *dbh, pzDoneExpRow *object) +{ + return pzDoneExpInsert(dbh, object->exp_name, object->camera, object->telescope); +} + +bool pzDoneExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!pzDoneExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool pzDoneExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named PZDONEEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, PZDONEEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZDONEEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, PZDONEEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool pzDoneExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, PZDONEEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, PZDONEEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *pzDoneExpMetadataFromObject(const pzDoneExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + + + return md; +} + +pzDoneExpRow *pzDoneExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + + return pzDoneExpRowAlloc(exp_name, camera, telescope); +} +psArray *pzDoneExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, PZDONEEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + pzDoneExpRow *object = pzDoneExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool pzDoneExpDeleteObject(psDB *dbh, const pzDoneExpRow *object) +{ + psMetadata *where = pzDoneExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "pzDoneExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long pzDoneExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + pzDoneExpRow *object = objects->data[i]; + psMetadata *where = pzDoneExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDONEEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool pzDoneExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = pzDoneExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + PZDONEEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool pzDoneExpPrintObject(FILE *stream, pzDoneExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = pzDoneExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void pzDoneImfileRowFree(pzDoneImfileRow *object); + +pzDoneImfileRow *pzDoneImfileRowAlloc(const char *exp_name, const char *camera, const char *telescope, const char *class, const char *class_id, const char *uri) +{ + pzDoneImfileRow *_object; + + _object = psAlloc(sizeof(pzDoneImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzDoneImfileRowFree); + + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void pzDoneImfileRowFree(pzDoneImfileRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->class); + psFree(object->class_id); + psFree(object->uri); +} + +bool pzDoneImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, PZDONEIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool pzDoneImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, PZDONEIMFILE_TABLE_NAME); +} + +bool pzDoneImfileInsert(psDB * dbh, const char *exp_name, const char *camera, const char *telescope, const char *class, const char *class_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, PZDONEIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long pzDoneImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool pzDoneImfileInsertObject(psDB *dbh, pzDoneImfileRow *object) +{ + return pzDoneImfileInsert(dbh, object->exp_name, object->camera, object->telescope, object->class, object->class_id, object->uri); +} + +bool pzDoneImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!pzDoneImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool pzDoneImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named PZDONEIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, PZDONEIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", PZDONEIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, PZDONEIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool pzDoneImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, PZDONEIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *pzDoneImfileMetadataFromObject(const pzDoneImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, object->class)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +pzDoneImfileRow *pzDoneImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + char* class = psMetadataLookupPtr(&status, md, "class"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return pzDoneImfileRowAlloc(exp_name, camera, telescope, class, class_id, uri); +} +psArray *pzDoneImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + pzDoneImfileRow *object = pzDoneImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool pzDoneImfileDeleteObject(psDB *dbh, const pzDoneImfileRow *object) +{ + psMetadata *where = pzDoneImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "pzDoneImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long pzDoneImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + pzDoneImfileRow *object = objects->data[i]; + psMetadata *where = pzDoneImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, PZDONEIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from pzDoneImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool pzDoneImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = pzDoneImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + PZDONEIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool pzDoneImfilePrintObject(FILE *stream, pzDoneImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = pzDoneImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void newExpRowFree(newExpRow *object); + +newExpRow *newExpRowAlloc(psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state, const char *reduction) +{ + newExpRow *_object; + + _object = psAlloc(sizeof(newExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)newExpRowFree); + + _object->exp_id = exp_id; + _object->tmp_exp_name = psStringCopy(tmp_exp_name); + _object->tmp_camera = psStringCopy(tmp_camera); + _object->tmp_telescope = psStringCopy(tmp_telescope); + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->workdir_state = psStringCopy(workdir_state); + _object->reduction = psStringCopy(reduction); + + return _object; +} + +static void newExpRowFree(newExpRow *object) +{ + psFree(object->tmp_exp_name); + psFree(object->tmp_camera); + psFree(object->tmp_telescope); + psFree(object->state); + psFree(object->workdir); + psFree(object->workdir_state); + psFree(object->reduction); +} + +bool newExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_exp_name", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_camera", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_telescope", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, "destination for output files", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, NEWEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool newExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, NEWEXP_TABLE_NAME); +} + +bool newExpInsert(psDB * dbh, psS64 exp_id, const char *tmp_exp_name, const char *tmp_camera, const char *tmp_telescope, const char *state, const char *workdir, const char *workdir_state, const char *reduction) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_exp_name", PS_DATA_STRING, NULL, tmp_exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_camera", PS_DATA_STRING, NULL, tmp_camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_telescope", PS_DATA_STRING, NULL, tmp_telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, NEWEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long newExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool newExpInsertObject(psDB *dbh, newExpRow *object) +{ + return newExpInsert(dbh, object->exp_id, object->tmp_exp_name, object->tmp_camera, object->tmp_telescope, object->state, object->workdir, object->workdir_state, object->reduction); +} + +bool newExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!newExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool newExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named NEWEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, NEWEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", NEWEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, NEWEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool newExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, NEWEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, NEWEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *newExpMetadataFromObject(const newExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_exp_name", PS_DATA_STRING, NULL, object->tmp_exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_camera", PS_DATA_STRING, NULL, object->tmp_camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_telescope", PS_DATA_STRING, NULL, object->tmp_telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, object->workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + + + return md; +} + +newExpRow *newExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* tmp_exp_name = psMetadataLookupPtr(&status, md, "tmp_exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tmp_exp_name"); + return false; + } + char* tmp_camera = psMetadataLookupPtr(&status, md, "tmp_camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tmp_camera"); + return false; + } + char* tmp_telescope = psMetadataLookupPtr(&status, md, "tmp_telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tmp_telescope"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* workdir_state = psMetadataLookupPtr(&status, md, "workdir_state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir_state"); + return false; + } + char* reduction = psMetadataLookupPtr(&status, md, "reduction"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction"); + return false; + } + + return newExpRowAlloc(exp_id, tmp_exp_name, tmp_camera, tmp_telescope, state, workdir, workdir_state, reduction); +} +psArray *newExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, NEWEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + newExpRow *object = newExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool newExpDeleteObject(psDB *dbh, const newExpRow *object) +{ + psMetadata *where = newExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "newExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long newExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + newExpRow *object = objects->data[i]; + psMetadata *where = newExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, NEWEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool newExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = newExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + NEWEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool newExpPrintObject(FILE *stream, newExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = newExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void newImfileRowFree(newImfileRow *object); + +newImfileRow *newImfileRowAlloc(psS64 exp_id, const char *tmp_class_id, const char *uri) +{ + newImfileRow *_object; + + _object = psAlloc(sizeof(newImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)newImfileRowFree); + + _object->exp_id = exp_id; + _object->tmp_class_id = psStringCopy(tmp_class_id); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void newImfileRowFree(newImfileRow *object) +{ + psFree(object->tmp_class_id); + psFree(object->uri); +} + +bool newImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id) ref newExp(exp_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, NEWIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool newImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, NEWIMFILE_TABLE_NAME); +} + +bool newImfileInsert(psDB * dbh, psS64 exp_id, const char *tmp_class_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, NULL, tmp_class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, NEWIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long newImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool newImfileInsertObject(psDB *dbh, newImfileRow *object) +{ + return newImfileInsert(dbh, object->exp_id, object->tmp_class_id, object->uri); +} + +bool newImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!newImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool newImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named NEWIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, NEWIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", NEWIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, NEWIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool newImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, NEWIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, NEWIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *newImfileMetadataFromObject(const newImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, NULL, object->tmp_class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +newImfileRow *newImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* tmp_class_id = psMetadataLookupPtr(&status, md, "tmp_class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tmp_class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return newImfileRowAlloc(exp_id, tmp_class_id, uri); +} +psArray *newImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, NEWIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + newImfileRow *object = newImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool newImfileDeleteObject(psDB *dbh, const newImfileRow *object) +{ + psMetadata *where = newImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "newImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long newImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + newImfileRow *object = objects->data[i]; + psMetadata *where = newImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, NEWIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from newImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool newImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = newImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + NEWIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool newImfilePrintObject(FILE *stream, newImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = newImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void rawExpRowFree(rawExpRow *object); + +rawExpRow *rawExpRowAlloc(psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *reduction, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault) +{ + rawExpRow *_object; + + _object = psAlloc(sizeof(rawExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)rawExpRowFree); + + _object->exp_id = exp_id; + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->dateobs = psTimeCopy(dateobs); + _object->exp_tag = psStringCopy(exp_tag); + _object->exp_type = psStringCopy(exp_type); + _object->filelevel = psStringCopy(filelevel); + _object->workdir = psStringCopy(workdir); + _object->reduction = psStringCopy(reduction); + _object->filter = psStringCopy(filter); + _object->airmass = airmass; + _object->ra = ra; + _object->decl = decl; + _object->exp_time = exp_time; + _object->sat_pixel_frac = sat_pixel_frac; + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->alt = alt; + _object->az = az; + _object->ccd_temp = ccd_temp; + _object->posang = posang; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->object = psStringCopy(object); + _object->solang = solang; + _object->fault = fault; + + return _object; +} + +static void rawExpRowFree(rawExpRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->dateobs); + psFree(object->exp_tag); + psFree(object->exp_type); + psFree(object->filelevel); + psFree(object->workdir); + psFree(object->reduction); + psFree(object->filter); + psFree(object->object); +} + +bool rawExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id) ref newExp(exp_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, "destination for output files", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, RAWEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool rawExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, RAWEXP_TABLE_NAME); +} + +bool rawExpInsert(psDB * dbh, psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *exp_tag, const char *exp_type, const char *filelevel, const char *workdir, const char *reduction, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psF32 solang, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, airmass)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, decl)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, exp_time)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, sat_pixel_frac)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, alt)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, az)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, ccd_temp)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, posang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang", PS_DATA_F32, NULL, solang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, RAWEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long rawExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool rawExpInsertObject(psDB *dbh, rawExpRow *object) +{ + return rawExpInsert(dbh, object->exp_id, object->exp_name, object->camera, object->telescope, object->dateobs, object->exp_tag, object->exp_type, object->filelevel, object->workdir, object->reduction, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->sat_pixel_frac, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->object, object->solang, object->fault); +} + +bool rawExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!rawExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool rawExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named RAWEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, RAWEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", RAWEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, RAWEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool rawExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, RAWEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, RAWEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *rawExpMetadataFromObject(const rawExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, object->filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, object->airmass)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, object->ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, object->decl)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, object->exp_time)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, object->sat_pixel_frac)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, object->alt)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, object->az)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, object->ccd_temp)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, object->posang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object->object)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang", PS_DATA_F32, NULL, object->solang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +rawExpRow *rawExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + char* exp_type = psMetadataLookupPtr(&status, md, "exp_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type"); + return false; + } + char* filelevel = psMetadataLookupPtr(&status, md, "filelevel"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filelevel"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* reduction = psMetadataLookupPtr(&status, md, "reduction"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction"); + return false; + } + char* filter = psMetadataLookupPtr(&status, md, "filter"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter"); + return false; + } + psF32 airmass = psMetadataLookupF32(&status, md, "airmass"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass"); + return false; + } + psF64 ra = psMetadataLookupF64(&status, md, "ra"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra"); + return false; + } + psF64 decl = psMetadataLookupF64(&status, md, "decl"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl"); + return false; + } + psF32 exp_time = psMetadataLookupF32(&status, md, "exp_time"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time"); + return false; + } + psF32 sat_pixel_frac = psMetadataLookupF32(&status, md, "sat_pixel_frac"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sat_pixel_frac"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 alt = psMetadataLookupF64(&status, md, "alt"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt"); + return false; + } + psF64 az = psMetadataLookupF64(&status, md, "az"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az"); + return false; + } + psF32 ccd_temp = psMetadataLookupF32(&status, md, "ccd_temp"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp"); + return false; + } + psF64 posang = psMetadataLookupF64(&status, md, "posang"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* object = psMetadataLookupPtr(&status, md, "object"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object"); + return false; + } + psF32 solang = psMetadataLookupF32(&status, md, "solang"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item solang"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return rawExpRowAlloc(exp_id, exp_name, camera, telescope, dateobs, exp_tag, exp_type, filelevel, workdir, reduction, filter, airmass, ra, decl, exp_time, sat_pixel_frac, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, user_1, user_2, user_3, user_4, user_5, object, solang, fault); +} +psArray *rawExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, RAWEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + rawExpRow *object = rawExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool rawExpDeleteObject(psDB *dbh, const rawExpRow *object) +{ + psMetadata *where = rawExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "rawExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long rawExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + rawExpRow *object = objects->data[i]; + psMetadata *where = rawExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, RAWEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool rawExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = rawExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + RAWEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool rawExpPrintObject(FILE *stream, rawExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = rawExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void rawImfileRowFree(rawImfileRow *object); + +rawImfileRow *rawImfileRowAlloc(psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *tmp_class_id, const char *class_id, const char *uri, const char *exp_type, const char *filelevel, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psS16 fault) +{ + rawImfileRow *_object; + + _object = psAlloc(sizeof(rawImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)rawImfileRowFree); + + _object->exp_id = exp_id; + _object->exp_name = psStringCopy(exp_name); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->dateobs = psTimeCopy(dateobs); + _object->tmp_class_id = psStringCopy(tmp_class_id); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->exp_type = psStringCopy(exp_type); + _object->filelevel = psStringCopy(filelevel); + _object->filter = psStringCopy(filter); + _object->airmass = airmass; + _object->ra = ra; + _object->decl = decl; + _object->exp_time = exp_time; + _object->sat_pixel_frac = sat_pixel_frac; + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->alt = alt; + _object->az = az; + _object->ccd_temp = ccd_temp; + _object->posang = posang; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->object = psStringCopy(object); + _object->fault = fault; + + return _object; +} + +static void rawImfileRowFree(rawImfileRow *object) +{ + psFree(object->exp_name); + psFree(object->camera); + psFree(object->telescope); + psFree(object->dateobs); + psFree(object->tmp_class_id); + psFree(object->class_id); + psFree(object->uri); + psFree(object->exp_type); + psFree(object->filelevel); + psFree(object->filter); + psFree(object->object); +} + +bool rawImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id, tmp_class_id) ref newImfile(exp_id, tmp_class_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, RAWIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool rawImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, RAWIMFILE_TABLE_NAME); +} + +bool rawImfileInsert(psDB * dbh, psS64 exp_id, const char *exp_name, const char *camera, const char *telescope, psTime* dateobs, const char *tmp_class_id, const char *class_id, const char *uri, const char *exp_type, const char *filelevel, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF32 sat_pixel_frac, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *object, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, NULL, tmp_class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, airmass)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, decl)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, exp_time)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, sat_pixel_frac)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, alt)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, az)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, ccd_temp)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, posang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, RAWIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long rawImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool rawImfileInsertObject(psDB *dbh, rawImfileRow *object) +{ + return rawImfileInsert(dbh, object->exp_id, object->exp_name, object->camera, object->telescope, object->dateobs, object->tmp_class_id, object->class_id, object->uri, object->exp_type, object->filelevel, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->sat_pixel_frac, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->object, object->fault); +} + +bool rawImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!rawImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool rawImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named RAWIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, RAWIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", RAWIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, RAWIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool rawImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, RAWIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, RAWIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *rawImfileMetadataFromObject(const rawImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_name", PS_DATA_STRING, NULL, object->exp_name)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_name"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dateobs", PS_DATA_TIME, NULL, object->dateobs)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dateobs"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tmp_class_id", PS_DATA_STRING, NULL, object->tmp_class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tmp_class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, object->filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass", PS_DATA_F32, NULL, object->airmass)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ra", PS_DATA_F64, NULL, object->ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "decl", PS_DATA_F64, NULL, object->decl)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item decl"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time", PS_DATA_F32, NULL, object->exp_time)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sat_pixel_frac", PS_DATA_F32, NULL, object->sat_pixel_frac)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sat_pixel_frac"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "alt", PS_DATA_F64, NULL, object->alt)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item alt"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "az", PS_DATA_F64, NULL, object->az)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item az"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp", PS_DATA_F32, NULL, object->ccd_temp)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang", PS_DATA_F64, NULL, object->posang)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "object", PS_DATA_STRING, NULL, object->object)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item object"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +rawImfileRow *rawImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* exp_name = psMetadataLookupPtr(&status, md, "exp_name"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_name"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs"); + return false; + } + char* tmp_class_id = psMetadataLookupPtr(&status, md, "tmp_class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tmp_class_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* exp_type = psMetadataLookupPtr(&status, md, "exp_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type"); + return false; + } + char* filelevel = psMetadataLookupPtr(&status, md, "filelevel"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filelevel"); + return false; + } + char* filter = psMetadataLookupPtr(&status, md, "filter"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter"); + return false; + } + psF32 airmass = psMetadataLookupF32(&status, md, "airmass"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass"); + return false; + } + psF64 ra = psMetadataLookupF64(&status, md, "ra"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ra"); + return false; + } + psF64 decl = psMetadataLookupF64(&status, md, "decl"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item decl"); + return false; + } + psF32 exp_time = psMetadataLookupF32(&status, md, "exp_time"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time"); + return false; + } + psF32 sat_pixel_frac = psMetadataLookupF32(&status, md, "sat_pixel_frac"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sat_pixel_frac"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 alt = psMetadataLookupF64(&status, md, "alt"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item alt"); + return false; + } + psF64 az = psMetadataLookupF64(&status, md, "az"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item az"); + return false; + } + psF32 ccd_temp = psMetadataLookupF32(&status, md, "ccd_temp"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp"); + return false; + } + psF64 posang = psMetadataLookupF64(&status, md, "posang"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* object = psMetadataLookupPtr(&status, md, "object"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return rawImfileRowAlloc(exp_id, exp_name, camera, telescope, dateobs, tmp_class_id, class_id, uri, exp_type, filelevel, filter, airmass, ra, decl, exp_time, sat_pixel_frac, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, user_1, user_2, user_3, user_4, user_5, object, fault); +} +psArray *rawImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, RAWIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + rawImfileRow *object = rawImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool rawImfileDeleteObject(psDB *dbh, const rawImfileRow *object) +{ + psMetadata *where = rawImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "rawImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long rawImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + rawImfileRow *object = objects->data[i]; + psMetadata *where = rawImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, RAWIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from rawImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool rawImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = rawImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + RAWIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool rawImfilePrintObject(FILE *stream, rawImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = rawImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void guidePendingExpRowFree(guidePendingExpRow *object); + +guidePendingExpRow *guidePendingExpRowAlloc(psS64 guide_id, psS64 exp_id, const char *recipe) +{ + guidePendingExpRow *_object; + + _object = psAlloc(sizeof(guidePendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)guidePendingExpRowFree); + + _object->guide_id = guide_id; + _object->exp_id = exp_id; + _object->recipe = psStringCopy(recipe); + + return _object; +} + +static void guidePendingExpRowFree(guidePendingExpRow *object) +{ + psFree(object->recipe); +} + +bool guidePendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Key", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, GUIDEPENDINGEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool guidePendingExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, GUIDEPENDINGEXP_TABLE_NAME); +} + +bool guidePendingExpInsert(psDB * dbh, psS64 guide_id, psS64 exp_id, const char *recipe) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, guide_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, GUIDEPENDINGEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long guidePendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool guidePendingExpInsertObject(psDB *dbh, guidePendingExpRow *object) +{ + return guidePendingExpInsert(dbh, object->guide_id, object->exp_id, object->recipe); +} + +bool guidePendingExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!guidePendingExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool guidePendingExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named GUIDEPENDINGEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, GUIDEPENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", GUIDEPENDINGEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool guidePendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, GUIDEPENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *guidePendingExpMetadataFromObject(const guidePendingExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "guide_id", PS_DATA_S64, NULL, object->guide_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item guide_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + + + return md; +} + +guidePendingExpRow *guidePendingExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 guide_id = psMetadataLookupS64(&status, md, "guide_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item guide_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + + return guidePendingExpRowAlloc(guide_id, exp_id, recipe); +} +psArray *guidePendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + guidePendingExpRow *object = guidePendingExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool guidePendingExpDeleteObject(psDB *dbh, const guidePendingExpRow *object) +{ + psMetadata *where = guidePendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "guidePendingExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long guidePendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + guidePendingExpRow *object = objects->data[i]; + psMetadata *where = guidePendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, GUIDEPENDINGEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from guidePendingExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool guidePendingExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = guidePendingExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + GUIDEPENDINGEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool guidePendingExpPrintObject(FILE *stream, guidePendingExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = guidePendingExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void chipRunRowFree(chipRunRow *object); + +chipRunRow *chipRunRowAlloc(psS64 chip_id, psS64 exp_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb) +{ + chipRunRow *_object; + + _object = psAlloc(sizeof(chipRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)chipRunRowFree); + + _object->chip_id = chip_id; + _object->exp_id = exp_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->workdir_state = psStringCopy(workdir_state); + _object->label = psStringCopy(label); + _object->reduction = psStringCopy(reduction); + _object->expgroup = psStringCopy(expgroup); + _object->dvodb = psStringCopy(dvodb); + + return _object; +} + +static void chipRunRowFree(chipRunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->workdir_state); + psFree(object->label); + psFree(object->reduction); + psFree(object->expgroup); + psFree(object->dvodb); +} + +bool chipRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Key INDEX(chip_id, exp_id) fkey (exp_id) ref rawExp(exp_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction class", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CHIPRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool chipRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CHIPRUN_TABLE_NAME); +} + +bool chipRunInsert(psDB * dbh, psS64 chip_id, psS64 exp_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, expgroup)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CHIPRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long chipRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CHIPRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool chipRunInsertObject(psDB *dbh, chipRunRow *object) +{ + return chipRunInsert(dbh, object->chip_id, object->exp_id, object->state, object->workdir, object->workdir_state, object->label, object->reduction, object->expgroup, object->dvodb); +} + +bool chipRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!chipRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool chipRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CHIPRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, CHIPRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CHIPRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool chipRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CHIPRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CHIPRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *chipRunMetadataFromObject(const chipRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, object->workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, object->expgroup)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + + return md; +} + +chipRunRow *chipRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* workdir_state = psMetadataLookupPtr(&status, md, "workdir_state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir_state"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + char* reduction = psMetadataLookupPtr(&status, md, "reduction"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction"); + return false; + } + char* expgroup = psMetadataLookupPtr(&status, md, "expgroup"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item expgroup"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + + return chipRunRowAlloc(chip_id, exp_id, state, workdir, workdir_state, label, reduction, expgroup, dvodb); +} +psArray *chipRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CHIPRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + chipRunRow *object = chipRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool chipRunDeleteObject(psDB *dbh, const chipRunRow *object) +{ + psMetadata *where = chipRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "chipRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long chipRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + chipRunRow *object = objects->data[i]; + psMetadata *where = chipRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool chipRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = chipRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CHIPRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool chipRunPrintObject(FILE *stream, chipRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = chipRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void chipProcessedImfileRowFree(chipProcessedImfileRow *object); + +chipProcessedImfileRow *chipProcessedImfileRowAlloc(psS64 chip_id, psS64 exp_id, const char *class_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault) +{ + chipProcessedImfileRow *_object; + + _object = psAlloc(sizeof(chipProcessedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)chipProcessedImfileRowFree); + + _object->chip_id = chip_id; + _object->exp_id = exp_id; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->bias = bias; + _object->bias_stdev = bias_stdev; + _object->fringe_0 = fringe_0; + _object->fringe_1 = fringe_1; + _object->fringe_2 = fringe_2; + _object->sigma_ra = sigma_ra; + _object->sigma_dec = sigma_dec; + _object->ap_resid = ap_resid; + _object->ap_resid_stdev = ap_resid_stdev; + _object->fwhm = fwhm; + _object->fwhm_range = fwhm_range; + _object->n_stars = n_stars; + _object->n_extended = n_extended; + _object->n_cr = n_cr; + _object->n_astrom = n_astrom; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void chipProcessedImfileRowFree(chipProcessedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->path_base); +} + +bool chipProcessedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey (chip_id, exp_id) ref chipRun(chip_id, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey (exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, "# replace this with fwhm_major", 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, "# replace this with fwhm_minor", 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool chipProcessedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME); +} + +bool chipProcessedImfileInsert(psDB * dbh, psS64 chip_id, psS64 exp_id, const char *class_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 bias, psF32 bias_stdev, psF32 fringe_0, psF32 fringe_1, psF32 fringe_2, psF32 sigma_ra, psF32 sigma_dec, psF32 ap_resid, psF32 ap_resid_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, bias)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, bias_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, sigma_ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, sigma_dec)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, ap_resid)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, ap_resid_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, fwhm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, fwhm_range)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, n_stars)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, n_extended)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, n_cr)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, n_astrom)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long chipProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool chipProcessedImfileInsertObject(psDB *dbh, chipProcessedImfileRow *object) +{ + return chipProcessedImfileInsert(dbh, object->chip_id, object->exp_id, object->class_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bias, object->bias_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->sigma_ra, object->sigma_dec, object->ap_resid, object->ap_resid_stdev, object->fwhm, object->fwhm_range, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault); +} + +bool chipProcessedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!chipProcessedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool chipProcessedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CHIPPROCESSEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, CHIPPROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPPROCESSEDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool chipProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CHIPPROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *chipProcessedImfileMetadataFromObject(const chipProcessedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias", PS_DATA_F32, NULL, object->bias)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bias_stdev", PS_DATA_F32, NULL, object->bias_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bias_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F32, NULL, object->fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F32, NULL, object->fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F32, NULL, object->fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, object->sigma_ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, object->sigma_dec)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid", PS_DATA_F32, NULL, object->ap_resid)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ap_resid_stdev", PS_DATA_F32, NULL, object->ap_resid_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ap_resid_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, object->fwhm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, object->fwhm_range)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, object->n_stars)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, object->n_extended)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, object->n_cr)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, object->n_astrom)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +chipProcessedImfileRow *chipProcessedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psF32 bg = psMetadataLookupF32(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF32 bg_stdev = psMetadataLookupF32(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF32 bg_mean_stdev = psMetadataLookupF32(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF32 bias = psMetadataLookupF32(&status, md, "bias"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bias"); + return false; + } + psF32 bias_stdev = psMetadataLookupF32(&status, md, "bias_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bias_stdev"); + return false; + } + psF32 fringe_0 = psMetadataLookupF32(&status, md, "fringe_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0"); + return false; + } + psF32 fringe_1 = psMetadataLookupF32(&status, md, "fringe_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1"); + return false; + } + psF32 fringe_2 = psMetadataLookupF32(&status, md, "fringe_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2"); + return false; + } + psF32 sigma_ra = psMetadataLookupF32(&status, md, "sigma_ra"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra"); + return false; + } + psF32 sigma_dec = psMetadataLookupF32(&status, md, "sigma_dec"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec"); + return false; + } + psF32 ap_resid = psMetadataLookupF32(&status, md, "ap_resid"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ap_resid"); + return false; + } + psF32 ap_resid_stdev = psMetadataLookupF32(&status, md, "ap_resid_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ap_resid_stdev"); + return false; + } + psF32 fwhm = psMetadataLookupF32(&status, md, "fwhm"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm"); + return false; + } + psF32 fwhm_range = psMetadataLookupF32(&status, md, "fwhm_range"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm_range"); + return false; + } + psS32 n_stars = psMetadataLookupS32(&status, md, "n_stars"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_stars"); + return false; + } + psS32 n_extended = psMetadataLookupS32(&status, md, "n_extended"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_extended"); + return false; + } + psS32 n_cr = psMetadataLookupS32(&status, md, "n_cr"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_cr"); + return false; + } + psS32 n_astrom = psMetadataLookupS32(&status, md, "n_astrom"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_astrom"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return chipProcessedImfileRowAlloc(chip_id, exp_id, class_id, uri, bg, bg_stdev, bg_mean_stdev, bias, bias_stdev, fringe_0, fringe_1, fringe_2, sigma_ra, sigma_dec, ap_resid, ap_resid_stdev, fwhm, fwhm_range, n_stars, n_extended, n_cr, n_astrom, path_base, fault); +} +psArray *chipProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + chipProcessedImfileRow *object = chipProcessedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool chipProcessedImfileDeleteObject(psDB *dbh, const chipProcessedImfileRow *object) +{ + psMetadata *where = chipProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "chipProcessedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long chipProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + chipProcessedImfileRow *object = objects->data[i]; + psMetadata *where = chipProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPPROCESSEDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipProcessedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool chipProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = chipProcessedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CHIPPROCESSEDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool chipProcessedImfilePrintObject(FILE *stream, chipProcessedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = chipProcessedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void chipMaskRowFree(chipMaskRow *object); + +chipMaskRow *chipMaskRowAlloc(const char *label) +{ + chipMaskRow *_object; + + _object = psAlloc(sizeof(chipMaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)chipMaskRowFree); + + _object->label = psStringCopy(label); + + return _object; +} + +static void chipMaskRowFree(chipMaskRow *object) +{ + psFree(object->label); +} + +bool chipMaskCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CHIPMASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool chipMaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CHIPMASK_TABLE_NAME); +} + +bool chipMaskInsert(psDB * dbh, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CHIPMASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long chipMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask"); + return count; + + deleted += count; + } + + return deleted; +} +bool chipMaskInsertObject(psDB *dbh, chipMaskRow *object) +{ + return chipMaskInsert(dbh, object->label); +} + +bool chipMaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!chipMaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool chipMaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CHIPMASK_TABLE_NAME + if (!psFitsMoveExtName(fits, CHIPMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CHIPMASK_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CHIPMASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool chipMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CHIPMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CHIPMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *chipMaskMetadataFromObject(const chipMaskRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + + return md; +} + +chipMaskRow *chipMaskObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return chipMaskRowAlloc(label); +} +psArray *chipMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CHIPMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + chipMaskRow *object = chipMaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool chipMaskDeleteObject(psDB *dbh, const chipMaskRow *object) +{ + psMetadata *where = chipMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "chipMaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long chipMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + chipMaskRow *object = objects->data[i]; + psMetadata *where = chipMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CHIPMASK_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from chipMask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool chipMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = chipMaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CHIPMASK_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool chipMaskPrintObject(FILE *stream, chipMaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = chipMaskMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void camRunRowFree(camRunRow *object); + +camRunRow *camRunRowAlloc(psS64 cam_id, psS64 chip_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb) +{ + camRunRow *_object; + + _object = psAlloc(sizeof(camRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)camRunRowFree); + + _object->cam_id = cam_id; + _object->chip_id = chip_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->workdir_state = psStringCopy(workdir_state); + _object->label = psStringCopy(label); + _object->reduction = psStringCopy(reduction); + _object->expgroup = psStringCopy(expgroup); + _object->dvodb = psStringCopy(dvodb); + + return _object; +} + +static void camRunRowFree(camRunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->workdir_state); + psFree(object->label); + psFree(object->reduction); + psFree(object->expgroup); + psFree(object->dvodb); +} + +bool camRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Key INDEX(cam_id, chip_id) fkey(chip_id) ref chipRun(chip_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CAMRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool camRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CAMRUN_TABLE_NAME); +} + +bool camRunInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *reduction, const char *expgroup, const char *dvodb) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, expgroup)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CAMRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long camRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CAMRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool camRunInsertObject(psDB *dbh, camRunRow *object) +{ + return camRunInsert(dbh, object->cam_id, object->chip_id, object->state, object->workdir, object->workdir_state, object->label, object->reduction, object->expgroup, object->dvodb); +} + +bool camRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!camRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool camRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CAMRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, CAMRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CAMRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool camRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CAMRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CAMRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *camRunMetadataFromObject(const camRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, object->workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "expgroup", PS_DATA_STRING, NULL, object->expgroup)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item expgroup"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + + + return md; +} + +camRunRow *camRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id"); + return false; + } + psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* workdir_state = psMetadataLookupPtr(&status, md, "workdir_state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir_state"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + char* reduction = psMetadataLookupPtr(&status, md, "reduction"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction"); + return false; + } + char* expgroup = psMetadataLookupPtr(&status, md, "expgroup"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item expgroup"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + + return camRunRowAlloc(cam_id, chip_id, state, workdir, workdir_state, label, reduction, expgroup, dvodb); +} +psArray *camRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CAMRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + camRunRow *object = camRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool camRunDeleteObject(psDB *dbh, const camRunRow *object) +{ + psMetadata *where = camRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "camRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long camRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + camRunRow *object = objects->data[i]; + psMetadata *where = camRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool camRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = camRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CAMRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool camRunPrintObject(FILE *stream, camRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = camRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void camProcessedExpRowFree(camProcessedExpRow *object); + +camProcessedExpRow *camProcessedExpRowAlloc(psS64 cam_id, psS64 chip_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault) +{ + camProcessedExpRow *_object; + + _object = psAlloc(sizeof(camProcessedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)camProcessedExpRowFree); + + _object->cam_id = cam_id; + _object->chip_id = chip_id; + _object->uri = psStringCopy(uri); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->sigma_ra = sigma_ra; + _object->sigma_dec = sigma_dec; + _object->zp_mean = zp_mean; + _object->zp_stdev = zp_stdev; + _object->fwhm = fwhm; + _object->fwhm_range = fwhm_range; + _object->n_stars = n_stars; + _object->n_extended = n_extended; + _object->n_cr = n_cr; + _object->n_astrom = n_astrom; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void camProcessedExpRowFree(camProcessedExpRow *object) +{ + psFree(object->uri); + psFree(object->path_base); +} + +bool camProcessedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, "Primary Key fkey(cam_id, chip_id) ref camRun(cam_id, chip_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CAMPROCESSEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool camProcessedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CAMPROCESSEDEXP_TABLE_NAME); +} + +bool camProcessedExpInsert(psDB * dbh, psS64 cam_id, psS64 chip_id, const char *uri, psF32 bg, psF32 bg_stdev, psF32 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psF32 zp_mean, psF32 zp_stdev, psF32 fwhm, psF32 fwhm_range, psS32 n_stars, psS32 n_extended, psS32 n_cr, psS32 n_astrom, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, sigma_ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, sigma_dec)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, zp_mean)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, zp_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, fwhm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, fwhm_range)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, n_stars)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, n_extended)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, n_cr)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, n_astrom)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CAMPROCESSEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long camProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool camProcessedExpInsertObject(psDB *dbh, camProcessedExpRow *object) +{ + return camProcessedExpInsert(dbh, object->cam_id, object->chip_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->zp_mean, object->zp_stdev, object->fwhm, object->fwhm_range, object->n_stars, object->n_extended, object->n_cr, object->n_astrom, object->path_base, object->fault); +} + +bool camProcessedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!camProcessedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool camProcessedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CAMPROCESSEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, CAMPROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMPROCESSEDEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool camProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CAMPROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *camProcessedExpMetadataFromObject(const camProcessedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "chip_id", PS_DATA_S64, NULL, object->chip_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item chip_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F32, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F32, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F32, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_ra", PS_DATA_F32, NULL, object->sigma_ra)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_ra"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "sigma_dec", PS_DATA_F32, NULL, object->sigma_dec)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item sigma_dec"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_mean", PS_DATA_F32, NULL, object->zp_mean)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_mean"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "zp_stdev", PS_DATA_F32, NULL, object->zp_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item zp_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm", PS_DATA_F32, NULL, object->fwhm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fwhm_range", PS_DATA_F32, NULL, object->fwhm_range)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fwhm_range"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_stars", PS_DATA_S32, NULL, object->n_stars)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_stars"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_extended", PS_DATA_S32, NULL, object->n_extended)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_extended"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_cr", PS_DATA_S32, NULL, object->n_cr)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_cr"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "n_astrom", PS_DATA_S32, NULL, object->n_astrom)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item n_astrom"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +camProcessedExpRow *camProcessedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id"); + return false; + } + psS64 chip_id = psMetadataLookupS64(&status, md, "chip_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item chip_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psF32 bg = psMetadataLookupF32(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF32 bg_stdev = psMetadataLookupF32(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF32 bg_mean_stdev = psMetadataLookupF32(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF32 sigma_ra = psMetadataLookupF32(&status, md, "sigma_ra"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_ra"); + return false; + } + psF32 sigma_dec = psMetadataLookupF32(&status, md, "sigma_dec"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item sigma_dec"); + return false; + } + psF32 zp_mean = psMetadataLookupF32(&status, md, "zp_mean"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_mean"); + return false; + } + psF32 zp_stdev = psMetadataLookupF32(&status, md, "zp_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item zp_stdev"); + return false; + } + psF32 fwhm = psMetadataLookupF32(&status, md, "fwhm"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm"); + return false; + } + psF32 fwhm_range = psMetadataLookupF32(&status, md, "fwhm_range"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fwhm_range"); + return false; + } + psS32 n_stars = psMetadataLookupS32(&status, md, "n_stars"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_stars"); + return false; + } + psS32 n_extended = psMetadataLookupS32(&status, md, "n_extended"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_extended"); + return false; + } + psS32 n_cr = psMetadataLookupS32(&status, md, "n_cr"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_cr"); + return false; + } + psS32 n_astrom = psMetadataLookupS32(&status, md, "n_astrom"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item n_astrom"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return camProcessedExpRowAlloc(cam_id, chip_id, uri, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, zp_mean, zp_stdev, fwhm, fwhm_range, n_stars, n_extended, n_cr, n_astrom, path_base, fault); +} +psArray *camProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + camProcessedExpRow *object = camProcessedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool camProcessedExpDeleteObject(psDB *dbh, const camProcessedExpRow *object) +{ + psMetadata *where = camProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "camProcessedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long camProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + camProcessedExpRow *object = objects->data[i]; + psMetadata *where = camProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMPROCESSEDEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camProcessedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool camProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = camProcessedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CAMPROCESSEDEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool camProcessedExpPrintObject(FILE *stream, camProcessedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = camProcessedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void camMaskRowFree(camMaskRow *object); + +camMaskRow *camMaskRowAlloc(const char *label) +{ + camMaskRow *_object; + + _object = psAlloc(sizeof(camMaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)camMaskRowFree); + + _object->label = psStringCopy(label); + + return _object; +} + +static void camMaskRowFree(camMaskRow *object) +{ + psFree(object->label); +} + +bool camMaskCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, CAMMASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool camMaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, CAMMASK_TABLE_NAME); +} + +bool camMaskInsert(psDB * dbh, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, CAMMASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long camMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask"); + return count; + + deleted += count; + } + + return deleted; +} +bool camMaskInsertObject(psDB *dbh, camMaskRow *object) +{ + return camMaskInsert(dbh, object->label); +} + +bool camMaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!camMaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool camMaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named CAMMASK_TABLE_NAME + if (!psFitsMoveExtName(fits, CAMMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", CAMMASK_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, CAMMASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool camMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, CAMMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, CAMMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *camMaskMetadataFromObject(const camMaskRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + + return md; +} + +camMaskRow *camMaskObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return camMaskRowAlloc(label); +} +psArray *camMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, CAMMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + camMaskRow *object = camMaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool camMaskDeleteObject(psDB *dbh, const camMaskRow *object) +{ + psMetadata *where = camMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "camMaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long camMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + camMaskRow *object = objects->data[i]; + psMetadata *where = camMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, CAMMASK_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from camMask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool camMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = camMaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + CAMMASK_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool camMaskPrintObject(FILE *stream, camMaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = camMaskMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void warpRunRowFree(warpRunRow *object); + +warpRunRow *warpRunRowAlloc(psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered) +{ + warpRunRow *_object; + + _object = psAlloc(sizeof(warpRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)warpRunRowFree); + + _object->warp_id = warp_id; + _object->mode = psStringCopy(mode); + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->dvodb = psStringCopy(dvodb); + _object->registered = psTimeCopy(registered); + + return _object; +} + +static void warpRunRowFree(warpRunRow *object) +{ + psFree(object->mode); + psFree(object->state); + psFree(object->workdir); + psFree(object->dvodb); + psFree(object->registered); +} + +bool warpRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, WARPRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool warpRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, WARPRUN_TABLE_NAME); +} + +bool warpRunInsert(psDB * dbh, psS64 warp_id, const char *mode, const char *state, const char *workdir, const char *dvodb, psTime* registered) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, WARPRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long warpRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool warpRunInsertObject(psDB *dbh, warpRunRow *object) +{ + return warpRunInsert(dbh, object->warp_id, object->mode, object->state, object->workdir, object->dvodb, object->registered); +} + +bool warpRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!warpRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool warpRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named WARPRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, WARPRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, WARPRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool warpRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, WARPRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, WARPRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *warpRunMetadataFromObject(const warpRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, object->mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + + return md; +} + +warpRunRow *warpRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + char* mode = psMetadataLookupPtr(&status, md, "mode"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item mode"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + + return warpRunRowAlloc(warp_id, mode, state, workdir, dvodb, registered); +} +psArray *warpRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, WARPRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + warpRunRow *object = warpRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool warpRunDeleteObject(psDB *dbh, const warpRunRow *object) +{ + psMetadata *where = warpRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "warpRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long warpRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + warpRunRow *object = objects->data[i]; + psMetadata *where = warpRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool warpRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = warpRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + WARPRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool warpRunPrintObject(FILE *stream, warpRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = warpRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void warpInputExpRowFree(warpInputExpRow *object); + +warpInputExpRow *warpInputExpRowAlloc(psS64 warp_id, psS64 cam_id, bool magiced) +{ + warpInputExpRow *_object; + + _object = psAlloc(sizeof(warpInputExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)warpInputExpRowFree); + + _object->warp_id = warp_id; + _object->cam_id = cam_id; + _object->magiced = magiced; + + return _object; +} + +static void warpInputExpRowFree(warpInputExpRow *object) +{ +} + +bool warpInputExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id) ref warpRun(warp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key fkey(cam_id) ref camProcessedExp(cam_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magiced"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, WARPINPUTEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool warpInputExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, WARPINPUTEXP_TABLE_NAME); +} + +bool warpInputExpInsert(psDB * dbh, psS64 warp_id, psS64 cam_id, bool magiced) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, magiced)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magiced"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, WARPINPUTEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long warpInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool warpInputExpInsertObject(psDB *dbh, warpInputExpRow *object) +{ + return warpInputExpInsert(dbh, object->warp_id, object->cam_id, object->magiced); +} + +bool warpInputExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!warpInputExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool warpInputExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named WARPINPUTEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, WARPINPUTEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPINPUTEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, WARPINPUTEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool warpInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, WARPINPUTEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *warpInputExpMetadataFromObject(const warpInputExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, object->magiced)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magiced"); + psFree(md); + return false; + } + + + return md; +} + +warpInputExpRow *warpInputExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id"); + return false; + } + bool magiced = psMetadataLookupBool(&status, md, "magiced"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magiced"); + return false; + } + + return warpInputExpRowAlloc(warp_id, cam_id, magiced); +} +psArray *warpInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + warpInputExpRow *object = warpInputExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool warpInputExpDeleteObject(psDB *dbh, const warpInputExpRow *object) +{ + psMetadata *where = warpInputExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "warpInputExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long warpInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + warpInputExpRow *object = objects->data[i]; + psMetadata *where = warpInputExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPINPUTEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpInputExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool warpInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = warpInputExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + WARPINPUTEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool warpInputExpPrintObject(FILE *stream, warpInputExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = warpInputExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void warpSkyCellMapRowFree(warpSkyCellMapRow *object); + +warpSkyCellMapRow *warpSkyCellMapRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault) +{ + warpSkyCellMapRow *_object; + + _object = psAlloc(sizeof(warpSkyCellMapRow)); + psMemSetDeallocator(_object, (psFreeFunc)warpSkyCellMapRowFree); + + _object->warp_id = warp_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->cam_id = cam_id; + _object->class_id = psStringCopy(class_id); + _object->fault = fault; + + return _object; +} + +static void warpSkyCellMapRowFree(warpSkyCellMapRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->class_id); +} + +bool warpSkyCellMapCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id, cam_id) ref warpInputExp(warp_id, cam_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, WARPSKYCELLMAP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool warpSkyCellMapDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, WARPSKYCELLMAP_TABLE_NAME); +} + +bool warpSkyCellMapInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, psS64 cam_id, const char *class_id, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, WARPSKYCELLMAP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long warpSkyCellMapDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap"); + return count; + + deleted += count; + } + + return deleted; +} +bool warpSkyCellMapInsertObject(psDB *dbh, warpSkyCellMapRow *object) +{ + return warpSkyCellMapInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->cam_id, object->class_id, object->fault); +} + +bool warpSkyCellMapInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!warpSkyCellMapInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool warpSkyCellMapInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named WARPSKYCELLMAP_TABLE_NAME + if (!psFitsMoveExtName(fits, WARPSKYCELLMAP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPSKYCELLMAP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, WARPSKYCELLMAP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool warpSkyCellMapSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, WARPSKYCELLMAP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *warpSkyCellMapMetadataFromObject(const warpSkyCellMapRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "cam_id", PS_DATA_S64, NULL, object->cam_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item cam_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +warpSkyCellMapRow *warpSkyCellMapObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + psS64 cam_id = psMetadataLookupS64(&status, md, "cam_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item cam_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return warpSkyCellMapRowAlloc(warp_id, skycell_id, tess_id, cam_id, class_id, fault); +} +psArray *warpSkyCellMapSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + warpSkyCellMapRow *object = warpSkyCellMapObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool warpSkyCellMapDeleteObject(psDB *dbh, const warpSkyCellMapRow *object) +{ + psMetadata *where = warpSkyCellMapMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "warpSkyCellMapRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long warpSkyCellMapDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + warpSkyCellMapRow *object = objects->data[i]; + psMetadata *where = warpSkyCellMapMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPSKYCELLMAP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyCellMap"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool warpSkyCellMapPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = warpSkyCellMapMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + WARPSKYCELLMAP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool warpSkyCellMapPrintObject(FILE *stream, warpSkyCellMapRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = warpSkyCellMapMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void warpSkyfileRowFree(warpSkyfileRow *object); + +warpSkyfileRow *warpSkyfileRowAlloc(psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psF64 pixel_fill, psS16 fault) +{ + warpSkyfileRow *_object; + + _object = psAlloc(sizeof(warpSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)warpSkyfileRowFree); + + _object->warp_id = warp_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->uri = psStringCopy(uri); + _object->path_base = psStringCopy(path_base); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->pixel_fill = pixel_fill; + _object->fault = fault; + + return _object; +} + +static void warpSkyfileRowFree(warpSkyfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->uri); + psFree(object->path_base); +} + +bool warpSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id, skycell_id, tess_id) ref warpSkyCellMap(warp_id, skycell_id, tess_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "pixel_fill", PS_DATA_F64, "Key", 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item pixel_fill"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, WARPSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool warpSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, WARPSKYFILE_TABLE_NAME); +} + +bool warpSkyfileInsert(psDB * dbh, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psF64 pixel_fill, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "pixel_fill", PS_DATA_F64, NULL, pixel_fill)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item pixel_fill"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, WARPSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long warpSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool warpSkyfileInsertObject(psDB *dbh, warpSkyfileRow *object) +{ + return warpSkyfileInsert(dbh, object->warp_id, object->skycell_id, object->tess_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->pixel_fill, object->fault); +} + +bool warpSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!warpSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool warpSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named WARPSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, WARPSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", WARPSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, WARPSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool warpSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, WARPSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *warpSkyfileMetadataFromObject(const warpSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "pixel_fill", PS_DATA_F64, NULL, object->pixel_fill)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item pixel_fill"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +warpSkyfileRow *warpSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 pixel_fill = psMetadataLookupF64(&status, md, "pixel_fill"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item pixel_fill"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return warpSkyfileRowAlloc(warp_id, skycell_id, tess_id, uri, path_base, bg, bg_stdev, pixel_fill, fault); +} +psArray *warpSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + warpSkyfileRow *object = warpSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool warpSkyfileDeleteObject(psDB *dbh, const warpSkyfileRow *object) +{ + psMetadata *where = warpSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "warpSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long warpSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + warpSkyfileRow *object = objects->data[i]; + psMetadata *where = warpSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, WARPSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from warpSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool warpSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = warpSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + WARPSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool warpSkyfilePrintObject(FILE *stream, warpSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = warpSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void diffRunRowFree(diffRunRow *object); + +diffRunRow *diffRunRowAlloc(psS64 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id) +{ + diffRunRow *_object; + + _object = psAlloc(sizeof(diffRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)diffRunRowFree); + + _object->diff_id = diff_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->dvodb = psStringCopy(dvodb); + _object->registered = psTimeCopy(registered); + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + + return _object; +} + +static void diffRunRowFree(diffRunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->dvodb); + psFree(object->registered); + psFree(object->skycell_id); + psFree(object->tess_id); +} + +bool diffRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DIFFRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool diffRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DIFFRUN_TABLE_NAME); +} + +bool diffRunInsert(psDB * dbh, psS64 diff_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DIFFRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long diffRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool diffRunInsertObject(psDB *dbh, diffRunRow *object) +{ + return diffRunInsert(dbh, object->diff_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id); +} + +bool diffRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!diffRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool diffRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DIFFRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, DIFFRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DIFFRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool diffRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DIFFRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DIFFRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *diffRunMetadataFromObject(const diffRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + + return md; +} + +diffRunRow *diffRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + + return diffRunRowAlloc(diff_id, state, workdir, dvodb, registered, skycell_id, tess_id); +} +psArray *diffRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DIFFRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + diffRunRow *object = diffRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool diffRunDeleteObject(psDB *dbh, const diffRunRow *object) +{ + psMetadata *where = diffRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "diffRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long diffRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + diffRunRow *object = objects->data[i]; + psMetadata *where = diffRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool diffRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = diffRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DIFFRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool diffRunPrintObject(FILE *stream, diffRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = diffRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void diffInputSkyfileRowFree(diffInputSkyfileRow *object); + +diffInputSkyfileRow *diffInputSkyfileRowAlloc(psS64 diff_id, bool template, psS64 stack_id, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *kind) +{ + diffInputSkyfileRow *_object; + + _object = psAlloc(sizeof(diffInputSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)diffInputSkyfileRowFree); + + _object->diff_id = diff_id; + _object->template = template; + _object->stack_id = stack_id; + _object->warp_id = warp_id; + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->kind = psStringCopy(kind); + + return _object; +} + +static void diffInputSkyfileRowFree(diffInputSkyfileRow *object) +{ + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->kind); +} + +bool diffInputSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key fkey(diff_id) ref diffRun(diff_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "fkey(stack_id) ref stackSumSkyfile(stack_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "fkey(warp_id, skycell_id, tess_id) ref warpSkyfile(warp_id, skycell_id, tess_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DIFFINPUTSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool diffInputSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DIFFINPUTSKYFILE_TABLE_NAME); +} + +bool diffInputSkyfileInsert(psDB * dbh, psS64 diff_id, bool template, psS64 stack_id, psS64 warp_id, const char *skycell_id, const char *tess_id, const char *kind) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, template)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, kind)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DIFFINPUTSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long diffInputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool diffInputSkyfileInsertObject(psDB *dbh, diffInputSkyfileRow *object) +{ + return diffInputSkyfileInsert(dbh, object->diff_id, object->template, object->stack_id, object->warp_id, object->skycell_id, object->tess_id, object->kind); +} + +bool diffInputSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!diffInputSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool diffInputSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DIFFINPUTSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DIFFINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFINPUTSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool diffInputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DIFFINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *diffInputSkyfileMetadataFromObject(const diffInputSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, object->template)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item template"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "kind", PS_DATA_STRING, NULL, object->kind)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item kind"); + psFree(md); + return false; + } + + + return md; +} + +diffInputSkyfileRow *diffInputSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id"); + return false; + } + bool template = psMetadataLookupBool(&status, md, "template"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item template"); + return false; + } + psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id"); + return false; + } + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + char* kind = psMetadataLookupPtr(&status, md, "kind"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item kind"); + return false; + } + + return diffInputSkyfileRowAlloc(diff_id, template, stack_id, warp_id, skycell_id, tess_id, kind); +} +psArray *diffInputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + diffInputSkyfileRow *object = diffInputSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool diffInputSkyfileDeleteObject(psDB *dbh, const diffInputSkyfileRow *object) +{ + psMetadata *where = diffInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "diffInputSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long diffInputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + diffInputSkyfileRow *object = objects->data[i]; + psMetadata *where = diffInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFINPUTSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffInputSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool diffInputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = diffInputSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DIFFINPUTSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool diffInputSkyfilePrintObject(FILE *stream, diffInputSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = diffInputSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void diffSkyfileRowFree(diffSkyfileRow *object); + +diffSkyfileRow *diffSkyfileRowAlloc(psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault) +{ + diffSkyfileRow *_object; + + _object = psAlloc(sizeof(diffSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)diffSkyfileRowFree); + + _object->diff_id = diff_id; + _object->uri = psStringCopy(uri); + _object->path_base = psStringCopy(path_base); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->fault = fault; + + return _object; +} + +static void diffSkyfileRowFree(diffSkyfileRow *object) +{ + psFree(object->uri); + psFree(object->path_base); +} + +bool diffSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Primary Key fkey(diff_id) ref diffRun(diff_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DIFFSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool diffSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DIFFSKYFILE_TABLE_NAME); +} + +bool diffSkyfileInsert(psDB * dbh, psS64 diff_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DIFFSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long diffSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool diffSkyfileInsertObject(psDB *dbh, diffSkyfileRow *object) +{ + return diffSkyfileInsert(dbh, object->diff_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->fault); +} + +bool diffSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!diffSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool diffSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DIFFSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DIFFSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DIFFSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DIFFSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool diffSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DIFFSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *diffSkyfileMetadataFromObject(const diffSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +diffSkyfileRow *diffSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return diffSkyfileRowAlloc(diff_id, uri, path_base, bg, bg_stdev, fault); +} +psArray *diffSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + diffSkyfileRow *object = diffSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool diffSkyfileDeleteObject(psDB *dbh, const diffSkyfileRow *object) +{ + psMetadata *where = diffSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "diffSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long diffSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + diffSkyfileRow *object = objects->data[i]; + psMetadata *where = diffSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DIFFSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from diffSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool diffSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = diffSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DIFFSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool diffSkyfilePrintObject(FILE *stream, diffSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = diffSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void stackRunRowFree(stackRunRow *object); + +stackRunRow *stackRunRowAlloc(psS64 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id) +{ + stackRunRow *_object; + + _object = psAlloc(sizeof(stackRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)stackRunRowFree); + + _object->stack_id = stack_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->dvodb = psStringCopy(dvodb); + _object->registered = psTimeCopy(registered); + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + + return _object; +} + +static void stackRunRowFree(stackRunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->dvodb); + psFree(object->registered); + psFree(object->skycell_id); + psFree(object->tess_id); +} + +bool stackRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, STACKRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool stackRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, STACKRUN_TABLE_NAME); +} + +bool stackRunInsert(psDB * dbh, psS64 stack_id, const char *state, const char *workdir, const char *dvodb, psTime* registered, const char *skycell_id, const char *tess_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, STACKRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long stackRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool stackRunInsertObject(psDB *dbh, stackRunRow *object) +{ + return stackRunInsert(dbh, object->stack_id, object->state, object->workdir, object->dvodb, object->registered, object->skycell_id, object->tess_id); +} + +bool stackRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!stackRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool stackRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named STACKRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, STACKRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, STACKRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool stackRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, STACKRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, STACKRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *stackRunMetadataFromObject(const stackRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "skycell_id", PS_DATA_STRING, NULL, object->skycell_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item skycell_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "tess_id", PS_DATA_STRING, NULL, object->tess_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + psFree(md); + return false; + } + + + return md; +} + +stackRunRow *stackRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + char* skycell_id = psMetadataLookupPtr(&status, md, "skycell_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item skycell_id"); + return false; + } + char* tess_id = psMetadataLookupPtr(&status, md, "tess_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item tess_id"); + return false; + } + + return stackRunRowAlloc(stack_id, state, workdir, dvodb, registered, skycell_id, tess_id); +} +psArray *stackRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, STACKRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + stackRunRow *object = stackRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool stackRunDeleteObject(psDB *dbh, const stackRunRow *object) +{ + psMetadata *where = stackRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "stackRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long stackRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + stackRunRow *object = objects->data[i]; + psMetadata *where = stackRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool stackRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = stackRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + STACKRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool stackRunPrintObject(FILE *stream, stackRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = stackRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void stackInputSkyfileRowFree(stackInputSkyfileRow *object); + +stackInputSkyfileRow *stackInputSkyfileRowAlloc(psS64 stack_id, psS64 warp_id) +{ + stackInputSkyfileRow *_object; + + _object = psAlloc(sizeof(stackInputSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)stackInputSkyfileRowFree); + + _object->stack_id = stack_id; + _object->warp_id = warp_id; + + return _object; +} + +static void stackInputSkyfileRowFree(stackInputSkyfileRow *object) +{ +} + +bool stackInputSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key fkey(stack_id) ref stackRun(stack_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, "Primary Key fkey(warp_id) ref warpSkyfile(warp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, STACKINPUTSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool stackInputSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, STACKINPUTSKYFILE_TABLE_NAME); +} + +bool stackInputSkyfileInsert(psDB * dbh, psS64 stack_id, psS64 warp_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, STACKINPUTSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long stackInputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool stackInputSkyfileInsertObject(psDB *dbh, stackInputSkyfileRow *object) +{ + return stackInputSkyfileInsert(dbh, object->stack_id, object->warp_id); +} + +bool stackInputSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!stackInputSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool stackInputSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named STACKINPUTSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, STACKINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKINPUTSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool stackInputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, STACKINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *stackInputSkyfileMetadataFromObject(const stackInputSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "warp_id", PS_DATA_S64, NULL, object->warp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item warp_id"); + psFree(md); + return false; + } + + + return md; +} + +stackInputSkyfileRow *stackInputSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id"); + return false; + } + psS64 warp_id = psMetadataLookupS64(&status, md, "warp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item warp_id"); + return false; + } + + return stackInputSkyfileRowAlloc(stack_id, warp_id); +} +psArray *stackInputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + stackInputSkyfileRow *object = stackInputSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool stackInputSkyfileDeleteObject(psDB *dbh, const stackInputSkyfileRow *object) +{ + psMetadata *where = stackInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "stackInputSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long stackInputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + stackInputSkyfileRow *object = objects->data[i]; + psMetadata *where = stackInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKINPUTSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackInputSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool stackInputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = stackInputSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + STACKINPUTSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool stackInputSkyfilePrintObject(FILE *stream, stackInputSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = stackInputSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void stackSumSkyfileRowFree(stackSumSkyfileRow *object); + +stackSumSkyfileRow *stackSumSkyfileRowAlloc(psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault) +{ + stackSumSkyfileRow *_object; + + _object = psAlloc(sizeof(stackSumSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)stackSumSkyfileRowFree); + + _object->stack_id = stack_id; + _object->uri = psStringCopy(uri); + _object->path_base = psStringCopy(path_base); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->fault = fault; + + return _object; +} + +static void stackSumSkyfileRowFree(stackSumSkyfileRow *object) +{ + psFree(object->uri); + psFree(object->path_base); +} + +bool stackSumSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, "Primary Key fkey(stack_id) ref stackRun(stack_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, STACKSUMSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool stackSumSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, STACKSUMSKYFILE_TABLE_NAME); +} + +bool stackSumSkyfileInsert(psDB * dbh, psS64 stack_id, const char *uri, const char *path_base, psF64 bg, psF64 bg_stdev, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, STACKSUMSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long stackSumSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool stackSumSkyfileInsertObject(psDB *dbh, stackSumSkyfileRow *object) +{ + return stackSumSkyfileInsert(dbh, object->stack_id, object->uri, object->path_base, object->bg, object->bg_stdev, object->fault); +} + +bool stackSumSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!stackSumSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool stackSumSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named STACKSUMSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, STACKSUMSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", STACKSUMSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, STACKSUMSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool stackSumSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, STACKSUMSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *stackSumSkyfileMetadataFromObject(const stackSumSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "stack_id", PS_DATA_S64, NULL, object->stack_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item stack_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +stackSumSkyfileRow *stackSumSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 stack_id = psMetadataLookupS64(&status, md, "stack_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item stack_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return stackSumSkyfileRowAlloc(stack_id, uri, path_base, bg, bg_stdev, fault); +} +psArray *stackSumSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + stackSumSkyfileRow *object = stackSumSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool stackSumSkyfileDeleteObject(psDB *dbh, const stackSumSkyfileRow *object) +{ + psMetadata *where = stackSumSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "stackSumSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long stackSumSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + stackSumSkyfileRow *object = objects->data[i]; + psMetadata *where = stackSumSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, STACKSUMSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from stackSumSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool stackSumSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = stackSumSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + STACKSUMSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool stackSumSkyfilePrintObject(FILE *stream, stackSumSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = stackSumSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detRunRowFree(detRunRow *object); + +detRunRow *detRunRowAlloc(psS64 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *filelevel, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *reduction, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent) +{ + detRunRow *_object; + + _object = psAlloc(sizeof(detRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)detRunRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->det_type = psStringCopy(det_type); + _object->mode = psStringCopy(mode); + _object->state = psStringCopy(state); + _object->filelevel = psStringCopy(filelevel); + _object->workdir = psStringCopy(workdir); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->exp_type = psStringCopy(exp_type); + _object->reduction = psStringCopy(reduction); + _object->filter = psStringCopy(filter); + _object->airmass_min = airmass_min; + _object->airmass_max = airmass_max; + _object->exp_time_min = exp_time_min; + _object->exp_time_max = exp_time_max; + _object->ccd_temp_min = ccd_temp_min; + _object->ccd_temp_max = ccd_temp_max; + _object->posang_min = posang_min; + _object->posang_max = posang_max; + _object->registered = psTimeCopy(registered); + _object->time_begin = psTimeCopy(time_begin); + _object->time_end = psTimeCopy(time_end); + _object->use_begin = psTimeCopy(use_begin); + _object->use_end = psTimeCopy(use_end); + _object->solang_min = solang_min; + _object->solang_max = solang_max; + _object->label = psStringCopy(label); + _object->parent = parent; + + return _object; +} + +static void detRunRowFree(detRunRow *object) +{ + psFree(object->det_type); + psFree(object->mode); + psFree(object->state); + psFree(object->filelevel); + psFree(object->workdir); + psFree(object->camera); + psFree(object->telescope); + psFree(object->exp_type); + psFree(object->reduction); + psFree(object->filter); + psFree(object->registered); + psFree(object->time_begin); + psFree(object->time_end); + psFree(object->use_begin); + psFree(object->use_end); + psFree(object->label); +} + +bool detRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Key INDEX(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_type", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, "destination for output files", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, "XXX this should be dropped", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, "Reduction clas", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_min", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_max", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_min", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_max", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_min", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_max", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_min", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_max", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_begin", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_end", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_begin", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_end", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_min", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_max", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "parent", PS_DATA_S32, "Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item parent"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETRUN_TABLE_NAME); +} + +bool detRunInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *filelevel, const char *workdir, const char *camera, const char *telescope, const char *exp_type, const char *reduction, const char *filter, psF32 airmass_min, psF32 airmass_max, psF32 exp_time_min, psF32 exp_time_max, psF32 ccd_temp_min, psF32 ccd_temp_max, psF64 posang_min, psF64 posang_max, psTime* registered, psTime* time_begin, psTime* time_end, psTime* use_begin, psTime* use_end, psF32 solang_min, psF32 solang_max, const char *label, psS32 parent) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_type", PS_DATA_STRING, NULL, det_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_min", PS_DATA_F32, NULL, airmass_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_max", PS_DATA_F32, NULL, airmass_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_min", PS_DATA_F32, NULL, exp_time_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_max", PS_DATA_F32, NULL, exp_time_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_min", PS_DATA_F32, NULL, ccd_temp_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_max", PS_DATA_F32, NULL, ccd_temp_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_min", PS_DATA_F64, NULL, posang_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_max", PS_DATA_F64, NULL, posang_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_begin", PS_DATA_TIME, NULL, time_begin)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_end", PS_DATA_TIME, NULL, time_end)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_begin", PS_DATA_TIME, NULL, use_begin)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_end", PS_DATA_TIME, NULL, use_end)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_min", PS_DATA_F32, NULL, solang_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_max", PS_DATA_F32, NULL, solang_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "parent", PS_DATA_S32, NULL, parent)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item parent"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool detRunInsertObject(psDB *dbh, detRunRow *object) +{ + return detRunInsert(dbh, object->det_id, object->iteration, object->det_type, object->mode, object->state, object->filelevel, object->workdir, object->camera, object->telescope, object->exp_type, object->reduction, object->filter, object->airmass_min, object->airmass_max, object->exp_time_min, object->exp_time_max, object->ccd_temp_min, object->ccd_temp_max, object->posang_min, object->posang_max, object->registered, object->time_begin, object->time_end, object->use_begin, object->use_end, object->solang_min, object->solang_max, object->label, object->parent); +} + +bool detRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, DETRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detRunMetadataFromObject(const detRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_type", PS_DATA_STRING, NULL, object->det_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "mode", PS_DATA_STRING, NULL, object->mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item mode"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filelevel", PS_DATA_STRING, NULL, object->filelevel)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filelevel"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, NULL, object->camera)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item camera"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "telescope", PS_DATA_STRING, NULL, object->telescope)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_type", PS_DATA_STRING, NULL, object->exp_type)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "reduction", PS_DATA_STRING, NULL, object->reduction)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item reduction"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "filter", PS_DATA_STRING, NULL, object->filter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item filter"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_min", PS_DATA_F32, NULL, object->airmass_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "airmass_max", PS_DATA_F32, NULL, object->airmass_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item airmass_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_min", PS_DATA_F32, NULL, object->exp_time_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_time_max", PS_DATA_F32, NULL, object->exp_time_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_time_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_min", PS_DATA_F32, NULL, object->ccd_temp_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "ccd_temp_max", PS_DATA_F32, NULL, object->ccd_temp_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item ccd_temp_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_min", PS_DATA_F64, NULL, object->posang_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "posang_max", PS_DATA_F64, NULL, object->posang_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item posang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_begin", PS_DATA_TIME, NULL, object->time_begin)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "time_end", PS_DATA_TIME, NULL, object->time_end)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item time_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_begin", PS_DATA_TIME, NULL, object->use_begin)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_begin"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "use_end", PS_DATA_TIME, NULL, object->use_end)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item use_end"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_min", PS_DATA_F32, NULL, object->solang_min)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_min"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "solang_max", PS_DATA_F32, NULL, object->solang_max)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item solang_max"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "parent", PS_DATA_S32, NULL, object->parent)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item parent"); + psFree(md); + return false; + } + + + return md; +} + +detRunRow *detRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* det_type = psMetadataLookupPtr(&status, md, "det_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_type"); + return false; + } + char* mode = psMetadataLookupPtr(&status, md, "mode"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item mode"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* filelevel = psMetadataLookupPtr(&status, md, "filelevel"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filelevel"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* camera = psMetadataLookupPtr(&status, md, "camera"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item camera"); + return false; + } + char* telescope = psMetadataLookupPtr(&status, md, "telescope"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item telescope"); + return false; + } + char* exp_type = psMetadataLookupPtr(&status, md, "exp_type"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_type"); + return false; + } + char* reduction = psMetadataLookupPtr(&status, md, "reduction"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item reduction"); + return false; + } + char* filter = psMetadataLookupPtr(&status, md, "filter"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter"); + return false; + } + psF32 airmass_min = psMetadataLookupF32(&status, md, "airmass_min"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass_min"); + return false; + } + psF32 airmass_max = psMetadataLookupF32(&status, md, "airmass_max"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item airmass_max"); + return false; + } + psF32 exp_time_min = psMetadataLookupF32(&status, md, "exp_time_min"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time_min"); + return false; + } + psF32 exp_time_max = psMetadataLookupF32(&status, md, "exp_time_max"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_time_max"); + return false; + } + psF32 ccd_temp_min = psMetadataLookupF32(&status, md, "ccd_temp_min"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp_min"); + return false; + } + psF32 ccd_temp_max = psMetadataLookupF32(&status, md, "ccd_temp_max"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item ccd_temp_max"); + return false; + } + psF64 posang_min = psMetadataLookupF64(&status, md, "posang_min"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang_min"); + return false; + } + psF64 posang_max = psMetadataLookupF64(&status, md, "posang_max"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item posang_max"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + psTime* time_begin = psMetadataLookupPtr(&status, md, "time_begin"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item time_begin"); + return false; + } + psTime* time_end = psMetadataLookupPtr(&status, md, "time_end"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item time_end"); + return false; + } + psTime* use_begin = psMetadataLookupPtr(&status, md, "use_begin"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item use_begin"); + return false; + } + psTime* use_end = psMetadataLookupPtr(&status, md, "use_end"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item use_end"); + return false; + } + psF32 solang_min = psMetadataLookupF32(&status, md, "solang_min"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item solang_min"); + return false; + } + psF32 solang_max = psMetadataLookupF32(&status, md, "solang_max"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item solang_max"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + psS32 parent = psMetadataLookupS32(&status, md, "parent"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item parent"); + return false; + } + + return detRunRowAlloc(det_id, iteration, det_type, mode, state, filelevel, workdir, camera, telescope, exp_type, reduction, filter, airmass_min, airmass_max, exp_time_min, exp_time_max, ccd_temp_min, ccd_temp_max, posang_min, posang_max, registered, time_begin, time_end, use_begin, use_end, solang_min, solang_max, label, parent); +} +psArray *detRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detRunRow *object = detRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detRunDeleteObject(psDB *dbh, const detRunRow *object) +{ + psMetadata *where = detRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detRunRow *object = objects->data[i]; + psMetadata *where = detRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detRunPrintObject(FILE *stream, detRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detInputExpRowFree(detInputExpRow *object); + +detInputExpRow *detInputExpRowAlloc(psS64 det_id, psS32 iteration, psS64 exp_id, bool include) +{ + detInputExpRow *_object; + + _object = psAlloc(sizeof(detInputExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detInputExpRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_id = exp_id; + _object->include = include; + + return _object; +} + +static void detInputExpRowFree(detInputExpRow *object) +{ +} + +bool detInputExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id) ref detRun(det_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(exp_id) ref rawExp(exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key INDEX(det_id, exp_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "include", PS_DATA_BOOL, "INDEX(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item include"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETINPUTEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detInputExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETINPUTEXP_TABLE_NAME); +} + +bool detInputExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, psS64 exp_id, bool include) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "include", PS_DATA_BOOL, NULL, include)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item include"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETINPUTEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detInputExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detInputExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool detInputExpInsertObject(psDB *dbh, detInputExpRow *object) +{ + return detInputExpInsert(dbh, object->det_id, object->iteration, object->exp_id, object->include); +} + +bool detInputExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detInputExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detInputExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETINPUTEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, DETINPUTEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETINPUTEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETINPUTEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detInputExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETINPUTEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detInputExpMetadataFromObject(const detInputExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "include", PS_DATA_BOOL, NULL, object->include)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item include"); + psFree(md); + return false; + } + + + return md; +} + +detInputExpRow *detInputExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + bool include = psMetadataLookupBool(&status, md, "include"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item include"); + return false; + } + + return detInputExpRowAlloc(det_id, iteration, exp_id, include); +} +psArray *detInputExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detInputExpRow *object = detInputExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detInputExpDeleteObject(psDB *dbh, const detInputExpRow *object) +{ + psMetadata *where = detInputExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detInputExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detInputExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detInputExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detInputExpRow *object = objects->data[i]; + psMetadata *where = detInputExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETINPUTEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detInputExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detInputExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detInputExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETINPUTEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detInputExpPrintObject(FILE *stream, detInputExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detInputExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detProcessedImfileRowFree(detProcessedImfileRow *object); + +detProcessedImfileRow *detProcessedImfileRowAlloc(psS64 det_id, psS64 exp_id, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detProcessedImfileRow *_object; + + _object = psAlloc(sizeof(detProcessedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detProcessedImfileRowFree); + + _object->det_id = det_id; + _object->exp_id = exp_id; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->fringe_0 = fringe_0; + _object->fringe_1 = fringe_1; + _object->fringe_2 = fringe_2; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detProcessedImfileRowFree(detProcessedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); + psFree(object->path_base); +} + +bool detProcessedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(exp_id, class_id) ref rawImfile(exp_id, class_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key INDEX(det_id, class_id)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, "INDEX(det_id, exp_id)", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETPROCESSEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detProcessedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETPROCESSEDIMFILE_TABLE_NAME); +} + +bool detProcessedImfileInsert(psDB * dbh, psS64 det_id, psS64 exp_id, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETPROCESSEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detProcessedImfileInsertObject(psDB *dbh, detProcessedImfileRow *object) +{ + return detProcessedImfileInsert(dbh, object->det_id, object->exp_id, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detProcessedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detProcessedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detProcessedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETPROCESSEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETPROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETPROCESSEDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETPROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detProcessedImfileMetadataFromObject(const detProcessedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, object->fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, object->fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, object->fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detProcessedImfileRow *detProcessedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 fringe_0 = psMetadataLookupF64(&status, md, "fringe_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0"); + return false; + } + psF64 fringe_1 = psMetadataLookupF64(&status, md, "fringe_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1"); + return false; + } + psF64 fringe_2 = psMetadataLookupF64(&status, md, "fringe_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detProcessedImfileRowAlloc(det_id, exp_id, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, fringe_0, fringe_1, fringe_2, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detProcessedImfileRow *object = detProcessedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detProcessedImfileDeleteObject(psDB *dbh, const detProcessedImfileRow *object) +{ + psMetadata *where = detProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detProcessedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detProcessedImfileRow *object = objects->data[i]; + psMetadata *where = detProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETPROCESSEDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detProcessedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detProcessedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETPROCESSEDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detProcessedImfilePrintObject(FILE *stream, detProcessedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detProcessedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detProcessedExpRowFree(detProcessedExpRow *object); + +detProcessedExpRow *detProcessedExpRowAlloc(psS64 det_id, psS64 exp_id, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detProcessedExpRow *_object; + + _object = psAlloc(sizeof(detProcessedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detProcessedExpRowFree); + + _object->det_id = det_id; + _object->exp_id = exp_id; + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->fringe_0 = fringe_0; + _object->fringe_1 = fringe_1; + _object->fringe_2 = fringe_2; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detProcessedExpRowFree(detProcessedExpRow *object) +{ + psFree(object->recipe); + psFree(object->path_base); +} + +bool detProcessedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detInputExp(det_id, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(det_id, exp_id) ref detProcessedImfile(det_id, exp_id)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETPROCESSEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detProcessedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETPROCESSEDEXP_TABLE_NAME); +} + +bool detProcessedExpInsert(psDB * dbh, psS64 det_id, psS64 exp_id, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETPROCESSEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool detProcessedExpInsertObject(psDB *dbh, detProcessedExpRow *object) +{ + return detProcessedExpInsert(dbh, object->det_id, object->exp_id, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detProcessedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detProcessedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detProcessedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETPROCESSEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, DETPROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETPROCESSEDEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETPROCESSEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETPROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detProcessedExpMetadataFromObject(const detProcessedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, object->fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, object->fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, object->fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detProcessedExpRow *detProcessedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 fringe_0 = psMetadataLookupF64(&status, md, "fringe_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0"); + return false; + } + psF64 fringe_1 = psMetadataLookupF64(&status, md, "fringe_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1"); + return false; + } + psF64 fringe_2 = psMetadataLookupF64(&status, md, "fringe_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detProcessedExpRowAlloc(det_id, exp_id, recipe, bg, bg_stdev, bg_mean_stdev, fringe_0, fringe_1, fringe_2, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detProcessedExpRow *object = detProcessedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detProcessedExpDeleteObject(psDB *dbh, const detProcessedExpRow *object) +{ + psMetadata *where = detProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detProcessedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detProcessedExpRow *object = objects->data[i]; + psMetadata *where = detProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETPROCESSEDEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detProcessedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detProcessedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detProcessedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETPROCESSEDEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detProcessedExpPrintObject(FILE *stream, detProcessedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detProcessedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detStackedImfileRowFree(detStackedImfileRow *object); + +detStackedImfileRow *detStackedImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, psS16 fault) +{ + detStackedImfileRow *_object; + + _object = psAlloc(sizeof(detStackedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detStackedImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->fault = fault; + + return _object; +} + +static void detStackedImfileRowFree(detStackedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); +} + +bool detStackedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, class_id) ref detProcessedImfile(det_id, class_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETSTACKEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detStackedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETSTACKEDIMFILE_TABLE_NAME); +} + +bool detStackedImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETSTACKEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detStackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detStackedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detStackedImfileInsertObject(psDB *dbh, detStackedImfileRow *object) +{ + return detStackedImfileInsert(dbh, object->det_id, object->iteration, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->fault); +} + +bool detStackedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detStackedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detStackedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETSTACKEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETSTACKEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETSTACKEDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detStackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETSTACKEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detStackedImfileMetadataFromObject(const detStackedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detStackedImfileRow *detStackedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detStackedImfileRowAlloc(det_id, iteration, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, user_1, user_2, user_3, user_4, user_5, fault); +} +psArray *detStackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detStackedImfileRow *object = detStackedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detStackedImfileDeleteObject(psDB *dbh, const detStackedImfileRow *object) +{ + psMetadata *where = detStackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detStackedImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detStackedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detStackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detStackedImfileRow *object = objects->data[i]; + psMetadata *where = detStackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETSTACKEDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detStackedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detStackedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detStackedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETSTACKEDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detStackedImfilePrintObject(FILE *stream, detStackedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detStackedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detNormalizedStatImfileRowFree(detNormalizedStatImfileRow *object); + +detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault) +{ + detNormalizedStatImfileRow *_object; + + _object = psAlloc(sizeof(detNormalizedStatImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detNormalizedStatImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->class_id = psStringCopy(class_id); + _object->norm = norm; + _object->fault = fault; + + return _object; +} + +static void detNormalizedStatImfileRowFree(detNormalizedStatImfileRow *object) +{ + psFree(object->class_id); +} + +bool detNormalizedStatImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, iteration, class_id) ref detStackedImfile(det_id, iteration, class_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "norm", PS_DATA_F32, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detNormalizedStatImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME); +} + +bool detNormalizedStatImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, psF32 norm, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "norm", PS_DATA_F32, NULL, norm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detNormalizedStatImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detNormalizedStatImfileInsertObject(psDB *dbh, detNormalizedStatImfileRow *object) +{ + return detNormalizedStatImfileInsert(dbh, object->det_id, object->iteration, object->class_id, object->norm, object->fault); +} + +bool detNormalizedStatImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detNormalizedStatImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detNormalizedStatImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETNORMALIZEDSTATIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETNORMALIZEDSTATIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETNORMALIZEDSTATIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detNormalizedStatImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETNORMALIZEDSTATIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detNormalizedStatImfileMetadataFromObject(const detNormalizedStatImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "norm", PS_DATA_F32, NULL, object->norm)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item norm"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detNormalizedStatImfileRow *detNormalizedStatImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + psF32 norm = psMetadataLookupF32(&status, md, "norm"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item norm"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detNormalizedStatImfileRowAlloc(det_id, iteration, class_id, norm, fault); +} +psArray *detNormalizedStatImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detNormalizedStatImfileRow *object = detNormalizedStatImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detNormalizedStatImfileDeleteObject(psDB *dbh, const detNormalizedStatImfileRow *object) +{ + psMetadata *where = detNormalizedStatImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detNormalizedStatImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detNormalizedStatImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detNormalizedStatImfileRow *object = objects->data[i]; + psMetadata *where = detNormalizedStatImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDSTATIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedStatImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detNormalizedStatImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detNormalizedStatImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETNORMALIZEDSTATIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detNormalizedStatImfilePrintObject(FILE *stream, detNormalizedStatImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detNormalizedStatImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detNormalizedImfileRowFree(detNormalizedImfileRow *object); + +detNormalizedImfileRow *detNormalizedImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detNormalizedImfileRow *_object; + + _object = psAlloc(sizeof(detNormalizedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detNormalizedImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detNormalizedImfileRowFree(detNormalizedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->path_base); +} + +bool detNormalizedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id) ref detInputExp(det_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, iteration, class_id) ref detNormalizedStatImfile(det_id, iteration, class_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key INDEX(det_id, iteration)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detNormalizedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETNORMALIZEDIMFILE_TABLE_NAME); +} + +bool detNormalizedImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detNormalizedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detNormalizedImfileInsertObject(psDB *dbh, detNormalizedImfileRow *object) +{ + return detNormalizedImfileInsert(dbh, object->det_id, object->iteration, object->class_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detNormalizedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detNormalizedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detNormalizedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETNORMALIZEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETNORMALIZEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETNORMALIZEDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detNormalizedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETNORMALIZEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detNormalizedImfileMetadataFromObject(const detNormalizedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detNormalizedImfileRow *detNormalizedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detNormalizedImfileRowAlloc(det_id, iteration, class_id, uri, bg, bg_stdev, bg_mean_stdev, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detNormalizedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detNormalizedImfileRow *object = detNormalizedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detNormalizedImfileDeleteObject(psDB *dbh, const detNormalizedImfileRow *object) +{ + psMetadata *where = detNormalizedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detNormalizedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detNormalizedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detNormalizedImfileRow *object = objects->data[i]; + psMetadata *where = detNormalizedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detNormalizedImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detNormalizedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETNORMALIZEDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detNormalizedImfilePrintObject(FILE *stream, detNormalizedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detNormalizedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detNormalizedExpRowFree(detNormalizedExpRow *object); + +detNormalizedExpRow *detNormalizedExpRowAlloc(psS64 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detNormalizedExpRow *_object; + + _object = psAlloc(sizeof(detNormalizedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detNormalizedExpRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detNormalizedExpRowFree(detNormalizedExpRow *object) +{ + psFree(object->recipe); + psFree(object->path_base); +} + +bool detNormalizedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, iteration) ref detNormalizedImfile(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETNORMALIZEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detNormalizedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETNORMALIZEDEXP_TABLE_NAME); +} + +bool detNormalizedExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETNORMALIZEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detNormalizedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool detNormalizedExpInsertObject(psDB *dbh, detNormalizedExpRow *object) +{ + return detNormalizedExpInsert(dbh, object->det_id, object->iteration, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detNormalizedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detNormalizedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detNormalizedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETNORMALIZEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, DETNORMALIZEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETNORMALIZEDEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detNormalizedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETNORMALIZEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detNormalizedExpMetadataFromObject(const detNormalizedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detNormalizedExpRow *detNormalizedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detNormalizedExpRowAlloc(det_id, iteration, recipe, bg, bg_stdev, bg_mean_stdev, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detNormalizedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detNormalizedExpRow *object = detNormalizedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detNormalizedExpDeleteObject(psDB *dbh, const detNormalizedExpRow *object) +{ + psMetadata *where = detNormalizedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detNormalizedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detNormalizedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detNormalizedExpRow *object = objects->data[i]; + psMetadata *where = detNormalizedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETNORMALIZEDEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detNormalizedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detNormalizedExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detNormalizedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETNORMALIZEDEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detNormalizedExpPrintObject(FILE *stream, detNormalizedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detNormalizedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detResidImfileRowFree(detResidImfileRow *object); + +detResidImfileRow *detResidImfileRowAlloc(psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 bg_skewness, psF64 bg_kurtosis, psF64 bin_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 fringe_resid_0, psF64 fringe_resid_1, psF64 fringe_resid_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detResidImfileRow *_object; + + _object = psAlloc(sizeof(detResidImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detResidImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_id = exp_id; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->bg_skewness = bg_skewness; + _object->bg_kurtosis = bg_kurtosis; + _object->bin_stdev = bin_stdev; + _object->fringe_0 = fringe_0; + _object->fringe_1 = fringe_1; + _object->fringe_2 = fringe_2; + _object->fringe_resid_0 = fringe_resid_0; + _object->fringe_resid_1 = fringe_resid_1; + _object->fringe_resid_2 = fringe_resid_2; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detResidImfileRowFree(detResidImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); + psFree(object->path_base); +} + +bool detResidImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration, exp_id) ref detInputExp(det_id, iteration, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, exp_id, class_id) ref detProcessedImfile(det_id, exp_id, class_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detNormalizedExp(det_id, iteration)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key INDEX(det_id, iteration, exp_id)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETRESIDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detResidImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETRESIDIMFILE_TABLE_NAME); +} + +bool detResidImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, psS64 exp_id, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 bg_skewness, psF64 bg_kurtosis, psF64 bin_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 fringe_resid_0, psF64 fringe_resid_1, psF64 fringe_resid_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, bg_skewness)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, bg_kurtosis)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, bin_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, fringe_resid_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, fringe_resid_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, fringe_resid_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETRESIDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detResidImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detResidImfileInsertObject(psDB *dbh, detResidImfileRow *object) +{ + return detResidImfileInsert(dbh, object->det_id, object->iteration, object->exp_id, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bg_skewness, object->bg_kurtosis, object->bin_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->fringe_resid_0, object->fringe_resid_1, object->fringe_resid_2, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detResidImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detResidImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detResidImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETRESIDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETRESIDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETRESIDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETRESIDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detResidImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETRESIDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detResidImfileMetadataFromObject(const detResidImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, object->bg_skewness)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, object->bg_kurtosis)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, object->bin_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, object->fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, object->fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, object->fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, object->fringe_resid_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, object->fringe_resid_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, object->fringe_resid_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detResidImfileRow *detResidImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 bg_skewness = psMetadataLookupF64(&status, md, "bg_skewness"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_skewness"); + return false; + } + psF64 bg_kurtosis = psMetadataLookupF64(&status, md, "bg_kurtosis"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_kurtosis"); + return false; + } + psF64 bin_stdev = psMetadataLookupF64(&status, md, "bin_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bin_stdev"); + return false; + } + psF64 fringe_0 = psMetadataLookupF64(&status, md, "fringe_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0"); + return false; + } + psF64 fringe_1 = psMetadataLookupF64(&status, md, "fringe_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1"); + return false; + } + psF64 fringe_2 = psMetadataLookupF64(&status, md, "fringe_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2"); + return false; + } + psF64 fringe_resid_0 = psMetadataLookupF64(&status, md, "fringe_resid_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_0"); + return false; + } + psF64 fringe_resid_1 = psMetadataLookupF64(&status, md, "fringe_resid_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_1"); + return false; + } + psF64 fringe_resid_2 = psMetadataLookupF64(&status, md, "fringe_resid_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_2"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detResidImfileRowAlloc(det_id, iteration, exp_id, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, bg_skewness, bg_kurtosis, bin_stdev, fringe_0, fringe_1, fringe_2, fringe_resid_0, fringe_resid_1, fringe_resid_2, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detResidImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detResidImfileRow *object = detResidImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detResidImfileDeleteObject(psDB *dbh, const detResidImfileRow *object) +{ + psMetadata *where = detResidImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detResidImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detResidImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detResidImfileRow *object = objects->data[i]; + psMetadata *where = detResidImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRESIDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detResidImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detResidImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETRESIDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detResidImfilePrintObject(FILE *stream, detResidImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detResidImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detResidExpRowFree(detResidExpRow *object); + +detResidExpRow *detResidExpRowAlloc(psS64 det_id, psS32 iteration, psS64 exp_id, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 bg_skewness, psF64 bg_kurtosis, psF64 bin_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 fringe_resid_0, psF64 fringe_resid_1, psF64 fringe_resid_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, bool accept, psS16 fault) +{ + detResidExpRow *_object; + + _object = psAlloc(sizeof(detResidExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detResidExpRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_id = exp_id; + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->bg_skewness = bg_skewness; + _object->bg_kurtosis = bg_kurtosis; + _object->bin_stdev = bin_stdev; + _object->fringe_0 = fringe_0; + _object->fringe_1 = fringe_1; + _object->fringe_2 = fringe_2; + _object->fringe_resid_0 = fringe_resid_0; + _object->fringe_resid_1 = fringe_resid_1; + _object->fringe_resid_2 = fringe_resid_2; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->accept = accept; + _object->fault = fault; + + return _object; +} + +static void detResidExpRowFree(detResidExpRow *object) +{ + psFree(object->recipe); + psFree(object->path_base); +} + +bool detResidExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration, exp_id) ref detInputExp(det_id, iteration, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, iteration, exp_id) ref detResidImfile(det_id, iteration, exp_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, "Primary Key INDEX(det_id, iteration)", 64)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETRESIDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detResidExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETRESIDEXP_TABLE_NAME); +} + +bool detResidExpInsert(psDB * dbh, psS64 det_id, psS32 iteration, psS64 exp_id, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 bg_skewness, psF64 bg_kurtosis, psF64 bin_stdev, psF64 fringe_0, psF64 fringe_1, psF64 fringe_2, psF64 fringe_resid_0, psF64 fringe_resid_1, psF64 fringe_resid_2, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, bool accept, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, bg_skewness)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, bg_kurtosis)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, bin_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, fringe_resid_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, fringe_resid_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, fringe_resid_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, accept)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETRESIDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detResidExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool detResidExpInsertObject(psDB *dbh, detResidExpRow *object) +{ + return detResidExpInsert(dbh, object->det_id, object->iteration, object->exp_id, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->bg_skewness, object->bg_kurtosis, object->bin_stdev, object->fringe_0, object->fringe_1, object->fringe_2, object->fringe_resid_0, object->fringe_resid_1, object->fringe_resid_2, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->accept, object->fault); +} + +bool detResidExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detResidExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detResidExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETRESIDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, DETRESIDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETRESIDEXP_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETRESIDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detResidExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETRESIDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detResidExpMetadataFromObject(const detResidExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_S64, NULL, object->exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "recipe", PS_DATA_STRING, NULL, object->recipe)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item recipe"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_skewness", PS_DATA_F64, NULL, object->bg_skewness)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_skewness"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_kurtosis", PS_DATA_F64, NULL, object->bg_kurtosis)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_kurtosis"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bin_stdev", PS_DATA_F64, NULL, object->bin_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bin_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_0", PS_DATA_F64, NULL, object->fringe_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_1", PS_DATA_F64, NULL, object->fringe_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_2", PS_DATA_F64, NULL, object->fringe_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_0", PS_DATA_F64, NULL, object->fringe_resid_0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_0"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_1", PS_DATA_F64, NULL, object->fringe_resid_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fringe_resid_2", PS_DATA_F64, NULL, object->fringe_resid_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fringe_resid_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, object->accept)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detResidExpRow *detResidExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + psS64 exp_id = psMetadataLookupS64(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + return false; + } + char* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 bg_skewness = psMetadataLookupF64(&status, md, "bg_skewness"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_skewness"); + return false; + } + psF64 bg_kurtosis = psMetadataLookupF64(&status, md, "bg_kurtosis"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_kurtosis"); + return false; + } + psF64 bin_stdev = psMetadataLookupF64(&status, md, "bin_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bin_stdev"); + return false; + } + psF64 fringe_0 = psMetadataLookupF64(&status, md, "fringe_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_0"); + return false; + } + psF64 fringe_1 = psMetadataLookupF64(&status, md, "fringe_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_1"); + return false; + } + psF64 fringe_2 = psMetadataLookupF64(&status, md, "fringe_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_2"); + return false; + } + psF64 fringe_resid_0 = psMetadataLookupF64(&status, md, "fringe_resid_0"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_0"); + return false; + } + psF64 fringe_resid_1 = psMetadataLookupF64(&status, md, "fringe_resid_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_1"); + return false; + } + psF64 fringe_resid_2 = psMetadataLookupF64(&status, md, "fringe_resid_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fringe_resid_2"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + bool accept = psMetadataLookupBool(&status, md, "accept"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item accept"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detResidExpRowAlloc(det_id, iteration, exp_id, recipe, bg, bg_stdev, bg_mean_stdev, bg_skewness, bg_kurtosis, bin_stdev, fringe_0, fringe_1, fringe_2, fringe_resid_0, fringe_resid_1, fringe_resid_2, user_1, user_2, user_3, user_4, user_5, path_base, accept, fault); +} +psArray *detResidExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detResidExpRow *object = detResidExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detResidExpDeleteObject(psDB *dbh, const detResidExpRow *object) +{ + psMetadata *where = detResidExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidExp"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detResidExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detResidExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detResidExpRow *object = objects->data[i]; + psMetadata *where = detResidExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRESIDEXP_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detResidExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detResidExpPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detResidExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETRESIDEXP_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detResidExpPrintObject(FILE *stream, detResidExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detResidExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detRunSummaryRowFree(detRunSummaryRow *object); + +detRunSummaryRow *detRunSummaryRowAlloc(psS64 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault) +{ + detRunSummaryRow *_object; + + _object = psAlloc(sizeof(detRunSummaryRow)); + psMemSetDeallocator(_object, (psFreeFunc)detRunSummaryRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->accept = accept; + _object->fault = fault; + + return _object; +} + +static void detRunSummaryRowFree(detRunSummaryRow *object) +{ +} + +bool detRunSummaryCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detInputExp(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key fkey(det_id, iteration) ref detResidExp(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETRUNSUMMARY_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detRunSummaryDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETRUNSUMMARY_TABLE_NAME); +} + +bool detRunSummaryInsert(psDB * dbh, psS64 det_id, psS32 iteration, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, bool accept, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, accept)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETRUNSUMMARY_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detRunSummaryDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRunSummary"); + return count; + + deleted += count; + } + + return deleted; +} +bool detRunSummaryInsertObject(psDB *dbh, detRunSummaryRow *object) +{ + return detRunSummaryInsert(dbh, object->det_id, object->iteration, object->bg, object->bg_stdev, object->bg_mean_stdev, object->accept, object->fault); +} + +bool detRunSummaryInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detRunSummaryInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detRunSummaryInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETRUNSUMMARY_TABLE_NAME + if (!psFitsMoveExtName(fits, DETRUNSUMMARY_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETRUNSUMMARY_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETRUNSUMMARY_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detRunSummarySelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETRUNSUMMARY_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detRunSummaryMetadataFromObject(const detRunSummaryRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, object->accept)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item accept"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detRunSummaryRow *detRunSummaryObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + bool accept = psMetadataLookupBool(&status, md, "accept"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item accept"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detRunSummaryRowAlloc(det_id, iteration, bg, bg_stdev, bg_mean_stdev, accept, fault); +} +psArray *detRunSummarySelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detRunSummaryRow *object = detRunSummaryObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detRunSummaryDeleteObject(psDB *dbh, const detRunSummaryRow *object) +{ + psMetadata *where = detRunSummaryMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRunSummary"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detRunSummaryRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detRunSummaryDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detRunSummaryRow *object = objects->data[i]; + psMetadata *where = detRunSummaryMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETRUNSUMMARY_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRunSummary"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detRunSummaryPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detRunSummaryMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETRUNSUMMARY_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detRunSummaryPrintObject(FILE *stream, detRunSummaryRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detRunSummaryMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void detRegisteredImfileRowFree(detRegisteredImfileRow *object); + +detRegisteredImfileRow *detRegisteredImfileRowAlloc(psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + detRegisteredImfileRow *_object; + + _object = psAlloc(sizeof(detRegisteredImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detRegisteredImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->user_1 = user_1; + _object->user_2 = user_2; + _object->user_3 = user_3; + _object->user_4 = user_4; + _object->user_5 = user_5; + _object->path_base = psStringCopy(path_base); + _object->fault = fault; + + return _object; +} + +static void detRegisteredImfileRowFree(detRegisteredImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->path_base); +} + +bool detRegisteredImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, "Primary Key fkey(det_id, iteration) ref detRun(det_id, iteration)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, 0.0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "Key NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, DETREGISTEREDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool detRegisteredImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, DETREGISTEREDIMFILE_TABLE_NAME); +} + +bool detRegisteredImfileInsert(psDB * dbh, psS64 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 user_1, psF64 user_2, psF64 user_3, psF64 user_4, psF64 user_5, const char *path_base, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, DETREGISTEREDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long detRegisteredImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRegisteredImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool detRegisteredImfileInsertObject(psDB *dbh, detRegisteredImfileRow *object) +{ + return detRegisteredImfileInsert(dbh, object->det_id, object->iteration, object->class_id, object->uri, object->bg, object->bg_stdev, object->bg_mean_stdev, object->user_1, object->user_2, object->user_3, object->user_4, object->user_5, object->path_base, object->fault); +} + +bool detRegisteredImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!detRegisteredImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool detRegisteredImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named DETREGISTEREDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, DETREGISTEREDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", DETREGISTEREDIMFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool detRegisteredImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, DETREGISTEREDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *detRegisteredImfileMetadataFromObject(const detRegisteredImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S64, NULL, object->det_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "iteration", PS_DATA_S32, NULL, object->iteration)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item iteration"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class_id", PS_DATA_STRING, NULL, object->class_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item class_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg", PS_DATA_F64, NULL, object->bg)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_stdev", PS_DATA_F64, NULL, object->bg_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "bg_mean_stdev", PS_DATA_F64, NULL, object->bg_mean_stdev)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item bg_mean_stdev"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_1", PS_DATA_F64, NULL, object->user_1)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_1"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_2", PS_DATA_F64, NULL, object->user_2)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_2"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_3", PS_DATA_F64, NULL, object->user_3)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_3"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_4", PS_DATA_F64, NULL, object->user_4)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_4"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "user_5", PS_DATA_F64, NULL, object->user_5)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item user_5"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "path_base", PS_DATA_STRING, NULL, object->path_base)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item path_base"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +detRegisteredImfileRow *detRegisteredImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 det_id = psMetadataLookupS64(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + psS32 iteration = psMetadataLookupS32(&status, md, "iteration"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item iteration"); + return false; + } + char* class_id = psMetadataLookupPtr(&status, md, "class_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item class_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + psF64 bg = psMetadataLookupF64(&status, md, "bg"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg"); + return false; + } + psF64 bg_stdev = psMetadataLookupF64(&status, md, "bg_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_stdev"); + return false; + } + psF64 bg_mean_stdev = psMetadataLookupF64(&status, md, "bg_mean_stdev"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item bg_mean_stdev"); + return false; + } + psF64 user_1 = psMetadataLookupF64(&status, md, "user_1"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_1"); + return false; + } + psF64 user_2 = psMetadataLookupF64(&status, md, "user_2"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_2"); + return false; + } + psF64 user_3 = psMetadataLookupF64(&status, md, "user_3"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_3"); + return false; + } + psF64 user_4 = psMetadataLookupF64(&status, md, "user_4"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_4"); + return false; + } + psF64 user_5 = psMetadataLookupF64(&status, md, "user_5"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item user_5"); + return false; + } + char* path_base = psMetadataLookupPtr(&status, md, "path_base"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item path_base"); + return false; + } + psS16 fault = psMetadataLookupS16(&status, md, "fault"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item fault"); + return false; + } + + return detRegisteredImfileRowAlloc(det_id, iteration, class_id, uri, bg, bg_stdev, bg_mean_stdev, user_1, user_2, user_3, user_4, user_5, path_base, fault); +} +psArray *detRegisteredImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + detRegisteredImfileRow *object = detRegisteredImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool detRegisteredImfileDeleteObject(psDB *dbh, const detRegisteredImfileRow *object) +{ + psMetadata *where = detRegisteredImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRegisteredImfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "detRegisteredImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long detRegisteredImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + detRegisteredImfileRow *object = objects->data[i]; + psMetadata *where = detRegisteredImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, DETREGISTEREDIMFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from detRegisteredImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool detRegisteredImfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = detRegisteredImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + DETREGISTEREDIMFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool detRegisteredImfilePrintObject(FILE *stream, detRegisteredImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = detRegisteredImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void magicRunRowFree(magicRunRow *object); + +magicRunRow *magicRunRowAlloc(psS64 magic_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, psTime* registered) +{ + magicRunRow *_object; + + _object = psAlloc(sizeof(magicRunRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicRunRowFree); + + _object->magic_id = magic_id; + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->workdir_state = psStringCopy(workdir_state); + _object->label = psStringCopy(label); + _object->dvodb = psStringCopy(dvodb); + _object->registered = psTimeCopy(registered); + + return _object; +} + +static void magicRunRowFree(magicRunRow *object) +{ + psFree(object->state); + psFree(object->workdir); + psFree(object->workdir_state); + psFree(object->label); + psFree(object->dvodb); + psFree(object->registered); +} + +bool magicRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, "Key", "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, "key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, NULL)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICRUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicRunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICRUN_TABLE_NAME); +} + +bool magicRunInsert(psDB * dbh, psS64 magic_id, const char *state, const char *workdir, const char *workdir_state, const char *label, const char *dvodb, psTime* registered) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICRUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicRunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICRUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicRun"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicRunInsertObject(psDB *dbh, magicRunRow *object) +{ + return magicRunInsert(dbh, object->magic_id, object->state, object->workdir, object->workdir_state, object->label, object->dvodb, object->registered); +} + +bool magicRunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicRunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicRunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICRUN_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICRUN_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, MAGICRUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicRunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICRUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicRunMetadataFromObject(const magicRunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "state", PS_DATA_STRING, NULL, object->state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir", PS_DATA_STRING, NULL, object->workdir)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "workdir_state", PS_DATA_STRING, NULL, object->workdir_state)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item workdir_state"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dvodb", PS_DATA_STRING, NULL, object->dvodb)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dvodb"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "registered", PS_DATA_TIME, NULL, object->registered)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item registered"); + psFree(md); + return false; + } + + + return md; +} + +magicRunRow *magicRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + char* state = psMetadataLookupPtr(&status, md, "state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item state"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + char* workdir_state = psMetadataLookupPtr(&status, md, "workdir_state"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir_state"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + char* dvodb = psMetadataLookupPtr(&status, md, "dvodb"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dvodb"); + return false; + } + psTime* registered = psMetadataLookupPtr(&status, md, "registered"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item registered"); + return false; + } + + return magicRunRowAlloc(magic_id, state, workdir, workdir_state, label, dvodb, registered); +} +psArray *magicRunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICRUN_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicRunRow *object = magicRunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicRunDeleteObject(psDB *dbh, const magicRunRow *object) +{ + psMetadata *where = magicRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICRUN_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicRun"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "magicRunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicRunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicRunRow *object = objects->data[i]; + psMetadata *where = magicRunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICRUN_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicRun"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicRunPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = magicRunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICRUN_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool magicRunPrintObject(FILE *stream, magicRunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicRunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void magicInputSkyfileRowFree(magicInputSkyfileRow *object); + +magicInputSkyfileRow *magicInputSkyfileRowAlloc(psS64 magic_id, psS64 diff_id, psS32 node) +{ + magicInputSkyfileRow *_object; + + _object = psAlloc(sizeof(magicInputSkyfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicInputSkyfileRowFree); + + _object->magic_id = magic_id; + _object->diff_id = diff_id; + _object->node = node; + + return _object; +} + +static void magicInputSkyfileRowFree(magicInputSkyfileRow *object) +{ +} + +bool magicInputSkyfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, "Key fkey(diff_id) ref diffRun(diff_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_S32, "AUTO_INCREMENT INDEX(magic_id, node)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICINPUTSKYFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicInputSkyfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICINPUTSKYFILE_TABLE_NAME); +} + +bool magicInputSkyfileInsert(psDB * dbh, psS64 magic_id, psS64 diff_id, psS32 node) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_S32, NULL, node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICINPUTSKYFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicInputSkyfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicInputSkyfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicInputSkyfileInsertObject(psDB *dbh, magicInputSkyfileRow *object) +{ + return magicInputSkyfileInsert(dbh, object->magic_id, object->diff_id, object->node); +} + +bool magicInputSkyfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicInputSkyfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicInputSkyfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICINPUTSKYFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICINPUTSKYFILE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicInputSkyfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICINPUTSKYFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicInputSkyfileMetadataFromObject(const magicInputSkyfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "diff_id", PS_DATA_S64, NULL, object->diff_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item diff_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_S32, NULL, object->node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + + + return md; +} + +magicInputSkyfileRow *magicInputSkyfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + psS64 diff_id = psMetadataLookupS64(&status, md, "diff_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item diff_id"); + return false; + } + psS32 node = psMetadataLookupS32(&status, md, "node"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item node"); + return false; + } + + return magicInputSkyfileRowAlloc(magic_id, diff_id, node); +} +psArray *magicInputSkyfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicInputSkyfileRow *object = magicInputSkyfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicInputSkyfileDeleteObject(psDB *dbh, const magicInputSkyfileRow *object) +{ + psMetadata *where = magicInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicInputSkyfile"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "magicInputSkyfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicInputSkyfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicInputSkyfileRow *object = objects->data[i]; + psMetadata *where = magicInputSkyfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICINPUTSKYFILE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicInputSkyfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicInputSkyfilePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = magicInputSkyfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICINPUTSKYFILE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool magicInputSkyfilePrintObject(FILE *stream, magicInputSkyfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicInputSkyfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void magicTreeRowFree(magicTreeRow *object); + +magicTreeRow *magicTreeRowAlloc(psS64 magic_id, const char *node, const char *dep) +{ + magicTreeRow *_object; + + _object = psAlloc(sizeof(magicTreeRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicTreeRowFree); + + _object->magic_id = magic_id; + _object->node = psStringCopy(node); + _object->dep = psStringCopy(dep); + + return _object; +} + +static void magicTreeRowFree(magicTreeRow *object) +{ + psFree(object->node); + psFree(object->dep); +} + +bool magicTreeCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dep", PS_DATA_STRING, "fkey(magic_id, dep) ref magicInputSkyfile(magic_id, node)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dep"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICTREE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicTreeDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICTREE_TABLE_NAME); +} + +bool magicTreeInsert(psDB * dbh, psS64 magic_id, const char *node, const char *dep) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, NULL, node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dep", PS_DATA_STRING, NULL, dep)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dep"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICTREE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicTreeDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICTREE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicTree"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicTreeInsertObject(psDB *dbh, magicTreeRow *object) +{ + return magicTreeInsert(dbh, object->magic_id, object->node, object->dep); +} + +bool magicTreeInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicTreeInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicTreeInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICTREE_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICTREE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICTREE_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, MAGICTREE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicTreeSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICTREE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICTREE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicTreeMetadataFromObject(const magicTreeRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, NULL, object->node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "dep", PS_DATA_STRING, NULL, object->dep)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item dep"); + psFree(md); + return false; + } + + + return md; +} + +magicTreeRow *magicTreeObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + char* node = psMetadataLookupPtr(&status, md, "node"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item node"); + return false; + } + char* dep = psMetadataLookupPtr(&status, md, "dep"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dep"); + return false; + } + + return magicTreeRowAlloc(magic_id, node, dep); +} +psArray *magicTreeSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICTREE_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicTreeRow *object = magicTreeObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicTreeDeleteObject(psDB *dbh, const magicTreeRow *object) +{ + psMetadata *where = magicTreeMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICTREE_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicTree"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "magicTreeRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicTreeDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicTreeRow *object = objects->data[i]; + psMetadata *where = magicTreeMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICTREE_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicTree"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicTreePrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = magicTreeMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICTREE_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool magicTreePrintObject(FILE *stream, magicTreeRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicTreeMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void magicNodeResultRowFree(magicNodeResultRow *object); + +magicNodeResultRow *magicNodeResultRowAlloc(psS64 magic_id, const char *node, const char *uri) +{ + magicNodeResultRow *_object; + + _object = psAlloc(sizeof(magicNodeResultRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicNodeResultRowFree); + + _object->magic_id = magic_id; + _object->node = psStringCopy(node); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void magicNodeResultRowFree(magicNodeResultRow *object) +{ + psFree(object->node); + psFree(object->uri); +} + +bool magicNodeResultCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, "Primary Key fkey(magic_id, node) ref magicInputSkyfile(magic_id, node)", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICNODERESULT_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicNodeResultDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICNODERESULT_TABLE_NAME); +} + +bool magicNodeResultInsert(psDB * dbh, psS64 magic_id, const char *node, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, NULL, node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICNODERESULT_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicNodeResultDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICNODERESULT_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicNodeResult"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicNodeResultInsertObject(psDB *dbh, magicNodeResultRow *object) +{ + return magicNodeResultInsert(dbh, object->magic_id, object->node, object->uri); +} + +bool magicNodeResultInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicNodeResultInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicNodeResultInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICNODERESULT_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICNODERESULT_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICNODERESULT_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, MAGICNODERESULT_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicNodeResultSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICNODERESULT_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICNODERESULT_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicNodeResultMetadataFromObject(const magicNodeResultRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "node", PS_DATA_STRING, NULL, object->node)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item node"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +magicNodeResultRow *magicNodeResultObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + char* node = psMetadataLookupPtr(&status, md, "node"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item node"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return magicNodeResultRowAlloc(magic_id, node, uri); +} +psArray *magicNodeResultSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICNODERESULT_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicNodeResultRow *object = magicNodeResultObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicNodeResultDeleteObject(psDB *dbh, const magicNodeResultRow *object) +{ + psMetadata *where = magicNodeResultMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICNODERESULT_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicNodeResult"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "magicNodeResultRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicNodeResultDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicNodeResultRow *object = objects->data[i]; + psMetadata *where = magicNodeResultMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICNODERESULT_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicNodeResult"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicNodeResultPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = magicNodeResultMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICNODERESULT_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool magicNodeResultPrintObject(FILE *stream, magicNodeResultRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicNodeResultMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void magicMaskRowFree(magicMaskRow *object); + +magicMaskRow *magicMaskRowAlloc(psS64 magic_id, const char *uri) +{ + magicMaskRow *_object; + + _object = psAlloc(sizeof(magicMaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)magicMaskRowFree); + + _object->magic_id = magic_id; + _object->uri = psStringCopy(uri); + + return _object; +} + +static void magicMaskRowFree(magicMaskRow *object) +{ + psFree(object->uri); +} + +bool magicMaskCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, "Primary Key fkey(magic_id) ref magicRun(magic_id)", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, MAGICMASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool magicMaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, MAGICMASK_TABLE_NAME); +} + +bool magicMaskInsert(psDB * dbh, psS64 magic_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, MAGICMASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long magicMaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, MAGICMASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicMask"); + return count; + + deleted += count; + } + + return deleted; +} +bool magicMaskInsertObject(psDB *dbh, magicMaskRow *object) +{ + return magicMaskInsert(dbh, object->magic_id, object->uri); +} + +bool magicMaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!magicMaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool magicMaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named MAGICMASK_TABLE_NAME + if (!psFitsMoveExtName(fits, MAGICMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", MAGICMASK_TABLE_NAME); + return false; + } + + // check HDU type + if (psFitsGetExtType(fits) != PS_FITS_TYPE_BINARY_TABLE) { + psError(PS_ERR_UNKNOWN, true, "FITS HDU type is not PS_FITS_TYPE_BINARY_TABLE"); + return false; + } + + // read fits table + rowSet = psFitsReadTable(fits); + if (!rowSet) { + psError(PS_ERR_UNKNOWN, true, "FITS read error or FITS table is empty"); + psFree(rowSet); + return false; + } + + if (!psDBInsertRows(dbh, MAGICMASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool magicMaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, MAGICMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, MAGICMASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *magicMaskMetadataFromObject(const magicMaskRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "magic_id", PS_DATA_S64, NULL, object->magic_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item magic_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "uri", PS_DATA_STRING, NULL, object->uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item uri"); + psFree(md); + return false; + } + + + return md; +} + +magicMaskRow *magicMaskObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS64 magic_id = psMetadataLookupS64(&status, md, "magic_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item magic_id"); + return false; + } + char* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return magicMaskRowAlloc(magic_id, uri); +} +psArray *magicMaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, MAGICMASK_TABLE_NAME, where, limit); + if (!rowSet) { + return NULL; + } + + // convert psMetadata rows to row objects + + returnSet = psArrayAllocEmpty(rowSet->n); + + for (i = 0; i < rowSet->n; i++) { + magicMaskRow *object = magicMaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool magicMaskDeleteObject(psDB *dbh, const magicMaskRow *object) +{ + psMetadata *where = magicMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICMASK_TABLE_NAME, where, 0); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicMask"); + return false; + } + if (count > 1) { + // XXX should this be a psAbort() instead? It is possible that + // having an object match multiple rows was by design. + psError(PS_ERR_UNKNOWN, true, "magicMaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long magicMaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + magicMaskRow *object = objects->data[i]; + psMetadata *where = magicMaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, MAGICMASK_TABLE_NAME, where, limit); + psFree(where); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from magicMask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool magicMaskPrintObjects(FILE *stream, psArray *objects, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(objects, false); + + psMetadata *output = psMetadataAlloc(); + for (long i = 0; i < psArrayLength(objects); i++) { + psMetadata *md = magicMaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + MAGICMASK_TABLE_NAME, + PS_META_DUPLICATE_OK, + NULL, + md + )) { + psError(PS_ERR_UNKNOWN, false, "failed to add metadata"); + psFree(md); + psFree(output); + return false; + } + psFree(md); + } + + if (!ippdbPrintMetadataRaw(stream, output, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(output); + } + psFree(output); + + return true; +} +bool magicMaskPrintObject(FILE *stream, magicMaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = magicMaskMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.h =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.h (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/src/ippdb.h (revision 22077) @@ -0,0 +1,9872 @@ +/* + * header.c + * + * Copyright (C) 2006 Joshua Hoblitt + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the Free + * Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along with + * program; see the file COPYING. If not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +/* + * + * This file was generated by glueforge 1.01 + * + * Do NOT directly edit this file. + * + */ + +#ifndef IPPDB_H +#define IPPDB_H 1 + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/// @addtogroup ippdb +/// @{ + +/** Opens a new database connection + * + * @return A new psDB object if the database connection is successful or NULL + * on failure. + */ + +psDB *ippdbInit( + const char *host, ///< Database server hostname + const char *user, ///< Database username + const char *passwd, ///< Database password + const char *dbname, ///< Database table.namespace + unsigned int port ///< Database port +); + +/** Closes a database connection + */ + +void ippdbCleanup( + psDB *dbh ///< Database handle +); + +/** Formats and prints a metadata + * + * Any internal use fields are stripped. + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool ippdbPrintMetadata( + FILE *stream, ///< a stream + psMetadata *md, ///< An array of metadata + bool mdcf ///< format as mdconfig or simple +); + +/** Formats and prints a metadata + * + * The metadata is printed verbatium without removing any fields. + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool ippdbPrintMetadataRaw( + FILE *stream, ///< a stream + psMetadata *md, ///< An array of metadata + bool mdcf ///< format as mdconfig or simple +); + +/** Formats and prints an array of metadata + * + * Any internal use fields are stripped. + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool ippdbPrintMetadatas( + FILE *stream, ///< a stream + psArray *mds, ///< An array of metadata + const char *mdname, ///< name of the metadata(s) + bool mdcf ///< format as mdconfig or simple +); + +/** Formats and prints an array of metadata + * + * The metadatas are printed verbatium without removing any fields. + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool ippdbPrintMetadatasRaw( + FILE *stream, ///< a stream + psArray *mds, ///< An array of metadata + const char *mdname, ///< name of the metadata(s) + bool mdcf ///< format as mdconfig or simple +); + +/** summitExpRow data structure + * + * Structure for representing a single row of summitExp table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; + psTime* dateobs; + char *exp_type; + char *uri; + psS32 imfiles; +} summitExpRow; + +/** Creates a new summitExpRow object + * + * @return A new summitExpRow object or NULL on failure. + */ + +summitExpRow *summitExpRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_type, + const char *uri, + psS32 imfiles +); + +/** Creates a new summitExp table + * + * @return true on success + */ + +bool summitExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a summitExp table + * + * @return true on success + */ + +bool summitExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool summitExpInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_type, + const char *uri, + psS32 imfiles +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long summitExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single summitExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool summitExpInsertObject( + psDB *dbh, ///< Database handle + summitExpRow *object ///< summitExpRow object +); + +/** Insert an array of summitExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool summitExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of summitExpRow objects +); + +/** Insert data from a binary FITS table summitExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool summitExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool summitExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a summitExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *summitExpMetadataFromObject( + const summitExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A summitExpRow pointer or NULL on error + */ + +summitExpRow *summitExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as summitExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *summitExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an summitExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool summitExpDeleteObject( + psDB *dbh, ///< Database handle + const summitExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long summitExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of summitExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool summitExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of summitExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an summitExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool summitExpPrintObject( + FILE *stream, ///< a stream + summitExpRow *object, ///< an summitExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** summitImfileRow data structure + * + * Structure for representing a single row of summitImfile table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; + char *file_id; + psS32 bytes; + char *md5sum; + char *class; + char *class_id; + char *uri; +} summitImfileRow; + +/** Creates a new summitImfileRow object + * + * @return A new summitImfileRow object or NULL on failure. + */ + +summitImfileRow *summitImfileRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope, + const char *file_id, + psS32 bytes, + const char *md5sum, + const char *class, + const char *class_id, + const char *uri +); + +/** Creates a new summitImfile table + * + * @return true on success + */ + +bool summitImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a summitImfile table + * + * @return true on success + */ + +bool summitImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool summitImfileInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope, + const char *file_id, + psS32 bytes, + const char *md5sum, + const char *class, + const char *class_id, + const char *uri +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long summitImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single summitImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool summitImfileInsertObject( + psDB *dbh, ///< Database handle + summitImfileRow *object ///< summitImfileRow object +); + +/** Insert an array of summitImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool summitImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of summitImfileRow objects +); + +/** Insert data from a binary FITS table summitImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool summitImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool summitImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a summitImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *summitImfileMetadataFromObject( + const summitImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A summitImfileRow pointer or NULL on error + */ + +summitImfileRow *summitImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as summitImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *summitImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an summitImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool summitImfileDeleteObject( + psDB *dbh, ///< Database handle + const summitImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long summitImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of summitImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool summitImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of summitImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an summitImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool summitImfilePrintObject( + FILE *stream, ///< a stream + summitImfileRow *object, ///< an summitImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** pzPendingExpRow data structure + * + * Structure for representing a single row of pzPendingExp table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; +} pzPendingExpRow; + +/** Creates a new pzPendingExpRow object + * + * @return A new pzPendingExpRow object or NULL on failure. + */ + +pzPendingExpRow *pzPendingExpRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope +); + +/** Creates a new pzPendingExp table + * + * @return true on success + */ + +bool pzPendingExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a pzPendingExp table + * + * @return true on success + */ + +bool pzPendingExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzPendingExpInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzPendingExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single pzPendingExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzPendingExpInsertObject( + psDB *dbh, ///< Database handle + pzPendingExpRow *object ///< pzPendingExpRow object +); + +/** Insert an array of pzPendingExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool pzPendingExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of pzPendingExpRow objects +); + +/** Insert data from a binary FITS table pzPendingExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool pzPendingExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool pzPendingExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a pzPendingExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *pzPendingExpMetadataFromObject( + const pzPendingExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A pzPendingExpRow pointer or NULL on error + */ + +pzPendingExpRow *pzPendingExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as pzPendingExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *pzPendingExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an pzPendingExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool pzPendingExpDeleteObject( + psDB *dbh, ///< Database handle + const pzPendingExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzPendingExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of pzPendingExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzPendingExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of pzPendingExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an pzPendingExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzPendingExpPrintObject( + FILE *stream, ///< a stream + pzPendingExpRow *object, ///< an pzPendingExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** pzPendingImfileRow data structure + * + * Structure for representing a single row of pzPendingImfile table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; + char *class; + char *class_id; +} pzPendingImfileRow; + +/** Creates a new pzPendingImfileRow object + * + * @return A new pzPendingImfileRow object or NULL on failure. + */ + +pzPendingImfileRow *pzPendingImfileRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope, + const char *class, + const char *class_id +); + +/** Creates a new pzPendingImfile table + * + * @return true on success + */ + +bool pzPendingImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a pzPendingImfile table + * + * @return true on success + */ + +bool pzPendingImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzPendingImfileInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope, + const char *class, + const char *class_id +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzPendingImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single pzPendingImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzPendingImfileInsertObject( + psDB *dbh, ///< Database handle + pzPendingImfileRow *object ///< pzPendingImfileRow object +); + +/** Insert an array of pzPendingImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool pzPendingImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of pzPendingImfileRow objects +); + +/** Insert data from a binary FITS table pzPendingImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool pzPendingImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool pzPendingImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a pzPendingImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *pzPendingImfileMetadataFromObject( + const pzPendingImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A pzPendingImfileRow pointer or NULL on error + */ + +pzPendingImfileRow *pzPendingImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as pzPendingImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *pzPendingImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an pzPendingImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool pzPendingImfileDeleteObject( + psDB *dbh, ///< Database handle + const pzPendingImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzPendingImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of pzPendingImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzPendingImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of pzPendingImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an pzPendingImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzPendingImfilePrintObject( + FILE *stream, ///< a stream + pzPendingImfileRow *object, ///< an pzPendingImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** pzDoneExpRow data structure + * + * Structure for representing a single row of pzDoneExp table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; +} pzDoneExpRow; + +/** Creates a new pzDoneExpRow object + * + * @return A new pzDoneExpRow object or NULL on failure. + */ + +pzDoneExpRow *pzDoneExpRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope +); + +/** Creates a new pzDoneExp table + * + * @return true on success + */ + +bool pzDoneExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a pzDoneExp table + * + * @return true on success + */ + +bool pzDoneExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzDoneExpInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzDoneExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single pzDoneExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzDoneExpInsertObject( + psDB *dbh, ///< Database handle + pzDoneExpRow *object ///< pzDoneExpRow object +); + +/** Insert an array of pzDoneExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool pzDoneExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of pzDoneExpRow objects +); + +/** Insert data from a binary FITS table pzDoneExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool pzDoneExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool pzDoneExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a pzDoneExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *pzDoneExpMetadataFromObject( + const pzDoneExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A pzDoneExpRow pointer or NULL on error + */ + +pzDoneExpRow *pzDoneExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as pzDoneExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *pzDoneExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an pzDoneExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool pzDoneExpDeleteObject( + psDB *dbh, ///< Database handle + const pzDoneExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzDoneExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of pzDoneExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzDoneExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of pzDoneExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an pzDoneExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzDoneExpPrintObject( + FILE *stream, ///< a stream + pzDoneExpRow *object, ///< an pzDoneExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** pzDoneImfileRow data structure + * + * Structure for representing a single row of pzDoneImfile table data. + */ + +typedef struct { + char *exp_name; + char *camera; + char *telescope; + char *class; + char *class_id; + char *uri; +} pzDoneImfileRow; + +/** Creates a new pzDoneImfileRow object + * + * @return A new pzDoneImfileRow object or NULL on failure. + */ + +pzDoneImfileRow *pzDoneImfileRowAlloc( + const char *exp_name, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *uri +); + +/** Creates a new pzDoneImfile table + * + * @return true on success + */ + +bool pzDoneImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a pzDoneImfile table + * + * @return true on success + */ + +bool pzDoneImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzDoneImfileInsert( + psDB *dbh, ///< Database handle + const char *exp_name, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *uri +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzDoneImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single pzDoneImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool pzDoneImfileInsertObject( + psDB *dbh, ///< Database handle + pzDoneImfileRow *object ///< pzDoneImfileRow object +); + +/** Insert an array of pzDoneImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool pzDoneImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of pzDoneImfileRow objects +); + +/** Insert data from a binary FITS table pzDoneImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool pzDoneImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool pzDoneImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a pzDoneImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *pzDoneImfileMetadataFromObject( + const pzDoneImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A pzDoneImfileRow pointer or NULL on error + */ + +pzDoneImfileRow *pzDoneImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as pzDoneImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *pzDoneImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an pzDoneImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool pzDoneImfileDeleteObject( + psDB *dbh, ///< Database handle + const pzDoneImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long pzDoneImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of pzDoneImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzDoneImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of pzDoneImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an pzDoneImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool pzDoneImfilePrintObject( + FILE *stream, ///< a stream + pzDoneImfileRow *object, ///< an pzDoneImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** newExpRow data structure + * + * Structure for representing a single row of newExp table data. + */ + +typedef struct { + psS64 exp_id; + char *tmp_exp_name; + char *tmp_camera; + char *tmp_telescope; + char *state; + char *workdir; + char *workdir_state; + char *reduction; +} newExpRow; + +/** Creates a new newExpRow object + * + * @return A new newExpRow object or NULL on failure. + */ + +newExpRow *newExpRowAlloc( + psS64 exp_id, + const char *tmp_exp_name, + const char *tmp_camera, + const char *tmp_telescope, + const char *state, + const char *workdir, + const char *workdir_state, + const char *reduction +); + +/** Creates a new newExp table + * + * @return true on success + */ + +bool newExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a newExp table + * + * @return true on success + */ + +bool newExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool newExpInsert( + psDB *dbh, ///< Database handle + psS64 exp_id, + const char *tmp_exp_name, + const char *tmp_camera, + const char *tmp_telescope, + const char *state, + const char *workdir, + const char *workdir_state, + const char *reduction +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long newExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single newExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool newExpInsertObject( + psDB *dbh, ///< Database handle + newExpRow *object ///< newExpRow object +); + +/** Insert an array of newExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool newExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of newExpRow objects +); + +/** Insert data from a binary FITS table newExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool newExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool newExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a newExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *newExpMetadataFromObject( + const newExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A newExpRow pointer or NULL on error + */ + +newExpRow *newExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as newExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *newExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an newExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool newExpDeleteObject( + psDB *dbh, ///< Database handle + const newExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long newExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of newExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool newExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of newExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an newExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool newExpPrintObject( + FILE *stream, ///< a stream + newExpRow *object, ///< an newExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** newImfileRow data structure + * + * Structure for representing a single row of newImfile table data. + */ + +typedef struct { + psS64 exp_id; + char *tmp_class_id; + char *uri; +} newImfileRow; + +/** Creates a new newImfileRow object + * + * @return A new newImfileRow object or NULL on failure. + */ + +newImfileRow *newImfileRowAlloc( + psS64 exp_id, + const char *tmp_class_id, + const char *uri +); + +/** Creates a new newImfile table + * + * @return true on success + */ + +bool newImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a newImfile table + * + * @return true on success + */ + +bool newImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool newImfileInsert( + psDB *dbh, ///< Database handle + psS64 exp_id, + const char *tmp_class_id, + const char *uri +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long newImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single newImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool newImfileInsertObject( + psDB *dbh, ///< Database handle + newImfileRow *object ///< newImfileRow object +); + +/** Insert an array of newImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool newImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of newImfileRow objects +); + +/** Insert data from a binary FITS table newImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool newImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool newImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a newImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *newImfileMetadataFromObject( + const newImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A newImfileRow pointer or NULL on error + */ + +newImfileRow *newImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as newImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *newImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an newImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool newImfileDeleteObject( + psDB *dbh, ///< Database handle + const newImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long newImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of newImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool newImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of newImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an newImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool newImfilePrintObject( + FILE *stream, ///< a stream + newImfileRow *object, ///< an newImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** rawExpRow data structure + * + * Structure for representing a single row of rawExp table data. + */ + +typedef struct { + psS64 exp_id; + char *exp_name; + char *camera; + char *telescope; + psTime* dateobs; + char *exp_tag; + char *exp_type; + char *filelevel; + char *workdir; + char *reduction; + char *filter; + psF32 airmass; + psF64 ra; + psF64 decl; + psF32 exp_time; + psF32 sat_pixel_frac; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 alt; + psF64 az; + psF32 ccd_temp; + psF64 posang; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *object; + psF32 solang; + psS16 fault; +} rawExpRow; + +/** Creates a new rawExpRow object + * + * @return A new rawExpRow object or NULL on failure. + */ + +rawExpRow *rawExpRowAlloc( + psS64 exp_id, + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_tag, + const char *exp_type, + const char *filelevel, + const char *workdir, + const char *reduction, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF32 sat_pixel_frac, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *object, + psF32 solang, + psS16 fault +); + +/** Creates a new rawExp table + * + * @return true on success + */ + +bool rawExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a rawExp table + * + * @return true on success + */ + +bool rawExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool rawExpInsert( + psDB *dbh, ///< Database handle + psS64 exp_id, + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_tag, + const char *exp_type, + const char *filelevel, + const char *workdir, + const char *reduction, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF32 sat_pixel_frac, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *object, + psF32 solang, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long rawExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single rawExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool rawExpInsertObject( + psDB *dbh, ///< Database handle + rawExpRow *object ///< rawExpRow object +); + +/** Insert an array of rawExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool rawExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of rawExpRow objects +); + +/** Insert data from a binary FITS table rawExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool rawExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool rawExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a rawExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *rawExpMetadataFromObject( + const rawExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A rawExpRow pointer or NULL on error + */ + +rawExpRow *rawExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as rawExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *rawExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an rawExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool rawExpDeleteObject( + psDB *dbh, ///< Database handle + const rawExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long rawExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of rawExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool rawExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of rawExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an rawExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool rawExpPrintObject( + FILE *stream, ///< a stream + rawExpRow *object, ///< an rawExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** rawImfileRow data structure + * + * Structure for representing a single row of rawImfile table data. + */ + +typedef struct { + psS64 exp_id; + char *exp_name; + char *camera; + char *telescope; + psTime* dateobs; + char *tmp_class_id; + char *class_id; + char *uri; + char *exp_type; + char *filelevel; + char *filter; + psF32 airmass; + psF64 ra; + psF64 decl; + psF32 exp_time; + psF32 sat_pixel_frac; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 alt; + psF64 az; + psF32 ccd_temp; + psF64 posang; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *object; + psS16 fault; +} rawImfileRow; + +/** Creates a new rawImfileRow object + * + * @return A new rawImfileRow object or NULL on failure. + */ + +rawImfileRow *rawImfileRowAlloc( + psS64 exp_id, + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *tmp_class_id, + const char *class_id, + const char *uri, + const char *exp_type, + const char *filelevel, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF32 sat_pixel_frac, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *object, + psS16 fault +); + +/** Creates a new rawImfile table + * + * @return true on success + */ + +bool rawImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a rawImfile table + * + * @return true on success + */ + +bool rawImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool rawImfileInsert( + psDB *dbh, ///< Database handle + psS64 exp_id, + const char *exp_name, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *tmp_class_id, + const char *class_id, + const char *uri, + const char *exp_type, + const char *filelevel, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF32 sat_pixel_frac, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *object, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long rawImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single rawImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool rawImfileInsertObject( + psDB *dbh, ///< Database handle + rawImfileRow *object ///< rawImfileRow object +); + +/** Insert an array of rawImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool rawImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of rawImfileRow objects +); + +/** Insert data from a binary FITS table rawImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool rawImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool rawImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a rawImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *rawImfileMetadataFromObject( + const rawImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A rawImfileRow pointer or NULL on error + */ + +rawImfileRow *rawImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as rawImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *rawImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an rawImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool rawImfileDeleteObject( + psDB *dbh, ///< Database handle + const rawImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long rawImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of rawImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool rawImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of rawImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an rawImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool rawImfilePrintObject( + FILE *stream, ///< a stream + rawImfileRow *object, ///< an rawImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** guidePendingExpRow data structure + * + * Structure for representing a single row of guidePendingExp table data. + */ + +typedef struct { + psS64 guide_id; + psS64 exp_id; + char *recipe; +} guidePendingExpRow; + +/** Creates a new guidePendingExpRow object + * + * @return A new guidePendingExpRow object or NULL on failure. + */ + +guidePendingExpRow *guidePendingExpRowAlloc( + psS64 guide_id, + psS64 exp_id, + const char *recipe +); + +/** Creates a new guidePendingExp table + * + * @return true on success + */ + +bool guidePendingExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a guidePendingExp table + * + * @return true on success + */ + +bool guidePendingExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool guidePendingExpInsert( + psDB *dbh, ///< Database handle + psS64 guide_id, + psS64 exp_id, + const char *recipe +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long guidePendingExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single guidePendingExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool guidePendingExpInsertObject( + psDB *dbh, ///< Database handle + guidePendingExpRow *object ///< guidePendingExpRow object +); + +/** Insert an array of guidePendingExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool guidePendingExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of guidePendingExpRow objects +); + +/** Insert data from a binary FITS table guidePendingExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool guidePendingExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool guidePendingExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a guidePendingExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *guidePendingExpMetadataFromObject( + const guidePendingExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A guidePendingExpRow pointer or NULL on error + */ + +guidePendingExpRow *guidePendingExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as guidePendingExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *guidePendingExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an guidePendingExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool guidePendingExpDeleteObject( + psDB *dbh, ///< Database handle + const guidePendingExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long guidePendingExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of guidePendingExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool guidePendingExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of guidePendingExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an guidePendingExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool guidePendingExpPrintObject( + FILE *stream, ///< a stream + guidePendingExpRow *object, ///< an guidePendingExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** chipRunRow data structure + * + * Structure for representing a single row of chipRun table data. + */ + +typedef struct { + psS64 chip_id; + psS64 exp_id; + char *state; + char *workdir; + char *workdir_state; + char *label; + char *reduction; + char *expgroup; + char *dvodb; +} chipRunRow; + +/** Creates a new chipRunRow object + * + * @return A new chipRunRow object or NULL on failure. + */ + +chipRunRow *chipRunRowAlloc( + psS64 chip_id, + psS64 exp_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *reduction, + const char *expgroup, + const char *dvodb +); + +/** Creates a new chipRun table + * + * @return true on success + */ + +bool chipRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a chipRun table + * + * @return true on success + */ + +bool chipRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipRunInsert( + psDB *dbh, ///< Database handle + psS64 chip_id, + psS64 exp_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *reduction, + const char *expgroup, + const char *dvodb +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single chipRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipRunInsertObject( + psDB *dbh, ///< Database handle + chipRunRow *object ///< chipRunRow object +); + +/** Insert an array of chipRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool chipRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of chipRunRow objects +); + +/** Insert data from a binary FITS table chipRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool chipRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool chipRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a chipRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *chipRunMetadataFromObject( + const chipRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A chipRunRow pointer or NULL on error + */ + +chipRunRow *chipRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as chipRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *chipRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an chipRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool chipRunDeleteObject( + psDB *dbh, ///< Database handle + const chipRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of chipRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of chipRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an chipRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipRunPrintObject( + FILE *stream, ///< a stream + chipRunRow *object, ///< an chipRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** chipProcessedImfileRow data structure + * + * Structure for representing a single row of chipProcessedImfile table data. + */ + +typedef struct { + psS64 chip_id; + psS64 exp_id; + char *class_id; + char *uri; + psF32 bg; + psF32 bg_stdev; + psF32 bg_mean_stdev; + psF32 bias; + psF32 bias_stdev; + psF32 fringe_0; + psF32 fringe_1; + psF32 fringe_2; + psF32 sigma_ra; + psF32 sigma_dec; + psF32 ap_resid; + psF32 ap_resid_stdev; + psF32 fwhm; + psF32 fwhm_range; + psS32 n_stars; + psS32 n_extended; + psS32 n_cr; + psS32 n_astrom; + char *path_base; + psS16 fault; +} chipProcessedImfileRow; + +/** Creates a new chipProcessedImfileRow object + * + * @return A new chipProcessedImfileRow object or NULL on failure. + */ + +chipProcessedImfileRow *chipProcessedImfileRowAlloc( + psS64 chip_id, + psS64 exp_id, + const char *class_id, + const char *uri, + psF32 bg, + psF32 bg_stdev, + psF32 bg_mean_stdev, + psF32 bias, + psF32 bias_stdev, + psF32 fringe_0, + psF32 fringe_1, + psF32 fringe_2, + psF32 sigma_ra, + psF32 sigma_dec, + psF32 ap_resid, + psF32 ap_resid_stdev, + psF32 fwhm, + psF32 fwhm_range, + psS32 n_stars, + psS32 n_extended, + psS32 n_cr, + psS32 n_astrom, + const char *path_base, + psS16 fault +); + +/** Creates a new chipProcessedImfile table + * + * @return true on success + */ + +bool chipProcessedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a chipProcessedImfile table + * + * @return true on success + */ + +bool chipProcessedImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipProcessedImfileInsert( + psDB *dbh, ///< Database handle + psS64 chip_id, + psS64 exp_id, + const char *class_id, + const char *uri, + psF32 bg, + psF32 bg_stdev, + psF32 bg_mean_stdev, + psF32 bias, + psF32 bias_stdev, + psF32 fringe_0, + psF32 fringe_1, + psF32 fringe_2, + psF32 sigma_ra, + psF32 sigma_dec, + psF32 ap_resid, + psF32 ap_resid_stdev, + psF32 fwhm, + psF32 fwhm_range, + psS32 n_stars, + psS32 n_extended, + psS32 n_cr, + psS32 n_astrom, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipProcessedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single chipProcessedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipProcessedImfileInsertObject( + psDB *dbh, ///< Database handle + chipProcessedImfileRow *object ///< chipProcessedImfileRow object +); + +/** Insert an array of chipProcessedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool chipProcessedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of chipProcessedImfileRow objects +); + +/** Insert data from a binary FITS table chipProcessedImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool chipProcessedImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool chipProcessedImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a chipProcessedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *chipProcessedImfileMetadataFromObject( + const chipProcessedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A chipProcessedImfileRow pointer or NULL on error + */ + +chipProcessedImfileRow *chipProcessedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as chipProcessedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *chipProcessedImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an chipProcessedImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool chipProcessedImfileDeleteObject( + psDB *dbh, ///< Database handle + const chipProcessedImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipProcessedImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of chipProcessedImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipProcessedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of chipProcessedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an chipProcessedImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipProcessedImfilePrintObject( + FILE *stream, ///< a stream + chipProcessedImfileRow *object, ///< an chipProcessedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** chipMaskRow data structure + * + * Structure for representing a single row of chipMask table data. + */ + +typedef struct { + char *label; +} chipMaskRow; + +/** Creates a new chipMaskRow object + * + * @return A new chipMaskRow object or NULL on failure. + */ + +chipMaskRow *chipMaskRowAlloc( + const char *label +); + +/** Creates a new chipMask table + * + * @return true on success + */ + +bool chipMaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a chipMask table + * + * @return true on success + */ + +bool chipMaskDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipMaskInsert( + psDB *dbh, ///< Database handle + const char *label +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipMaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single chipMaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool chipMaskInsertObject( + psDB *dbh, ///< Database handle + chipMaskRow *object ///< chipMaskRow object +); + +/** Insert an array of chipMaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool chipMaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of chipMaskRow objects +); + +/** Insert data from a binary FITS table chipMaskRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool chipMaskInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool chipMaskSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a chipMaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *chipMaskMetadataFromObject( + const chipMaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A chipMaskRow pointer or NULL on error + */ + +chipMaskRow *chipMaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as chipMaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *chipMaskSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an chipMask + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool chipMaskDeleteObject( + psDB *dbh, ///< Database handle + const chipMaskRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long chipMaskDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of chipMaskRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipMaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of chipMaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an chipMaskRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool chipMaskPrintObject( + FILE *stream, ///< a stream + chipMaskRow *object, ///< an chipMaskRow object + bool mdcf ///< format as mdconfig or simple +); +/** camRunRow data structure + * + * Structure for representing a single row of camRun table data. + */ + +typedef struct { + psS64 cam_id; + psS64 chip_id; + char *state; + char *workdir; + char *workdir_state; + char *label; + char *reduction; + char *expgroup; + char *dvodb; +} camRunRow; + +/** Creates a new camRunRow object + * + * @return A new camRunRow object or NULL on failure. + */ + +camRunRow *camRunRowAlloc( + psS64 cam_id, + psS64 chip_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *reduction, + const char *expgroup, + const char *dvodb +); + +/** Creates a new camRun table + * + * @return true on success + */ + +bool camRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a camRun table + * + * @return true on success + */ + +bool camRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camRunInsert( + psDB *dbh, ///< Database handle + psS64 cam_id, + psS64 chip_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *reduction, + const char *expgroup, + const char *dvodb +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single camRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camRunInsertObject( + psDB *dbh, ///< Database handle + camRunRow *object ///< camRunRow object +); + +/** Insert an array of camRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool camRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of camRunRow objects +); + +/** Insert data from a binary FITS table camRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool camRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool camRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a camRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *camRunMetadataFromObject( + const camRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A camRunRow pointer or NULL on error + */ + +camRunRow *camRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as camRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *camRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an camRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool camRunDeleteObject( + psDB *dbh, ///< Database handle + const camRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of camRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of camRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an camRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camRunPrintObject( + FILE *stream, ///< a stream + camRunRow *object, ///< an camRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** camProcessedExpRow data structure + * + * Structure for representing a single row of camProcessedExp table data. + */ + +typedef struct { + psS64 cam_id; + psS64 chip_id; + char *uri; + psF32 bg; + psF32 bg_stdev; + psF32 bg_mean_stdev; + psF32 sigma_ra; + psF32 sigma_dec; + psF32 zp_mean; + psF32 zp_stdev; + psF32 fwhm; + psF32 fwhm_range; + psS32 n_stars; + psS32 n_extended; + psS32 n_cr; + psS32 n_astrom; + char *path_base; + psS16 fault; +} camProcessedExpRow; + +/** Creates a new camProcessedExpRow object + * + * @return A new camProcessedExpRow object or NULL on failure. + */ + +camProcessedExpRow *camProcessedExpRowAlloc( + psS64 cam_id, + psS64 chip_id, + const char *uri, + psF32 bg, + psF32 bg_stdev, + psF32 bg_mean_stdev, + psF32 sigma_ra, + psF32 sigma_dec, + psF32 zp_mean, + psF32 zp_stdev, + psF32 fwhm, + psF32 fwhm_range, + psS32 n_stars, + psS32 n_extended, + psS32 n_cr, + psS32 n_astrom, + const char *path_base, + psS16 fault +); + +/** Creates a new camProcessedExp table + * + * @return true on success + */ + +bool camProcessedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a camProcessedExp table + * + * @return true on success + */ + +bool camProcessedExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camProcessedExpInsert( + psDB *dbh, ///< Database handle + psS64 cam_id, + psS64 chip_id, + const char *uri, + psF32 bg, + psF32 bg_stdev, + psF32 bg_mean_stdev, + psF32 sigma_ra, + psF32 sigma_dec, + psF32 zp_mean, + psF32 zp_stdev, + psF32 fwhm, + psF32 fwhm_range, + psS32 n_stars, + psS32 n_extended, + psS32 n_cr, + psS32 n_astrom, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camProcessedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single camProcessedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camProcessedExpInsertObject( + psDB *dbh, ///< Database handle + camProcessedExpRow *object ///< camProcessedExpRow object +); + +/** Insert an array of camProcessedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool camProcessedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of camProcessedExpRow objects +); + +/** Insert data from a binary FITS table camProcessedExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool camProcessedExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool camProcessedExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a camProcessedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *camProcessedExpMetadataFromObject( + const camProcessedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A camProcessedExpRow pointer or NULL on error + */ + +camProcessedExpRow *camProcessedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as camProcessedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *camProcessedExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an camProcessedExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool camProcessedExpDeleteObject( + psDB *dbh, ///< Database handle + const camProcessedExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camProcessedExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of camProcessedExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camProcessedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of camProcessedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an camProcessedExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camProcessedExpPrintObject( + FILE *stream, ///< a stream + camProcessedExpRow *object, ///< an camProcessedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** camMaskRow data structure + * + * Structure for representing a single row of camMask table data. + */ + +typedef struct { + char *label; +} camMaskRow; + +/** Creates a new camMaskRow object + * + * @return A new camMaskRow object or NULL on failure. + */ + +camMaskRow *camMaskRowAlloc( + const char *label +); + +/** Creates a new camMask table + * + * @return true on success + */ + +bool camMaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a camMask table + * + * @return true on success + */ + +bool camMaskDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camMaskInsert( + psDB *dbh, ///< Database handle + const char *label +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camMaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single camMaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool camMaskInsertObject( + psDB *dbh, ///< Database handle + camMaskRow *object ///< camMaskRow object +); + +/** Insert an array of camMaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool camMaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of camMaskRow objects +); + +/** Insert data from a binary FITS table camMaskRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool camMaskInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool camMaskSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a camMaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *camMaskMetadataFromObject( + const camMaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A camMaskRow pointer or NULL on error + */ + +camMaskRow *camMaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as camMaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *camMaskSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an camMask + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool camMaskDeleteObject( + psDB *dbh, ///< Database handle + const camMaskRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long camMaskDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of camMaskRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camMaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of camMaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an camMaskRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool camMaskPrintObject( + FILE *stream, ///< a stream + camMaskRow *object, ///< an camMaskRow object + bool mdcf ///< format as mdconfig or simple +); +/** warpRunRow data structure + * + * Structure for representing a single row of warpRun table data. + */ + +typedef struct { + psS64 warp_id; + char *mode; + char *state; + char *workdir; + char *dvodb; + psTime* registered; +} warpRunRow; + +/** Creates a new warpRunRow object + * + * @return A new warpRunRow object or NULL on failure. + */ + +warpRunRow *warpRunRowAlloc( + psS64 warp_id, + const char *mode, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered +); + +/** Creates a new warpRun table + * + * @return true on success + */ + +bool warpRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a warpRun table + * + * @return true on success + */ + +bool warpRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpRunInsert( + psDB *dbh, ///< Database handle + psS64 warp_id, + const char *mode, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single warpRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpRunInsertObject( + psDB *dbh, ///< Database handle + warpRunRow *object ///< warpRunRow object +); + +/** Insert an array of warpRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool warpRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of warpRunRow objects +); + +/** Insert data from a binary FITS table warpRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool warpRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool warpRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a warpRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *warpRunMetadataFromObject( + const warpRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A warpRunRow pointer or NULL on error + */ + +warpRunRow *warpRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as warpRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *warpRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an warpRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool warpRunDeleteObject( + psDB *dbh, ///< Database handle + const warpRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of warpRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of warpRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an warpRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpRunPrintObject( + FILE *stream, ///< a stream + warpRunRow *object, ///< an warpRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** warpInputExpRow data structure + * + * Structure for representing a single row of warpInputExp table data. + */ + +typedef struct { + psS64 warp_id; + psS64 cam_id; + bool magiced; +} warpInputExpRow; + +/** Creates a new warpInputExpRow object + * + * @return A new warpInputExpRow object or NULL on failure. + */ + +warpInputExpRow *warpInputExpRowAlloc( + psS64 warp_id, + psS64 cam_id, + bool magiced +); + +/** Creates a new warpInputExp table + * + * @return true on success + */ + +bool warpInputExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a warpInputExp table + * + * @return true on success + */ + +bool warpInputExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpInputExpInsert( + psDB *dbh, ///< Database handle + psS64 warp_id, + psS64 cam_id, + bool magiced +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpInputExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single warpInputExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpInputExpInsertObject( + psDB *dbh, ///< Database handle + warpInputExpRow *object ///< warpInputExpRow object +); + +/** Insert an array of warpInputExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool warpInputExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of warpInputExpRow objects +); + +/** Insert data from a binary FITS table warpInputExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool warpInputExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool warpInputExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a warpInputExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *warpInputExpMetadataFromObject( + const warpInputExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A warpInputExpRow pointer or NULL on error + */ + +warpInputExpRow *warpInputExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as warpInputExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *warpInputExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an warpInputExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool warpInputExpDeleteObject( + psDB *dbh, ///< Database handle + const warpInputExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpInputExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of warpInputExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpInputExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of warpInputExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an warpInputExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpInputExpPrintObject( + FILE *stream, ///< a stream + warpInputExpRow *object, ///< an warpInputExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** warpSkyCellMapRow data structure + * + * Structure for representing a single row of warpSkyCellMap table data. + */ + +typedef struct { + psS64 warp_id; + char *skycell_id; + char *tess_id; + psS64 cam_id; + char *class_id; + psS16 fault; +} warpSkyCellMapRow; + +/** Creates a new warpSkyCellMapRow object + * + * @return A new warpSkyCellMapRow object or NULL on failure. + */ + +warpSkyCellMapRow *warpSkyCellMapRowAlloc( + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + psS64 cam_id, + const char *class_id, + psS16 fault +); + +/** Creates a new warpSkyCellMap table + * + * @return true on success + */ + +bool warpSkyCellMapCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a warpSkyCellMap table + * + * @return true on success + */ + +bool warpSkyCellMapDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpSkyCellMapInsert( + psDB *dbh, ///< Database handle + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + psS64 cam_id, + const char *class_id, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpSkyCellMapDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single warpSkyCellMapRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpSkyCellMapInsertObject( + psDB *dbh, ///< Database handle + warpSkyCellMapRow *object ///< warpSkyCellMapRow object +); + +/** Insert an array of warpSkyCellMapRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool warpSkyCellMapInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of warpSkyCellMapRow objects +); + +/** Insert data from a binary FITS table warpSkyCellMapRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool warpSkyCellMapInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool warpSkyCellMapSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a warpSkyCellMapRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *warpSkyCellMapMetadataFromObject( + const warpSkyCellMapRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A warpSkyCellMapRow pointer or NULL on error + */ + +warpSkyCellMapRow *warpSkyCellMapObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as warpSkyCellMapRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *warpSkyCellMapSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an warpSkyCellMap + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool warpSkyCellMapDeleteObject( + psDB *dbh, ///< Database handle + const warpSkyCellMapRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpSkyCellMapDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of warpSkyCellMapRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpSkyCellMapPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of warpSkyCellMapRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an warpSkyCellMapRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpSkyCellMapPrintObject( + FILE *stream, ///< a stream + warpSkyCellMapRow *object, ///< an warpSkyCellMapRow object + bool mdcf ///< format as mdconfig or simple +); +/** warpSkyfileRow data structure + * + * Structure for representing a single row of warpSkyfile table data. + */ + +typedef struct { + psS64 warp_id; + char *skycell_id; + char *tess_id; + char *uri; + char *path_base; + psF64 bg; + psF64 bg_stdev; + psF64 pixel_fill; + psS16 fault; +} warpSkyfileRow; + +/** Creates a new warpSkyfileRow object + * + * @return A new warpSkyfileRow object or NULL on failure. + */ + +warpSkyfileRow *warpSkyfileRowAlloc( + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psF64 pixel_fill, + psS16 fault +); + +/** Creates a new warpSkyfile table + * + * @return true on success + */ + +bool warpSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a warpSkyfile table + * + * @return true on success + */ + +bool warpSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psF64 pixel_fill, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single warpSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool warpSkyfileInsertObject( + psDB *dbh, ///< Database handle + warpSkyfileRow *object ///< warpSkyfileRow object +); + +/** Insert an array of warpSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool warpSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of warpSkyfileRow objects +); + +/** Insert data from a binary FITS table warpSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool warpSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool warpSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a warpSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *warpSkyfileMetadataFromObject( + const warpSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A warpSkyfileRow pointer or NULL on error + */ + +warpSkyfileRow *warpSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as warpSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *warpSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an warpSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool warpSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const warpSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long warpSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of warpSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of warpSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an warpSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool warpSkyfilePrintObject( + FILE *stream, ///< a stream + warpSkyfileRow *object, ///< an warpSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** diffRunRow data structure + * + * Structure for representing a single row of diffRun table data. + */ + +typedef struct { + psS64 diff_id; + char *state; + char *workdir; + char *dvodb; + psTime* registered; + char *skycell_id; + char *tess_id; +} diffRunRow; + +/** Creates a new diffRunRow object + * + * @return A new diffRunRow object or NULL on failure. + */ + +diffRunRow *diffRunRowAlloc( + psS64 diff_id, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered, + const char *skycell_id, + const char *tess_id +); + +/** Creates a new diffRun table + * + * @return true on success + */ + +bool diffRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a diffRun table + * + * @return true on success + */ + +bool diffRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffRunInsert( + psDB *dbh, ///< Database handle + psS64 diff_id, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered, + const char *skycell_id, + const char *tess_id +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single diffRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffRunInsertObject( + psDB *dbh, ///< Database handle + diffRunRow *object ///< diffRunRow object +); + +/** Insert an array of diffRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool diffRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of diffRunRow objects +); + +/** Insert data from a binary FITS table diffRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool diffRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool diffRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a diffRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *diffRunMetadataFromObject( + const diffRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A diffRunRow pointer or NULL on error + */ + +diffRunRow *diffRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as diffRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *diffRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an diffRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool diffRunDeleteObject( + psDB *dbh, ///< Database handle + const diffRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of diffRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of diffRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an diffRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffRunPrintObject( + FILE *stream, ///< a stream + diffRunRow *object, ///< an diffRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** diffInputSkyfileRow data structure + * + * Structure for representing a single row of diffInputSkyfile table data. + */ + +typedef struct { + psS64 diff_id; + bool template; + psS64 stack_id; + psS64 warp_id; + char *skycell_id; + char *tess_id; + char *kind; +} diffInputSkyfileRow; + +/** Creates a new diffInputSkyfileRow object + * + * @return A new diffInputSkyfileRow object or NULL on failure. + */ + +diffInputSkyfileRow *diffInputSkyfileRowAlloc( + psS64 diff_id, + bool template, + psS64 stack_id, + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + const char *kind +); + +/** Creates a new diffInputSkyfile table + * + * @return true on success + */ + +bool diffInputSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a diffInputSkyfile table + * + * @return true on success + */ + +bool diffInputSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffInputSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 diff_id, + bool template, + psS64 stack_id, + psS64 warp_id, + const char *skycell_id, + const char *tess_id, + const char *kind +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffInputSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single diffInputSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffInputSkyfileInsertObject( + psDB *dbh, ///< Database handle + diffInputSkyfileRow *object ///< diffInputSkyfileRow object +); + +/** Insert an array of diffInputSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool diffInputSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of diffInputSkyfileRow objects +); + +/** Insert data from a binary FITS table diffInputSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool diffInputSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool diffInputSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a diffInputSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *diffInputSkyfileMetadataFromObject( + const diffInputSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A diffInputSkyfileRow pointer or NULL on error + */ + +diffInputSkyfileRow *diffInputSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as diffInputSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *diffInputSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an diffInputSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool diffInputSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const diffInputSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffInputSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of diffInputSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffInputSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of diffInputSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an diffInputSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffInputSkyfilePrintObject( + FILE *stream, ///< a stream + diffInputSkyfileRow *object, ///< an diffInputSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** diffSkyfileRow data structure + * + * Structure for representing a single row of diffSkyfile table data. + */ + +typedef struct { + psS64 diff_id; + char *uri; + char *path_base; + psF64 bg; + psF64 bg_stdev; + psS16 fault; +} diffSkyfileRow; + +/** Creates a new diffSkyfileRow object + * + * @return A new diffSkyfileRow object or NULL on failure. + */ + +diffSkyfileRow *diffSkyfileRowAlloc( + psS64 diff_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psS16 fault +); + +/** Creates a new diffSkyfile table + * + * @return true on success + */ + +bool diffSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a diffSkyfile table + * + * @return true on success + */ + +bool diffSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 diff_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single diffSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool diffSkyfileInsertObject( + psDB *dbh, ///< Database handle + diffSkyfileRow *object ///< diffSkyfileRow object +); + +/** Insert an array of diffSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool diffSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of diffSkyfileRow objects +); + +/** Insert data from a binary FITS table diffSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool diffSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool diffSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a diffSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *diffSkyfileMetadataFromObject( + const diffSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A diffSkyfileRow pointer or NULL on error + */ + +diffSkyfileRow *diffSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as diffSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *diffSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an diffSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool diffSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const diffSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long diffSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of diffSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of diffSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an diffSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool diffSkyfilePrintObject( + FILE *stream, ///< a stream + diffSkyfileRow *object, ///< an diffSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** stackRunRow data structure + * + * Structure for representing a single row of stackRun table data. + */ + +typedef struct { + psS64 stack_id; + char *state; + char *workdir; + char *dvodb; + psTime* registered; + char *skycell_id; + char *tess_id; +} stackRunRow; + +/** Creates a new stackRunRow object + * + * @return A new stackRunRow object or NULL on failure. + */ + +stackRunRow *stackRunRowAlloc( + psS64 stack_id, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered, + const char *skycell_id, + const char *tess_id +); + +/** Creates a new stackRun table + * + * @return true on success + */ + +bool stackRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a stackRun table + * + * @return true on success + */ + +bool stackRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackRunInsert( + psDB *dbh, ///< Database handle + psS64 stack_id, + const char *state, + const char *workdir, + const char *dvodb, + psTime* registered, + const char *skycell_id, + const char *tess_id +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single stackRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackRunInsertObject( + psDB *dbh, ///< Database handle + stackRunRow *object ///< stackRunRow object +); + +/** Insert an array of stackRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool stackRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of stackRunRow objects +); + +/** Insert data from a binary FITS table stackRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool stackRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool stackRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a stackRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *stackRunMetadataFromObject( + const stackRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A stackRunRow pointer or NULL on error + */ + +stackRunRow *stackRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as stackRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *stackRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an stackRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool stackRunDeleteObject( + psDB *dbh, ///< Database handle + const stackRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of stackRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of stackRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an stackRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackRunPrintObject( + FILE *stream, ///< a stream + stackRunRow *object, ///< an stackRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** stackInputSkyfileRow data structure + * + * Structure for representing a single row of stackInputSkyfile table data. + */ + +typedef struct { + psS64 stack_id; + psS64 warp_id; +} stackInputSkyfileRow; + +/** Creates a new stackInputSkyfileRow object + * + * @return A new stackInputSkyfileRow object or NULL on failure. + */ + +stackInputSkyfileRow *stackInputSkyfileRowAlloc( + psS64 stack_id, + psS64 warp_id +); + +/** Creates a new stackInputSkyfile table + * + * @return true on success + */ + +bool stackInputSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a stackInputSkyfile table + * + * @return true on success + */ + +bool stackInputSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackInputSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 stack_id, + psS64 warp_id +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackInputSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single stackInputSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackInputSkyfileInsertObject( + psDB *dbh, ///< Database handle + stackInputSkyfileRow *object ///< stackInputSkyfileRow object +); + +/** Insert an array of stackInputSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool stackInputSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of stackInputSkyfileRow objects +); + +/** Insert data from a binary FITS table stackInputSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool stackInputSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool stackInputSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a stackInputSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *stackInputSkyfileMetadataFromObject( + const stackInputSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A stackInputSkyfileRow pointer or NULL on error + */ + +stackInputSkyfileRow *stackInputSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as stackInputSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *stackInputSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an stackInputSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool stackInputSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const stackInputSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackInputSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of stackInputSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackInputSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of stackInputSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an stackInputSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackInputSkyfilePrintObject( + FILE *stream, ///< a stream + stackInputSkyfileRow *object, ///< an stackInputSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** stackSumSkyfileRow data structure + * + * Structure for representing a single row of stackSumSkyfile table data. + */ + +typedef struct { + psS64 stack_id; + char *uri; + char *path_base; + psF64 bg; + psF64 bg_stdev; + psS16 fault; +} stackSumSkyfileRow; + +/** Creates a new stackSumSkyfileRow object + * + * @return A new stackSumSkyfileRow object or NULL on failure. + */ + +stackSumSkyfileRow *stackSumSkyfileRowAlloc( + psS64 stack_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psS16 fault +); + +/** Creates a new stackSumSkyfile table + * + * @return true on success + */ + +bool stackSumSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a stackSumSkyfile table + * + * @return true on success + */ + +bool stackSumSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackSumSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 stack_id, + const char *uri, + const char *path_base, + psF64 bg, + psF64 bg_stdev, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackSumSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single stackSumSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool stackSumSkyfileInsertObject( + psDB *dbh, ///< Database handle + stackSumSkyfileRow *object ///< stackSumSkyfileRow object +); + +/** Insert an array of stackSumSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool stackSumSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of stackSumSkyfileRow objects +); + +/** Insert data from a binary FITS table stackSumSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool stackSumSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool stackSumSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a stackSumSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *stackSumSkyfileMetadataFromObject( + const stackSumSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A stackSumSkyfileRow pointer or NULL on error + */ + +stackSumSkyfileRow *stackSumSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as stackSumSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *stackSumSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an stackSumSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool stackSumSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const stackSumSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long stackSumSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of stackSumSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackSumSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of stackSumSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an stackSumSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool stackSumSkyfilePrintObject( + FILE *stream, ///< a stream + stackSumSkyfileRow *object, ///< an stackSumSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detRunRow data structure + * + * Structure for representing a single row of detRun table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *det_type; + char *mode; + char *state; + char *filelevel; + char *workdir; + char *camera; + char *telescope; + char *exp_type; + char *reduction; + char *filter; + psF32 airmass_min; + psF32 airmass_max; + psF32 exp_time_min; + psF32 exp_time_max; + psF32 ccd_temp_min; + psF32 ccd_temp_max; + psF64 posang_min; + psF64 posang_max; + psTime* registered; + psTime* time_begin; + psTime* time_end; + psTime* use_begin; + psTime* use_end; + psF32 solang_min; + psF32 solang_max; + char *label; + psS32 parent; +} detRunRow; + +/** Creates a new detRunRow object + * + * @return A new detRunRow object or NULL on failure. + */ + +detRunRow *detRunRowAlloc( + psS64 det_id, + psS32 iteration, + const char *det_type, + const char *mode, + const char *state, + const char *filelevel, + const char *workdir, + const char *camera, + const char *telescope, + const char *exp_type, + const char *reduction, + const char *filter, + psF32 airmass_min, + psF32 airmass_max, + psF32 exp_time_min, + psF32 exp_time_max, + psF32 ccd_temp_min, + psF32 ccd_temp_max, + psF64 posang_min, + psF64 posang_max, + psTime* registered, + psTime* time_begin, + psTime* time_end, + psTime* use_begin, + psTime* use_end, + psF32 solang_min, + psF32 solang_max, + const char *label, + psS32 parent +); + +/** Creates a new detRun table + * + * @return true on success + */ + +bool detRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detRun table + * + * @return true on success + */ + +bool detRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRunInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *det_type, + const char *mode, + const char *state, + const char *filelevel, + const char *workdir, + const char *camera, + const char *telescope, + const char *exp_type, + const char *reduction, + const char *filter, + psF32 airmass_min, + psF32 airmass_max, + psF32 exp_time_min, + psF32 exp_time_max, + psF32 ccd_temp_min, + psF32 ccd_temp_max, + psF64 posang_min, + psF64 posang_max, + psTime* registered, + psTime* time_begin, + psTime* time_end, + psTime* use_begin, + psTime* use_end, + psF32 solang_min, + psF32 solang_max, + const char *label, + psS32 parent +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRunInsertObject( + psDB *dbh, ///< Database handle + detRunRow *object ///< detRunRow object +); + +/** Insert an array of detRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detRunRow objects +); + +/** Insert data from a binary FITS table detRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detRunMetadataFromObject( + const detRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detRunRow pointer or NULL on error + */ + +detRunRow *detRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detRunDeleteObject( + psDB *dbh, ///< Database handle + const detRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRunPrintObject( + FILE *stream, ///< a stream + detRunRow *object, ///< an detRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** detInputExpRow data structure + * + * Structure for representing a single row of detInputExp table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + psS64 exp_id; + bool include; +} detInputExpRow; + +/** Creates a new detInputExpRow object + * + * @return A new detInputExpRow object or NULL on failure. + */ + +detInputExpRow *detInputExpRowAlloc( + psS64 det_id, + psS32 iteration, + psS64 exp_id, + bool include +); + +/** Creates a new detInputExp table + * + * @return true on success + */ + +bool detInputExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detInputExp table + * + * @return true on success + */ + +bool detInputExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detInputExpInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + psS64 exp_id, + bool include +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detInputExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detInputExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detInputExpInsertObject( + psDB *dbh, ///< Database handle + detInputExpRow *object ///< detInputExpRow object +); + +/** Insert an array of detInputExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detInputExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detInputExpRow objects +); + +/** Insert data from a binary FITS table detInputExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detInputExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detInputExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detInputExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detInputExpMetadataFromObject( + const detInputExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detInputExpRow pointer or NULL on error + */ + +detInputExpRow *detInputExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detInputExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detInputExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detInputExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detInputExpDeleteObject( + psDB *dbh, ///< Database handle + const detInputExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detInputExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detInputExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detInputExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detInputExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detInputExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detInputExpPrintObject( + FILE *stream, ///< a stream + detInputExpRow *object, ///< an detInputExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** detProcessedImfileRow data structure + * + * Structure for representing a single row of detProcessedImfile table data. + */ + +typedef struct { + psS64 det_id; + psS64 exp_id; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 fringe_0; + psF64 fringe_1; + psF64 fringe_2; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detProcessedImfileRow; + +/** Creates a new detProcessedImfileRow object + * + * @return A new detProcessedImfileRow object or NULL on failure. + */ + +detProcessedImfileRow *detProcessedImfileRowAlloc( + psS64 det_id, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detProcessedImfile table + * + * @return true on success + */ + +bool detProcessedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detProcessedImfile table + * + * @return true on success + */ + +bool detProcessedImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detProcessedImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detProcessedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detProcessedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detProcessedImfileInsertObject( + psDB *dbh, ///< Database handle + detProcessedImfileRow *object ///< detProcessedImfileRow object +); + +/** Insert an array of detProcessedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detProcessedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detProcessedImfileRow objects +); + +/** Insert data from a binary FITS table detProcessedImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detProcessedImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detProcessedImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detProcessedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detProcessedImfileMetadataFromObject( + const detProcessedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detProcessedImfileRow pointer or NULL on error + */ + +detProcessedImfileRow *detProcessedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detProcessedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detProcessedImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detProcessedImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detProcessedImfileDeleteObject( + psDB *dbh, ///< Database handle + const detProcessedImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detProcessedImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detProcessedImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detProcessedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detProcessedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detProcessedImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detProcessedImfilePrintObject( + FILE *stream, ///< a stream + detProcessedImfileRow *object, ///< an detProcessedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detProcessedExpRow data structure + * + * Structure for representing a single row of detProcessedExp table data. + */ + +typedef struct { + psS64 det_id; + psS64 exp_id; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 fringe_0; + psF64 fringe_1; + psF64 fringe_2; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detProcessedExpRow; + +/** Creates a new detProcessedExpRow object + * + * @return A new detProcessedExpRow object or NULL on failure. + */ + +detProcessedExpRow *detProcessedExpRowAlloc( + psS64 det_id, + psS64 exp_id, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detProcessedExp table + * + * @return true on success + */ + +bool detProcessedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detProcessedExp table + * + * @return true on success + */ + +bool detProcessedExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detProcessedExpInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS64 exp_id, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detProcessedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detProcessedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detProcessedExpInsertObject( + psDB *dbh, ///< Database handle + detProcessedExpRow *object ///< detProcessedExpRow object +); + +/** Insert an array of detProcessedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detProcessedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detProcessedExpRow objects +); + +/** Insert data from a binary FITS table detProcessedExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detProcessedExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detProcessedExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detProcessedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detProcessedExpMetadataFromObject( + const detProcessedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detProcessedExpRow pointer or NULL on error + */ + +detProcessedExpRow *detProcessedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detProcessedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detProcessedExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detProcessedExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detProcessedExpDeleteObject( + psDB *dbh, ///< Database handle + const detProcessedExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detProcessedExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detProcessedExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detProcessedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detProcessedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detProcessedExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detProcessedExpPrintObject( + FILE *stream, ///< a stream + detProcessedExpRow *object, ///< an detProcessedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** detStackedImfileRow data structure + * + * Structure for representing a single row of detStackedImfile table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + psS16 fault; +} detStackedImfileRow; + +/** Creates a new detStackedImfileRow object + * + * @return A new detStackedImfileRow object or NULL on failure. + */ + +detStackedImfileRow *detStackedImfileRowAlloc( + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + psS16 fault +); + +/** Creates a new detStackedImfile table + * + * @return true on success + */ + +bool detStackedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detStackedImfile table + * + * @return true on success + */ + +bool detStackedImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detStackedImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detStackedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detStackedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detStackedImfileInsertObject( + psDB *dbh, ///< Database handle + detStackedImfileRow *object ///< detStackedImfileRow object +); + +/** Insert an array of detStackedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detStackedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detStackedImfileRow objects +); + +/** Insert data from a binary FITS table detStackedImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detStackedImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detStackedImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detStackedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detStackedImfileMetadataFromObject( + const detStackedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detStackedImfileRow pointer or NULL on error + */ + +detStackedImfileRow *detStackedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detStackedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detStackedImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detStackedImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detStackedImfileDeleteObject( + psDB *dbh, ///< Database handle + const detStackedImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detStackedImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detStackedImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detStackedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detStackedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detStackedImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detStackedImfilePrintObject( + FILE *stream, ///< a stream + detStackedImfileRow *object, ///< an detStackedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detNormalizedStatImfileRow data structure + * + * Structure for representing a single row of detNormalizedStatImfile table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *class_id; + psF32 norm; + psS16 fault; +} detNormalizedStatImfileRow; + +/** Creates a new detNormalizedStatImfileRow object + * + * @return A new detNormalizedStatImfileRow object or NULL on failure. + */ + +detNormalizedStatImfileRow *detNormalizedStatImfileRowAlloc( + psS64 det_id, + psS32 iteration, + const char *class_id, + psF32 norm, + psS16 fault +); + +/** Creates a new detNormalizedStatImfile table + * + * @return true on success + */ + +bool detNormalizedStatImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detNormalizedStatImfile table + * + * @return true on success + */ + +bool detNormalizedStatImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *class_id, + psF32 norm, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedStatImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detNormalizedStatImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertObject( + psDB *dbh, ///< Database handle + detNormalizedStatImfileRow *object ///< detNormalizedStatImfileRow object +); + +/** Insert an array of detNormalizedStatImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detNormalizedStatImfileRow objects +); + +/** Insert data from a binary FITS table detNormalizedStatImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detNormalizedStatImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detNormalizedStatImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detNormalizedStatImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detNormalizedStatImfileMetadataFromObject( + const detNormalizedStatImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detNormalizedStatImfileRow pointer or NULL on error + */ + +detNormalizedStatImfileRow *detNormalizedStatImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detNormalizedStatImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detNormalizedStatImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detNormalizedStatImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detNormalizedStatImfileDeleteObject( + psDB *dbh, ///< Database handle + const detNormalizedStatImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedStatImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detNormalizedStatImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedStatImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detNormalizedStatImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detNormalizedStatImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedStatImfilePrintObject( + FILE *stream, ///< a stream + detNormalizedStatImfileRow *object, ///< an detNormalizedStatImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detNormalizedImfileRow data structure + * + * Structure for representing a single row of detNormalizedImfile table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *class_id; + char *uri; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detNormalizedImfileRow; + +/** Creates a new detNormalizedImfileRow object + * + * @return A new detNormalizedImfileRow object or NULL on failure. + */ + +detNormalizedImfileRow *detNormalizedImfileRowAlloc( + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detNormalizedImfile table + * + * @return true on success + */ + +bool detNormalizedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detNormalizedImfile table + * + * @return true on success + */ + +bool detNormalizedImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detNormalizedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedImfileInsertObject( + psDB *dbh, ///< Database handle + detNormalizedImfileRow *object ///< detNormalizedImfileRow object +); + +/** Insert an array of detNormalizedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detNormalizedImfileRow objects +); + +/** Insert data from a binary FITS table detNormalizedImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detNormalizedImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detNormalizedImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detNormalizedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detNormalizedImfileMetadataFromObject( + const detNormalizedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detNormalizedImfileRow pointer or NULL on error + */ + +detNormalizedImfileRow *detNormalizedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detNormalizedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detNormalizedImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detNormalizedImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detNormalizedImfileDeleteObject( + psDB *dbh, ///< Database handle + const detNormalizedImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detNormalizedImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detNormalizedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detNormalizedImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedImfilePrintObject( + FILE *stream, ///< a stream + detNormalizedImfileRow *object, ///< an detNormalizedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detNormalizedExpRow data structure + * + * Structure for representing a single row of detNormalizedExp table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detNormalizedExpRow; + +/** Creates a new detNormalizedExpRow object + * + * @return A new detNormalizedExpRow object or NULL on failure. + */ + +detNormalizedExpRow *detNormalizedExpRowAlloc( + psS64 det_id, + psS32 iteration, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detNormalizedExp table + * + * @return true on success + */ + +bool detNormalizedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detNormalizedExp table + * + * @return true on success + */ + +bool detNormalizedExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedExpInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detNormalizedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedExpInsertObject( + psDB *dbh, ///< Database handle + detNormalizedExpRow *object ///< detNormalizedExpRow object +); + +/** Insert an array of detNormalizedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detNormalizedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detNormalizedExpRow objects +); + +/** Insert data from a binary FITS table detNormalizedExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detNormalizedExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detNormalizedExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detNormalizedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detNormalizedExpMetadataFromObject( + const detNormalizedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detNormalizedExpRow pointer or NULL on error + */ + +detNormalizedExpRow *detNormalizedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detNormalizedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detNormalizedExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detNormalizedExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detNormalizedExpDeleteObject( + psDB *dbh, ///< Database handle + const detNormalizedExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detNormalizedExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detNormalizedExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detNormalizedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detNormalizedExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detNormalizedExpPrintObject( + FILE *stream, ///< a stream + detNormalizedExpRow *object, ///< an detNormalizedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** detResidImfileRow data structure + * + * Structure for representing a single row of detResidImfile table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + psS64 exp_id; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 bg_skewness; + psF64 bg_kurtosis; + psF64 bin_stdev; + psF64 fringe_0; + psF64 fringe_1; + psF64 fringe_2; + psF64 fringe_resid_0; + psF64 fringe_resid_1; + psF64 fringe_resid_2; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detResidImfileRow; + +/** Creates a new detResidImfileRow object + * + * @return A new detResidImfileRow object or NULL on failure. + */ + +detResidImfileRow *detResidImfileRowAlloc( + psS64 det_id, + psS32 iteration, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 bg_skewness, + psF64 bg_kurtosis, + psF64 bin_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 fringe_resid_0, + psF64 fringe_resid_1, + psF64 fringe_resid_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detResidImfile table + * + * @return true on success + */ + +bool detResidImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detResidImfile table + * + * @return true on success + */ + +bool detResidImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detResidImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + psS64 exp_id, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 bg_skewness, + psF64 bg_kurtosis, + psF64 bin_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 fringe_resid_0, + psF64 fringe_resid_1, + psF64 fringe_resid_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detResidImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detResidImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detResidImfileInsertObject( + psDB *dbh, ///< Database handle + detResidImfileRow *object ///< detResidImfileRow object +); + +/** Insert an array of detResidImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detResidImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detResidImfileRow objects +); + +/** Insert data from a binary FITS table detResidImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detResidImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detResidImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detResidImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detResidImfileMetadataFromObject( + const detResidImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detResidImfileRow pointer or NULL on error + */ + +detResidImfileRow *detResidImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detResidImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detResidImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detResidImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detResidImfileDeleteObject( + psDB *dbh, ///< Database handle + const detResidImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detResidImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detResidImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detResidImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detResidImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detResidImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detResidImfilePrintObject( + FILE *stream, ///< a stream + detResidImfileRow *object, ///< an detResidImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** detResidExpRow data structure + * + * Structure for representing a single row of detResidExp table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + psS64 exp_id; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 bg_skewness; + psF64 bg_kurtosis; + psF64 bin_stdev; + psF64 fringe_0; + psF64 fringe_1; + psF64 fringe_2; + psF64 fringe_resid_0; + psF64 fringe_resid_1; + psF64 fringe_resid_2; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + bool accept; + psS16 fault; +} detResidExpRow; + +/** Creates a new detResidExpRow object + * + * @return A new detResidExpRow object or NULL on failure. + */ + +detResidExpRow *detResidExpRowAlloc( + psS64 det_id, + psS32 iteration, + psS64 exp_id, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 bg_skewness, + psF64 bg_kurtosis, + psF64 bin_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 fringe_resid_0, + psF64 fringe_resid_1, + psF64 fringe_resid_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + bool accept, + psS16 fault +); + +/** Creates a new detResidExp table + * + * @return true on success + */ + +bool detResidExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detResidExp table + * + * @return true on success + */ + +bool detResidExpDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detResidExpInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + psS64 exp_id, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 bg_skewness, + psF64 bg_kurtosis, + psF64 bin_stdev, + psF64 fringe_0, + psF64 fringe_1, + psF64 fringe_2, + psF64 fringe_resid_0, + psF64 fringe_resid_1, + psF64 fringe_resid_2, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + bool accept, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detResidExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detResidExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detResidExpInsertObject( + psDB *dbh, ///< Database handle + detResidExpRow *object ///< detResidExpRow object +); + +/** Insert an array of detResidExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detResidExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detResidExpRow objects +); + +/** Insert data from a binary FITS table detResidExpRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detResidExpInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detResidExpSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detResidExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detResidExpMetadataFromObject( + const detResidExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detResidExpRow pointer or NULL on error + */ + +detResidExpRow *detResidExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detResidExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detResidExpSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detResidExp + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detResidExpDeleteObject( + psDB *dbh, ///< Database handle + const detResidExpRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detResidExpDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detResidExpRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detResidExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detResidExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detResidExpRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detResidExpPrintObject( + FILE *stream, ///< a stream + detResidExpRow *object, ///< an detResidExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** detRunSummaryRow data structure + * + * Structure for representing a single row of detRunSummary table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + bool accept; + psS16 fault; +} detRunSummaryRow; + +/** Creates a new detRunSummaryRow object + * + * @return A new detRunSummaryRow object or NULL on failure. + */ + +detRunSummaryRow *detRunSummaryRowAlloc( + psS64 det_id, + psS32 iteration, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + bool accept, + psS16 fault +); + +/** Creates a new detRunSummary table + * + * @return true on success + */ + +bool detRunSummaryCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detRunSummary table + * + * @return true on success + */ + +bool detRunSummaryDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRunSummaryInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + bool accept, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRunSummaryDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detRunSummaryRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRunSummaryInsertObject( + psDB *dbh, ///< Database handle + detRunSummaryRow *object ///< detRunSummaryRow object +); + +/** Insert an array of detRunSummaryRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detRunSummaryInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detRunSummaryRow objects +); + +/** Insert data from a binary FITS table detRunSummaryRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detRunSummaryInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detRunSummarySelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detRunSummaryRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detRunSummaryMetadataFromObject( + const detRunSummaryRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detRunSummaryRow pointer or NULL on error + */ + +detRunSummaryRow *detRunSummaryObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detRunSummaryRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detRunSummarySelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detRunSummary + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detRunSummaryDeleteObject( + psDB *dbh, ///< Database handle + const detRunSummaryRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRunSummaryDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detRunSummaryRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRunSummaryPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detRunSummaryRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detRunSummaryRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRunSummaryPrintObject( + FILE *stream, ///< a stream + detRunSummaryRow *object, ///< an detRunSummaryRow object + bool mdcf ///< format as mdconfig or simple +); +/** detRegisteredImfileRow data structure + * + * Structure for representing a single row of detRegisteredImfile table data. + */ + +typedef struct { + psS64 det_id; + psS32 iteration; + char *class_id; + char *uri; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 user_1; + psF64 user_2; + psF64 user_3; + psF64 user_4; + psF64 user_5; + char *path_base; + psS16 fault; +} detRegisteredImfileRow; + +/** Creates a new detRegisteredImfileRow object + * + * @return A new detRegisteredImfileRow object or NULL on failure. + */ + +detRegisteredImfileRow *detRegisteredImfileRowAlloc( + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Creates a new detRegisteredImfile table + * + * @return true on success + */ + +bool detRegisteredImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a detRegisteredImfile table + * + * @return true on success + */ + +bool detRegisteredImfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRegisteredImfileInsert( + psDB *dbh, ///< Database handle + psS64 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 user_1, + psF64 user_2, + psF64 user_3, + psF64 user_4, + psF64 user_5, + const char *path_base, + psS16 fault +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRegisteredImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single detRegisteredImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool detRegisteredImfileInsertObject( + psDB *dbh, ///< Database handle + detRegisteredImfileRow *object ///< detRegisteredImfileRow object +); + +/** Insert an array of detRegisteredImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool detRegisteredImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of detRegisteredImfileRow objects +); + +/** Insert data from a binary FITS table detRegisteredImfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool detRegisteredImfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool detRegisteredImfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a detRegisteredImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *detRegisteredImfileMetadataFromObject( + const detRegisteredImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A detRegisteredImfileRow pointer or NULL on error + */ + +detRegisteredImfileRow *detRegisteredImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as detRegisteredImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *detRegisteredImfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an detRegisteredImfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool detRegisteredImfileDeleteObject( + psDB *dbh, ///< Database handle + const detRegisteredImfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long detRegisteredImfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of detRegisteredImfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRegisteredImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of detRegisteredImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an detRegisteredImfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool detRegisteredImfilePrintObject( + FILE *stream, ///< a stream + detRegisteredImfileRow *object, ///< an detRegisteredImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** magicRunRow data structure + * + * Structure for representing a single row of magicRun table data. + */ + +typedef struct { + psS64 magic_id; + char *state; + char *workdir; + char *workdir_state; + char *label; + char *dvodb; + psTime* registered; +} magicRunRow; + +/** Creates a new magicRunRow object + * + * @return A new magicRunRow object or NULL on failure. + */ + +magicRunRow *magicRunRowAlloc( + psS64 magic_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *dvodb, + psTime* registered +); + +/** Creates a new magicRun table + * + * @return true on success + */ + +bool magicRunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicRun table + * + * @return true on success + */ + +bool magicRunDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicRunInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + const char *state, + const char *workdir, + const char *workdir_state, + const char *label, + const char *dvodb, + psTime* registered +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicRunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicRunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicRunInsertObject( + psDB *dbh, ///< Database handle + magicRunRow *object ///< magicRunRow object +); + +/** Insert an array of magicRunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicRunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicRunRow objects +); + +/** Insert data from a binary FITS table magicRunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool magicRunInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool magicRunSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a magicRunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicRunMetadataFromObject( + const magicRunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicRunRow pointer or NULL on error + */ + +magicRunRow *magicRunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicRunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicRunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an magicRun + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool magicRunDeleteObject( + psDB *dbh, ///< Database handle + const magicRunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicRunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of magicRunRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicRunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicRunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicRunRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicRunPrintObject( + FILE *stream, ///< a stream + magicRunRow *object, ///< an magicRunRow object + bool mdcf ///< format as mdconfig or simple +); +/** magicInputSkyfileRow data structure + * + * Structure for representing a single row of magicInputSkyfile table data. + */ + +typedef struct { + psS64 magic_id; + psS64 diff_id; + psS32 node; +} magicInputSkyfileRow; + +/** Creates a new magicInputSkyfileRow object + * + * @return A new magicInputSkyfileRow object or NULL on failure. + */ + +magicInputSkyfileRow *magicInputSkyfileRowAlloc( + psS64 magic_id, + psS64 diff_id, + psS32 node +); + +/** Creates a new magicInputSkyfile table + * + * @return true on success + */ + +bool magicInputSkyfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicInputSkyfile table + * + * @return true on success + */ + +bool magicInputSkyfileDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicInputSkyfileInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + psS64 diff_id, + psS32 node +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicInputSkyfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicInputSkyfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicInputSkyfileInsertObject( + psDB *dbh, ///< Database handle + magicInputSkyfileRow *object ///< magicInputSkyfileRow object +); + +/** Insert an array of magicInputSkyfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicInputSkyfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicInputSkyfileRow objects +); + +/** Insert data from a binary FITS table magicInputSkyfileRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool magicInputSkyfileInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool magicInputSkyfileSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a magicInputSkyfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicInputSkyfileMetadataFromObject( + const magicInputSkyfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicInputSkyfileRow pointer or NULL on error + */ + +magicInputSkyfileRow *magicInputSkyfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicInputSkyfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicInputSkyfileSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an magicInputSkyfile + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool magicInputSkyfileDeleteObject( + psDB *dbh, ///< Database handle + const magicInputSkyfileRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicInputSkyfileDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of magicInputSkyfileRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicInputSkyfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicInputSkyfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicInputSkyfileRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicInputSkyfilePrintObject( + FILE *stream, ///< a stream + magicInputSkyfileRow *object, ///< an magicInputSkyfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** magicTreeRow data structure + * + * Structure for representing a single row of magicTree table data. + */ + +typedef struct { + psS64 magic_id; + char *node; + char *dep; +} magicTreeRow; + +/** Creates a new magicTreeRow object + * + * @return A new magicTreeRow object or NULL on failure. + */ + +magicTreeRow *magicTreeRowAlloc( + psS64 magic_id, + const char *node, + const char *dep +); + +/** Creates a new magicTree table + * + * @return true on success + */ + +bool magicTreeCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicTree table + * + * @return true on success + */ + +bool magicTreeDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicTreeInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + const char *node, + const char *dep +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicTreeDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicTreeRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicTreeInsertObject( + psDB *dbh, ///< Database handle + magicTreeRow *object ///< magicTreeRow object +); + +/** Insert an array of magicTreeRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicTreeInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicTreeRow objects +); + +/** Insert data from a binary FITS table magicTreeRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool magicTreeInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool magicTreeSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a magicTreeRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicTreeMetadataFromObject( + const magicTreeRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicTreeRow pointer or NULL on error + */ + +magicTreeRow *magicTreeObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicTreeRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicTreeSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an magicTree + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool magicTreeDeleteObject( + psDB *dbh, ///< Database handle + const magicTreeRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicTreeDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of magicTreeRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicTreePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicTreeRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicTreeRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicTreePrintObject( + FILE *stream, ///< a stream + magicTreeRow *object, ///< an magicTreeRow object + bool mdcf ///< format as mdconfig or simple +); +/** magicNodeResultRow data structure + * + * Structure for representing a single row of magicNodeResult table data. + */ + +typedef struct { + psS64 magic_id; + char *node; + char *uri; +} magicNodeResultRow; + +/** Creates a new magicNodeResultRow object + * + * @return A new magicNodeResultRow object or NULL on failure. + */ + +magicNodeResultRow *magicNodeResultRowAlloc( + psS64 magic_id, + const char *node, + const char *uri +); + +/** Creates a new magicNodeResult table + * + * @return true on success + */ + +bool magicNodeResultCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicNodeResult table + * + * @return true on success + */ + +bool magicNodeResultDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicNodeResultInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + const char *node, + const char *uri +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicNodeResultDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicNodeResultRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicNodeResultInsertObject( + psDB *dbh, ///< Database handle + magicNodeResultRow *object ///< magicNodeResultRow object +); + +/** Insert an array of magicNodeResultRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicNodeResultInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicNodeResultRow objects +); + +/** Insert data from a binary FITS table magicNodeResultRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool magicNodeResultInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool magicNodeResultSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a magicNodeResultRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicNodeResultMetadataFromObject( + const magicNodeResultRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicNodeResultRow pointer or NULL on error + */ + +magicNodeResultRow *magicNodeResultObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicNodeResultRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicNodeResultSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an magicNodeResult + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool magicNodeResultDeleteObject( + psDB *dbh, ///< Database handle + const magicNodeResultRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicNodeResultDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of magicNodeResultRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicNodeResultPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicNodeResultRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicNodeResultRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicNodeResultPrintObject( + FILE *stream, ///< a stream + magicNodeResultRow *object, ///< an magicNodeResultRow object + bool mdcf ///< format as mdconfig or simple +); +/** magicMaskRow data structure + * + * Structure for representing a single row of magicMask table data. + */ + +typedef struct { + psS64 magic_id; + char *uri; +} magicMaskRow; + +/** Creates a new magicMaskRow object + * + * @return A new magicMaskRow object or NULL on failure. + */ + +magicMaskRow *magicMaskRowAlloc( + psS64 magic_id, + const char *uri +); + +/** Creates a new magicMask table + * + * @return true on success + */ + +bool magicMaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a magicMask table + * + * @return true on success + */ + +bool magicMaskDropTable( + psDB *dbh ///< Database handle +); + +/** Insert a single row into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicMaskInsert( + psDB *dbh, ///< Database handle + psS64 magic_id, + const char *uri +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicMaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single magicMaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool magicMaskInsertObject( + psDB *dbh, ///< Database handle + magicMaskRow *object ///< magicMaskRow object +); + +/** Insert an array of magicMaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool magicMaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of magicMaskRow objects +); + +/** Insert data from a binary FITS table magicMaskRow into the database + * + * This function expects a psFits object with a FITS table as the first + * extension. The table must have at least one row of data in it, that is of + * the appropriate format (number of columns and their type). All other + * extensions are ignored. + * + * @return true on success + */ + +bool magicMaskInsertFits( + psDB *dbh, ///< Database handle + const psFits *fits ///< psFits object +); + +/** Selects up to limit from the database and returns them in a binary FITS table + * + * This function assumes an empty psFits object and will create a FITS table + * as the first extension. + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return true on success + */ + +bool magicMaskSelectRowsFits( + psDB *dbh, ///< Database handle + psFits *fits, ///< psFits object + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); + +/** Convert a magicMaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *magicMaskMetadataFromObject( + const magicMaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A magicMaskRow pointer or NULL on error + */ + +magicMaskRow *magicMaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as magicMaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *magicMaskSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an magicMask + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +bool magicMaskDeleteObject( + psDB *dbh, ///< Database handle + const magicMaskRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * Note that a 'where' search psMetadata is constructed from each object and + * used to find rows to delete. + * + * @return A The number of rows removed or a negative value on error + */ + +long long magicMaskDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of magicMaskRow objects + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicMaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of magicMaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an magicMaskRow object + * + * When mdcf is set the formated output is in psMetadataConfig + * format, otherwise it is in a simple tabular format. + * + * @return true on success + */ + +bool magicMaskPrintObject( + FILE *stream, ///< a stream + magicMaskRow *object, ///< an magicMaskRow object + bool mdcf ///< format as mdconfig or simple +); + +/// @} + +#ifdef __cplusplus +} +#endif + +#endif // MAGICMASK_DB_H Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/.cvsignore (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/.cvsignore (revision 22077) @@ -0,0 +1,25 @@ +.deps +Makefile +Makefile.in +atconfig +.libs +alloc +cleanup +createtable +dbcleanup +dbsetup +droptable +init +insert +insertfits +insertobject +metadatafromobject +objectfrommetadata +package.m4 +pop +popfits +popobject +selectrowsfits +testsuite +testsuite.dir +testsuite.log Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/Makefile.am (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/Makefile.am (revision 22077) @@ -0,0 +1,64 @@ +# copied from bison-1.875d + +EXTRA_DIST = $(TESTSUITE_AT) testsuite package.m4 + +DISTCLEANFILES = atconfig $(check_SCRIPTS) +MAINTAINERCLEANFILES = Makefile.in $(TESTSUITE) + +## ------------ ## +## package.m4. ## +## ------------ ## + +$(srcdir)/package.m4: $(top_srcdir)/configure.ac + { \ + echo '# Signature of the current package.'; \ + echo 'm4_define([AT_PACKAGE_NAME], [@PACKAGE_NAME@])'; \ + echo 'm4_define([AT_PACKAGE_TARNAME], [@PACKAGE_TARNAME@])'; \ + echo 'm4_define([AT_PACKAGE_VERSION], [@PACKAGE_VERSION@])'; \ + echo 'm4_define([AT_PACKAGE_STRING], [@PACKAGE_STRING@])'; \ + echo 'm4_define([AT_PACKAGE_BUGREPORT], [@PACKAGE_BUGREPORT@])'; \ + } >$(srcdir)/package.m4 + +## ------------ ## +## Test suite. ## +## ------------ ## + +TESTSUITE = $(srcdir)/testsuite + +AUTOTEST = $(AUTOM4TE) --language=autotest +$(TESTSUITE): package.m4 $(TESTSUITE_AT) + $(AUTOTEST) -I $(srcdir) testsuite.at -o $@.tmp + mv $@.tmp $@ + +atconfig: $(top_builddir)/config.status + cd $(top_builddir) && ./config.status tests/$@ + +clean-local: + test ! -f $(TESTSUITE) || $(SHELL) $(TESTSUITE) --clean + +check-local: atconfig $(TESTSUITE) + $(SHELL) $(TESTSUITE) + +# +# END BISON +# + +UNITS = \ + alloc \ + init \ + cleanup \ + createtable \ + droptable \ + insert \ + insertobject \ + insertfits \ + selectrowsfits \ + metadatafromobject \ + objectfrommetadata + +AM_CPPFLAGS = -I$(top_srcdir)/src$ +AM_CFLAGS = @ippdb_CFLAGS@ $(PSLIB_CFLAGS)$ +AM_LDFLAGS = $(PSLIB_LIBS)$ +LDADD = $(top_builddir)/src/libippdb.la$ + +check_PROGRAMS = dbsetup dbcleanup $(UNITS) Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/alloc.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/alloc.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/alloc.c (revision 22077) @@ -0,0 +1,2291 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + summitExpRow *object; + + object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + summitImfileRow *object; + + object = summitImfileRowAlloc("a string", "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->file_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bytes == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + pzPendingExpRow *object; + + object = pzPendingExpRowAlloc("a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + pzPendingImfileRow *object; + + object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + pzDoneExpRow *object; + + object = pzDoneExpRowAlloc("a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + pzDoneImfileRow *object; + + object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + newExpRow *object; + + object = newExpRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + newImfileRow *object; + + object = newImfileRowAlloc(-64, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + rawExpRow *object; + + object = rawExpRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sat_pixel_frac == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->alt == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->az == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + rawImfileRow *object; + + object = rawImfileRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sat_pixel_frac == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->alt == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->az == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + guidePendingExpRow *object; + + object = guidePendingExpRowAlloc(-64, -64, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->guide_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + chipRunRow *object; + + object = chipRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->chip_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->expgroup, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + chipProcessedImfileRow *object; + + object = chipProcessedImfileRowAlloc(-64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->chip_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bias == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bias_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ap_resid == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ap_resid_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm_range == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_stars == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_extended == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_cr == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_astrom == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + chipMaskRow *object; + + object = chipMaskRowAlloc("a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + camRunRow *object; + + object = camRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->cam_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->chip_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->expgroup, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + camProcessedExpRow *object; + + object = camProcessedExpRowAlloc(-64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->cam_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->chip_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->zp_mean == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->zp_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm_range == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_stars == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_extended == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_cr == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_astrom == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + camMaskRow *object; + + object = camMaskRowAlloc("a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + warpRunRow *object; + + object = warpRunRowAlloc(-64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + warpInputExpRow *object; + + object = warpInputExpRowAlloc(-64, -64, true ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->cam_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->magiced == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + warpSkyCellMapRow *object; + + object = warpSkyCellMapRowAlloc(-64, "a string", "a string", -64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->cam_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + warpSkyfileRow *object; + + object = warpSkyfileRowAlloc(-64, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->pixel_fill == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + diffRunRow *object; + + object = diffRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->diff_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + diffInputSkyfileRow *object; + + object = diffInputSkyfileRowAlloc(-64, true, -64, -64, "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->diff_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->template == true) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->stack_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + diffSkyfileRow *object; + + object = diffSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->diff_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + stackRunRow *object; + + object = stackRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->stack_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + stackInputSkyfileRow *object; + + object = stackInputSkyfileRowAlloc(-64, -64 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->stack_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->warp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + stackSumSkyfileRow *object; + + object = stackSumSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->stack_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detRunRow *object; + + object = detRunRowAlloc(-64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->det_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang_min == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang_max == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->parent == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detInputExpRow *object; + + object = detInputExpRowAlloc(-64, -32, -64, true ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->include == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detProcessedImfileRow *object; + + object = detProcessedImfileRowAlloc(-64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detProcessedExpRow *object; + + object = detProcessedExpRowAlloc(-64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detStackedImfileRow *object; + + object = detStackedImfileRowAlloc(-64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detNormalizedStatImfileRow *object; + + object = detNormalizedStatImfileRowAlloc(-64, -32, "a string", 32.32, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->norm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detNormalizedImfileRow *object; + + object = detNormalizedImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detNormalizedExpRow *object; + + object = detNormalizedExpRowAlloc(-64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detResidImfileRow *object; + + object = detResidImfileRowAlloc(-64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_skewness == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_kurtosis == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bin_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detResidExpRow *object; + + object = detResidExpRowAlloc(-64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_skewness == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_kurtosis == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bin_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->accept == true) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detRunSummaryRow *object; + + object = detRunSummaryRowAlloc(-64, -32, 64.64, 64.64, 64.64, true, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->accept == true) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detRegisteredImfileRow *object; + + object = detRegisteredImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fault == -16) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicRunRow *object; + + object = magicRunRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicInputSkyfileRow *object; + + object = magicInputSkyfileRowAlloc(-64, -64, -32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->diff_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->node == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicTreeRow *object; + + object = magicTreeRowAlloc(-64, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->node, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dep, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicNodeResultRow *object; + + object = magicNodeResultRowAlloc(-64, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->node, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + magicMaskRow *object; + + object = magicMaskRowAlloc(-64, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->magic_id == -64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/cleanup.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/cleanup.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/cleanup.c (revision 22077) @@ -0,0 +1,17 @@ +#include +#include +#include + +int main () +{ + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + ippdbCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/createtable.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/createtable.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/createtable.c (revision 22077) @@ -0,0 +1,668 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!summitExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!summitImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!pzPendingExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!pzPendingImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!pzDoneExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!pzDoneImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!newExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!newImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!rawExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!rawImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!guidePendingExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!chipRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!chipProcessedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!chipMaskCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!camRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!camProcessedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!camMaskCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!warpRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!warpInputExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!warpSkyCellMapCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!warpSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!diffRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!diffInputSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!diffSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!stackRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!stackInputSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!stackSumSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detInputExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detProcessedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detProcessedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detStackedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detNormalizedStatImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detNormalizedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detNormalizedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detResidImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detResidExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detRunSummaryCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!detRegisteredImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicRunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicInputSkyfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicTreeCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicNodeResultCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!magicMaskCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbcleanup.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbcleanup.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbcleanup.c (revision 22077) @@ -0,0 +1,61 @@ +#include +#include + +int main () +{ + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test", 0); + if (!dbh) { + exit(EXIT_FAILURE); + } + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS guidePendingExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipProcessedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipMask"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camProcessedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camMask"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpInputExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpSkyCellMap"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffInputSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackInputSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackSumSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detInputExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detProcessedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detProcessedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detStackedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedStatImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRegisteredImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicRun"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicInputSkyfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicTree"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicNodeResult"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicMask"); + + psDBCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbsetup.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbsetup.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/dbsetup.c (revision 22077) @@ -0,0 +1,150 @@ +#include +#include +#include + +int main () +{ + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test", 0); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // remove the table if it already exists + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitExp"); + summitExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS summitImfile"); + summitImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingExp"); + pzPendingExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzPendingImfile"); + pzPendingImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneExp"); + pzDoneExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS pzDoneImfile"); + pzDoneImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newExp"); + newExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS newImfile"); + newImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawExp"); + rawExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS rawImfile"); + rawImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS guidePendingExp"); + guidePendingExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipRun"); + chipRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipProcessedImfile"); + chipProcessedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS chipMask"); + chipMaskCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camRun"); + camRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camProcessedExp"); + camProcessedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS camMask"); + camMaskCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpRun"); + warpRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpInputExp"); + warpInputExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpSkyCellMap"); + warpSkyCellMapCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS warpSkyfile"); + warpSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffRun"); + diffRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffInputSkyfile"); + diffInputSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS diffSkyfile"); + diffSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackRun"); + stackRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackInputSkyfile"); + stackInputSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS stackSumSkyfile"); + stackSumSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRun"); + detRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detInputExp"); + detInputExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detProcessedImfile"); + detProcessedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detProcessedExp"); + detProcessedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detStackedImfile"); + detStackedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedStatImfile"); + detNormalizedStatImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedImfile"); + detNormalizedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detNormalizedExp"); + detNormalizedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidImfile"); + detResidImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detResidExp"); + detResidExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRunSummary"); + detRunSummaryCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS detRegisteredImfile"); + detRegisteredImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicRun"); + magicRunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicInputSkyfile"); + magicInputSkyfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicTree"); + magicTreeCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicNodeResult"); + magicNodeResultCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS magicMask"); + magicMaskCreateTable(dbh); + + psDBCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/droptable.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/droptable.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/droptable.c (revision 22077) @@ -0,0 +1,668 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!summitExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!summitImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzPendingExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzPendingImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzDoneExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzDoneImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!rawExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!rawImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!guidePendingExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipProcessedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipMaskDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camProcessedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camMaskDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpInputExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpSkyCellMapDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffInputSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackInputSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackSumSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detInputExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRunSummaryDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRegisteredImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicRunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicInputSkyfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicTreeDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicNodeResultDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicMaskDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/init.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/init.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/init.c (revision 22077) @@ -0,0 +1,17 @@ +#include +#include +#include + +int main () +{ + psDB *dbh; + + dbh = ippdbInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insert.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insert.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insert.c (revision 22077) @@ -0,0 +1,668 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!summitExpInsert(dbh, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!summitImfileInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzPendingExpInsert(dbh, "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzPendingImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzDoneExpInsert(dbh, "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!pzDoneImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newExpInsert(dbh, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newImfileInsert(dbh, -64, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!rawExpInsert(dbh, -64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!rawImfileInsert(dbh, -64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!guidePendingExpInsert(dbh, -64, -64, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipRunInsert(dbh, -64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipProcessedImfileInsert(dbh, -64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!chipMaskInsert(dbh, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camRunInsert(dbh, -64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camProcessedExpInsert(dbh, -64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!camMaskInsert(dbh, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpRunInsert(dbh, -64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpInputExpInsert(dbh, -64, -64, true)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpSkyCellMapInsert(dbh, -64, "a string", "a string", -64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!warpSkyfileInsert(dbh, -64, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffRunInsert(dbh, -64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffInputSkyfileInsert(dbh, -64, true, -64, -64, "a string", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!diffSkyfileInsert(dbh, -64, "a string", "a string", 64.64, 64.64, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackRunInsert(dbh, -64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackInputSkyfileInsert(dbh, -64, -64)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!stackSumSkyfileInsert(dbh, -64, "a string", "a string", 64.64, 64.64, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRunInsert(dbh, -64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detInputExpInsert(dbh, -64, -32, -64, true)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileInsert(dbh, -64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpInsert(dbh, -64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileInsert(dbh, -64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileInsert(dbh, -64, -32, "a string", 32.32, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedImfileInsert(dbh, -64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpInsert(dbh, -64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileInsert(dbh, -64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidExpInsert(dbh, -64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRunSummaryInsert(dbh, -64, -32, 64.64, 64.64, 64.64, true, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRegisteredImfileInsert(dbh, -64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicRunInsert(dbh, -64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicInputSkyfileInsert(dbh, -64, -64, -32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicTreeInsert(dbh, -64, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicNodeResultInsert(dbh, -64, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!magicMaskInsert(dbh, -64, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertfits.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertfits.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertfits.c (revision 22077) @@ -0,0 +1,1156 @@ +#include +#include +#include +#include +#include + +#define TMP_FILENAME "./blargh" + +int main () +{ + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!summitExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!summitImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzPendingExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzPendingImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzDoneExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzDoneImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!newExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!newImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!rawExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!rawImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!guidePendingExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipProcessedImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipMaskInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camProcessedExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camMaskInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpInputExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpSkyCellMapInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffInputSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackInputSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackSumSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detInputExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detResidExpInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRunSummaryInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRegisteredImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicRunInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicInputSkyfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicTreeInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicNodeResultInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // open a temp + fits = psFitsOpen(TMP_FILENAME, "r"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicMaskInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertobject.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertobject.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/insertobject.c (revision 22077) @@ -0,0 +1,976 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + summitExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!summitExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + summitImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = summitImfileRowAlloc("a string", "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!summitImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + pzPendingExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = pzPendingExpRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!pzPendingExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + pzPendingImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!pzPendingImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + pzDoneExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = pzDoneExpRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!pzDoneExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + pzDoneImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!pzDoneImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + newExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = newExpRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!newExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + newImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = newImfileRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!newImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + rawExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = rawExpRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!rawExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + rawImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = rawImfileRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!rawImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + guidePendingExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = guidePendingExpRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!guidePendingExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + chipRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = chipRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!chipRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + chipProcessedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = chipProcessedImfileRowAlloc(-64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!chipProcessedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + chipMaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = chipMaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!chipMaskInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + camRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = camRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!camRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + camProcessedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = camProcessedExpRowAlloc(-64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!camProcessedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + camMaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = camMaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!camMaskInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + warpRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = warpRunRowAlloc(-64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!warpRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + warpInputExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = warpInputExpRowAlloc(-64, -64, true); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!warpInputExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + warpSkyCellMapRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = warpSkyCellMapRowAlloc(-64, "a string", "a string", -64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!warpSkyCellMapInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + warpSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = warpSkyfileRowAlloc(-64, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!warpSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + diffRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = diffRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!diffRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + diffInputSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = diffInputSkyfileRowAlloc(-64, true, -64, -64, "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!diffInputSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + diffSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = diffSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!diffSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + stackRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = stackRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!stackRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + stackInputSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = stackInputSkyfileRowAlloc(-64, -64); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!stackInputSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + stackSumSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = stackSumSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!stackSumSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detRunRowAlloc(-64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detInputExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detInputExpRowAlloc(-64, -32, -64, true); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detInputExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detProcessedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detProcessedImfileRowAlloc(-64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detProcessedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detProcessedExpRowAlloc(-64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detStackedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detStackedImfileRowAlloc(-64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detNormalizedStatImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detNormalizedStatImfileRowAlloc(-64, -32, "a string", 32.32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detNormalizedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detNormalizedImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detNormalizedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detNormalizedExpRowAlloc(-64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detResidImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detResidImfileRowAlloc(-64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detResidExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detResidExpRowAlloc(-64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detResidExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detRunSummaryRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detRunSummaryRowAlloc(-64, -32, 64.64, 64.64, 64.64, true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detRunSummaryInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + detRegisteredImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = detRegisteredImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!detRegisteredImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicRunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicRunRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicRunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicInputSkyfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicInputSkyfileRowAlloc(-64, -64, -32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicInputSkyfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicTreeRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicTreeRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicTreeInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicNodeResultRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicNodeResultRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicNodeResultInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + magicMaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = magicMaskRowAlloc(-64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!magicMaskInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/metadatafromobject.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/metadatafromobject.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/metadatafromobject.c (revision 22077) @@ -0,0 +1,2573 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + psMetadata *md; + summitExpRow *object; + bool status; + + object = summitExpRowAlloc("a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = summitExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "imfiles") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + summitImfileRow *object; + bool status; + + object = summitImfileRowAlloc("a string", "a string", "a string", "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = summitImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "file_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "bytes") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "md5sum"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + pzPendingExpRow *object; + bool status; + + object = pzPendingExpRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzPendingExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + pzPendingImfileRow *object; + bool status; + + object = pzPendingImfileRowAlloc("a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzPendingImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + pzDoneExpRow *object; + bool status; + + object = pzDoneExpRowAlloc("a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzDoneExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + pzDoneImfileRow *object; + bool status; + + object = pzDoneImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzDoneImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + newExpRow *object; + bool status; + + object = newExpRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = newExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tmp_exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tmp_camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tmp_telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir_state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + newImfileRow *object; + bool status; + + object = newImfileRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = newImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tmp_class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + rawExpRow *object; + bool status; + + object = rawExpRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", 32.32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = rawExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "ra") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "decl") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sat_pixel_frac") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "alt") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "az") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "posang") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "solang") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + rawImfileRow *object; + bool status; + + object = rawImfileRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = rawImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_name"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tmp_class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "airmass") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "ra") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "decl") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "exp_time") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sat_pixel_frac") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "alt") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "az") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ccd_temp") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "posang") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + guidePendingExpRow *object; + bool status; + + object = guidePendingExpRowAlloc(-64, -64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = guidePendingExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + chipRunRow *object; + bool status; + + object = chipRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = chipRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir_state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "expgroup"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + chipProcessedImfileRow *object; + bool status; + + object = chipProcessedImfileRowAlloc(-64, -64, "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = chipProcessedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bias") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bias_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fringe_0") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fringe_1") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fringe_2") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ap_resid") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ap_resid_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_stars") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_extended") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_cr") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + chipMaskRow *object; + bool status; + + object = chipMaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = chipMaskMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + camRunRow *object; + bool status; + + object = camRunRowAlloc(-64, -64, "a string", "a string", "a string", "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = camRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir_state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "expgroup"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + camProcessedExpRow *object; + bool status; + + object = camProcessedExpRowAlloc(-64, -64, "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, -32, -32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = camProcessedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "bg_mean_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sigma_ra") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "sigma_dec") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "zp_mean") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "zp_stdev") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fwhm") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "fwhm_range") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_stars") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_extended") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_cr") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "n_astrom") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + camMaskRow *object; + bool status; + + object = camMaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = camMaskMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + warpRunRow *object; + bool status; + + object = warpRunRowAlloc(-64, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = warpRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + warpInputExpRow *object; + bool status; + + object = warpInputExpRowAlloc(-64, -64, true); + if (!object) { + exit(EXIT_FAILURE); + } + + md = warpInputExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "magiced") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + warpSkyCellMapRow *object; + bool status; + + object = warpSkyCellMapRowAlloc(-64, "a string", "a string", -64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = warpSkyCellMapMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + warpSkyfileRow *object; + bool status; + + object = warpSkyfileRowAlloc(-64, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = warpSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "pixel_fill") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + diffRunRow *object; + bool status; + + object = diffRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = diffRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + diffInputSkyfileRow *object; + bool status; + + object = diffInputSkyfileRowAlloc(-64, true, -64, -64, "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = diffInputSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "template") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "kind"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + diffSkyfileRow *object; + bool status; + + object = diffSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = diffSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + stackRunRow *object; + bool status; + + object = stackRunRowAlloc(-64, "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = stackRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "skycell_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "tess_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + stackInputSkyfileRow *object; + bool status; + + object = stackInputSkyfileRowAlloc(-64, -64); + if (!object) { + exit(EXIT_FAILURE); + } + + md = stackInputSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + stackSumSkyfileRow *object; + bool status; + + object = stackSumSkyfileRowAlloc(-64, "a string", "a string", 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = stackSumSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detRunRow *object; + bool status; + + object = detRunRowAlloc(-64, -32, "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 32.32, 32.32, 32.32, 32.32, 32.32, 64.64, 64.64, "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", "0001-01-01T00:00:00Z", 32.32, 32.32, "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "det_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "mode"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filelevel"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "camera"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "telescope"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "reduction"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "filter"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "airmass_min") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "airmass_max") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "exp_time_min") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "exp_time_max") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ccd_temp_min") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "ccd_temp_max") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "posang_min") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "posang_max") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "solang_min") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "solang_max") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "parent") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detInputExpRow *object; + bool status; + + object = detInputExpRowAlloc(-64, -32, -64, true); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detInputExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "include") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detProcessedImfileRow *object; + bool status; + + object = detProcessedImfileRowAlloc(-64, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detProcessedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detProcessedExpRow *object; + bool status; + + object = detProcessedExpRowAlloc(-64, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detProcessedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detStackedImfileRow *object; + bool status; + + object = detStackedImfileRowAlloc(-64, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detStackedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detNormalizedStatImfileRow *object; + bool status; + + object = detNormalizedStatImfileRowAlloc(-64, -32, "a string", 32.32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedStatImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF32(&status, md, "norm") == 32.32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detNormalizedImfileRow *object; + bool status; + + object = detNormalizedImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detNormalizedExpRow *object; + bool status; + + object = detNormalizedExpRowAlloc(-64, -32, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detResidImfileRow *object; + bool status; + + object = detResidImfileRowAlloc(-64, -32, -64, "a string", "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detResidImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_skewness") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_kurtosis") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detResidExpRow *object; + bool status; + + object = detResidExpRowAlloc(-64, -32, -64, "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detResidExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_skewness") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_kurtosis") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bin_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_0") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "fringe_resid_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "accept") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detRunSummaryRow *object; + bool status; + + object = detRunSummaryRowAlloc(-64, -32, 64.64, 64.64, 64.64, true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detRunSummaryMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupBool(&status, md, "accept") == true) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detRegisteredImfileRow *object; + bool status; + + object = detRegisteredImfileRowAlloc(-64, -32, "a string", "a string", 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detRegisteredImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "class_id"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "bg_mean_stdev") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_1") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_2") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_3") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_4") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "user_5") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "path_base"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicRunRow *object; + bool status; + + object = magicRunRowAlloc(-64, "a string", "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir_state"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dvodb"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicInputSkyfileRow *object; + bool status; + + object = magicInputSkyfileRowAlloc(-64, -64, -32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicInputSkyfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "node") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicTreeRow *object; + bool status; + + object = magicTreeRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicTreeMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "node"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "dep"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicNodeResultRow *object; + bool status; + + object = magicNodeResultRowAlloc(-64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicNodeResultMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "node"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + magicMaskRow *object; + bool status; + + object = magicMaskRowAlloc(-64, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = magicMaskMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/objectfrommetadata.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/objectfrommetadata.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/objectfrommetadata.c (revision 22077) @@ -0,0 +1,4079 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + psMetadata *md; + summitExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = summitExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + summitImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "file_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "bytes", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "md5sum", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = summitImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->file_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bytes == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->md5sum, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + pzPendingExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = pzPendingExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + pzPendingImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = pzPendingImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + pzDoneExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = pzDoneExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + pzDoneImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = pzDoneImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + newExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tmp_exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tmp_camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tmp_telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir_state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "reduction", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = newExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + newImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tmp_class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = newImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + rawExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filelevel", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "reduction", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sat_pixel_frac", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "solang", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = rawExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sat_pixel_frac == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->alt == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->az == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + rawImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_name", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tmp_class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filelevel", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "ra", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "decl", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sat_pixel_frac", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "alt", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "az", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = rawImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_name, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tmp_class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sat_pixel_frac == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->alt == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->az == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + guidePendingExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = guidePendingExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + chipRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir_state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "reduction", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "expgroup", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = chipRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->expgroup, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + chipProcessedImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bias", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bias_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ap_resid", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ap_resid_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm_range", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_stars", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_extended", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_cr", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_astrom", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = chipProcessedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bias == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bias_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ap_resid == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ap_resid_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm_range == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_stars == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_extended == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_cr == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_astrom == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + chipMaskRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = chipMaskObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + camRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir_state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "reduction", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "expgroup", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = camRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->expgroup, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + camProcessedExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_ra", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "sigma_dec", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_mean", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "zp_stdev", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "fwhm_range", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_stars", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_extended", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_cr", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "n_astrom", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = camProcessedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->zp_mean == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->zp_stdev == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fwhm_range == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_stars == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_extended == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_cr == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->n_astrom == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + camMaskRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = camMaskObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + warpRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "mode", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = warpRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + warpInputExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "magiced", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = warpInputExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->magiced == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + warpSkyCellMapRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = warpSkyCellMapObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + warpSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "pixel_fill", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = warpSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->pixel_fill == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + diffRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = diffRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + diffInputSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "template", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "kind", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = diffInputSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->template == true) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->kind, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + diffSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = diffSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + stackRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "skycell_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "tess_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = stackRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->skycell_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->tess_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + stackInputSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = stackInputSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + stackSumSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = stackSumSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "det_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "mode", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filelevel", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "camera", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "telescope", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "reduction", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "filter", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass_min", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "airmass_max", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time_min", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "exp_time_max", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp_min", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "ccd_temp_max", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang_min", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "posang_max", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "solang_min", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "solang_max", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "parent", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = detRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->det_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->mode, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filelevel, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->camera, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->telescope, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_type, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->reduction, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->filter, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->airmass_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->exp_time_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->ccd_temp_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang_min == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->posang_max == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang_min == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->solang_max == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->parent == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detInputExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "include", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = detInputExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->include == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detProcessedImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detProcessedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detProcessedExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detProcessedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detStackedImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detStackedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detNormalizedStatImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF32(md, PS_LIST_TAIL, "norm", 0, NULL, 32.32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detNormalizedStatImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->norm == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detNormalizedImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detNormalizedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detNormalizedExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detNormalizedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detResidImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_skewness", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_kurtosis", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bin_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detResidImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_skewness == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_kurtosis == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bin_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detResidExpRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_skewness", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_kurtosis", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bin_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_0", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "fringe_resid_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detResidExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_skewness == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_kurtosis == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bin_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_0 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->fringe_resid_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->accept == true) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detRunSummaryRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "accept", PS_DATA_BOOL, NULL, true)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detRunSummaryObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->accept == true) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detRegisteredImfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "iteration", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "class_id", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "bg_mean_stdev", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_1", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_2", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_3", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_4", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddF64(md, PS_LIST_TAIL, "user_5", 0, NULL, 64.64)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "path_base", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detRegisteredImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->bg_mean_stdev == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_1 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_2 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_3 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_4 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->user_5 == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->path_base, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicRunRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir_state", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dvodb", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir_state, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dvodb, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicInputSkyfileRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "node", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicInputSkyfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->node == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicTreeRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "node", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "dep", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicTreeObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->node, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->dep, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicNodeResultRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "node", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicNodeResultObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->node, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + magicMaskRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = magicMaskObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/selectrowsfits.c =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/selectrowsfits.c (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/selectrowsfits.c (revision 22077) @@ -0,0 +1,978 @@ +#include +#include +#include + +#define TMP_FILENAME "./blargh" + +int main () +{ + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!summitExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!summitImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzPendingExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzPendingImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzDoneExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!pzDoneImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!newExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!newImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!rawExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!rawImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!guidePendingExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipProcessedImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!chipMaskSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camProcessedExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!camMaskSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpInputExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpSkyCellMapSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!warpSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffInputSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!diffSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackInputSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!stackSumSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detInputExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedStatImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detResidExpSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRunSummarySelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!detRegisteredImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicRunSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicInputSkyfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicTreeSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicNodeResultSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + { + psDB *dbh; + psFits *fits; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + fits = psFitsOpen(TMP_FILENAME, "w"); + if (!fits) { + exit(EXIT_FAILURE); + } + + if (!magicMaskSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-1_1_27/ippdb/tests/testsuite.at =================================================================== --- /tags/ipp-1-X/rel-1_1_27/ippdb/tests/testsuite.at (revision 22077) +++ /tags/ipp-1-X/rel-1_1_27/ippdb/tests/testsuite.at (revision 22077) @@ -0,0 +1,119 @@ +m4_version_prereq([2.59]) + +AT_INIT + +### +AT_SETUP([Alloc()]) +AT_KEYWORDS([Alloc]) + +AT_CHECK([alloc]) + +AT_CLEANUP + +### +AT_SETUP([Init()]) +AT_KEYWORDS([Init]) + +AT_CHECK([init]) + +AT_CLEANUP + +### +AT_SETUP([Cleanup()]) +AT_KEYWORDS([Cleanup]) + +AT_CHECK([cleanup]) + +AT_CLEANUP + +### +AT_SETUP([CreateTable()]) +AT_KEYWORDS([CreateTable]) + +# make sure the table is not there. +AT_CHECK([dbcleanup]) +AT_CHECK([createtable]) +AT_CHECK([dbcleanup]) + +AT_CLEANUP + +### +AT_SETUP([DropTable()]) +AT_KEYWORDS([DropTable]) + +# make sure the table is not there. +AT_CHECK([dbsetup]) +AT_CHECK([droptable]) +AT_CHECK([dbcleanup]) + +AT_CLEANUP + +### +AT_SETUP([Insert()]) +AT_KEYWORDS([Insert]) + +AT_CHECK([dbsetup]) +AT_CHECK([insert]) +AT_CHECK([dbcleanup]) + +AT_CLEANUP + +### +AT_SETUP([InsertObject()]) +AT_KEYWORDS([InsertObject]) + +AT_CHECK([dbsetup]) +AT_CHECK([insertobject]) +AT_CHECK([dbcleanup]) + +AT_CLEANUP + +### +AT_SETUP([InsertFits()]) +AT_KEYWORDS([InsertFits]) + +AT_CHECK([dbsetup]) +# run insert so there is a row in the table +AT_CHECK([insert]) +# run popfis so there is afits file to read +AT_CHECK([selectrowsfits]) +AT_CHECK([insertfits]) +AT_CHECK([dbcleanup]) +if [ test -f "blargh" ] ; then + rm -f "blargh" +fi + +AT_CLEANUP + +### +AT_SETUP([SelectRowsFits()]) +AT_KEYWORDS([SelectRowsFits]) + +AT_CHECK([dbsetup]) +# run insert so there is a row in the table +AT_CHECK([insert]) +AT_CHECK([selectrowsfits]) +AT_CHECK([dbcleanup]) +if [ test -f "blargh" ] ; then + rm -f "blargh" +fi + +AT_CLEANUP + +### +AT_SETUP([MetadataFromObject()]) +AT_KEYWORDS([MetadataFromObject]) + +AT_CHECK([metadatafromobject]) + +AT_CLEANUP + +### +AT_SETUP([ObjectFromMetadata()]) +AT_KEYWORDS([ObjectFromMetadata]) + +AT_CHECK([objectfrommetadata]) + +AT_CLEANUP + +###