Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/.cvsignore (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/.cvsignore (revision 22016) @@ -0,0 +1,2 @@ +ippdb.m4 +ippdb.mdc Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/Makefile =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/Makefile (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/Makefile (revision 22016) @@ -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-0_0_79/dbconfig/config.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/config.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/config.md (revision 22016) @@ -0,0 +1,5 @@ +glueforge METADATA + pkg_name STR ippdb + pkg_namespace STR ippdb + pkg_version STR 0.0.79 +END Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/dimm.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/dimm.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/dimm.md (revision 22016) @@ -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-0_0_79/dbconfig/dome.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/dome.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/dome.md (revision 22016) @@ -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-0_0_79/dbconfig/ipp.m4 =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/ipp.m4 (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/ipp.m4 (revision 22016) @@ -0,0 +1,11 @@ +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(p4.md) Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/p4.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/p4.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/p4.md (revision 22016) @@ -0,0 +1,82 @@ +# $Id: p4.md,v 1.5 2007-01-19 00:11:41 jhoblitt Exp $ + +# define a new p4run for a single skycell +p4Run METADATA + p4_id S32 0 # Primary Key AUTO_INCREMENT + survey_mode STR 64 # Key + state STR 64 # Key + workdir STR 255 + filter STR 64 + skycell_id STR 64 + tess_id STR 64 + ra F64 0.0 + decl F64 0.0 + input_ss STR 64 + output_ss STR 64 +END + +# the list of imfiles in our skycell keyed against phase 3 +p4InputImfile METADATA + p4_id S32 0 # Primary Key + exp_tag STR 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 + +p4WarpedImfile METADATA + p4_id S32 0 # Primary Key + exp_tag STR 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 + uri STR 255 +# bg F64 0.0 +# bg_stdev F64 0.0 +# bg_mean_stdev F64 0.0 + b1_uri STR 255 + b2_uri STR 255 +END + +p4StackedImfile METADATA + p4_id S32 0 # Primary Key +# class is not yet consistently carried through pXtools +# class STR 64 # 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 + b1_uri STR 255 + b2_uri STR 255 +END + +# one diff image per input to the current stack +# XXX how will diff against the static sky be handled? +p4DiffImfile METADATA + p4_id S32 0 # Primary Key + exp_tag STR 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 + uri STR 255 +# bg F64 0.0 +# bg_stdev F64 0.0 +# bg_mean_stdev F64 0.0 + b1_uri STR 255 + b2_uri STR 255 +END + +# output from magic +p4MagicMaskImfile METADATA + p4_id S32 0 # Primary Key + exp_tag STR 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 + uri STR 255 +END Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_absorption.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_absorption.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_absorption.md (revision 22016) @@ -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-0_0_79/dbconfig/skyp_emission.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_emission.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_emission.md (revision 22016) @@ -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-0_0_79/dbconfig/skyp_ir.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_ir.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_ir.md (revision 22016) @@ -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-0_0_79/dbconfig/skyp_transparency.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_transparency.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/skyp_transparency.md (revision 22016) @@ -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-0_0_79/dbconfig/tasks.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/tasks.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/tasks.md (revision 22016) @@ -0,0 +1,403 @@ +# $Id: tasks.md,v 1.114 2007-01-20 00:31:25 jhoblitt Exp $ + +# this table records all exposure ID ever seen from the summit +# exp_id == 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_tags under Mysql 5+ +# +#CREATE FUNCTION genTag (exp_id varchar(64)) RETURNS VARCHAR(64) +#BEGIN +# UPDATE expTagCounter SET counter = LAST_INSERT_ID(counter + 1); +# RETURN CONCAT(exp_id, '.', 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_id 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_id 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_id STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key +END + +pzPendingImfile METADATA + exp_id 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 + exp_tag STR 64 # Unique Key +END + +# list of exposures that have had all of their imfiles downloaded +pzDoneExp METADATA + exp_id STR 64 # Primary Key + camera STR 64 # Primary Key + telescope STR 64 # Primary Key +END + +pzDoneImfile METADATA + exp_id 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 + exp_tag STR 64 # Unique Key + uri STR 255 +END + +newExp METADATA + exp_tag STR 64 # Primary Key + exp_id STR 64 # Key + camera STR 64 # Key + telescope STR 64 # Key + imfiles S32 0 + workdir STR 255 # destination for output files +END + +# class needs to be carried here so it can go into rawImfile and be normalized +# from there +newImfile METADATA + exp_tag STR 64 # Primary Key + class STR 64 # Primary Key + class_id STR 64 # Primary Key + uri STR 255 +END + +# paired with rawImfile +rawExp METADATA + exp_tag STR 64 # Primary Key + exp_id STR 64 # Key + camera STR 64 + telescope STR 64 + dateobs UTC 0001-01-01T00:00:00Z + exp_type STR 64 + imfiles S32 0 + workdir STR 255 # destination for output files + filter STR 64 + airmass F32 0.0 + ra F64 0.0 + decl F64 0.0 + exp_time 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 + object STR 64 + fault S16 0 # NOT NULL +END + +rawImfile METADATA + exp_tag STR 64 # Primary Key + class STR 64 + class_id STR 64 # Primary Key + uri STR 255 + exp_type STR 64 + filter STR 64 + airmass F32 0.0 + ra F64 0.0 + decl F64 0.0 + exp_time 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 + object STR 64 + dateobs UTC 0001-01-01T00:00:00Z + fault S16 0 # NOT NULL +END + +# +# XXX - temporarily (???) stot carrying around class in imfiles after rawImfile +# + +p1PendingExp METADATA + exp_tag STR 64 # Primary Key + recipe STR 64 + p1_version S32 0 +END + +# do we need nclass? +# class is missing + +p2PendingExp METADATA + exp_tag STR 64 # Primary Key + recipe STR 64 + p1_version S32 0 + p2_version S32 0 + label STR 64 # key +END + +# uris in & out ? + +p2PendingImfile METADATA + exp_tag STR 64 # Primary Key + class_id STR 64 # Primary Key + uri STR 255 + recipe STR 64 + p1_version S32 0 + p2_version S32 0 +END + +# nclass & ndone? +# and/or logging imfile done better? + +p2ProcessedExp METADATA + exp_tag STR 64 # Primary Key + p1_version S32 0 + p2_version S32 0 + label STR 64 # key +END + +p2Mask METADATA + label STR 64 # Primary Key +END + +# uris in & out ? +# state? + +p2ProcessedImfile METADATA + exp_tag STR 64 # Primary Key + 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 + b1_uri STR 255 + b2_uri STR 255 + p1_version S32 0 + p2_version S32 0 + fault S16 0 # NOT NULL +END + +# imfiles is not here... is it needed? + +p3PendingExp METADATA + exp_tag STR 64 # Primary Key + p2_version S32 0 + p3_version S32 0 + label STR 64 # key +END + +p3ProcessedExp METADATA + exp_tag 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 + sigma_ra F32 0.0 + sigma_dec F32 0.0 + nastro S32 0 + b1_uri STR 255 + b2_uri STR 255 + zp_mean F32 0.0 + zp_stdev F32 0.0 + p2_version S32 0 + p3_version S32 0 + label STR 64 # key + fault S16 0 # NOT NULL +END + +p3Mask METADATA + label STR 64 # Primary Key +END + +detRun METADATA + det_id S32 0 # Primary Key AUTO_INCREMENT + iteration S32 0 # Key + det_type STR 64 # Key + mode STR 64 # Key + state STR 64 # Key + workdir STR 255 # destination for output files + camera STR 64 + telescope STR 64 + exp_type STR 64 + 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 +END + +detInputExp METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + exp_tag STR 64 # Primary Key + include BOOL f +END + +detProcessedImfile METADATA + det_id S32 0 # Primary Key + exp_tag STR 64 # Primary Key + 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 + b1_uri STR 255 + b2_uri STR 255 + fault S16 0 # NOT NULL +END + +detProcessedExp METADATA + det_id S32 0 # Primary Key + exp_tag STR 64 # Primary Key + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + b1_uri STR 255 + b2_uri STR 255 + fault S16 0 # NOT NULL +END + +detStackedImfile METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + 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 + fault S16 0 # NOT NULL +END + +detNormalizedStatImfile METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + class_id STR 64 # Primary Key + norm F32 0.0 + fault S16 0 # NOT NULL +END + +detNormalizedImfile METADATA + det_id S32 0 # Primary Key + 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 + b1_uri STR 255 + b2_uri STR 255 + fault S16 0 # NOT NULL +END + +detNormalizedExp METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + b1_uri STR 255 + b2_uri STR 255 + fault S16 0 # NOT NULL +END + +#detMasterFrame METADATA +# det_id S32 0 # Primary Key +# iteration S32 0 # Primary Key +# comment STR 255 +#END +# +## drop? +#detMasterImfile METADATA +# det_id S32 0 # Primary Key +# class_id STR 64 # Primary Key +# uri STR 255 +# recipe STR 64 +#END + +detResidImfile METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + exp_tag STR 64 # Primary Key + 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 + b1_uri STR 255 + b2_uri STR 255 + fault S16 0 # NOT NULL +END + +detResidExp METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + exp_tag STR 64 # Primary Key + recipe STR 64 + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + b1_uri STR 255 + b2_uri STR 255 + accept BOOL f + fault S16 0 # NOT NULL +END + +detRunSummary METADATA + det_id S32 0 # Primary Key + iteration S32 0 # Primary Key + bg F64 0.0 + bg_stdev F64 0.0 + bg_mean_stdev F64 0.0 + accept BOOL f + fault S16 0 # NOT NULL +END Index: /tags/ipp-1-X/rel-0_0_79/dbconfig/telescope.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/telescope.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/telescope.md (revision 22016) @@ -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-0_0_79/dbconfig/weather.md =================================================================== --- /tags/ipp-1-X/rel-0_0_79/dbconfig/weather.md (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/dbconfig/weather.md (revision 22016) @@ -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-0_0_79/ippdb/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/.cvsignore (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/.cvsignore (revision 22016) @@ -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-0_0_79/ippdb/COPYING =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/COPYING (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/COPYING (revision 22016) @@ -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-0_0_79/ippdb/Doxyfile.in =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/Doxyfile.in (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/Doxyfile.in (revision 22016) @@ -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-0_0_79/ippdb/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/Makefile.am (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/Makefile.am (revision 22016) @@ -0,0 +1,57 @@ +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/expTagCounterRow.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/p1PendingExpRow.3 \ + $(top_builddir)/docs/man/man3/p2PendingExpRow.3 \ + $(top_builddir)/docs/man/man3/p2PendingImfileRow.3 \ + $(top_builddir)/docs/man/man3/p2ProcessedExpRow.3 \ + $(top_builddir)/docs/man/man3/p2MaskRow.3 \ + $(top_builddir)/docs/man/man3/p2ProcessedImfileRow.3 \ + $(top_builddir)/docs/man/man3/p3PendingExpRow.3 \ + $(top_builddir)/docs/man/man3/p3ProcessedExpRow.3 \ + $(top_builddir)/docs/man/man3/p3MaskRow.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/p4RunRow.3 \ + $(top_builddir)/docs/man/man3/p4InputImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4WarpedImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4StackedImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4DiffImfileRow.3 \ + $(top_builddir)/docs/man/man3/p4MagicMaskImfileRow.3 + + +docs/man/man3/ippdb.3 docs/man/man3/expTagCounterRow.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/p1PendingExpRow.3 docs/man/man3/p2PendingExpRow.3 docs/man/man3/p2PendingImfileRow.3 docs/man/man3/p2ProcessedExpRow.3 docs/man/man3/p2MaskRow.3 docs/man/man3/p2ProcessedImfileRow.3 docs/man/man3/p3PendingExpRow.3 docs/man/man3/p3ProcessedExpRow.3 docs/man/man3/p3MaskRow.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/p4RunRow.3 docs/man/man3/p4InputImfileRow.3 docs/man/man3/p4WarpedImfileRow.3 docs/man/man3/p4StackedImfileRow.3 docs/man/man3/p4DiffImfileRow.3 docs/man/man3/p4MagicMaskImfileRow.3: + $(DOXYGEN) + +endif + +clean-local: + -rm -rf docs Index: /tags/ipp-1-X/rel-0_0_79/ippdb/autogen.sh =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/autogen.sh (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/autogen.sh (revision 22016) @@ -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 +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-0_0_79/ippdb/configure.ac =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/configure.ac (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/configure.ac (revision 22016) @@ -0,0 +1,47 @@ +dnl +dnl This file was generated by glueforge 0.36 +dnl +dnl Do NOT directly edit this file. +dnl + +AC_PREREQ(2.59) + +AC_INIT([ippdb], [0.0.79], [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]) + +IPP_STDOPTS + +AC_LANG(C) +AC_PROG_CC +AC_PROG_INSTALL +AC_PROG_LIBTOOL + +PKG_CHECK_MODULES([PSLIB], [pslib >= 0.9.0]) + +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? +ippdb_CFLAGS="-Wall -Werror -pedantic -std=c99 -fno-strict-aliasing" +AC_SUBST([ippdb_CFLAGS]) + +AC_CONFIG_FILES([ + Makefile + src/Makefile + ippdb.pc + Doxyfile +]) +AC_OUTPUT Index: /tags/ipp-1-X/rel-0_0_79/ippdb/ippdb.pc.in =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/ippdb.pc.in (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/ippdb.pc.in (revision 22016) @@ -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-0_0_79/ippdb/src/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/src/.cvsignore (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/src/.cvsignore (revision 22016) @@ -0,0 +1,6 @@ +.deps +Makefile +Makefile.in +.libs +libippdb.la +libippdb_la-ippdb.lo Index: /tags/ipp-1-X/rel-0_0_79/ippdb/src/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/src/Makefile.am (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/src/Makefile.am (revision 22016) @@ -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-0_0_79/ippdb/src/ippdb.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/src/ippdb.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/src/ippdb.c (revision 22016) @@ -0,0 +1,15817 @@ +/* + * 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 0.36 + * + * Do NOT directly edit this file. + * + */ + +#include +#include + +#include "ippdb.h" + +#define EXPTAGCOUNTER_TABLE_NAME "expTagCounter" +#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 P1PENDINGEXP_TABLE_NAME "p1PendingExp" +#define P2PENDINGEXP_TABLE_NAME "p2PendingExp" +#define P2PENDINGIMFILE_TABLE_NAME "p2PendingImfile" +#define P2PROCESSEDEXP_TABLE_NAME "p2ProcessedExp" +#define P2MASK_TABLE_NAME "p2Mask" +#define P2PROCESSEDIMFILE_TABLE_NAME "p2ProcessedImfile" +#define P3PENDINGEXP_TABLE_NAME "p3PendingExp" +#define P3PROCESSEDEXP_TABLE_NAME "p3ProcessedExp" +#define P3MASK_TABLE_NAME "p3Mask" +#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 P4RUN_TABLE_NAME "p4Run" +#define P4INPUTIMFILE_TABLE_NAME "p4InputImfile" +#define P4WARPEDIMFILE_TABLE_NAME "p4WarpedImfile" +#define P4STACKEDIMFILE_TABLE_NAME "p4StackedImfile" +#define P4DIFFIMFILE_TABLE_NAME "p4DiffImfile" +#define P4MAGICMASKIMFILE_TABLE_NAME "p4MagicMaskImfile" +#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 expTagCounterRowFree(expTagCounterRow *object); + +expTagCounterRow *expTagCounterRowAlloc(psU64 counter) +{ + expTagCounterRow *_object; + + _object = psAlloc(sizeof(expTagCounterRow)); + psMemSetDeallocator(_object, (psFreeFunc)expTagCounterRowFree); + + _object->counter = counter; + + return _object; +} + +static void expTagCounterRowFree(expTagCounterRow *object) +{ +} + +bool expTagCounterCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "counter", PS_DATA_U64, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item counter"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, EXPTAGCOUNTER_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool expTagCounterDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, EXPTAGCOUNTER_TABLE_NAME); +} + +bool expTagCounterInsert(psDB * dbh, psU64 counter) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "counter", PS_DATA_U64, NULL, counter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item counter"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, EXPTAGCOUNTER_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long expTagCounterDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from expTagCounter"); + return count; + + deleted += count; + } + + return deleted; +} +bool expTagCounterInsertObject(psDB *dbh, expTagCounterRow *object) +{ + return expTagCounterInsert(dbh, object->counter); +} + +bool expTagCounterInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!expTagCounterInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool expTagCounterInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named EXPTAGCOUNTER_TABLE_NAME + if (!psFitsMoveExtName(fits, EXPTAGCOUNTER_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", EXPTAGCOUNTER_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, EXPTAGCOUNTER_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool expTagCounterSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, EXPTAGCOUNTER_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *expTagCounterMetadataFromObject(const expTagCounterRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "counter", PS_DATA_U64, NULL, object->counter)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item counter"); + psFree(md); + return false; + } + + + return md; +} + +expTagCounterRow *expTagCounterObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psU64 counter = psMetadataLookupU64(&status, md, "counter"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item counter"); + return false; + } + + return expTagCounterRowAlloc(counter); +} +psArray *expTagCounterSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, EXPTAGCOUNTER_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++) { + expTagCounterRow *object = expTagCounterObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool expTagCounterDeleteObject(psDB *dbh, const expTagCounterRow *object) +{ + psMetadata *where = expTagCounterMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from expTagCounter"); + 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, "expTagCounterRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long expTagCounterDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + expTagCounterRow *object = objects->data[i]; + psMetadata *where = expTagCounterMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, EXPTAGCOUNTER_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from expTagCounter"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool expTagCounterPrintObjects(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 = expTagCounterMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + EXPTAGCOUNTER_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 expTagCounterPrintObject(FILE *stream, expTagCounterRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = expTagCounterMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void summitExpRowFree(summitExpRow *object); + +summitExpRow *summitExpRowAlloc(const char *exp_id, 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_id = psStringCopy(exp_id); + _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_id); + 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_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, 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, "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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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_id, 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_id, 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_id = psStringCopy(exp_id); + _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_id); + 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_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, 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, "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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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_id, 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_id, const char *camera, const char *telescope) +{ + pzPendingExpRow *_object; + + _object = psAlloc(sizeof(pzPendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzPendingExpRowFree); + + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + + return _object; +} + +static void pzPendingExpRowFree(pzPendingExpRow *object) +{ + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); +} + +bool pzPendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, const char *camera, const char *telescope) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, 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, "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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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_id, 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_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag) +{ + pzPendingImfileRow *_object; + + _object = psAlloc(sizeof(pzPendingImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzPendingImfileRowFree); + + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->exp_tag = psStringCopy(exp_tag); + + return _object; +} + +static void pzPendingImfileRowFree(pzPendingImfileRow *object) +{ + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); + psFree(object->class); + psFree(object->class_id); + psFree(object->exp_tag); +} + +bool pzPendingImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "exp_tag", PS_DATA_STRING, "Unique Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + 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_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + 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_id, object->camera, object->telescope, object->class, object->class_id, object->exp_tag); +} + +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_id", PS_DATA_STRING, 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, "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, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + + + return md; +} + +pzPendingImfileRow *pzPendingImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + + return pzPendingImfileRowAlloc(exp_id, camera, telescope, class, class_id, exp_tag); +} +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_id, const char *camera, const char *telescope) +{ + pzDoneExpRow *_object; + + _object = psAlloc(sizeof(pzDoneExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzDoneExpRowFree); + + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + + return _object; +} + +static void pzDoneExpRowFree(pzDoneExpRow *object) +{ + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); +} + +bool pzDoneExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, const char *camera, const char *telescope) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_id, 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_id", PS_DATA_STRING, 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, "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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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_id, 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_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag, const char *uri) +{ + pzDoneImfileRow *_object; + + _object = psAlloc(sizeof(pzDoneImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)pzDoneImfileRowFree); + + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->exp_tag = psStringCopy(exp_tag); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void pzDoneImfileRowFree(pzDoneImfileRow *object) +{ + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); + psFree(object->class); + psFree(object->class_id); + psFree(object->exp_tag); + psFree(object->uri); +} + +bool pzDoneImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "exp_tag", PS_DATA_STRING, "Unique Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + 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_id, const char *camera, const char *telescope, const char *class, const char *class_id, const char *exp_tag, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "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, "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_id, object->camera, object->telescope, object->class, object->class_id, object->exp_tag, 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_id", PS_DATA_STRING, 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, "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, "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, "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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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* 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* uri = psMetadataLookupPtr(&status, md, "uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item uri"); + return false; + } + + return pzDoneImfileRowAlloc(exp_id, camera, telescope, class, class_id, exp_tag, 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(const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psS32 imfiles, const char *workdir) +{ + newExpRow *_object; + + _object = psAlloc(sizeof(newExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)newExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->imfiles = imfiles; + _object->workdir = psStringCopy(workdir); + + return _object; +} + +static void newExpRowFree(newExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); + psFree(object->workdir); +} + +bool newExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "camera", PS_DATA_STRING, "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, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item telescope"); + 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; + } + 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; + } + + 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, const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psS32 imfiles, const char *workdir) +{ + psMetadata *md = psMetadataAlloc(); + 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_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "imfiles", PS_DATA_S32, NULL, imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + 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; + } + + 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_tag, object->exp_id, object->camera, object->telescope, object->imfiles, object->workdir); +} + +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_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_id", PS_DATA_STRING, 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, "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, "imfiles", PS_DATA_S32, NULL, object->imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + 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; + } + + + return md; +} + +newExpRow *newExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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; + } + psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles"); + return false; + } + char* workdir = psMetadataLookupPtr(&status, md, "workdir"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item workdir"); + return false; + } + + return newExpRowAlloc(exp_tag, exp_id, camera, telescope, imfiles, workdir); +} +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(const char *exp_tag, const char *class, const char *class_id, const char *uri) +{ + newImfileRow *_object; + + _object = psAlloc(sizeof(newImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)newImfileRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void newImfileRowFree(newImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class); + psFree(object->class_id); + psFree(object->uri); +} + +bool newImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, NEWIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool newImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, NEWIMFILE_TABLE_NAME); +} + +bool newImfileInsert(psDB * dbh, const char *exp_tag, const char *class, const char *class_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, 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_tag, object->class, object->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_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, "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; +} + +newImfileRow *newImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* 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 newImfileRowAlloc(exp_tag, class, 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(const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles, const char *workdir, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psS16 fault) +{ + rawExpRow *_object; + + _object = psAlloc(sizeof(rawExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)rawExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->exp_id = psStringCopy(exp_id); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->dateobs = psTimeCopy(dateobs); + _object->exp_type = psStringCopy(exp_type); + _object->imfiles = imfiles; + _object->workdir = psStringCopy(workdir); + _object->filter = psStringCopy(filter); + _object->airmass = airmass; + _object->ra = ra; + _object->decl = decl; + _object->exp_time = exp_time; + _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->object = psStringCopy(object); + _object->fault = fault; + + return _object; +} + +static void rawExpRowFree(rawExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->exp_id); + psFree(object->camera); + psFree(object->telescope); + psFree(object->dateobs); + psFree(object->exp_type); + psFree(object->workdir); + psFree(object->filter); + psFree(object->object); +} + +bool rawExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_id", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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_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, "imfiles", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + 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, "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, "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, "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, "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, const char *exp_tag, const char *exp_id, const char *camera, const char *telescope, psTime* dateobs, const char *exp_type, psS32 imfiles, const char *workdir, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + 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_id", PS_DATA_STRING, NULL, exp_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_id"); + 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, "imfiles", PS_DATA_S32, NULL, imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + 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, "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, "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, "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, 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_tag, object->exp_id, object->camera, object->telescope, object->dateobs, object->exp_type, object->imfiles, object->workdir, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, 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_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_id", PS_DATA_STRING, 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, "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, "imfiles", PS_DATA_S32, NULL, object->imfiles)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item imfiles"); + 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, "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, "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, "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; +} + +rawExpRow *rawExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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_id = psMetadataLookupPtr(&status, md, "exp_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_id"); + 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; + } + psS32 imfiles = psMetadataLookupS32(&status, md, "imfiles"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item imfiles"); + 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* 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; + } + 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; + } + 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 rawExpRowAlloc(exp_tag, exp_id, camera, telescope, dateobs, exp_type, imfiles, workdir, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, 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(const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault) +{ + rawImfileRow *_object; + + _object = psAlloc(sizeof(rawImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)rawImfileRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->class = psStringCopy(class); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->exp_type = psStringCopy(exp_type); + _object->filter = psStringCopy(filter); + _object->airmass = airmass; + _object->ra = ra; + _object->decl = decl; + _object->exp_time = exp_time; + _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->object = psStringCopy(object); + _object->dateobs = psTimeCopy(dateobs); + _object->fault = fault; + + return _object; +} + +static void rawImfileRowFree(rawImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class); + psFree(object->class_id); + psFree(object->uri); + psFree(object->exp_type); + psFree(object->filter); + psFree(object->object); + psFree(object->dateobs); +} + +bool rawImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "class", PS_DATA_STRING, NULL, "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; + } + 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, "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, "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, "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, "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, "fault", PS_DATA_S16, "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, const char *exp_tag, const char *class, const char *class_id, const char *uri, const char *exp_type, const char *filter, psF32 airmass, psF64 ra, psF64 decl, psF32 exp_time, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF64 alt, psF64 az, psF32 ccd_temp, psF64 posang, const char *object, psTime* dateobs, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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; + } + 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, "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, "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, "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, "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, "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_tag, object->class, object->class_id, object->uri, object->exp_type, object->filter, object->airmass, object->ra, object->decl, object->exp_time, object->bg, object->bg_stdev, object->bg_mean_stdev, object->alt, object->az, object->ccd_temp, object->posang, object->object, object->dateobs, 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_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, "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; + } + 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, "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, "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, "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, "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, "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; + 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* 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; + } + 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* 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; + } + 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; + } + char* object = psMetadataLookupPtr(&status, md, "object"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item object"); + return false; + } + psTime* dateobs = psMetadataLookupPtr(&status, md, "dateobs"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item dateobs"); + 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_tag, class, class_id, uri, exp_type, filter, airmass, ra, decl, exp_time, bg, bg_stdev, bg_mean_stdev, alt, az, ccd_temp, posang, object, dateobs, 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 p1PendingExpRowFree(p1PendingExpRow *object); + +p1PendingExpRow *p1PendingExpRowAlloc(const char *exp_tag, const char *recipe, psS32 p1_version) +{ + p1PendingExpRow *_object; + + _object = psAlloc(sizeof(p1PendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)p1PendingExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->recipe = psStringCopy(recipe); + _object->p1_version = p1_version; + + return _object; +} + +static void p1PendingExpRowFree(p1PendingExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->recipe); +} + +bool p1PendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "p1_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P1PENDINGEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p1PendingExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P1PENDINGEXP_TABLE_NAME); +} + +bool p1PendingExpInsert(psDB * dbh, const char *exp_tag, const char *recipe, psS32 p1_version) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P1PENDINGEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p1PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool p1PendingExpInsertObject(psDB *dbh, p1PendingExpRow *object) +{ + return p1PendingExpInsert(dbh, object->exp_tag, object->recipe, object->p1_version); +} + +bool p1PendingExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p1PendingExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p1PendingExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P1PENDINGEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, P1PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P1PENDINGEXP_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, P1PENDINGEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p1PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P1PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p1PendingExpMetadataFromObject(const p1PendingExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, object->p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + + + return md; +} + +p1PendingExpRow *p1PendingExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version"); + return false; + } + + return p1PendingExpRowAlloc(exp_tag, recipe, p1_version); +} +psArray *p1PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P1PENDINGEXP_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++) { + p1PendingExpRow *object = p1PendingExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p1PendingExpDeleteObject(psDB *dbh, const p1PendingExpRow *object) +{ + psMetadata *where = p1PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp"); + 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, "p1PendingExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p1PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p1PendingExpRow *object = objects->data[i]; + psMetadata *where = p1PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P1PENDINGEXP_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p1PendingExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p1PendingExpPrintObjects(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 = p1PendingExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P1PENDINGEXP_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 p1PendingExpPrintObject(FILE *stream, p1PendingExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p1PendingExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p2PendingExpRowFree(p2PendingExpRow *object); + +p2PendingExpRow *p2PendingExpRowAlloc(const char *exp_tag, const char *recipe, psS32 p1_version, psS32 p2_version, const char *label) +{ + p2PendingExpRow *_object; + + _object = psAlloc(sizeof(p2PendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)p2PendingExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->recipe = psStringCopy(recipe); + _object->p1_version = p1_version; + _object->p2_version = p2_version; + _object->label = psStringCopy(label); + + return _object; +} + +static void p2PendingExpRowFree(p2PendingExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->recipe); + psFree(object->label); +} + +bool p2PendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "p1_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + bool status = psDBCreateTable(dbh, P2PENDINGEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p2PendingExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P2PENDINGEXP_TABLE_NAME); +} + +bool p2PendingExpInsert(psDB * dbh, const char *exp_tag, const char *recipe, psS32 p1_version, psS32 p2_version, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + bool status = psDBInsertOneRow(dbh, P2PENDINGEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p2PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool p2PendingExpInsertObject(psDB *dbh, p2PendingExpRow *object) +{ + return p2PendingExpInsert(dbh, object->exp_tag, object->recipe, object->p1_version, object->p2_version, object->label); +} + +bool p2PendingExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p2PendingExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p2PendingExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P2PENDINGEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, P2PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PENDINGEXP_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, P2PENDINGEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p2PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P2PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p2PendingExpMetadataFromObject(const p2PendingExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, object->p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + + return md; +} + +p2PendingExpRow *p2PendingExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* recipe = psMetadataLookupPtr(&status, md, "recipe"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item recipe"); + return false; + } + psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version"); + return false; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return p2PendingExpRowAlloc(exp_tag, recipe, p1_version, p2_version, label); +} +psArray *p2PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P2PENDINGEXP_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++) { + p2PendingExpRow *object = p2PendingExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p2PendingExpDeleteObject(psDB *dbh, const p2PendingExpRow *object) +{ + psMetadata *where = p2PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp"); + 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, "p2PendingExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p2PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p2PendingExpRow *object = objects->data[i]; + psMetadata *where = p2PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PENDINGEXP_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p2PendingExpPrintObjects(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 = p2PendingExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P2PENDINGEXP_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 p2PendingExpPrintObject(FILE *stream, p2PendingExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p2PendingExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p2PendingImfileRowFree(p2PendingImfileRow *object); + +p2PendingImfileRow *p2PendingImfileRowAlloc(const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psS32 p1_version, psS32 p2_version) +{ + p2PendingImfileRow *_object; + + _object = psAlloc(sizeof(p2PendingImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p2PendingImfileRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->recipe = psStringCopy(recipe); + _object->p1_version = p1_version; + _object->p2_version = p2_version; + + return _object; +} + +static void p2PendingImfileRowFree(p2PendingImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); +} + +bool p2PendingImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "p1_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P2PENDINGIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p2PendingImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P2PENDINGIMFILE_TABLE_NAME); +} + +bool p2PendingImfileInsert(psDB * dbh, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psS32 p1_version, psS32 p2_version) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P2PENDINGIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p2PendingImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p2PendingImfileInsertObject(psDB *dbh, p2PendingImfileRow *object) +{ + return p2PendingImfileInsert(dbh, object->exp_tag, object->class_id, object->uri, object->recipe, object->p1_version, object->p2_version); +} + +bool p2PendingImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p2PendingImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p2PendingImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P2PENDINGIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P2PENDINGIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PENDINGIMFILE_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, P2PENDINGIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p2PendingImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P2PENDINGIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p2PendingImfileMetadataFromObject(const p2PendingImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "p1_version", PS_DATA_S32, NULL, object->p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + + + return md; +} + +p2PendingImfileRow *p2PendingImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* 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; + } + psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version"); + return false; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + return false; + } + + return p2PendingImfileRowAlloc(exp_tag, class_id, uri, recipe, p1_version, p2_version); +} +psArray *p2PendingImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P2PENDINGIMFILE_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++) { + p2PendingImfileRow *object = p2PendingImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p2PendingImfileDeleteObject(psDB *dbh, const p2PendingImfileRow *object) +{ + psMetadata *where = p2PendingImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile"); + 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, "p2PendingImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p2PendingImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p2PendingImfileRow *object = objects->data[i]; + psMetadata *where = p2PendingImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PENDINGIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2PendingImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p2PendingImfilePrintObjects(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 = p2PendingImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P2PENDINGIMFILE_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 p2PendingImfilePrintObject(FILE *stream, p2PendingImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p2PendingImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p2ProcessedExpRowFree(p2ProcessedExpRow *object); + +p2ProcessedExpRow *p2ProcessedExpRowAlloc(const char *exp_tag, psS32 p1_version, psS32 p2_version, const char *label) +{ + p2ProcessedExpRow *_object; + + _object = psAlloc(sizeof(p2ProcessedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)p2ProcessedExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->p1_version = p1_version; + _object->p2_version = p2_version; + _object->label = psStringCopy(label); + + return _object; +} + +static void p2ProcessedExpRowFree(p2ProcessedExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->label); +} + +bool p2ProcessedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + bool status = psDBCreateTable(dbh, P2PROCESSEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p2ProcessedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P2PROCESSEDEXP_TABLE_NAME); +} + +bool p2ProcessedExpInsert(psDB * dbh, const char *exp_tag, psS32 p1_version, psS32 p2_version, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + 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, "p1_version", PS_DATA_S32, NULL, p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + bool status = psDBInsertOneRow(dbh, P2PROCESSEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p2ProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool p2ProcessedExpInsertObject(psDB *dbh, p2ProcessedExpRow *object) +{ + return p2ProcessedExpInsert(dbh, object->exp_tag, object->p1_version, object->p2_version, object->label); +} + +bool p2ProcessedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p2ProcessedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p2ProcessedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P2PROCESSEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, P2PROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PROCESSEDEXP_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, P2PROCESSEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p2ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P2PROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p2ProcessedExpMetadataFromObject(const p2ProcessedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "p1_version", PS_DATA_S32, NULL, object->p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; + } + + + return md; +} + +p2ProcessedExpRow *p2ProcessedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version"); + return false; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return p2ProcessedExpRowAlloc(exp_tag, p1_version, p2_version, label); +} +psArray *p2ProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P2PROCESSEDEXP_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++) { + p2ProcessedExpRow *object = p2ProcessedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p2ProcessedExpDeleteObject(psDB *dbh, const p2ProcessedExpRow *object) +{ + psMetadata *where = p2ProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp"); + 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, "p2ProcessedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p2ProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p2ProcessedExpRow *object = objects->data[i]; + psMetadata *where = p2ProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PROCESSEDEXP_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p2ProcessedExpPrintObjects(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 = p2ProcessedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P2PROCESSEDEXP_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 p2ProcessedExpPrintObject(FILE *stream, p2ProcessedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p2ProcessedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p2MaskRowFree(p2MaskRow *object); + +p2MaskRow *p2MaskRowAlloc(const char *label) +{ + p2MaskRow *_object; + + _object = psAlloc(sizeof(p2MaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)p2MaskRowFree); + + _object->label = psStringCopy(label); + + return _object; +} + +static void p2MaskRowFree(p2MaskRow *object) +{ + psFree(object->label); +} + +bool p2MaskCreateTable(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, P2MASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p2MaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P2MASK_TABLE_NAME); +} + +bool p2MaskInsert(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, P2MASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p2MaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask"); + return count; + + deleted += count; + } + + return deleted; +} +bool p2MaskInsertObject(psDB *dbh, p2MaskRow *object) +{ + return p2MaskInsert(dbh, object->label); +} + +bool p2MaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p2MaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p2MaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P2MASK_TABLE_NAME + if (!psFitsMoveExtName(fits, P2MASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2MASK_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, P2MASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p2MaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P2MASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P2MASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p2MaskMetadataFromObject(const p2MaskRow *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; +} + +p2MaskRow *p2MaskObjectFromMetadata(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 p2MaskRowAlloc(label); +} +psArray *p2MaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P2MASK_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++) { + p2MaskRow *object = p2MaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p2MaskDeleteObject(psDB *dbh, const p2MaskRow *object) +{ + psMetadata *where = p2MaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask"); + 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, "p2MaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p2MaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p2MaskRow *object = objects->data[i]; + psMetadata *where = p2MaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2MASK_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2Mask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p2MaskPrintObjects(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 = p2MaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P2MASK_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 p2MaskPrintObject(FILE *stream, p2MaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p2MaskMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p2ProcessedImfileRowFree(p2ProcessedImfileRow *object); + +p2ProcessedImfileRow *p2ProcessedImfileRowAlloc(const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS32 p1_version, psS32 p2_version, psS16 fault) +{ + p2ProcessedImfileRow *_object; + + _object = psAlloc(sizeof(p2ProcessedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p2ProcessedImfileRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _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->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->p1_version = p1_version; + _object->p2_version = p2_version; + _object->fault = fault; + + return _object; +} + +static void p2ProcessedImfileRowFree(p2ProcessedImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool p2ProcessedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P2PROCESSEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p2ProcessedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P2PROCESSEDIMFILE_TABLE_NAME); +} + +bool p2ProcessedImfileInsert(psDB * dbh, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS32 p1_version, psS32 p2_version, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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, P2PROCESSEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p2ProcessedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p2ProcessedImfileInsertObject(psDB *dbh, p2ProcessedImfileRow *object) +{ + return p2ProcessedImfileInsert(dbh, object->exp_tag, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, object->p1_version, object->p2_version, object->fault); +} + +bool p2ProcessedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p2ProcessedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p2ProcessedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P2PROCESSEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P2PROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P2PROCESSEDIMFILE_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, P2PROCESSEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p2ProcessedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P2PROCESSEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p2ProcessedImfileMetadataFromObject(const p2ProcessedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p1_version", PS_DATA_S32, NULL, object->p1_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p1_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + 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; +} + +p2ProcessedImfileRow *p2ProcessedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* 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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + return false; + } + psS32 p1_version = psMetadataLookupS32(&status, md, "p1_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p1_version"); + return false; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + 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 p2ProcessedImfileRowAlloc(exp_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, p1_version, p2_version, fault); +} +psArray *p2ProcessedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P2PROCESSEDIMFILE_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++) { + p2ProcessedImfileRow *object = p2ProcessedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p2ProcessedImfileDeleteObject(psDB *dbh, const p2ProcessedImfileRow *object) +{ + psMetadata *where = p2ProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile"); + 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, "p2ProcessedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p2ProcessedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p2ProcessedImfileRow *object = objects->data[i]; + psMetadata *where = p2ProcessedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P2PROCESSEDIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p2ProcessedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p2ProcessedImfilePrintObjects(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 = p2ProcessedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P2PROCESSEDIMFILE_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 p2ProcessedImfilePrintObject(FILE *stream, p2ProcessedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p2ProcessedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p3PendingExpRowFree(p3PendingExpRow *object); + +p3PendingExpRow *p3PendingExpRowAlloc(const char *exp_tag, psS32 p2_version, psS32 p3_version, const char *label) +{ + p3PendingExpRow *_object; + + _object = psAlloc(sizeof(p3PendingExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)p3PendingExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->p2_version = p2_version; + _object->p3_version = p3_version; + _object->label = psStringCopy(label); + + return _object; +} + +static void p3PendingExpRowFree(p3PendingExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->label); +} + +bool p3PendingExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + 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; + } + + bool status = psDBCreateTable(dbh, P3PENDINGEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p3PendingExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P3PENDINGEXP_TABLE_NAME); +} + +bool p3PendingExpInsert(psDB * dbh, const char *exp_tag, psS32 p2_version, psS32 p3_version, const char *label) +{ + psMetadata *md = psMetadataAlloc(); + 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, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P3PENDINGEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p3PendingExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool p3PendingExpInsertObject(psDB *dbh, p3PendingExpRow *object) +{ + return p3PendingExpInsert(dbh, object->exp_tag, object->p2_version, object->p3_version, object->label); +} + +bool p3PendingExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p3PendingExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p3PendingExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P3PENDINGEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, P3PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3PENDINGEXP_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, P3PENDINGEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p3PendingExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P3PENDINGEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p3PendingExpMetadataFromObject(const p3PendingExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "label", PS_DATA_STRING, NULL, object->label)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item label"); + psFree(md); + return false; + } + + + return md; +} + +p3PendingExpRow *p3PendingExpObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + return false; + } + + return p3PendingExpRowAlloc(exp_tag, p2_version, p3_version, label); +} +psArray *p3PendingExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P3PENDINGEXP_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++) { + p3PendingExpRow *object = p3PendingExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p3PendingExpDeleteObject(psDB *dbh, const p3PendingExpRow *object) +{ + psMetadata *where = p3PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp"); + 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, "p3PendingExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p3PendingExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p3PendingExpRow *object = objects->data[i]; + psMetadata *where = p3PendingExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3PENDINGEXP_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3PendingExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p3PendingExpPrintObjects(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 = p3PendingExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P3PENDINGEXP_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 p3PendingExpPrintObject(FILE *stream, p3PendingExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p3PendingExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p3ProcessedExpRowFree(p3ProcessedExpRow *object); + +p3ProcessedExpRow *p3ProcessedExpRowAlloc(const char *exp_tag, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS32 p2_version, psS32 p3_version, const char *label, psS16 fault) +{ + p3ProcessedExpRow *_object; + + _object = psAlloc(sizeof(p3ProcessedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)p3ProcessedExpRowFree); + + _object->exp_tag = psStringCopy(exp_tag); + _object->uri = psStringCopy(uri); + _object->recipe = psStringCopy(recipe); + _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->nastro = nastro; + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->zp_mean = zp_mean; + _object->zp_stdev = zp_stdev; + _object->p2_version = p2_version; + _object->p3_version = p3_version; + _object->label = psStringCopy(label); + _object->fault = fault; + + return _object; +} + +static void p3ProcessedExpRowFree(p3ProcessedExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->uri); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); + psFree(object->label); +} + +bool p3ProcessedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "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, "nastro", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item nastro"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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, "p2_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + 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, "fault", PS_DATA_S16, "NOT NULL", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P3PROCESSEDEXP_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p3ProcessedExpDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P3PROCESSEDEXP_TABLE_NAME); +} + +bool p3ProcessedExpInsert(psDB * dbh, const char *exp_tag, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psF32 sigma_ra, psF32 sigma_dec, psS32 nastro, const char *b1_uri, const char *b2_uri, psF32 zp_mean, psF32 zp_stdev, psS32 p2_version, psS32 p3_version, const char *label, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "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, "nastro", PS_DATA_S32, NULL, nastro)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item nastro"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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, "p2_version", PS_DATA_S32, NULL, p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "fault", PS_DATA_S16, NULL, fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P3PROCESSEDEXP_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p3ProcessedExpDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp"); + return count; + + deleted += count; + } + + return deleted; +} +bool p3ProcessedExpInsertObject(psDB *dbh, p3ProcessedExpRow *object) +{ + return p3ProcessedExpInsert(dbh, object->exp_tag, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->sigma_ra, object->sigma_dec, object->nastro, object->b1_uri, object->b2_uri, object->zp_mean, object->zp_stdev, object->p2_version, object->p3_version, object->label, object->fault); +} + +bool p3ProcessedExpInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p3ProcessedExpInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p3ProcessedExpInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P3PROCESSEDEXP_TABLE_NAME + if (!psFitsMoveExtName(fits, P3PROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3PROCESSEDEXP_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, P3PROCESSEDEXP_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p3ProcessedExpSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P3PROCESSEDEXP_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p3ProcessedExpMetadataFromObject(const p3ProcessedExpRow *object) +{ + psMetadata *md = psMetadataAlloc(); + 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, "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, "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, "nastro", PS_DATA_S32, NULL, object->nastro)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item nastro"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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, "p2_version", PS_DATA_S32, NULL, object->p2_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p2_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "fault", PS_DATA_S16, NULL, object->fault)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item fault"); + psFree(md); + return false; + } + + + return md; +} + +p3ProcessedExpRow *p3ProcessedExpObjectFromMetadata(psMetadata *md) +{ + +bool status = 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* 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; + } + 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; + } + psS32 nastro = psMetadataLookupS32(&status, md, "nastro"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item nastro"); + return false; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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; + } + psS32 p2_version = psMetadataLookupS32(&status, md, "p2_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p2_version"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* label = psMetadataLookupPtr(&status, md, "label"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item label"); + 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 p3ProcessedExpRowAlloc(exp_tag, uri, recipe, bg, bg_stdev, bg_mean_stdev, sigma_ra, sigma_dec, nastro, b1_uri, b2_uri, zp_mean, zp_stdev, p2_version, p3_version, label, fault); +} +psArray *p3ProcessedExpSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P3PROCESSEDEXP_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++) { + p3ProcessedExpRow *object = p3ProcessedExpObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p3ProcessedExpDeleteObject(psDB *dbh, const p3ProcessedExpRow *object) +{ + psMetadata *where = p3ProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp"); + 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, "p3ProcessedExpRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p3ProcessedExpDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p3ProcessedExpRow *object = objects->data[i]; + psMetadata *where = p3ProcessedExpMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3PROCESSEDEXP_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3ProcessedExp"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p3ProcessedExpPrintObjects(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 = p3ProcessedExpMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P3PROCESSEDEXP_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 p3ProcessedExpPrintObject(FILE *stream, p3ProcessedExpRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p3ProcessedExpMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p3MaskRowFree(p3MaskRow *object); + +p3MaskRow *p3MaskRowAlloc(const char *label) +{ + p3MaskRow *_object; + + _object = psAlloc(sizeof(p3MaskRow)); + psMemSetDeallocator(_object, (psFreeFunc)p3MaskRowFree); + + _object->label = psStringCopy(label); + + return _object; +} + +static void p3MaskRowFree(p3MaskRow *object) +{ + psFree(object->label); +} + +bool p3MaskCreateTable(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, P3MASK_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p3MaskDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P3MASK_TABLE_NAME); +} + +bool p3MaskInsert(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, P3MASK_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p3MaskDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask"); + return count; + + deleted += count; + } + + return deleted; +} +bool p3MaskInsertObject(psDB *dbh, p3MaskRow *object) +{ + return p3MaskInsert(dbh, object->label); +} + +bool p3MaskInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p3MaskInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p3MaskInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P3MASK_TABLE_NAME + if (!psFitsMoveExtName(fits, P3MASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P3MASK_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, P3MASK_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p3MaskSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P3MASK_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P3MASK_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p3MaskMetadataFromObject(const p3MaskRow *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; +} + +p3MaskRow *p3MaskObjectFromMetadata(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 p3MaskRowAlloc(label); +} +psArray *p3MaskSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P3MASK_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++) { + p3MaskRow *object = p3MaskObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p3MaskDeleteObject(psDB *dbh, const p3MaskRow *object) +{ + psMetadata *where = p3MaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask"); + 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, "p3MaskRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p3MaskDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p3MaskRow *object = objects->data[i]; + psMetadata *where = p3MaskMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P3MASK_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p3Mask"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p3MaskPrintObjects(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 = p3MaskMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P3MASK_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 p3MaskPrintObject(FILE *stream, p3MaskRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p3MaskMetadataFromObject(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(psS32 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, 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) +{ + 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->workdir = psStringCopy(workdir); + _object->camera = psStringCopy(camera); + _object->telescope = psStringCopy(telescope); + _object->exp_type = psStringCopy(exp_type); + _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); + + return _object; +} + +static void detRunRowFree(detRunRow *object) +{ + psFree(object->det_type); + psFree(object->mode); + psFree(object->state); + psFree(object->workdir); + psFree(object->camera); + psFree(object->telescope); + psFree(object->exp_type); + psFree(object->filter); + psFree(object->registered); + psFree(object->time_begin); + psFree(object->time_end); + psFree(object->use_begin); + psFree(object->use_end); +} + +bool detRunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "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", 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, "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, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_type"); + 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; + } + + 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, psS32 det_id, psS32 iteration, const char *det_type, const char *mode, const char *state, const char *workdir, const char *camera, const char *telescope, const char *exp_type, 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) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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, "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, "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; + } + + 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->workdir, object->camera, object->telescope, object->exp_type, 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); +} + +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_S32, 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, "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, "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; + } + + + return md; +} + +detRunRow *detRunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 det_id = psMetadataLookupS32(&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* 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* 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; + } + + return detRunRowAlloc(det_id, iteration, det_type, mode, state, workdir, camera, telescope, exp_type, 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); +} +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(psS32 det_id, psS32 iteration, const char *exp_tag, bool include) +{ + detInputExpRow *_object; + + _object = psAlloc(sizeof(detInputExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detInputExpRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_tag = psStringCopy(exp_tag); + _object->include = include; + + return _object; +} + +static void detInputExpRowFree(detInputExpRow *object) +{ + psFree(object->exp_tag); +} + +bool detInputExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 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, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "include", PS_DATA_BOOL, NULL, 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, psS32 det_id, psS32 iteration, const char *exp_tag, bool include) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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_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, "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_tag, 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_S32, 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_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, "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; + psS32 det_id = psMetadataLookupS32(&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* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + 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_tag, 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(psS32 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + detProcessedImfileRow *_object; + + _object = psAlloc(sizeof(detProcessedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detProcessedImfileRowFree); + + _object->det_id = det_id; + _object->exp_tag = psStringCopy(exp_tag); + _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->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->fault = fault; + + return _object; +} + +static void detProcessedImfileRowFree(detProcessedImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detProcessedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "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, psS32 det_id, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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_tag, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, 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_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + 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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, 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(psS32 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + detProcessedExpRow *_object; + + _object = psAlloc(sizeof(detProcessedExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detProcessedExpRowFree); + + _object->det_id = det_id; + _object->exp_tag = psStringCopy(exp_tag); + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->fault = fault; + + return _object; +} + +static void detProcessedExpRowFree(detProcessedExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detProcessedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item det_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "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, psS32 det_id, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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_tag, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, 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_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&status, md, "det_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item det_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + 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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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_tag, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, 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(psS32 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, 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->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_S32, "Primary Key", 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, "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, "fault", PS_DATA_S16, "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, psS32 det_id, psS32 iteration, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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, "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->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_S32, 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, "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; + psS32 det_id = psMetadataLookupS32(&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; + } + 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, 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(psS32 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_S32, "Primary Key", 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, "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, "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, psS32 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_S32, 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_S32, 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; + psS32 det_id = psMetadataLookupS32(&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(psS32 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, 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->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->fault = fault; + + return _object; +} + +static void detNormalizedImfileRowFree(detNormalizedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detNormalizedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "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, psS32 det_id, psS32 iteration, const char *class_id, const char *uri, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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->b1_uri, object->b2_uri, 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_S32, 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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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, b1_uri, b2_uri, 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(psS32 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, 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->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->fault = fault; + + return _object; +} + +static void detNormalizedExpRowFree(detNormalizedExpRow *object) +{ + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detNormalizedExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 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, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "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, psS32 det_id, psS32 iteration, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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->b1_uri, object->b2_uri, 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_S32, 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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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, b1_uri, b2_uri, 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(psS32 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + detResidImfileRow *_object; + + _object = psAlloc(sizeof(detResidImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)detResidImfileRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_tag = psStringCopy(exp_tag); + _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->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->fault = fault; + + return _object; +} + +static void detResidImfileRowFree(detResidImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detResidImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 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, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "fault", PS_DATA_S16, "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, psS32 det_id, psS32 iteration, const char *exp_tag, const char *class_id, const char *uri, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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_tag, object->class_id, object->uri, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, 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_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&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* 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* 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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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_tag, class_id, uri, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, 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(psS32 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, bool accept, psS16 fault) +{ + detResidExpRow *_object; + + _object = psAlloc(sizeof(detResidExpRow)); + psMemSetDeallocator(_object, (psFreeFunc)detResidExpRowFree); + + _object->det_id = det_id; + _object->iteration = iteration; + _object->exp_tag = psStringCopy(exp_tag); + _object->recipe = psStringCopy(recipe); + _object->bg = bg; + _object->bg_stdev = bg_stdev; + _object->bg_mean_stdev = bg_mean_stdev; + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + _object->accept = accept; + _object->fault = fault; + + return _object; +} + +static void detResidExpRowFree(detResidExpRow *object) +{ + psFree(object->exp_tag); + psFree(object->recipe); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool detResidExpCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, "Primary Key", 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, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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, "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, psS32 det_id, psS32 iteration, const char *exp_tag, const char *recipe, psF64 bg, psF64 bg_stdev, psF64 bg_mean_stdev, const char *b1_uri, const char *b2_uri, bool accept, psS16 fault) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "det_id", PS_DATA_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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_tag, object->recipe, object->bg, object->bg_stdev, object->bg_mean_stdev, object->b1_uri, object->b2_uri, 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_S32, 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_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, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + 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; + psS32 det_id = psMetadataLookupS32(&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* 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* 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; + } + char* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + 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_tag, recipe, bg, bg_stdev, bg_mean_stdev, b1_uri, b2_uri, 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(psS32 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_S32, "Primary Key", 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, "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, "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, psS32 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_S32, 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_S32, 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; + psS32 det_id = psMetadataLookupS32(&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 p4RunRowFree(p4RunRow *object); + +p4RunRow *p4RunRowAlloc(psS32 p4_id, const char *survey_mode, const char *state, const char *workdir, const char *filter, const char *skycell_id, const char *tess_id, psF64 ra, psF64 decl, const char *input_ss, const char *output_ss) +{ + p4RunRow *_object; + + _object = psAlloc(sizeof(p4RunRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4RunRowFree); + + _object->p4_id = p4_id; + _object->survey_mode = psStringCopy(survey_mode); + _object->state = psStringCopy(state); + _object->workdir = psStringCopy(workdir); + _object->filter = psStringCopy(filter); + _object->skycell_id = psStringCopy(skycell_id); + _object->tess_id = psStringCopy(tess_id); + _object->ra = ra; + _object->decl = decl; + _object->input_ss = psStringCopy(input_ss); + _object->output_ss = psStringCopy(output_ss); + + return _object; +} + +static void p4RunRowFree(p4RunRow *object) +{ + psFree(object->survey_mode); + psFree(object->state); + psFree(object->workdir); + psFree(object->filter); + psFree(object->skycell_id); + psFree(object->tess_id); + psFree(object->input_ss); + psFree(object->output_ss); +} + +bool p4RunCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key AUTO_INCREMENT", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, "Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item survey_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, "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, "skycell_id", PS_DATA_STRING, NULL, "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, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item tess_id"); + 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, "input_ss", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P4RUN_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4RunDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4RUN_TABLE_NAME); +} + +bool p4RunInsert(psDB * dbh, psS32 p4_id, const char *survey_mode, const char *state, const char *workdir, const char *filter, const char *skycell_id, const char *tess_id, psF64 ra, psF64 decl, const char *input_ss, const char *output_ss) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, NULL, survey_mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item survey_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, "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, "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, "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, "input_ss", PS_DATA_STRING, NULL, input_ss)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, output_ss)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P4RUN_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4RunDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4RunInsertObject(psDB *dbh, p4RunRow *object) +{ + return p4RunInsert(dbh, object->p4_id, object->survey_mode, object->state, object->workdir, object->filter, object->skycell_id, object->tess_id, object->ra, object->decl, object->input_ss, object->output_ss); +} + +bool p4RunInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4RunInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4RunInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4RUN_TABLE_NAME + if (!psFitsMoveExtName(fits, P4RUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4RUN_TABLE_NAME); + return false; + } + + // 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, P4RUN_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4RunSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4RUN_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4RUN_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4RunMetadataFromObject(const p4RunRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "survey_mode", PS_DATA_STRING, NULL, object->survey_mode)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item survey_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, "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, "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, "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, "input_ss", PS_DATA_STRING, NULL, object->input_ss)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item input_ss"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "output_ss", PS_DATA_STRING, NULL, object->output_ss)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item output_ss"); + psFree(md); + return false; + } + + + return md; +} + +p4RunRow *p4RunObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* survey_mode = psMetadataLookupPtr(&status, md, "survey_mode"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item survey_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* filter = psMetadataLookupPtr(&status, md, "filter"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item filter"); + 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; + } + 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; + } + char* input_ss = psMetadataLookupPtr(&status, md, "input_ss"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item input_ss"); + return false; + } + char* output_ss = psMetadataLookupPtr(&status, md, "output_ss"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item output_ss"); + return false; + } + + return p4RunRowAlloc(p4_id, survey_mode, state, workdir, filter, skycell_id, tess_id, ra, decl, input_ss, output_ss); +} +psArray *p4RunSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4RUN_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++) { + p4RunRow *object = p4RunObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4RunDeleteObject(psDB *dbh, const p4RunRow *object) +{ + psMetadata *where = p4RunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run"); + 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, "p4RunRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4RunDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4RunRow *object = objects->data[i]; + psMetadata *where = p4RunMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4RUN_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4Run"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4RunPrintObjects(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 = p4RunMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4RUN_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 p4RunPrintObject(FILE *stream, p4RunRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4RunMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p4InputImfileRowFree(p4InputImfileRow *object); + +p4InputImfileRow *p4InputImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id) +{ + p4InputImfileRow *_object; + + _object = psAlloc(sizeof(p4InputImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4InputImfileRowFree); + + _object->p4_id = p4_id; + _object->exp_tag = psStringCopy(exp_tag); + _object->p3_version = p3_version; + _object->class_id = psStringCopy(class_id); + + return _object; +} + +static void p4InputImfileRowFree(p4InputImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); +} + +bool p4InputImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, P4INPUTIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4InputImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4INPUTIMFILE_TABLE_NAME); +} + +bool p4InputImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, P4INPUTIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4InputImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4InputImfileInsertObject(psDB *dbh, p4InputImfileRow *object) +{ + return p4InputImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id); +} + +bool p4InputImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4InputImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4InputImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4INPUTIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4INPUTIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4INPUTIMFILE_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, P4INPUTIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4InputImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4INPUTIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4InputImfileMetadataFromObject(const p4InputImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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; +} + +p4InputImfileRow *p4InputImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* 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 p4InputImfileRowAlloc(p4_id, exp_tag, p3_version, class_id); +} +psArray *p4InputImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4INPUTIMFILE_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++) { + p4InputImfileRow *object = p4InputImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4InputImfileDeleteObject(psDB *dbh, const p4InputImfileRow *object) +{ + psMetadata *where = p4InputImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile"); + 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, "p4InputImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4InputImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4InputImfileRow *object = objects->data[i]; + psMetadata *where = p4InputImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4INPUTIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4InputImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4InputImfilePrintObjects(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 = p4InputImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4INPUTIMFILE_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 p4InputImfilePrintObject(FILE *stream, p4InputImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4InputImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p4WarpedImfileRowFree(p4WarpedImfileRow *object); + +p4WarpedImfileRow *p4WarpedImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + p4WarpedImfileRow *_object; + + _object = psAlloc(sizeof(p4WarpedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4WarpedImfileRowFree); + + _object->p4_id = p4_id; + _object->exp_tag = psStringCopy(exp_tag); + _object->p3_version = p3_version; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + + return _object; +} + +static void p4WarpedImfileRowFree(p4WarpedImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool p4WarpedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P4WARPEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4WarpedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4WARPEDIMFILE_TABLE_NAME); +} + +bool p4WarpedImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P4WARPEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4WarpedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4WarpedImfileInsertObject(psDB *dbh, p4WarpedImfileRow *object) +{ + return p4WarpedImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri); +} + +bool p4WarpedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4WarpedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4WarpedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4WARPEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4WARPEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4WARPEDIMFILE_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, P4WARPEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4WarpedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4WARPEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4WarpedImfileMetadataFromObject(const p4WarpedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + + return md; +} + +p4WarpedImfileRow *p4WarpedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* 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* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + return false; + } + + return p4WarpedImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri); +} +psArray *p4WarpedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4WARPEDIMFILE_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++) { + p4WarpedImfileRow *object = p4WarpedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4WarpedImfileDeleteObject(psDB *dbh, const p4WarpedImfileRow *object) +{ + psMetadata *where = p4WarpedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile"); + 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, "p4WarpedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4WarpedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4WarpedImfileRow *object = objects->data[i]; + psMetadata *where = p4WarpedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4WARPEDIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4WarpedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4WarpedImfilePrintObjects(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 = p4WarpedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4WARPEDIMFILE_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 p4WarpedImfilePrintObject(FILE *stream, p4WarpedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4WarpedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p4StackedImfileRowFree(p4StackedImfileRow *object); + +p4StackedImfileRow *p4StackedImfileRowAlloc(psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + p4StackedImfileRow *_object; + + _object = psAlloc(sizeof(p4StackedImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4StackedImfileRowFree); + + _object->p4_id = p4_id; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + + return _object; +} + +static void p4StackedImfileRowFree(p4StackedImfileRow *object) +{ + psFree(object->class_id); + psFree(object->uri); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool p4StackedImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P4STACKEDIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4StackedImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4STACKEDIMFILE_TABLE_NAME); +} + +bool p4StackedImfileInsert(psDB * dbh, psS32 p4_id, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P4STACKEDIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4StackedImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4StackedImfileInsertObject(psDB *dbh, p4StackedImfileRow *object) +{ + return p4StackedImfileInsert(dbh, object->p4_id, object->class_id, object->uri, object->b1_uri, object->b2_uri); +} + +bool p4StackedImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4StackedImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4StackedImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4STACKEDIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4STACKEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4STACKEDIMFILE_TABLE_NAME); + return false; + } + + // 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, P4STACKEDIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4StackedImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4STACKEDIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4StackedImfileMetadataFromObject(const p4StackedImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + + return md; +} + +p4StackedImfileRow *p4StackedImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_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* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + return false; + } + + return p4StackedImfileRowAlloc(p4_id, class_id, uri, b1_uri, b2_uri); +} +psArray *p4StackedImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4STACKEDIMFILE_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++) { + p4StackedImfileRow *object = p4StackedImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4StackedImfileDeleteObject(psDB *dbh, const p4StackedImfileRow *object) +{ + psMetadata *where = p4StackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); + 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, "p4StackedImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4StackedImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4StackedImfileRow *object = objects->data[i]; + psMetadata *where = p4StackedImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4STACKEDIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4StackedImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4StackedImfilePrintObjects(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 = p4StackedImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4STACKEDIMFILE_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 p4StackedImfilePrintObject(FILE *stream, p4StackedImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4StackedImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p4DiffImfileRowFree(p4DiffImfileRow *object); + +p4DiffImfileRow *p4DiffImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + p4DiffImfileRow *_object; + + _object = psAlloc(sizeof(p4DiffImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4DiffImfileRowFree); + + _object->p4_id = p4_id; + _object->exp_tag = psStringCopy(exp_tag); + _object->p3_version = p3_version; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + _object->b1_uri = psStringCopy(b1_uri); + _object->b2_uri = psStringCopy(b2_uri); + + return _object; +} + +static void p4DiffImfileRowFree(p4DiffImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); + psFree(object->b1_uri); + psFree(object->b2_uri); +} + +bool p4DiffImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, "255")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBCreateTable(dbh, P4DIFFIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4DiffImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4DIFFIMFILE_TABLE_NAME); +} + +bool p4DiffImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri, const char *b1_uri, const char *b2_uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + bool status = psDBInsertOneRow(dbh, P4DIFFIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4DiffImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4DiffImfileInsertObject(psDB *dbh, p4DiffImfileRow *object) +{ + return p4DiffImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri, object->b1_uri, object->b2_uri); +} + +bool p4DiffImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4DiffImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4DiffImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4DIFFIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4DIFFIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4DIFFIMFILE_TABLE_NAME); + return false; + } + + // 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, P4DIFFIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4DiffImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4DIFFIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4DiffImfileMetadataFromObject(const p4DiffImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, "b1_uri", PS_DATA_STRING, NULL, object->b1_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b1_uri"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "b2_uri", PS_DATA_STRING, NULL, object->b2_uri)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item b2_uri"); + psFree(md); + return false; + } + + + return md; +} + +p4DiffImfileRow *p4DiffImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* 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* b1_uri = psMetadataLookupPtr(&status, md, "b1_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b1_uri"); + return false; + } + char* b2_uri = psMetadataLookupPtr(&status, md, "b2_uri"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item b2_uri"); + return false; + } + + return p4DiffImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri, b1_uri, b2_uri); +} +psArray *p4DiffImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4DIFFIMFILE_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++) { + p4DiffImfileRow *object = p4DiffImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4DiffImfileDeleteObject(psDB *dbh, const p4DiffImfileRow *object) +{ + psMetadata *where = p4DiffImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); + 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, "p4DiffImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4DiffImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4DiffImfileRow *object = objects->data[i]; + psMetadata *where = p4DiffImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4DIFFIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4DiffImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4DiffImfilePrintObjects(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 = p4DiffImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4DIFFIMFILE_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 p4DiffImfilePrintObject(FILE *stream, p4DiffImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4DiffImfileMetadataFromObject(object); + + if (!ippdbPrintMetadataRaw(stream, md, mdcf)) { + psError(PS_ERR_UNKNOWN, false, "failed to print metadata"); + psFree(md); + } + + psFree(md); + + return true; +} +static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object); + +p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc(psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) +{ + p4MagicMaskImfileRow *_object; + + _object = psAlloc(sizeof(p4MagicMaskImfileRow)); + psMemSetDeallocator(_object, (psFreeFunc)p4MagicMaskImfileRowFree); + + _object->p4_id = p4_id; + _object->exp_tag = psStringCopy(exp_tag); + _object->p3_version = p3_version; + _object->class_id = psStringCopy(class_id); + _object->uri = psStringCopy(uri); + + return _object; +} + +static void p4MagicMaskImfileRowFree(p4MagicMaskImfileRow *object) +{ + psFree(object->exp_tag); + psFree(object->class_id); + psFree(object->uri); +} + +bool p4MagicMaskImfileCreateTable(psDB *dbh) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, "Primary Key", "64")) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, "Primary Key", 0)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, P4MAGICMASKIMFILE_TABLE_NAME, md); + + psFree(md); + + return status; +} + +bool p4MagicMaskImfileDropTable(psDB *dbh) +{ + return psDBDropTable(dbh, P4MAGICMASKIMFILE_TABLE_NAME); +} + +bool p4MagicMaskImfileInsert(psDB * dbh, psS32 p4_id, const char *exp_tag, psS32 p3_version, const char *class_id, const char *uri) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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, P4MAGICMASKIMFILE_TABLE_NAME, md); + psFree(md); + + return status; +} + +long long p4MagicMaskImfileDelete(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + long long deleted = 0; + + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); + return count; + + deleted += count; + } + + return deleted; +} +bool p4MagicMaskImfileInsertObject(psDB *dbh, p4MagicMaskImfileRow *object) +{ + return p4MagicMaskImfileInsert(dbh, object->p4_id, object->exp_tag, object->p3_version, object->class_id, object->uri); +} + +bool p4MagicMaskImfileInsertObjects(psDB *dbh, psArray *objects) +{ + for (long i = 0; i < psArrayLength(objects); i++) { + if (!p4MagicMaskImfileInsertObject(dbh, objects->data[i])) { + return false; + } + } + + return true; +} + +bool p4MagicMaskImfileInsertFits(psDB *dbh, const psFits *fits) +{ + psArray *rowSet; + + // move to (the first?) extension named P4MAGICMASKIMFILE_TABLE_NAME + if (!psFitsMoveExtName(fits, P4MAGICMASKIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, true, "failed to find FITS extension %s", P4MAGICMASKIMFILE_TABLE_NAME); + return false; + } + + // 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, P4MAGICMASKIMFILE_TABLE_NAME, rowSet)) { + psError(PS_ERR_UNKNOWN, false, "databse insert failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +bool p4MagicMaskImfileSelectRowsFits(psDB *dbh, psFits *fits, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + + rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); + if (!rowSet) { + return false; + } + + // output to fits + if (!psFitsWriteTable(fits, NULL, rowSet, P4MAGICMASKIMFILE_TABLE_NAME)) { + psError(PS_ERR_UNKNOWN, false, "FITS table write failed"); + psFree(rowSet); + return false; + } + + psFree(rowSet); + + return true; +} + +psMetadata *p4MagicMaskImfileMetadataFromObject(const p4MagicMaskImfileRow *object) +{ + psMetadata *md = psMetadataAlloc(); + if (!psMetadataAdd(md, PS_LIST_TAIL, "p4_id", PS_DATA_S32, NULL, object->p4_id)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p4_id"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "exp_tag", PS_DATA_STRING, NULL, object->exp_tag)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item exp_tag"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "p3_version", PS_DATA_S32, NULL, object->p3_version)) { + psError(PS_ERR_UNKNOWN, false, "failed to add item p3_version"); + psFree(md); + return false; + } + if (!psMetadataAdd(md, PS_LIST_TAIL, "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; +} + +p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata(psMetadata *md) +{ + +bool status = false; + psS32 p4_id = psMetadataLookupS32(&status, md, "p4_id"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p4_id"); + return false; + } + char* exp_tag = psMetadataLookupPtr(&status, md, "exp_tag"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item exp_tag"); + return false; + } + psS32 p3_version = psMetadataLookupS32(&status, md, "p3_version"); + if (!status) { + psError(PS_ERR_UNKNOWN, true, "failed to lookup value for item p3_version"); + return false; + } + char* 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 p4MagicMaskImfileRowAlloc(p4_id, exp_tag, p3_version, class_id, uri); +} +psArray *p4MagicMaskImfileSelectRowObjects(psDB *dbh, const psMetadata *where, unsigned long long limit) +{ + psArray *rowSet; + psArray *returnSet; + psU64 i; + + rowSet = psDBSelectRows(dbh, P4MAGICMASKIMFILE_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++) { + p4MagicMaskImfileRow *object = p4MagicMaskImfileObjectFromMetadata(rowSet->data[i]); + psArrayAdd(returnSet, 0, object); + psFree(object); + } + + psFree(rowSet); + + return returnSet; +} +bool p4MagicMaskImfileDeleteObject(psDB *dbh, const p4MagicMaskImfileRow *object) +{ + psMetadata *where = p4MagicMaskImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, 0); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); + 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, "p4MagicMaskImfileRow object matched more then one row. Check your database schema"); + return false; + } + + return true; +} +long long p4MagicMaskImfileDeleteRowObjects(psDB *dbh, const psArray *objects, unsigned long long limit) +{ + long long deleted = 0; + + for (long long i = 0; i < objects->n; i++) { + p4MagicMaskImfileRow *object = objects->data[i]; + psMetadata *where = p4MagicMaskImfileMetadataFromObject(object); + long long count = psDBDeleteRows(dbh, P4MAGICMASKIMFILE_TABLE_NAME, where, limit); + psFree(where) + if (count < 0) { + psError(PS_ERR_UNKNOWN, true, "failed to delete row from p4MagicMaskImfile"); + return count; + } + + deleted += count; + } + + return deleted; +} +bool p4MagicMaskImfilePrintObjects(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 = p4MagicMaskImfileMetadataFromObject(objects->data[i]); + if (!psMetadataAddMetadata( + output, + PS_LIST_TAIL, + P4MAGICMASKIMFILE_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 p4MagicMaskImfilePrintObject(FILE *stream, p4MagicMaskImfileRow *object, bool mdcf) +{ + PS_ASSERT_PTR_NON_NULL(object, false); + + psMetadata *md = p4MagicMaskImfileMetadataFromObject(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-0_0_79/ippdb/src/ippdb.h =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/src/ippdb.h (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/src/ippdb.h (revision 22016) @@ -0,0 +1,8108 @@ +/* + * 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 0.36 + * + * 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 +); + +/** expTagCounterRow data structure + * + * Structure for representing a single row of expTagCounter table data. + */ + +typedef struct { + psU64 counter; +} expTagCounterRow; + +/** Creates a new expTagCounterRow object + * + * @return A new expTagCounterRow object or NULL on failure. + */ + +expTagCounterRow *expTagCounterRowAlloc( + psU64 counter +); + +/** Creates a new expTagCounter table + * + * @return true on success + */ + +bool expTagCounterCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a expTagCounter table + * + * @return true on success + */ + +bool expTagCounterDropTable( + 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 expTagCounterInsert( + psDB *dbh, ///< Database handle + psU64 counter +); + +/** 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 expTagCounterDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single expTagCounterRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool expTagCounterInsertObject( + psDB *dbh, ///< Database handle + expTagCounterRow *object ///< expTagCounterRow object +); + +/** Insert an array of expTagCounterRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool expTagCounterInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of expTagCounterRow objects +); + +/** Insert data from a binary FITS table expTagCounterRow 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 expTagCounterInsertFits( + 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 expTagCounterSelectRowsFits( + 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 expTagCounterRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *expTagCounterMetadataFromObject( + const expTagCounterRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A expTagCounterRow pointer or NULL on error + */ + +expTagCounterRow *expTagCounterObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as expTagCounterRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *expTagCounterSelectRowObjects( + 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 expTagCounter + * + * 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 expTagCounterDeleteObject( + psDB *dbh, ///< Database handle + const expTagCounterRow *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 expTagCounterDeleteRowObjects( + 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 expTagCounterRow 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 expTagCounterPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of expTagCounterRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an expTagCounterRow 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 expTagCounterPrintObject( + FILE *stream, ///< a stream + expTagCounterRow *object, ///< an expTagCounterRow object + bool mdcf ///< format as mdconfig or simple +); +/** summitExpRow data structure + * + * Structure for representing a single row of summitExp table data. + */ + +typedef struct { + char *exp_id; + 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_id, + 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_id, + 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_id; + 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_id, + 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_id, + 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_id; + char *camera; + char *telescope; +} pzPendingExpRow; + +/** Creates a new pzPendingExpRow object + * + * @return A new pzPendingExpRow object or NULL on failure. + */ + +pzPendingExpRow *pzPendingExpRowAlloc( + const char *exp_id, + 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_id, + 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_id; + char *camera; + char *telescope; + char *class; + char *class_id; + char *exp_tag; +} pzPendingImfileRow; + +/** Creates a new pzPendingImfileRow object + * + * @return A new pzPendingImfileRow object or NULL on failure. + */ + +pzPendingImfileRow *pzPendingImfileRowAlloc( + const char *exp_id, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *exp_tag +); + +/** 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_id, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *exp_tag +); + +/** 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_id; + char *camera; + char *telescope; +} pzDoneExpRow; + +/** Creates a new pzDoneExpRow object + * + * @return A new pzDoneExpRow object or NULL on failure. + */ + +pzDoneExpRow *pzDoneExpRowAlloc( + const char *exp_id, + 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_id, + 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_id; + char *camera; + char *telescope; + char *class; + char *class_id; + char *exp_tag; + char *uri; +} pzDoneImfileRow; + +/** Creates a new pzDoneImfileRow object + * + * @return A new pzDoneImfileRow object or NULL on failure. + */ + +pzDoneImfileRow *pzDoneImfileRowAlloc( + const char *exp_id, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *exp_tag, + 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_id, + const char *camera, + const char *telescope, + const char *class, + const char *class_id, + const char *exp_tag, + 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 { + char *exp_tag; + char *exp_id; + char *camera; + char *telescope; + psS32 imfiles; + char *workdir; +} newExpRow; + +/** Creates a new newExpRow object + * + * @return A new newExpRow object or NULL on failure. + */ + +newExpRow *newExpRowAlloc( + const char *exp_tag, + const char *exp_id, + const char *camera, + const char *telescope, + psS32 imfiles, + const char *workdir +); + +/** 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 + const char *exp_tag, + const char *exp_id, + const char *camera, + const char *telescope, + psS32 imfiles, + const char *workdir +); + +/** 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 { + char *exp_tag; + char *class; + char *class_id; + char *uri; +} newImfileRow; + +/** Creates a new newImfileRow object + * + * @return A new newImfileRow object or NULL on failure. + */ + +newImfileRow *newImfileRowAlloc( + const char *exp_tag, + const char *class, + const char *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 + const char *exp_tag, + 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 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 { + char *exp_tag; + char *exp_id; + char *camera; + char *telescope; + psTime* dateobs; + char *exp_type; + psS32 imfiles; + char *workdir; + char *filter; + psF32 airmass; + psF64 ra; + psF64 decl; + psF32 exp_time; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 alt; + psF64 az; + psF32 ccd_temp; + psF64 posang; + char *object; + psS16 fault; +} rawExpRow; + +/** Creates a new rawExpRow object + * + * @return A new rawExpRow object or NULL on failure. + */ + +rawExpRow *rawExpRowAlloc( + const char *exp_tag, + const char *exp_id, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_type, + psS32 imfiles, + const char *workdir, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + const char *object, + 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 + const char *exp_tag, + const char *exp_id, + const char *camera, + const char *telescope, + psTime* dateobs, + const char *exp_type, + psS32 imfiles, + const char *workdir, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + 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 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 { + char *exp_tag; + char *class; + char *class_id; + char *uri; + char *exp_type; + char *filter; + psF32 airmass; + psF64 ra; + psF64 decl; + psF32 exp_time; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF64 alt; + psF64 az; + psF32 ccd_temp; + psF64 posang; + char *object; + psTime* dateobs; + psS16 fault; +} rawImfileRow; + +/** Creates a new rawImfileRow object + * + * @return A new rawImfileRow object or NULL on failure. + */ + +rawImfileRow *rawImfileRowAlloc( + const char *exp_tag, + const char *class, + const char *class_id, + const char *uri, + const char *exp_type, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + const char *object, + psTime* dateobs, + 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 + const char *exp_tag, + const char *class, + const char *class_id, + const char *uri, + const char *exp_type, + const char *filter, + psF32 airmass, + psF64 ra, + psF64 decl, + psF32 exp_time, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF64 alt, + psF64 az, + psF32 ccd_temp, + psF64 posang, + const char *object, + psTime* dateobs, + 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 +); +/** p1PendingExpRow data structure + * + * Structure for representing a single row of p1PendingExp table data. + */ + +typedef struct { + char *exp_tag; + char *recipe; + psS32 p1_version; +} p1PendingExpRow; + +/** Creates a new p1PendingExpRow object + * + * @return A new p1PendingExpRow object or NULL on failure. + */ + +p1PendingExpRow *p1PendingExpRowAlloc( + const char *exp_tag, + const char *recipe, + psS32 p1_version +); + +/** Creates a new p1PendingExp table + * + * @return true on success + */ + +bool p1PendingExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p1PendingExp table + * + * @return true on success + */ + +bool p1PendingExpDropTable( + 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 p1PendingExpInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + const char *recipe, + psS32 p1_version +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long p1PendingExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p1PendingExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p1PendingExpInsertObject( + psDB *dbh, ///< Database handle + p1PendingExpRow *object ///< p1PendingExpRow object +); + +/** Insert an array of p1PendingExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p1PendingExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p1PendingExpRow objects +); + +/** Insert data from a binary FITS table p1PendingExpRow 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 p1PendingExpInsertFits( + 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 p1PendingExpSelectRowsFits( + 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 p1PendingExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p1PendingExpMetadataFromObject( + const p1PendingExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p1PendingExpRow pointer or NULL on error + */ + +p1PendingExpRow *p1PendingExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p1PendingExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p1PendingExpSelectRowObjects( + 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 p1PendingExp + * + * 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 p1PendingExpDeleteObject( + psDB *dbh, ///< Database handle + const p1PendingExpRow *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 p1PendingExpDeleteRowObjects( + 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 p1PendingExpRow 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 p1PendingExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p1PendingExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p1PendingExpRow 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 p1PendingExpPrintObject( + FILE *stream, ///< a stream + p1PendingExpRow *object, ///< an p1PendingExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** p2PendingExpRow data structure + * + * Structure for representing a single row of p2PendingExp table data. + */ + +typedef struct { + char *exp_tag; + char *recipe; + psS32 p1_version; + psS32 p2_version; + char *label; +} p2PendingExpRow; + +/** Creates a new p2PendingExpRow object + * + * @return A new p2PendingExpRow object or NULL on failure. + */ + +p2PendingExpRow *p2PendingExpRowAlloc( + const char *exp_tag, + const char *recipe, + psS32 p1_version, + psS32 p2_version, + const char *label +); + +/** Creates a new p2PendingExp table + * + * @return true on success + */ + +bool p2PendingExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p2PendingExp table + * + * @return true on success + */ + +bool p2PendingExpDropTable( + 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 p2PendingExpInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + const char *recipe, + psS32 p1_version, + psS32 p2_version, + 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 p2PendingExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p2PendingExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p2PendingExpInsertObject( + psDB *dbh, ///< Database handle + p2PendingExpRow *object ///< p2PendingExpRow object +); + +/** Insert an array of p2PendingExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p2PendingExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p2PendingExpRow objects +); + +/** Insert data from a binary FITS table p2PendingExpRow 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 p2PendingExpInsertFits( + 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 p2PendingExpSelectRowsFits( + 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 p2PendingExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p2PendingExpMetadataFromObject( + const p2PendingExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p2PendingExpRow pointer or NULL on error + */ + +p2PendingExpRow *p2PendingExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p2PendingExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p2PendingExpSelectRowObjects( + 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 p2PendingExp + * + * 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 p2PendingExpDeleteObject( + psDB *dbh, ///< Database handle + const p2PendingExpRow *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 p2PendingExpDeleteRowObjects( + 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 p2PendingExpRow 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 p2PendingExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p2PendingExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p2PendingExpRow 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 p2PendingExpPrintObject( + FILE *stream, ///< a stream + p2PendingExpRow *object, ///< an p2PendingExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** p2PendingImfileRow data structure + * + * Structure for representing a single row of p2PendingImfile table data. + */ + +typedef struct { + char *exp_tag; + char *class_id; + char *uri; + char *recipe; + psS32 p1_version; + psS32 p2_version; +} p2PendingImfileRow; + +/** Creates a new p2PendingImfileRow object + * + * @return A new p2PendingImfileRow object or NULL on failure. + */ + +p2PendingImfileRow *p2PendingImfileRowAlloc( + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psS32 p1_version, + psS32 p2_version +); + +/** Creates a new p2PendingImfile table + * + * @return true on success + */ + +bool p2PendingImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p2PendingImfile table + * + * @return true on success + */ + +bool p2PendingImfileDropTable( + 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 p2PendingImfileInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psS32 p1_version, + psS32 p2_version +); + +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * @return A The number of rows removed or a negative value on error + */ + +long long p2PendingImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p2PendingImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p2PendingImfileInsertObject( + psDB *dbh, ///< Database handle + p2PendingImfileRow *object ///< p2PendingImfileRow object +); + +/** Insert an array of p2PendingImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p2PendingImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p2PendingImfileRow objects +); + +/** Insert data from a binary FITS table p2PendingImfileRow 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 p2PendingImfileInsertFits( + 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 p2PendingImfileSelectRowsFits( + 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 p2PendingImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p2PendingImfileMetadataFromObject( + const p2PendingImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p2PendingImfileRow pointer or NULL on error + */ + +p2PendingImfileRow *p2PendingImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p2PendingImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p2PendingImfileSelectRowObjects( + 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 p2PendingImfile + * + * 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 p2PendingImfileDeleteObject( + psDB *dbh, ///< Database handle + const p2PendingImfileRow *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 p2PendingImfileDeleteRowObjects( + 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 p2PendingImfileRow 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 p2PendingImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p2PendingImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p2PendingImfileRow 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 p2PendingImfilePrintObject( + FILE *stream, ///< a stream + p2PendingImfileRow *object, ///< an p2PendingImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p2ProcessedExpRow data structure + * + * Structure for representing a single row of p2ProcessedExp table data. + */ + +typedef struct { + char *exp_tag; + psS32 p1_version; + psS32 p2_version; + char *label; +} p2ProcessedExpRow; + +/** Creates a new p2ProcessedExpRow object + * + * @return A new p2ProcessedExpRow object or NULL on failure. + */ + +p2ProcessedExpRow *p2ProcessedExpRowAlloc( + const char *exp_tag, + psS32 p1_version, + psS32 p2_version, + const char *label +); + +/** Creates a new p2ProcessedExp table + * + * @return true on success + */ + +bool p2ProcessedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p2ProcessedExp table + * + * @return true on success + */ + +bool p2ProcessedExpDropTable( + 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 p2ProcessedExpInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + psS32 p1_version, + psS32 p2_version, + 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 p2ProcessedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p2ProcessedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p2ProcessedExpInsertObject( + psDB *dbh, ///< Database handle + p2ProcessedExpRow *object ///< p2ProcessedExpRow object +); + +/** Insert an array of p2ProcessedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p2ProcessedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p2ProcessedExpRow objects +); + +/** Insert data from a binary FITS table p2ProcessedExpRow 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 p2ProcessedExpInsertFits( + 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 p2ProcessedExpSelectRowsFits( + 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 p2ProcessedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p2ProcessedExpMetadataFromObject( + const p2ProcessedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p2ProcessedExpRow pointer or NULL on error + */ + +p2ProcessedExpRow *p2ProcessedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p2ProcessedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p2ProcessedExpSelectRowObjects( + 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 p2ProcessedExp + * + * 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 p2ProcessedExpDeleteObject( + psDB *dbh, ///< Database handle + const p2ProcessedExpRow *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 p2ProcessedExpDeleteRowObjects( + 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 p2ProcessedExpRow 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 p2ProcessedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p2ProcessedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p2ProcessedExpRow 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 p2ProcessedExpPrintObject( + FILE *stream, ///< a stream + p2ProcessedExpRow *object, ///< an p2ProcessedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** p2MaskRow data structure + * + * Structure for representing a single row of p2Mask table data. + */ + +typedef struct { + char *label; +} p2MaskRow; + +/** Creates a new p2MaskRow object + * + * @return A new p2MaskRow object or NULL on failure. + */ + +p2MaskRow *p2MaskRowAlloc( + const char *label +); + +/** Creates a new p2Mask table + * + * @return true on success + */ + +bool p2MaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p2Mask table + * + * @return true on success + */ + +bool p2MaskDropTable( + 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 p2MaskInsert( + 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 p2MaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p2MaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p2MaskInsertObject( + psDB *dbh, ///< Database handle + p2MaskRow *object ///< p2MaskRow object +); + +/** Insert an array of p2MaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p2MaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p2MaskRow objects +); + +/** Insert data from a binary FITS table p2MaskRow 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 p2MaskInsertFits( + 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 p2MaskSelectRowsFits( + 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 p2MaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p2MaskMetadataFromObject( + const p2MaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p2MaskRow pointer or NULL on error + */ + +p2MaskRow *p2MaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p2MaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p2MaskSelectRowObjects( + 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 p2Mask + * + * 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 p2MaskDeleteObject( + psDB *dbh, ///< Database handle + const p2MaskRow *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 p2MaskDeleteRowObjects( + 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 p2MaskRow 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 p2MaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p2MaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p2MaskRow 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 p2MaskPrintObject( + FILE *stream, ///< a stream + p2MaskRow *object, ///< an p2MaskRow object + bool mdcf ///< format as mdconfig or simple +); +/** p2ProcessedImfileRow data structure + * + * Structure for representing a single row of p2ProcessedImfile table data. + */ + +typedef struct { + char *exp_tag; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS32 p1_version; + psS32 p2_version; + psS16 fault; +} p2ProcessedImfileRow; + +/** Creates a new p2ProcessedImfileRow object + * + * @return A new p2ProcessedImfileRow object or NULL on failure. + */ + +p2ProcessedImfileRow *p2ProcessedImfileRowAlloc( + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + psS32 p1_version, + psS32 p2_version, + psS16 fault +); + +/** Creates a new p2ProcessedImfile table + * + * @return true on success + */ + +bool p2ProcessedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p2ProcessedImfile table + * + * @return true on success + */ + +bool p2ProcessedImfileDropTable( + 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 p2ProcessedImfileInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + psS32 p1_version, + psS32 p2_version, + 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 p2ProcessedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p2ProcessedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p2ProcessedImfileInsertObject( + psDB *dbh, ///< Database handle + p2ProcessedImfileRow *object ///< p2ProcessedImfileRow object +); + +/** Insert an array of p2ProcessedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p2ProcessedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p2ProcessedImfileRow objects +); + +/** Insert data from a binary FITS table p2ProcessedImfileRow 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 p2ProcessedImfileInsertFits( + 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 p2ProcessedImfileSelectRowsFits( + 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 p2ProcessedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p2ProcessedImfileMetadataFromObject( + const p2ProcessedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p2ProcessedImfileRow pointer or NULL on error + */ + +p2ProcessedImfileRow *p2ProcessedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p2ProcessedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p2ProcessedImfileSelectRowObjects( + 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 p2ProcessedImfile + * + * 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 p2ProcessedImfileDeleteObject( + psDB *dbh, ///< Database handle + const p2ProcessedImfileRow *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 p2ProcessedImfileDeleteRowObjects( + 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 p2ProcessedImfileRow 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 p2ProcessedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p2ProcessedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p2ProcessedImfileRow 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 p2ProcessedImfilePrintObject( + FILE *stream, ///< a stream + p2ProcessedImfileRow *object, ///< an p2ProcessedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p3PendingExpRow data structure + * + * Structure for representing a single row of p3PendingExp table data. + */ + +typedef struct { + char *exp_tag; + psS32 p2_version; + psS32 p3_version; + char *label; +} p3PendingExpRow; + +/** Creates a new p3PendingExpRow object + * + * @return A new p3PendingExpRow object or NULL on failure. + */ + +p3PendingExpRow *p3PendingExpRowAlloc( + const char *exp_tag, + psS32 p2_version, + psS32 p3_version, + const char *label +); + +/** Creates a new p3PendingExp table + * + * @return true on success + */ + +bool p3PendingExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p3PendingExp table + * + * @return true on success + */ + +bool p3PendingExpDropTable( + 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 p3PendingExpInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + psS32 p2_version, + psS32 p3_version, + 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 p3PendingExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p3PendingExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p3PendingExpInsertObject( + psDB *dbh, ///< Database handle + p3PendingExpRow *object ///< p3PendingExpRow object +); + +/** Insert an array of p3PendingExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p3PendingExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p3PendingExpRow objects +); + +/** Insert data from a binary FITS table p3PendingExpRow 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 p3PendingExpInsertFits( + 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 p3PendingExpSelectRowsFits( + 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 p3PendingExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p3PendingExpMetadataFromObject( + const p3PendingExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p3PendingExpRow pointer or NULL on error + */ + +p3PendingExpRow *p3PendingExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p3PendingExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p3PendingExpSelectRowObjects( + 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 p3PendingExp + * + * 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 p3PendingExpDeleteObject( + psDB *dbh, ///< Database handle + const p3PendingExpRow *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 p3PendingExpDeleteRowObjects( + 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 p3PendingExpRow 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 p3PendingExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p3PendingExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p3PendingExpRow 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 p3PendingExpPrintObject( + FILE *stream, ///< a stream + p3PendingExpRow *object, ///< an p3PendingExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** p3ProcessedExpRow data structure + * + * Structure for representing a single row of p3ProcessedExp table data. + */ + +typedef struct { + char *exp_tag; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psF32 sigma_ra; + psF32 sigma_dec; + psS32 nastro; + char *b1_uri; + char *b2_uri; + psF32 zp_mean; + psF32 zp_stdev; + psS32 p2_version; + psS32 p3_version; + char *label; + psS16 fault; +} p3ProcessedExpRow; + +/** Creates a new p3ProcessedExpRow object + * + * @return A new p3ProcessedExpRow object or NULL on failure. + */ + +p3ProcessedExpRow *p3ProcessedExpRowAlloc( + const char *exp_tag, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF32 sigma_ra, + psF32 sigma_dec, + psS32 nastro, + const char *b1_uri, + const char *b2_uri, + psF32 zp_mean, + psF32 zp_stdev, + psS32 p2_version, + psS32 p3_version, + const char *label, + psS16 fault +); + +/** Creates a new p3ProcessedExp table + * + * @return true on success + */ + +bool p3ProcessedExpCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p3ProcessedExp table + * + * @return true on success + */ + +bool p3ProcessedExpDropTable( + 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 p3ProcessedExpInsert( + psDB *dbh, ///< Database handle + const char *exp_tag, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + psF32 sigma_ra, + psF32 sigma_dec, + psS32 nastro, + const char *b1_uri, + const char *b2_uri, + psF32 zp_mean, + psF32 zp_stdev, + psS32 p2_version, + psS32 p3_version, + const char *label, + 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 p3ProcessedExpDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p3ProcessedExpRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p3ProcessedExpInsertObject( + psDB *dbh, ///< Database handle + p3ProcessedExpRow *object ///< p3ProcessedExpRow object +); + +/** Insert an array of p3ProcessedExpRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p3ProcessedExpInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p3ProcessedExpRow objects +); + +/** Insert data from a binary FITS table p3ProcessedExpRow 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 p3ProcessedExpInsertFits( + 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 p3ProcessedExpSelectRowsFits( + 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 p3ProcessedExpRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p3ProcessedExpMetadataFromObject( + const p3ProcessedExpRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p3ProcessedExpRow pointer or NULL on error + */ + +p3ProcessedExpRow *p3ProcessedExpObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p3ProcessedExpRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p3ProcessedExpSelectRowObjects( + 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 p3ProcessedExp + * + * 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 p3ProcessedExpDeleteObject( + psDB *dbh, ///< Database handle + const p3ProcessedExpRow *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 p3ProcessedExpDeleteRowObjects( + 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 p3ProcessedExpRow 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 p3ProcessedExpPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p3ProcessedExpRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p3ProcessedExpRow 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 p3ProcessedExpPrintObject( + FILE *stream, ///< a stream + p3ProcessedExpRow *object, ///< an p3ProcessedExpRow object + bool mdcf ///< format as mdconfig or simple +); +/** p3MaskRow data structure + * + * Structure for representing a single row of p3Mask table data. + */ + +typedef struct { + char *label; +} p3MaskRow; + +/** Creates a new p3MaskRow object + * + * @return A new p3MaskRow object or NULL on failure. + */ + +p3MaskRow *p3MaskRowAlloc( + const char *label +); + +/** Creates a new p3Mask table + * + * @return true on success + */ + +bool p3MaskCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p3Mask table + * + * @return true on success + */ + +bool p3MaskDropTable( + 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 p3MaskInsert( + 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 p3MaskDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p3MaskRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p3MaskInsertObject( + psDB *dbh, ///< Database handle + p3MaskRow *object ///< p3MaskRow object +); + +/** Insert an array of p3MaskRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p3MaskInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p3MaskRow objects +); + +/** Insert data from a binary FITS table p3MaskRow 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 p3MaskInsertFits( + 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 p3MaskSelectRowsFits( + 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 p3MaskRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p3MaskMetadataFromObject( + const p3MaskRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p3MaskRow pointer or NULL on error + */ + +p3MaskRow *p3MaskObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p3MaskRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p3MaskSelectRowObjects( + 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 p3Mask + * + * 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 p3MaskDeleteObject( + psDB *dbh, ///< Database handle + const p3MaskRow *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 p3MaskDeleteRowObjects( + 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 p3MaskRow 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 p3MaskPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p3MaskRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p3MaskRow 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 p3MaskPrintObject( + FILE *stream, ///< a stream + p3MaskRow *object, ///< an p3MaskRow object + bool mdcf ///< format as mdconfig or simple +); +/** detRunRow data structure + * + * Structure for representing a single row of detRun table data. + */ + +typedef struct { + psS32 det_id; + psS32 iteration; + char *det_type; + char *mode; + char *state; + char *workdir; + char *camera; + char *telescope; + char *exp_type; + 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; +} detRunRow; + +/** Creates a new detRunRow object + * + * @return A new detRunRow object or NULL on failure. + */ + +detRunRow *detRunRowAlloc( + psS32 det_id, + psS32 iteration, + const char *det_type, + const char *mode, + const char *state, + const char *workdir, + const char *camera, + const char *telescope, + const char *exp_type, + 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 +); + +/** 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 + psS32 det_id, + psS32 iteration, + const char *det_type, + const char *mode, + const char *state, + const char *workdir, + const char *camera, + const char *telescope, + const char *exp_type, + 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 +); + +/** 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 { + psS32 det_id; + psS32 iteration; + char *exp_tag; + bool include; +} detInputExpRow; + +/** Creates a new detInputExpRow object + * + * @return A new detInputExpRow object or NULL on failure. + */ + +detInputExpRow *detInputExpRowAlloc( + psS32 det_id, + psS32 iteration, + const char *exp_tag, + 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 + psS32 det_id, + psS32 iteration, + const char *exp_tag, + 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 { + psS32 det_id; + char *exp_tag; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS16 fault; +} detProcessedImfileRow; + +/** Creates a new detProcessedImfileRow object + * + * @return A new detProcessedImfileRow object or NULL on failure. + */ + +detProcessedImfileRow *detProcessedImfileRowAlloc( + psS32 det_id, + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 det_id; + char *exp_tag; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS16 fault; +} detProcessedExpRow; + +/** Creates a new detProcessedExpRow object + * + * @return A new detProcessedExpRow object or NULL on failure. + */ + +detProcessedExpRow *detProcessedExpRowAlloc( + psS32 det_id, + const char *exp_tag, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + const char *exp_tag, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 det_id; + psS32 iteration; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + psS16 fault; +} detStackedImfileRow; + +/** Creates a new detStackedImfileRow object + * + * @return A new detStackedImfileRow object or NULL on failure. + */ + +detStackedImfileRow *detStackedImfileRowAlloc( + psS32 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + 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 + psS32 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_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 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 { + psS32 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( + psS32 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 + psS32 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 { + psS32 det_id; + psS32 iteration; + char *class_id; + char *uri; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS16 fault; +} detNormalizedImfileRow; + +/** Creates a new detNormalizedImfileRow object + * + * @return A new detNormalizedImfileRow object or NULL on failure. + */ + +detNormalizedImfileRow *detNormalizedImfileRowAlloc( + psS32 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + psS32 iteration, + const char *class_id, + const char *uri, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 det_id; + psS32 iteration; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS16 fault; +} detNormalizedExpRow; + +/** Creates a new detNormalizedExpRow object + * + * @return A new detNormalizedExpRow object or NULL on failure. + */ + +detNormalizedExpRow *detNormalizedExpRowAlloc( + psS32 det_id, + psS32 iteration, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + psS32 iteration, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 det_id; + psS32 iteration; + char *exp_tag; + char *class_id; + char *uri; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + psS16 fault; +} detResidImfileRow; + +/** Creates a new detResidImfileRow object + * + * @return A new detResidImfileRow object or NULL on failure. + */ + +detResidImfileRow *detResidImfileRowAlloc( + psS32 det_id, + psS32 iteration, + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + psS32 iteration, + const char *exp_tag, + const char *class_id, + const char *uri, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 det_id; + psS32 iteration; + char *exp_tag; + char *recipe; + psF64 bg; + psF64 bg_stdev; + psF64 bg_mean_stdev; + char *b1_uri; + char *b2_uri; + bool accept; + psS16 fault; +} detResidExpRow; + +/** Creates a new detResidExpRow object + * + * @return A new detResidExpRow object or NULL on failure. + */ + +detResidExpRow *detResidExpRowAlloc( + psS32 det_id, + psS32 iteration, + const char *exp_tag, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 + psS32 det_id, + psS32 iteration, + const char *exp_tag, + const char *recipe, + psF64 bg, + psF64 bg_stdev, + psF64 bg_mean_stdev, + const char *b1_uri, + const char *b2_uri, + 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 { + psS32 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( + psS32 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 + psS32 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 +); +/** p4RunRow data structure + * + * Structure for representing a single row of p4Run table data. + */ + +typedef struct { + psS32 p4_id; + char *survey_mode; + char *state; + char *workdir; + char *filter; + char *skycell_id; + char *tess_id; + psF64 ra; + psF64 decl; + char *input_ss; + char *output_ss; +} p4RunRow; + +/** Creates a new p4RunRow object + * + * @return A new p4RunRow object or NULL on failure. + */ + +p4RunRow *p4RunRowAlloc( + psS32 p4_id, + const char *survey_mode, + const char *state, + const char *workdir, + const char *filter, + const char *skycell_id, + const char *tess_id, + psF64 ra, + psF64 decl, + const char *input_ss, + const char *output_ss +); + +/** Creates a new p4Run table + * + * @return true on success + */ + +bool p4RunCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4Run table + * + * @return true on success + */ + +bool p4RunDropTable( + 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 p4RunInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *survey_mode, + const char *state, + const char *workdir, + const char *filter, + const char *skycell_id, + const char *tess_id, + psF64 ra, + psF64 decl, + const char *input_ss, + const char *output_ss +); + +/** 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 p4RunDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4RunRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4RunInsertObject( + psDB *dbh, ///< Database handle + p4RunRow *object ///< p4RunRow object +); + +/** Insert an array of p4RunRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4RunInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4RunRow objects +); + +/** Insert data from a binary FITS table p4RunRow into the database + * + * This function expects a psFits object with a FITS table as the first + * 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 p4RunInsertFits( + 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 p4RunSelectRowsFits( + 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 p4RunRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4RunMetadataFromObject( + const p4RunRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4RunRow pointer or NULL on error + */ + +p4RunRow *p4RunObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4RunRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4RunSelectRowObjects( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to return +); +/** Deletes a row from the database coresponding to an p4Run + * + * 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 p4RunDeleteObject( + psDB *dbh, ///< Database handle + const p4RunRow *object ///< Object to delete +); +/** Deletes up to limit rows from the database and returns the number of rows actually deleted. + * + * 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 p4RunDeleteRowObjects( + psDB *dbh, ///< Database handle + const psArray *objects, ///< Array of objects to delete + unsigned long long limit ///< Maximum number of elements to delete +); +/** Formats and prints an array of p4RunRow 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 p4RunPrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4RunRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4RunRow 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 p4RunPrintObject( + FILE *stream, ///< a stream + p4RunRow *object, ///< an p4RunRow object + bool mdcf ///< format as mdconfig or simple +); +/** p4InputImfileRow data structure + * + * Structure for representing a single row of p4InputImfile table data. + */ + +typedef struct { + psS32 p4_id; + char *exp_tag; + psS32 p3_version; + char *class_id; +} p4InputImfileRow; + +/** Creates a new p4InputImfileRow object + * + * @return A new p4InputImfileRow object or NULL on failure. + */ + +p4InputImfileRow *p4InputImfileRowAlloc( + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id +); + +/** Creates a new p4InputImfile table + * + * @return true on success + */ + +bool p4InputImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4InputImfile table + * + * @return true on success + */ + +bool p4InputImfileDropTable( + 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 p4InputImfileInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + 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 p4InputImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4InputImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4InputImfileInsertObject( + psDB *dbh, ///< Database handle + p4InputImfileRow *object ///< p4InputImfileRow object +); + +/** Insert an array of p4InputImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4InputImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4InputImfileRow objects +); + +/** Insert data from a binary FITS table p4InputImfileRow 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 p4InputImfileInsertFits( + 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 p4InputImfileSelectRowsFits( + 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 p4InputImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4InputImfileMetadataFromObject( + const p4InputImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4InputImfileRow pointer or NULL on error + */ + +p4InputImfileRow *p4InputImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4InputImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4InputImfileSelectRowObjects( + 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 p4InputImfile + * + * 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 p4InputImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4InputImfileRow *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 p4InputImfileDeleteRowObjects( + 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 p4InputImfileRow 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 p4InputImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4InputImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4InputImfileRow 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 p4InputImfilePrintObject( + FILE *stream, ///< a stream + p4InputImfileRow *object, ///< an p4InputImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p4WarpedImfileRow data structure + * + * Structure for representing a single row of p4WarpedImfile table data. + */ + +typedef struct { + psS32 p4_id; + char *exp_tag; + psS32 p3_version; + char *class_id; + char *uri; + char *b1_uri; + char *b2_uri; +} p4WarpedImfileRow; + +/** Creates a new p4WarpedImfileRow object + * + * @return A new p4WarpedImfileRow object or NULL on failure. + */ + +p4WarpedImfileRow *p4WarpedImfileRowAlloc( + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_uri +); + +/** Creates a new p4WarpedImfile table + * + * @return true on success + */ + +bool p4WarpedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4WarpedImfile table + * + * @return true on success + */ + +bool p4WarpedImfileDropTable( + 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 p4WarpedImfileInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_uri +); + +/** 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 p4WarpedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4WarpedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4WarpedImfileInsertObject( + psDB *dbh, ///< Database handle + p4WarpedImfileRow *object ///< p4WarpedImfileRow object +); + +/** Insert an array of p4WarpedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4WarpedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4WarpedImfileRow objects +); + +/** Insert data from a binary FITS table p4WarpedImfileRow 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 p4WarpedImfileInsertFits( + 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 p4WarpedImfileSelectRowsFits( + 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 p4WarpedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4WarpedImfileMetadataFromObject( + const p4WarpedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4WarpedImfileRow pointer or NULL on error + */ + +p4WarpedImfileRow *p4WarpedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4WarpedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4WarpedImfileSelectRowObjects( + 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 p4WarpedImfile + * + * 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 p4WarpedImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4WarpedImfileRow *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 p4WarpedImfileDeleteRowObjects( + 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 p4WarpedImfileRow 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 p4WarpedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4WarpedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4WarpedImfileRow 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 p4WarpedImfilePrintObject( + FILE *stream, ///< a stream + p4WarpedImfileRow *object, ///< an p4WarpedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p4StackedImfileRow data structure + * + * Structure for representing a single row of p4StackedImfile table data. + */ + +typedef struct { + psS32 p4_id; + char *class_id; + char *uri; + char *b1_uri; + char *b2_uri; +} p4StackedImfileRow; + +/** Creates a new p4StackedImfileRow object + * + * @return A new p4StackedImfileRow object or NULL on failure. + */ + +p4StackedImfileRow *p4StackedImfileRowAlloc( + psS32 p4_id, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_uri +); + +/** Creates a new p4StackedImfile table + * + * @return true on success + */ + +bool p4StackedImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4StackedImfile table + * + * @return true on success + */ + +bool p4StackedImfileDropTable( + 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 p4StackedImfileInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_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 p4StackedImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4StackedImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4StackedImfileInsertObject( + psDB *dbh, ///< Database handle + p4StackedImfileRow *object ///< p4StackedImfileRow object +); + +/** Insert an array of p4StackedImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4StackedImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4StackedImfileRow objects +); + +/** Insert data from a binary FITS table p4StackedImfileRow 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 p4StackedImfileInsertFits( + 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 p4StackedImfileSelectRowsFits( + 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 p4StackedImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4StackedImfileMetadataFromObject( + const p4StackedImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4StackedImfileRow pointer or NULL on error + */ + +p4StackedImfileRow *p4StackedImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4StackedImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4StackedImfileSelectRowObjects( + 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 p4StackedImfile + * + * 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 p4StackedImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4StackedImfileRow *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 p4StackedImfileDeleteRowObjects( + 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 p4StackedImfileRow 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 p4StackedImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4StackedImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4StackedImfileRow 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 p4StackedImfilePrintObject( + FILE *stream, ///< a stream + p4StackedImfileRow *object, ///< an p4StackedImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p4DiffImfileRow data structure + * + * Structure for representing a single row of p4DiffImfile table data. + */ + +typedef struct { + psS32 p4_id; + char *exp_tag; + psS32 p3_version; + char *class_id; + char *uri; + char *b1_uri; + char *b2_uri; +} p4DiffImfileRow; + +/** Creates a new p4DiffImfileRow object + * + * @return A new p4DiffImfileRow object or NULL on failure. + */ + +p4DiffImfileRow *p4DiffImfileRowAlloc( + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_uri +); + +/** Creates a new p4DiffImfile table + * + * @return true on success + */ + +bool p4DiffImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4DiffImfile table + * + * @return true on success + */ + +bool p4DiffImfileDropTable( + 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 p4DiffImfileInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id, + const char *uri, + const char *b1_uri, + const char *b2_uri +); + +/** 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 p4DiffImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4DiffImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4DiffImfileInsertObject( + psDB *dbh, ///< Database handle + p4DiffImfileRow *object ///< p4DiffImfileRow object +); + +/** Insert an array of p4DiffImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4DiffImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4DiffImfileRow objects +); + +/** Insert data from a binary FITS table p4DiffImfileRow 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 p4DiffImfileInsertFits( + 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 p4DiffImfileSelectRowsFits( + 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 p4DiffImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4DiffImfileMetadataFromObject( + const p4DiffImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4DiffImfileRow pointer or NULL on error + */ + +p4DiffImfileRow *p4DiffImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4DiffImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4DiffImfileSelectRowObjects( + 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 p4DiffImfile + * + * 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 p4DiffImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4DiffImfileRow *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 p4DiffImfileDeleteRowObjects( + 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 p4DiffImfileRow 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 p4DiffImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4DiffImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4DiffImfileRow 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 p4DiffImfilePrintObject( + FILE *stream, ///< a stream + p4DiffImfileRow *object, ///< an p4DiffImfileRow object + bool mdcf ///< format as mdconfig or simple +); +/** p4MagicMaskImfileRow data structure + * + * Structure for representing a single row of p4MagicMaskImfile table data. + */ + +typedef struct { + psS32 p4_id; + char *exp_tag; + psS32 p3_version; + char *class_id; + char *uri; +} p4MagicMaskImfileRow; + +/** Creates a new p4MagicMaskImfileRow object + * + * @return A new p4MagicMaskImfileRow object or NULL on failure. + */ + +p4MagicMaskImfileRow *p4MagicMaskImfileRowAlloc( + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + const char *class_id, + const char *uri +); + +/** Creates a new p4MagicMaskImfile table + * + * @return true on success + */ + +bool p4MagicMaskImfileCreateTable( + psDB *dbh ///< Database handle +); + +/** Deletes a p4MagicMaskImfile table + * + * @return true on success + */ + +bool p4MagicMaskImfileDropTable( + 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 p4MagicMaskImfileInsert( + psDB *dbh, ///< Database handle + psS32 p4_id, + const char *exp_tag, + psS32 p3_version, + 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 p4MagicMaskImfileDelete( + psDB *dbh, ///< Database handle + const psMetadata *where, ///< Row match criteria + unsigned long long limit ///< Maximum number of elements to delete +); + +/** Insert a single p4MagicMaskImfileRow object into a table + * + * This function constructs and inserts a single row based on it's parameters. + * + * @return true on success + */ + +bool p4MagicMaskImfileInsertObject( + psDB *dbh, ///< Database handle + p4MagicMaskImfileRow *object ///< p4MagicMaskImfileRow object +); + +/** Insert an array of p4MagicMaskImfileRow object into a table + * + * This function constructs and inserts multiple rows based on it's parameters. + * + * @return true on success + */ + +bool p4MagicMaskImfileInsertObjects( + psDB *dbh, ///< Database handle + psArray *objects ///< array of p4MagicMaskImfileRow objects +); + +/** Insert data from a binary FITS table p4MagicMaskImfileRow 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 p4MagicMaskImfileInsertFits( + 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 p4MagicMaskImfileSelectRowsFits( + 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 p4MagicMaskImfileRow into an equivalent psMetadata + * + * @return A psMetadata pointer or NULL on error + */ + +psMetadata *p4MagicMaskImfileMetadataFromObject( + const p4MagicMaskImfileRow *object ///< fooRow to convert into a psMetadata +); + +/** Convert a psMetadata into an equivalent fooRow + * + * @return A p4MagicMaskImfileRow pointer or NULL on error + */ + +p4MagicMaskImfileRow *p4MagicMaskImfileObjectFromMetadata( + psMetadata *md ///< psMetadata to convert into a fooRow +); +/** Selects up to limit rows from the database and returns as p4MagicMaskImfileRow objects in a psArray + * + * See psDBSelectRows() for documentation on the format of where. + * + * @return A psArray pointer or NULL on error + */ + +psArray *p4MagicMaskImfileSelectRowObjects( + 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 p4MagicMaskImfile + * + * 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 p4MagicMaskImfileDeleteObject( + psDB *dbh, ///< Database handle + const p4MagicMaskImfileRow *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 p4MagicMaskImfileDeleteRowObjects( + 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 p4MagicMaskImfileRow 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 p4MagicMaskImfilePrintObjects( + FILE *stream, ///< a stream + psArray *objects, ///< An array of p4MagicMaskImfileRow objects + bool mdcf ///< format as mdconfig or simple +); +/** Formats and prints an p4MagicMaskImfileRow 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 p4MagicMaskImfilePrintObject( + FILE *stream, ///< a stream + p4MagicMaskImfileRow *object, ///< an p4MagicMaskImfileRow object + bool mdcf ///< format as mdconfig or simple +); + +/// @} + +#ifdef __cplusplus +} +#endif + +#endif // P4MAGICMASKIMFILE_DB_H Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/.cvsignore =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/.cvsignore (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/.cvsignore (revision 22016) @@ -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-0_0_79/ippdb/tests/Makefile.am =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/Makefile.am (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/Makefile.am (revision 22016) @@ -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-0_0_79/ippdb/tests/alloc.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/alloc.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/alloc.c (revision 22016) @@ -0,0 +1,1630 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + expTagCounterRow *object; + + object = expTagCounterRowAlloc(64 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + 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_id, "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_id, "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_id, "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", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_id, "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->exp_tag, "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_id, "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", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_id, "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->exp_tag, "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("a string", "a string", "a string", "a string", -32, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_id, "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 (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + newImfileRow *object; + + object = newImfileRowAlloc("a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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); + } + + { + rawExpRow *object; + + object = rawExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_id, "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 (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "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->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 (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + rawImfileRow *object; + + object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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); + } + if (strncmp(object->exp_type, "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->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 (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p1PendingExpRow *object; + + object = p1PendingExpRowAlloc("a string", "a string", -32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p2PendingExpRow *object; + + object = p2PendingExpRowAlloc("a string", "a string", -32, -32, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p2PendingImfileRow *object; + + object = p2PendingImfileRowAlloc("a string", "a string", "a string", "a string", -32, -32 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p2ProcessedExpRow *object; + + object = p2ProcessedExpRowAlloc("a string", -32, -32, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p2MaskRow *object; + + object = p2MaskRowAlloc("a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p2ProcessedImfileRow *object; + + object = p2ProcessedImfileRowAlloc("a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -32, -32, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p3PendingExpRow *object; + + object = p3PendingExpRowAlloc("a string", -32, -32, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p3ProcessedExpRow *object; + + object = p3ProcessedExpRowAlloc("a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", "a string", 32.32, 32.32, -32, -32, "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->exp_tag, "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->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->nastro == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + 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->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p3MaskRow *object; + + object = p3MaskRowAlloc("a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detRunRow *object; + + object = detRunRowAlloc(-32, -32, "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" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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->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->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); + } + + psFree(object); + } + + { + detInputExpRow *object; + + object = detInputExpRowAlloc(-32, -32, "a string", true ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->include == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detProcessedImfileRow *object; + + object = detProcessedImfileRowAlloc(-32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detProcessedExpRow *object; + + object = detProcessedExpRowAlloc(-32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detStackedImfileRow *object; + + object = detStackedImfileRowAlloc(-32, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detNormalizedStatImfileRow *object; + + object = detNormalizedStatImfileRowAlloc(-32, -32, "a string", 32.32, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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); + } + + { + detNormalizedImfileRow *object; + + object = detNormalizedImfileRowAlloc(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detNormalizedExpRow *object; + + object = detNormalizedExpRowAlloc(-32, -32, "a string", 64.64, 64.64, 64.64, "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detResidImfileRow *object; + + object = detResidImfileRowAlloc(-32, -32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + detResidExpRow *object; + + object = detResidExpRowAlloc(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", true, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "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); + } + + { + detRunSummaryRow *object; + + object = detRunSummaryRowAlloc(-32, -32, 64.64, 64.64, 64.64, true, -16 ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->det_id == -32) { + 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); + } + + { + p4RunRow *object; + + object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->survey_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->filter, "a string", MAX_STRING_LENGTH)) { + 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->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p4InputImfileRow *object; + + object = p4InputImfileRowAlloc(-32, "a string", -32, "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p4WarpedImfileRow *object; + + object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p4StackedImfileRow *object; + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p4DiffImfileRow *object; + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + p4MagicMaskImfileRow *object; + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string" ); + + if (!object) { + exit(EXIT_FAILURE); + } + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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); + } + + psFree(object); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/cleanup.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/cleanup.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/cleanup.c (revision 22016) @@ -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-0_0_79/ippdb/tests/createtable.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/createtable.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/createtable.c (revision 22016) @@ -0,0 +1,563 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!expTagCounterCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + 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(!p1PendingExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p2PendingExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p2PendingImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p2ProcessedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p2MaskCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p2ProcessedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p3PendingExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p3ProcessedExpCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p3MaskCreateTable(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(!p4RunCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4InputImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4WarpedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4StackedImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4DiffImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if(!p4MagicMaskImfileCreateTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbcleanup.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbcleanup.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbcleanup.c (revision 22016) @@ -0,0 +1,54 @@ +#include +#include + +int main () +{ + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS expTagCounter"); + 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 p1PendingExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2PendingExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2PendingImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2ProcessedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2Mask"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2ProcessedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3PendingExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3ProcessedExp"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3Mask"); + 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 p4Run"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile"); + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile"); + + psDBCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbsetup.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbsetup.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/dbsetup.c (revision 22016) @@ -0,0 +1,129 @@ +#include +#include +#include + +int main () +{ + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + // remove the table if it already exists + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS expTagCounter"); + expTagCounterCreateTable(dbh); + + 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 p1PendingExp"); + p1PendingExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2PendingExp"); + p2PendingExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2PendingImfile"); + p2PendingImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2ProcessedExp"); + p2ProcessedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2Mask"); + p2MaskCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p2ProcessedImfile"); + p2ProcessedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3PendingExp"); + p3PendingExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3ProcessedExp"); + p3ProcessedExpCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p3Mask"); + p3MaskCreateTable(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 p4Run"); + p4RunCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4InputImfile"); + p4InputImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4WarpedImfile"); + p4WarpedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4StackedImfile"); + p4StackedImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4DiffImfile"); + p4DiffImfileCreateTable(dbh); + + p_psDBRunQuery(dbh, "DROP TABLE IF EXISTS p4MagicMaskImfile"); + p4MagicMaskImfileCreateTable(dbh); + + psDBCleanup(dbh); + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/droptable.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/droptable.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/droptable.c (revision 22016) @@ -0,0 +1,563 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!expTagCounterDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + 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 (!p1PendingExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2PendingExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2PendingImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2MaskDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p3PendingExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p3ProcessedExpDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p3MaskDropTable(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 (!p4RunDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4InputImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4WarpedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4StackedImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileDropTable(dbh)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/init.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/init.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/init.c (revision 22016) @@ -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-0_0_79/ippdb/tests/insert.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insert.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insert.c (revision 22016) @@ -0,0 +1,563 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!expTagCounterInsert(dbh, 64)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + 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", "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", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newExpInsert(dbh, "a string", "a string", "a string", "a string", -32, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!newImfileInsert(dbh, "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 (!rawExpInsert(dbh, "a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!rawImfileInsert(dbh, "a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p1PendingExpInsert(dbh, "a string", "a string", -32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2PendingExpInsert(dbh, "a string", "a string", -32, -32, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2PendingImfileInsert(dbh, "a string", "a string", "a string", "a string", -32, -32)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedExpInsert(dbh, "a string", -32, -32, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2MaskInsert(dbh, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedImfileInsert(dbh, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -32, -32, -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p3PendingExpInsert(dbh, "a string", -32, -32, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p3ProcessedExpInsert(dbh, "a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", "a string", 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 (!p3MaskInsert(dbh, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detRunInsert(dbh, -32, -32, "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")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detInputExpInsert(dbh, -32, -32, "a string", true)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedImfileInsert(dbh, -32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detProcessedExpInsert(dbh, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detStackedImfileInsert(dbh, -32, -32, "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 (!detNormalizedStatImfileInsert(dbh, -32, -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, -32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detNormalizedExpInsert(dbh, -32, -32, "a string", 64.64, 64.64, 64.64, "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidImfileInsert(dbh, -32, -32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!detResidExpInsert(dbh, -32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "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, -32, -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 (!p4RunInsert(dbh, -32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4InputImfileInsert(dbh, -32, "a string", -32, "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + { + psDB *dbh; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + if (!p4WarpedImfileInsert(dbh, -32, "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 (!p4StackedImfileInsert(dbh, -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 (!p4DiffImfileInsert(dbh, -32, "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 (!p4MagicMaskImfileInsert(dbh, -32, "a string", -32, "a string", "a string")) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertfits.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertfits.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertfits.c (revision 22016) @@ -0,0 +1,974 @@ +#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 (!expTagCounterInsertFits(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 (!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 (!p1PendingExpInsertFits(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 (!p2PendingExpInsertFits(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 (!p2PendingImfileInsertFits(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 (!p2ProcessedExpInsertFits(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 (!p2MaskInsertFits(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 (!p2ProcessedImfileInsertFits(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 (!p3PendingExpInsertFits(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 (!p3ProcessedExpInsertFits(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 (!p3MaskInsertFits(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 (!p4RunInsertFits(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 (!p4InputImfileInsertFits(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 (!p4WarpedImfileInsertFits(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 (!p4StackedImfileInsertFits(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 (!p4DiffImfileInsertFits(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 (!p4MagicMaskImfileInsertFits(dbh, fits)) { + exit(EXIT_FAILURE); + } + + if (!psFitsClose(fits)) { + exit(EXIT_FAILURE); + } + + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertobject.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertobject.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/insertobject.c (revision 22016) @@ -0,0 +1,822 @@ +#include +#include +#include + +int main () +{ + { + psDB *dbh; + expTagCounterRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = expTagCounterRowAlloc(64); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!expTagCounterInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + 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", "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", "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("a string", "a string", "a string", "a string", -32, "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("a string", "a string", "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("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", -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("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!rawImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p1PendingExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p1PendingExpRowAlloc("a string", "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p1PendingExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p2PendingExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p2PendingExpRowAlloc("a string", "a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p2PendingExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p2PendingImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p2PendingImfileRowAlloc("a string", "a string", "a string", "a string", -32, -32); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p2PendingImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p2ProcessedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p2ProcessedExpRowAlloc("a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p2MaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p2MaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p2MaskInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p2ProcessedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p2ProcessedImfileRowAlloc("a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -32, -32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p2ProcessedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p3PendingExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p3PendingExpRowAlloc("a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p3PendingExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p3ProcessedExpRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p3ProcessedExpRowAlloc("a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", "a string", 32.32, 32.32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p3ProcessedExpInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p3MaskRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p3MaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p3MaskInsertObject(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(-32, -32, "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"); + 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(-32, -32, "a string", 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(-32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "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(-32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "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(-32, -32, "a string", "a string", "a string", 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(-32, -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(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "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(-32, -32, "a string", 64.64, 64.64, 64.64, "a string", "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(-32, -32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "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(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "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(-32, -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; + p4RunRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4RunInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4InputImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4InputImfileRowAlloc(-32, "a string", -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4InputImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4WarpedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4WarpedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4StackedImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4StackedImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4DiffImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4DiffImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + { + psDB *dbh; + p4MagicMaskImfileRow *object; + + dbh = psDBInit("localhost", "test", NULL, "test"); + if (!dbh) { + exit(EXIT_FAILURE); + } + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + if (!p4MagicMaskImfileInsertObject(dbh, object)) { + exit(EXIT_FAILURE); + } + + psFree(object); + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/metadatafromobject.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/metadatafromobject.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/metadatafromobject.c (revision 22016) @@ -0,0 +1,1926 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + psMetadata *md; + expTagCounterRow *object; + bool status; + + object = expTagCounterRowAlloc(64); + if (!object) { + exit(EXIT_FAILURE); + } + + md = expTagCounterMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + 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_id"), "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_id"), "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_id"), "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", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzPendingImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "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, "exp_tag"), "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_id"), "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", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = pzDoneImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "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, "exp_tag"), "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("a string", "a string", "a string", "a string", -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = newExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "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 (!psMetadataLookupS32(&status, md, "imfiles") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "workdir"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + newImfileRow *object; + bool status; + + object = newImfileRowAlloc("a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = newImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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; + rawExpRow *object; + bool status; + + object = rawExpRowAlloc("a string", "a string", "a string", "a string", "0001-01-01T00:00:00Z", "a string", -32, "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = rawExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_id"), "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 (!psMetadataLookupS32(&status, md, "imfiles") == -32) { + 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, "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 (!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 (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + rawImfileRow *object; + bool status; + + object = rawImfileRowAlloc("a string", "a string", "a string", "a string", "a string", "a string", 32.32, 64.64, 64.64, 32.32, 64.64, 64.64, 64.64, 64.64, 64.64, 32.32, 64.64, "a string", "0001-01-01T00:00:00Z", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = rawImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_type"), "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 (!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 (strncmp(psMetadataLookupPtr(&status, md, "object"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p1PendingExpRow *object; + bool status; + + object = p1PendingExpRowAlloc("a string", "a string", -32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p1PendingExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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 (!psMetadataLookupS32(&status, md, "p1_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p2PendingExpRow *object; + bool status; + + object = p2PendingExpRowAlloc("a string", "a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p2PendingExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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 (!psMetadataLookupS32(&status, md, "p1_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p2PendingImfileRow *object; + bool status; + + object = p2PendingImfileRowAlloc("a string", "a string", "a string", "a string", -32, -32); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p2PendingImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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, "recipe"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p1_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p2ProcessedExpRow *object; + bool status; + + object = p2ProcessedExpRowAlloc("a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p2ProcessedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p1_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p2MaskRow *object; + bool status; + + object = p2MaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p2MaskMetadataFromObject(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; + p2ProcessedImfileRow *object; + bool status; + + object = p2ProcessedImfileRowAlloc("a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -32, -32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p2ProcessedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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, "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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p1_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p3PendingExpRow *object; + bool status; + + object = p3PendingExpRowAlloc("a string", -32, -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p3PendingExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p3ProcessedExpRow *object; + bool status; + + object = p3ProcessedExpRowAlloc("a string", "a string", "a string", 64.64, 64.64, 64.64, 32.32, 32.32, -32, "a string", "a string", 32.32, 32.32, -32, -32, "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p3ProcessedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "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 (!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 (!psMetadataLookupS32(&status, md, "nastro") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) { + 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 (!psMetadataLookupS32(&status, md, "p2_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "label"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p3MaskRow *object; + bool status; + + object = p3MaskRowAlloc("a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p3MaskMetadataFromObject(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; + detRunRow *object; + bool status; + + object = detRunRowAlloc(-32, -32, "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"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detRunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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, "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, "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); + } + + psFree(md); + } + + { + psMetadata *md; + detInputExpRow *object; + bool status; + + object = detInputExpRowAlloc(-32, -32, "a string", true); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detInputExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + 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(-32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detProcessedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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, "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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detProcessedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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, "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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, -32, "a string", "a string", "a string", 64.64, 64.64, 64.64, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detStackedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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); + } + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + detNormalizedStatImfileRow *object; + bool status; + + object = detNormalizedStatImfileRowAlloc(-32, -32, "a string", 32.32, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedStatImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, -32, "a string", 64.64, 64.64, 64.64, "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detNormalizedExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, -32, "a string", "a string", "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detResidImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + 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, "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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, -32, "a string", "a string", 64.64, 64.64, 64.64, "a string", "a string", true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detResidExpMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "iteration") == -32) { + 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, "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 (strncmp(psMetadataLookupPtr(&status, md, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "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(-32, -32, 64.64, 64.64, 64.64, true, -16); + if (!object) { + exit(EXIT_FAILURE); + } + + md = detRunSummaryMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "det_id") == -32) { + 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; + p4RunRow *object; + bool status; + + object = p4RunRowAlloc(-32, "a string", "a string", "a string", "a string", "a string", "a string", 64.64, 64.64, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4RunMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "survey_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, "filter"), "a string", MAX_STRING_LENGTH)) { + 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 (!psMetadataLookupF64(&status, md, "ra") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupF64(&status, md, "decl") == 64.64) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "input_ss"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "output_ss"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p4InputImfileRow *object; + bool status; + + object = p4InputImfileRowAlloc(-32, "a string", -32, "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4InputImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -32) { + 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; + p4WarpedImfileRow *object; + bool status; + + object = p4WarpedImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4WarpedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -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, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p4StackedImfileRow *object; + bool status; + + object = p4StackedImfileRowAlloc(-32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4StackedImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -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, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p4DiffImfileRow *object; + bool status; + + object = p4DiffImfileRowAlloc(-32, "a string", -32, "a string", "a string", "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4DiffImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -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, "b1_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "b2_uri"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + } + + { + psMetadata *md; + p4MagicMaskImfileRow *object; + bool status; + + object = p4MagicMaskImfileRowAlloc(-32, "a string", -32, "a string", "a string"); + if (!object) { + exit(EXIT_FAILURE); + } + + md = p4MagicMaskImfileMetadataFromObject(object); + if (!md) { + exit(EXIT_FAILURE); + } + + psFree(object); + + if (!psMetadataLookupS32(&status, md, "p4_id") == -32) { + psFree(md); + exit(EXIT_FAILURE); + } + if (strncmp(psMetadataLookupPtr(&status, md, "exp_tag"), "a string", MAX_STRING_LENGTH)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataLookupS32(&status, md, "p3_version") == -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); + } + + psFree(md); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/objectfrommetadata.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/objectfrommetadata.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/objectfrommetadata.c (revision 22016) @@ -0,0 +1,2953 @@ +#include +#include +#include +#include + +#define MAX_STRING_LENGTH 1024 + +int main () +{ + { + psMetadata *md; + expTagCounterRow *object; + + md = psMetadataAlloc(); + psFree(md); + exit(EXIT_FAILURE); + } + + object = expTagCounterObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + summitExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 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_id, "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_id", 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_id, "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_id", 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_id, "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_id", 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, "exp_tag", 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_id, "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->exp_tag, "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_id", 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_id, "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_id", 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, "exp_tag", 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_id, "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->exp_tag, "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(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 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 (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "workdir", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = newExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_id, "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 (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + newImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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 = newImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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; + rawExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_id", 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 (!psMetadataAddS32(md, PS_LIST_TAIL, "imfiles", 0, NULL, -32)) { + 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, "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 (!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 (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = rawExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_id, "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 (!object->imfiles == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->workdir, "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->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 (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + rawImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_type", 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 (!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 (!psMetadataAddStr(md, PS_LIST_TAIL, "object", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = rawImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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); + } + if (strncmp(object->exp_type, "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->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 (strncmp(object->object, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p1PendingExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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 (!psMetadataAddS32(md, PS_LIST_TAIL, "p1_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p1PendingExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p2PendingExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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 (!psMetadataAddS32(md, PS_LIST_TAIL, "p1_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p2PendingExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p2PendingImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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, "recipe", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p1_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p2PendingImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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->recipe, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p2ProcessedExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p1_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p2ProcessedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p2MaskRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p2MaskObjectFromMetadata(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; + p2ProcessedImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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, "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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p1_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = p2ProcessedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p1_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p3PendingExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p3PendingExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p3ProcessedExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 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 (!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 (!psMetadataAddS32(md, PS_LIST_TAIL, "nastro", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) { + 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 (!psMetadataAddS32(md, PS_LIST_TAIL, "p2_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = p3ProcessedExpObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (strncmp(object->exp_tag, "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->sigma_ra == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->sigma_dec == 32.32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->nastro == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + 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->p2_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->label, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p3MaskRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddStr(md, PS_LIST_TAIL, "label", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p3MaskObjectFromMetadata(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; + detRunRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "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, "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); + } + + object = detRunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->det_id == -32) { + 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->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->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); + } + + psFree(object); + } + + { + psMetadata *md; + detInputExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "exp_tag", 0, NULL, "a string")) { + 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); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->include == true) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detProcessedImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detProcessedExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detStackedImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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); + } + psFree(md); + exit(EXIT_FAILURE); + } + + object = detStackedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->det_id == -32) { + 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); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detNormalizedStatImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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); + + if (!object->det_id == -32) { + 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(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + 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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detNormalizedExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + 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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detResidImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "exp_tag", 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, "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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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->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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + detResidExpRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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, "exp_tag", 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 (!psMetadataAddStr(md, PS_LIST_TAIL, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 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); + + if (!object->det_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->iteration == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "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 (strncmp(object->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "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(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "det_id", 0, NULL, -32)) { + 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); + + if (!object->det_id == -32) { + 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; + p4RunRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "survey_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, "filter", 0, NULL, "a string")) { + 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 (!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 (!psMetadataAddStr(md, PS_LIST_TAIL, "input_ss", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "output_ss", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p4RunObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->survey_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->filter, "a string", MAX_STRING_LENGTH)) { + 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->ra == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->decl == 64.64) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->input_ss, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->output_ss, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p4InputImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 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); + } + + object = p4InputImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->class_id, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p4WarpedImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 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, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p4WarpedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p4StackedImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 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, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p4StackedImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p4DiffImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 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, "b1_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "b2_uri", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + + object = p4DiffImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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->b1_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->b2_uri, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + + psFree(object); + } + + { + psMetadata *md; + p4MagicMaskImfileRow *object; + + md = psMetadataAlloc(); + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p4_id", 0, NULL, -32)) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddStr(md, PS_LIST_TAIL, "exp_tag", 0, NULL, "a string")) { + psFree(md); + exit(EXIT_FAILURE); + } + if (!psMetadataAddS32(md, PS_LIST_TAIL, "p3_version", 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); + } + + object = p4MagicMaskImfileObjectFromMetadata(md); + if (!object) { + psFree(md); + exit(EXIT_FAILURE); + } + + psFree(md); + + if (!object->p4_id == -32) { + psFree(object); + exit(EXIT_FAILURE); + } + if (strncmp(object->exp_tag, "a string", MAX_STRING_LENGTH)) { + psFree(object); + exit(EXIT_FAILURE); + } + if (!object->p3_version == -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); + } + + psFree(object); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/selectrowsfits.c =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/selectrowsfits.c (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/selectrowsfits.c (revision 22016) @@ -0,0 +1,824 @@ +#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 (!expTagCounterSelectRowsFits(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 (!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 (!p1PendingExpSelectRowsFits(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 (!p2PendingExpSelectRowsFits(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 (!p2PendingImfileSelectRowsFits(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 (!p2ProcessedExpSelectRowsFits(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 (!p2MaskSelectRowsFits(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 (!p2ProcessedImfileSelectRowsFits(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 (!p3PendingExpSelectRowsFits(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 (!p3ProcessedExpSelectRowsFits(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 (!p3MaskSelectRowsFits(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 (!p4RunSelectRowsFits(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 (!p4InputImfileSelectRowsFits(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 (!p4WarpedImfileSelectRowsFits(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 (!p4StackedImfileSelectRowsFits(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 (!p4DiffImfileSelectRowsFits(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 (!p4MagicMaskImfileSelectRowsFits(dbh, fits, NULL, 1)) { + exit(EXIT_FAILURE); + } + + psFree(fits); + psDBCleanup(dbh); + } + + exit(EXIT_SUCCESS); +} Index: /tags/ipp-1-X/rel-0_0_79/ippdb/tests/testsuite.at =================================================================== --- /tags/ipp-1-X/rel-0_0_79/ippdb/tests/testsuite.at (revision 22016) +++ /tags/ipp-1-X/rel-0_0_79/ippdb/tests/testsuite.at (revision 22016) @@ -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 + +###