forge: main/database/src/converters.cc comparison

comparison main/database/src/converters.cc @ 12718:1af86934c14e octave-forge

Make compatible with Octaves new exception-based error handling. Retain compatibility with Octaves old error handling based on error_state. * src/error_helpers.[h,cc]: Added. * src/Makefile.in: Integrate error-helpers.[h,cc]. * src/config.h.in: Added. * configure.ac, src/config.h.in: Test presence of 'error_state' and presence of 'verror (octave_execution_exception&, const char *, va_list)'. * src/__pq_connect__.cc, src/command.cc, src/command.h, src/converters.cc, src/converters_arr_comp.cc, src/pq_connection.cc, src/pq_conninfo.cc, src/pq_exec.cc, src/pq_lo.cc, src/pq_update_types.cc: If necessary, include error-helpers.h, replace error() with c_verror(), set and check a different error indicator than error_state, use CHECK_ERROR or SET_ERR, explicitely check for errors instead of relying on Octave checking error_state when returning to the prompt.

author	i7tiol
date	Sat, 27 Feb 2016 11:11:04 +0000
parents	2257648e8ce1
children	52ca082757c2

comparison

equal deleted inserted replaced

-:87989220360f
+:1af86934c14e
 #include <sys/socket.h> // for AF_INET, needed in network address types
 #endif
 #include "converters.h"
 #include "pq_connection.h"
+#include "error-helpers.h"
 // remember to adjust OCT_PQ_NUM_CONVERTERS in converters.h
 #define PGSQL_AF_INET6 (AF_INET + 1) // defined so in postgresql, no
 // public header file available
 }
 int from_octave_str_bool (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-bool b = ov.bool_value ();
+bool b, err;
+SET_ERR (b = ov.bool_value (), err);
-if (error_state)
-{
+if (err)
-error ("can not convert octave_value to bool value");
+{
+c_verror ("can not convert octave_value to bool value");
 return 1;
 }
 val.push_back (b ? '1' : '0');
 val.push_back ('\0');
 }
 int from_octave_bin_bool (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-bool b = ov.bool_value ();
+bool b, err;
+SET_ERR (b = ov.bool_value (), err);
-if (error_state)
-{
+if (err)
-error ("can not convert octave_value to bool value");
+{
+c_verror ("can not convert octave_value to bool value");
 return 1;
 }
 val.push_back (char (b));
 }
 int from_octave_bin_oid (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-uint32_t oid = ov.uint_value ();
+uint32_t oid;
+bool err;
-if (error_state)
+SET_ERR (oid = ov.uint_value (), err);
-{
-error ("can not convert octave_value to oid value");
+if (err)
+{
+c_verror ("can not convert octave_value to oid value");
 return 1;
 }
 OCT_PQ_PUT(val, uint32_t, htobe32 (oid))
 double d;
 int64_t i;
 }
 swap;
-swap.d = ov.double_value ();
+bool err;
+SET_ERR (swap.d = ov.double_value (), err);
-if (error_state)
-{
+if (err)
-error ("can not convert octave_value to float8 value");
+{
+c_verror ("can not convert octave_value to float8 value");
 return 1;
 }
 OCT_PQ_PUT(val, int64_t, htobe64 (swap.i))
 float f;
 int32_t i;
 }
 swap;
-swap.f = ov.float_value ();
+bool err;
+SET_ERR (swap.f = ov.float_value (), err);
-if (error_state)
-{
+if (err)
-error ("can not convert octave_value to float4 value");
+{
+c_verror ("can not convert octave_value to float4 value");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (swap.i))
 }
 int from_octave_bin_bytea (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-uint8NDArray b = ov.uint8_array_value ();
+uint8NDArray b;
+bool err;
-if (error_state)
+SET_ERR (b = ov.uint8_array_value (), err);
-{
-error ("can not convert octave_value to bytea representation");
+if (err)
+{
+c_verror ("can not convert octave_value to bytea representation");
 return 1;
 }
 octave_idx_type nl = b.numel ();
 }
 int from_octave_bin_text (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-std::string s = ov.string_value ();
+std::string s;
+bool err;
-if (error_state)
+SET_ERR (s = ov.string_value (), err);
-{
-error ("can not convert octave_value to string");
+if (err)
+{
+c_verror ("can not convert octave_value to string");
 return 1;
 }
 octave_idx_type l = s.size ();
 }
 int from_octave_bin_int2 (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-int16_t i2 = ov.int_value ();
+int16_t i2;
+bool err;
-if (error_state)
+SET_ERR (i2 = ov.int_value (), err);
-{
-error ("can not convert octave_value to int2 value");
+if (err)
+{
+c_verror ("can not convert octave_value to int2 value");
 return 1;
 }
 OCT_PQ_PUT(val, int16_t, htobe16 (i2))
 }
 int from_octave_bin_int4 (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-int32_t i4 = ov.int_value ();
+int32_t i4;
+bool err;
-if (error_state)
+SET_ERR (i4 = ov.int_value (), err);
-{
-error ("can not convert octave_value to int4 value");
+if (err)
+{
+c_verror ("can not convert octave_value to int4 value");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (i4))
 }
 int from_octave_bin_int8 (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-int64_t i8 = ov.int64_scalar_value ();
+int64_t i8;
+bool err;
-if (error_state)
+SET_ERR (i8 = ov.int64_scalar_value (), err);
-{
-error ("can not convert octave_value to int8 value");
+if (err)
+{
+c_verror ("can not convert octave_value to int8 value");
 return 1;
 }
 OCT_PQ_PUT(val, int64_t, htobe64 (i8))
 if (int_dt)
 {
 // don't convert automatically because of possible overflow
 if (ov.is_float_type ())
 {
-error ("floating point octave_value provided for 8-byte time value, but postgresql is configured for int64");
+c_verror ("floating point octave_value provided for 8-byte time value, but postgresql is configured for int64");
 return 1;
 }
-int64_t i8 = ov.int64_scalar_value ();
+int64_t i8;
+bool err;
-if (error_state)
+SET_ERR (i8 = ov.int64_scalar_value (), err);
+if (err)
 {
-error ("can not convert octave_value to int64 time value");
+c_verror ("can not convert octave_value to int64 time value");
 return 1;
 }
 OCT_PQ_PUT(val, int64_t, htobe64 (i8))
 else
 {
 // don't convert automatically because of possible loss of accuracy
 if (ov.is_integer_type ())
 {
-error ("integer type octave_value provided for 8-byte time value, but postgresql is configured for double");
+c_verror ("integer type octave_value provided for 8-byte time value, but postgresql is configured for double");
 return 1;
 }
 union
 {
 double d;
 int64_t i;
 }
 swap;
-swap.d = ov.double_value ();
+bool err;
+SET_ERR (swap.d = ov.double_value (), err);
-if (error_state)
+if (err)
 {
-error ("can not convert octave_value to double time value");
+c_verror ("can not convert octave_value to double time value");
 return 1;
 }
 OCT_PQ_PUT(val, int64_t, htobe64 (swap.i))
 }
 int from_octave_bin_interval (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-Cell iv = ov.cell_value ();
+Cell iv;
-if (error_state || iv.numel () != 3)
+bool err;
-{
+SET_ERR (iv = ov.cell_value (), err);
-error ("interval: can not convert octave_value to cell with 3 elements");
+if (err || iv.numel () != 3)
+{
+c_verror ("interval: can not convert octave_value to cell with 3 elements");
 return 1;
 }
 if (time_8byte_from_octave (iv(0), val, conn.get_integer_datetimes ()))
 return 1;
 for (int id = 1; id < 3; id++)
 {
-int32_t i4 = iv(id).int_value ();
+int32_t i4;
+bool err;
-if (error_state)
+SET_ERR (i4 = iv(id).int_value (), err);
+if (err)
 {
-error ("interval: can not convert octave_value to int4 value");
+c_verror ("interval: can not convert octave_value to int4 value");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (i4))
 }
 }
 int from_octave_bin_timetz (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-Cell iv = ov.cell_value ();
+Cell iv;
-if (error_state || iv.numel () != 2)
+bool err;
-{
+SET_ERR (iv = ov.cell_value (), err);
-error ("timetz: can not convert octave_value to cell with 2 elements");
+if (err || iv.numel () != 2)
+{
+c_verror ("timetz: can not convert octave_value to cell with 2 elements");
 return 1;
 }
 if (time_8byte_from_octave (iv(0), val, conn.get_integer_datetimes ()))
 return 1;
-int32_t i4 = iv(1).int_value ();
+int32_t i4;
+SET_ERR (i4 = iv(1).int_value (), err);
-if (error_state)
-{
+if (err)
-error ("timetz: can not convert octave_value to int4 value");
+{
+c_verror ("timetz: can not convert octave_value to int4 value");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (i4))
 }
 int from_octave_bin_date (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-int32_t i4 = ov.int_value ();
+int32_t i4;
+bool err;
-if (error_state)
+SET_ERR (i4 = ov.int_value (), err);
-{
-error ("date: can not convert octave_value to int4 value");
+if (err)
+{
+c_verror ("date: can not convert octave_value to int4 value");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (i4))
 }
 int from_octave_bin_point (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-NDArray m = ov.array_value ();
+NDArray m;
+bool err;
-if (error_state || m.numel () != 2)
+SET_ERR (m = ov.array_value (), err);
-{
-error ("can not convert octave_value to point representation");
+if (err || m.numel () != 2)
+{
+c_verror ("can not convert octave_value to point representation");
 return 1;
 }
 union
 {
 }
 int from_octave_bin_lseg (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-NDArray m = ov.array_value ();
+NDArray m;
+bool err;
-if (error_state || m.numel () != 4)
+SET_ERR (m = ov.array_value (), err);
-{
-error ("can not convert octave_value to 4 doubles");
+if (err || m.numel () != 4)
+{
+c_verror ("can not convert octave_value to 4 doubles");
 return 1;
 }
 union
 {
 }
 int from_octave_bin_circle (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-NDArray m = ov.array_value ();
+NDArray m;
+bool err;
-if (error_state || m.numel () != 3)
+SET_ERR (m = ov.array_value (), err);
-{
-error ("can not convert octave_value to circle representation");
+if (err || m.numel () != 3)
+{
+c_verror ("can not convert octave_value to circle representation");
 return 1;
 }
 union
 {
 int from_octave_bin_polygon (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
 octave_idx_type nel;
-NDArray m = ov.array_value ();
+NDArray m;
+bool err;
-if (error_state || (nel = m.numel ()) % 2)
+SET_ERR (m = ov.array_value (), err);
-{
-error ("can not convert octave_value to polygon representation");
+if (err || (nel = m.numel ()) % 2)
+{
+c_verror ("can not convert octave_value to polygon representation");
 return 1;
 }
 union
 {
 }
 int from_octave_bin_path (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-octave_scalar_map tp = ov.scalar_map_value ();
+octave_scalar_map tp;
-if (error_state || ! tp.isfield ("closed") || ! tp.isfield ("path"))
+bool err;
-{
+SET_ERR (tp = ov.scalar_map_value (), err);
-error ("can not convert octave_value to path representation");
+if (err || ! tp.isfield ("closed") || ! tp.isfield ("path"))
+{
+c_verror ("can not convert octave_value to path representation");
 return 1;
 }
 octave_idx_type nel;
-char closed = char (tp.contents ("closed").bool_value ());
+char closed;
+SET_ERR (closed = char (tp.contents ("closed").bool_value ()), err);
-NDArray m = tp.contents ("path").array_value ();
+NDArray m;
-if (error_state || (nel = m.numel ()) % 2)
+if (! err)
 {
-error ("can not convert octave_value to path representation");
+SET_ERR (m = tp.contents ("path").array_value (), err);
+}
+if (err || (nel = m.numel ()) % 2)
+{
+c_verror ("can not convert octave_value to path representation");
 return 1;
 }
 union
 {
 // "no converter found" error thrown.
 int to_octave_str_unknown (const octave_pq_connection_rep &conn,
 const char *c, octave_value &ov, int nb)
 {
-error ("can not convert postgresql type 'unknown'");
+c_verror ("can not convert postgresql type 'unknown'");
 return 1;
 }
 int to_octave_bin_unknown (const octave_pq_connection_rep &conn,
 const char *c, octave_value &ov, int nb)
 {
-error ("can not convert postgresql type 'unknown'");
+c_verror ("can not convert postgresql type 'unknown'");
 return 1;
 }
 int from_octave_str_unknown (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-error ("can not convert postgresql type 'unknown'");
+c_verror ("can not convert postgresql type 'unknown'");
 return 1;
 }
 int from_octave_bin_unknown (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-error ("can not convert postgresql type 'unknown'");
+c_verror ("can not convert postgresql type 'unknown'");
 return 1;
 }
 oct_pq_conv_t conv_unknown = {0,
 if (nb < 0)
 nb = 0;
 if (nb > 4)
 {
-error ("internal error: received too many bytes for AF_INET type");
+c_verror ("internal error: received too many bytes for AF_INET type");
 return 1;
 }
 for (int8_t i = 0; i < nb; i++, c++)
 if (nb < 0)
 nb = 0;
 if (nb > 16)
 {
-error ("internal error: received too many bytes for AF_INET6 type");
+c_verror ("internal error: received too many bytes for AF_INET6 type");
 return 1;
 }
 int8_t n = nb / 2;
 {
 int nl = ov.numel ();
 uint8_t n_mbits;
+bool err;
 if (nl == 4 || nl == 5)
 {
-uint8NDArray a = ov.uint8_array_value ();
+uint8NDArray a;
+SET_ERR (a = ov.uint8_array_value (), err);
-if (error_state)
+if (err)
 {
-error ("can not convert octave_value to network type representation");
+c_verror ("can not convert octave_value to network type representation");
 return 1;
 }
 if (nl == 5)
 n_mbits = a(4).value ();
 for (int i = 0; i < 4; i++)
 val.push_back (a(i).value ());
 }
 else if (nl == 8 || nl == 9)
 {
-uint16NDArray a = ov.uint16_array_value ();
+uint16NDArray a;
+SET_ERR (a = ov.uint16_array_value (), err);
-if (error_state)
+if (err)
 {
-error ("can not convert octave_value to network type representation");
+c_verror ("can not convert octave_value to network type representation");
 return 1;
 }
 if (nl == 9)
 n_mbits = a(8).value ();
 OCT_PQ_PUT(val, uint16_t, htobe16(a(i).value ()))
 }
 }
 else
 {
-error ("invalid network type representation");
+c_verror ("invalid network type representation");
 return 1;
 }
 return 0;
 }
 if (to_octave_bin_cidr_inet (c, ov, cidr))
 return 1;
 if (! cidr)
 {
-error ("internal error: unexpected flag in cidr type");
+c_verror ("internal error: unexpected flag in cidr type");
 return 1;
 }
 return 0;
 if (to_octave_bin_cidr_inet (c, ov, cidr))
 return 1;
 if (cidr)
 {
-error ("internal error: unexpected flag in inet type");
+c_verror ("internal error: unexpected flag in inet type");
 return 1;
 }
 return 0;
 }
 int from_octave_bin_macaddr (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-uint8NDArray a = ov.uint8_array_value ();
+uint8NDArray a;
+bool err;
-if (error_state)
+SET_ERR (a = ov.uint8_array_value (), err);
-{
-error ("can not convert octave_value to macaddr representation");
+if (err)
+{
+c_verror ("can not convert octave_value to macaddr representation");
 return 1;
 }
 if (a.numel () != 6)
 {
-error ("macaddr representation must have 6 elements");
+c_verror ("macaddr representation must have 6 elements");
 return 1;
 }
 for (int i = 0; i < 6; i++)
 val.push_back (a(i).value ());
 }
 int from_octave_bin_bit (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-octave_scalar_map tp = ov.scalar_map_value ();
+octave_scalar_map tp;
-if (error_state || ! tp.isfield ("bitlen") || ! tp.isfield ("bits"))
+bool err;
-{
+SET_ERR (tp = ov.scalar_map_value (), err);
-error ("can not convert octave_value to bitstring representation");
+if (err || ! tp.isfield ("bitlen") || ! tp.isfield ("bits"))
-return 1;
+{
-}
+c_verror ("can not convert octave_value to bitstring representation");
+return 1;
-int32_t nbits = tp.contents ("bitlen").int_value ();
+}
-uint8NDArray a = tp.contents ("bits").uint8_array_value ();
+int32_t nbits;
+SET_ERR (nbits = tp.contents ("bitlen").int_value (), err);
-if (error_state || nbits < 0)
-{
+uint8NDArray a;
-error ("can not convert octave_value to bitstring representation");
+if (! err)
+{
+SET_ERR (a = tp.contents ("bits").uint8_array_value (), err);
+}
+if (err || nbits < 0)
+{
+c_verror ("can not convert octave_value to bitstring representation");
 return 1;
 }
 int32_t nbytes = (nbits + 7) / 8;
 if (a.numel () != nbytes)
 {
-error ("wrong number of elements in bitstring representation");
+c_verror ("wrong number of elements in bitstring representation");
 return 1;
 }
 OCT_PQ_PUT(val, int32_t, htobe32 (nbits))
 }
 int from_octave_bin_uuid (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-uint8NDArray b = ov.uint8_array_value ();
+uint8NDArray b;
+bool err;
-if (error_state)
+SET_ERR (b = ov.uint8_array_value (), err);
-{
-error ("can not convert octave_value to uuid representation");
+if (err)
+{
+c_verror ("can not convert octave_value to uuid representation");
 return 1;
 }
 if (b.numel () != 16)
 {
-error ("uuid representation must have 16 elements");
+c_verror ("uuid representation must have 16 elements");
 return 1;
 }
 for (int i = 0; i < 16; i++)
 val.push_back (b(i).value ());
 }
 int from_octave_bin_xml (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-std::string s = ov.string_value ();
+std::string s;
+bool err;
-if (error_state)
+SET_ERR (s = ov.string_value (), err);
-{
-error ("can not convert octave_value to string");
+if (err)
+{
+c_verror ("can not convert octave_value to string");
 return 1;
 }
 octave_idx_type l = s.size ();
 return 1;
 break;
 default:
 // should not get here
-error ("'record' converter: internal error, undefined type identifier");
+c_verror ("'record' converter: internal error, undefined type identifier");
 return 1;
 }
 p += nb_el;
 }
 int from_octave_bin_record (const octave_pq_connection_rep &conn,
 const octave_value &ov, oct_pq_dynvec_t &val)
 {
-error ("Type 'record' can't be sent to postgresql.");
+c_verror ("Type 'record' can't be sent to postgresql.");
 return 1;
 }
 oct_pq_conv_t conv_record = {0,

Mercurial > forge

comparison main/database/src/converters.cc @ 12718:1af86934c14e octave-forge