rdo-postgres 0.0.6 → 0.0.7

data/README.md

@@ -8,9 +8,8 @@ This is the PostgreSQL driver for [RDO—Ruby Data Objects]
 Refer to the RDO project [README](https://github.com/d11wtq/rdo) for usage
 information.
 
-This driver cannot be used with Postgres versions older than 7.4, since the
-protocol has changed and this driver takes advantage of newer protocol (3.0)
-features.
+This driver cannot be used with PostgreSQL versions older than 7.4. Those
+versions are no longer supported by PostgreSQL in any case.
 
 ## Installation
 
@@ -51,6 +50,33 @@ conn = RDO.connect(
 )
 ```
 
+### Type Support
+
+If not listed below, the String form of the value will be returned. The
+currently mapped types are:
+
+  - NULL -> nil
+  - BOOLEAN -> TrueClass/FalseClass
+  - TEXT -> String
+  - VARCHAR -> String
+  - CHAR -> String
+  - BYTEA -> String
+  - INTEGER -> Fixnum
+  - INT2 -> Fixnum
+  - INT4 -> Fixnum
+  - INT8 -> Fixnum
+  - FLOAT/REAL -> Float
+  - FLOAT4 -> Float
+  - FLOAT8 -> Float
+  - NUMERIC/DECIMAL -> BigDecimal
+  - DATE -> Date
+  - TIMESTAMP -> DateTime (in the system time zone)
+  - TIMESTAMPTZ -> DateTime (in the specified time zone)
+
+All 1-dimensional Arrays of the above listed are also available. Support for
+multi-dimensional Arrays is planned immediately. Support for custom-typed
+Arrays is coming.
+
 ### Bind parameters support
 
 PostgreSQL uses $1, $2 etc for bind parameters. RDO uses '?'. You can use
@@ -72,17 +98,13 @@ conn.execute("SELECT * FROM users WHERE banned = $1 AND created_at > ?", true, 1
 
 ## Contributing
 
-Contributions to support older versions of PostgreSQL (< 7.4) welcomed,
-though if the changes required break the native support for newer versions
-pull requests will not be accepted. It is possible to write a separate
-driver for older versions of PostgreSQL and register it under the driver
-name 'postgresql' instead of this one if that is preferable. Alternatively,
-use an explicit name that indicates legacy compatibility, such as
-'postgres73'.
-
 If you find any bugs, please send a pull request if you think you can
 fix it, or file in an issue in the issue tracker.
 
+I'm particulary interested in patches surrounding support for built-in type
+arrays, multi-dimensional arrays and arrays of custom types, such as ENUMs
+(in order of difficulty/preference).
+
 When sending pull requests, please use topic branches—don't send a pull
 request from the master branch of your fork, as that may change
 unintentionally.

data/ext/rdo_postgres/arrays.c

@@ -0,0 +1,48 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "arrays.h"
+#include "casts.h"
+#include "macros.h"
+#include <ruby.h>
+#include <libpq-fe.h>
+
+/** Parse a bytea string into a binary Ruby String */
+static VALUE rdo_postgres_array_bytea_parse_value(VALUE self, VALUE s) {
+  s = rb_call_super(1, &s);
+  Check_Type(s, T_STRING);
+  return rdo_postgres_cast_bytea(RSTRING_PTR(s), RSTRING_LEN(s));
+}
+
+/** Format a value as a bytea */
+static VALUE rdo_postgres_array_bytea_format_value(VALUE self, VALUE v) {
+  if (TYPE(v) != T_STRING) {
+    v = RDO_OBJ_TO_S(v);
+  }
+
+  size_t          len   = 0;
+  unsigned char * bytea = PQescapeBytea((unsigned char *) RSTRING_PTR(v),
+      RSTRING_LEN(v), &len);
+
+  VALUE escaped   = rb_str_new((char *) bytea, len - 1);
+  VALUE formatted = rb_call_super(1, &escaped);
+
+  PQfreemem(bytea);
+
+  return formatted;
+}
+
+/** Initialize Array extensions */
+void Init_rdo_postgres_arrays(void) {
+  VALUE cByteaArray = rb_path2class("RDO::Postgres::Array::Bytea");
+
+  rb_define_method(cByteaArray,
+      "parse_value", rdo_postgres_array_bytea_parse_value, 1);
+
+  rb_define_method(cByteaArray,
+      "format_value", rdo_postgres_array_bytea_format_value, 1);
+}

data/ext/rdo_postgres/arrays.h

@@ -0,0 +1,9 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+/** Initialize Array C extensions */
+void Init_rdo_postgres_arrays(void);

data/ext/rdo_postgres/casts.c

@@ -7,13 +7,18 @@
 
 #include "casts.h"
 #include <stdlib.h>
-#include <postgres.h>
-#include <catalog/pg_type.h>
 #include "macros.h"
+#include "types.h"
 
 /** Predicate test if the given string is formatted as \x0afe... */
 #define RDO_PG_NEW_HEX_P(s, len) (len >= 2 && s[0] == '\\' && s[1] == 'x')
 
+/** Parse a PostgreSQL array and return an Array for the given type */
+#define RDO_PG_ARRAY(clsname, s, len) \
+  (rb_funcall((rb_funcall(rb_path2class("RDO::Postgres::Array::" clsname), \
+                          rb_intern("parse"), 1, rb_str_new(s, len))), \
+              rb_intern("to_a"), 0))
+
 /** Lookup table for fast conversion of bytea hex strings to binary data */
 static char * RDOPostgres_HexLookup;
 
@@ -45,19 +50,27 @@ static VALUE rdo_postgres_cast_bytea_hex(char * hex, size_t len) {
 
 /** Cast from a bytea to a String according to a regular escape format */
 static VALUE rdo_postgres_cast_bytea_escape(char * escaped, size_t len) {
-  unsigned char * buffer  = PQunescapeBytea(escaped, &len);
+  unsigned char * buffer  = PQunescapeBytea((unsigned char *) escaped, &len);
 
   if (buffer == NULL) {
     rb_raise(rb_eRuntimeError,
         "Failed to allocate memory for PQunescapeBytea() conversion");
   }
 
-  VALUE str = rb_str_new(buffer, len);
+  VALUE str = rb_str_new((char *) buffer, len);
   PQfreemem(buffer);
 
   return str;
 }
 
+/** Cast from a bytea to a String, automatically detecting the format */
+VALUE rdo_postgres_cast_bytea(char * escaped, size_t len) {
+  if (RDO_PG_NEW_HEX_P(escaped, len))
+    return rdo_postgres_cast_bytea_hex(escaped, len);
+  else
+    return rdo_postgres_cast_bytea_escape(escaped, len);
+}
+
 /** Get the value as a ruby type */
 VALUE rdo_postgres_cast_value(PGresult * res, int row, int col, int enc) {
   if (PQgetisnull(res, row, col)) {
@@ -68,42 +81,72 @@ VALUE rdo_postgres_cast_value(PGresult * res, int row, int col, int enc) {
   int    length = PQgetlength(res, row, col);
 
   switch (PQftype(res, col)) {
-    case INT2OID:
-    case INT4OID:
-    case INT8OID:
+    case RDO_PG_INT2OID:
+    case RDO_PG_INT4OID:
+    case RDO_PG_INT8OID:
       return RDO_FIXNUM(value);
 
-    case FLOAT4OID:
-    case FLOAT8OID:
+    case RDO_PG_FLOAT4OID:
+    case RDO_PG_FLOAT8OID:
       return RDO_FLOAT(value);
 
-    case NUMERICOID:
+    case RDO_PG_NUMERICOID:
       return RDO_DECIMAL(value);
 
-    case BOOLOID:
+    case RDO_PG_BOOLOID:
       return RDO_BOOL(value);
 
-    case BYTEAOID:
-      if (RDO_PG_NEW_HEX_P(value, length))
-        return rdo_postgres_cast_bytea_hex(value, length);
-      else
-        return rdo_postgres_cast_bytea_escape(value, length);
+    case RDO_PG_BYTEAOID:
+      return rdo_postgres_cast_bytea(value, length);
 
-    case DATEOID:
+    case RDO_PG_DATEOID:
       return RDO_DATE(value);
 
-    case TIMESTAMPOID:
+    case RDO_PG_TIMESTAMPOID:
       return RDO_DATE_TIME_WITHOUT_ZONE(value);
 
-    case TIMESTAMPTZOID:
+    case RDO_PG_TIMESTAMPTZOID:
       return RDO_DATE_TIME_WITH_ZONE(value);
 
-    case TEXTOID:
-    case CHAROID:
-    case VARCHAROID:
-    case BPCHAROID:
+    case RDO_PG_TEXTOID:
+    case RDO_PG_CHAROID:
+    case RDO_PG_VARCHAROID:
+    case RDO_PG_BPCHAROID:
       return RDO_STRING(value, length, enc);
 
+    case RDO_PG_TEXTARRAYOID:
+    case RDO_PG_CHARARRAYOID:
+    case RDO_PG_BPCHARARRAYOID:
+    case RDO_PG_VARCHARARRAYOID:
+      return RDO_PG_ARRAY("Text", value, length);
+
+    case RDO_PG_INT2ARRAYOID:
+    case RDO_PG_INT4ARRAYOID:
+    case RDO_PG_INT8ARRAYOID:
+      return RDO_PG_ARRAY("Integer", value, length);
+
+    case RDO_PG_FLOAT4ARRAYOID:
+    case RDO_PG_FLOAT8ARRAYOID:
+      return RDO_PG_ARRAY("Float", value, length);
+
+    case RDO_PG_NUMERICARRAYOID:
+      return RDO_PG_ARRAY("Numeric", value, length);
+
+    case RDO_PG_BOOLARRAYOID:
+      return RDO_PG_ARRAY("Boolean", value, length);
+
+    case RDO_PG_BYTEAARRAYOID:
+      return RDO_PG_ARRAY("Bytea", value, length);
+
+    case RDO_PG_DATEARRAYOID:
+      return RDO_PG_ARRAY("Date", value, length);
+
+    case RDO_PG_TIMESTAMPARRAYOID:
+      return RDO_PG_ARRAY("Timestamp", value, length);
+
+    case RDO_PG_TIMESTAMPTZARRAYOID:
+      return RDO_PG_ARRAY("TimestampTZ", value, length);
+
     default:
       return RDO_BINARY_STRING(value, length);
   }
@@ -111,11 +154,11 @@ VALUE rdo_postgres_cast_value(PGresult * res, int row, int col, int enc) {
 
 /* Initialize hex decoding lookup table */
 void Init_rdo_postgres_casts(void) {
-  RDOPostgres_HexLookup = malloc(sizeof(char) * 128);
+  RDOPostgres_HexLookup = malloc(sizeof(char) * 256);
 
   if (RDOPostgres_HexLookup == NULL) {
     rb_raise(rb_eRuntimeError,
-        "Failed to allocate 128 bytes for internal lookup table");
+        "Failed to allocate 256 bytes for internal lookup table");
   }
 
   char c;

data/ext/rdo_postgres/casts.h

@@ -12,5 +12,8 @@
 /** Cast the given value from the result to a ruby type */
 VALUE rdo_postgres_cast_value(PGresult * res, int row, int col, int enc);
 
+/** Special case for casting a bytea value */
+VALUE rdo_postgres_cast_bytea(char * escaped, size_t len);
+
 /** Initialize the casting framework */
 void Init_rdo_postgres_casts(void);

data/ext/rdo_postgres/driver.c

@@ -49,12 +49,10 @@ static VALUE rdo_postgres_driver_open(VALUE self) {
       RSTRING_PTR(rb_funcall(self, rb_intern("connect_db_string"), 0)));
 
   if (driver->conn_ptr == NULL || PQstatus(driver->conn_ptr) == CONNECTION_BAD) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "PostgreSQL connection failed: %s",
+    RDO_ERROR("PostgreSQL connection failed: %s",
         PQerrorMessage(driver->conn_ptr));
   } else if (PQprotocolVersion(driver->conn_ptr) < 3) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "rdo-postgres requires PostgreSQL protocol version >= 3 (using %u). "
+    RDO_ERROR("rdo-postgres requires PostgreSQL protocol version >= 3 (using %u). "
         "PostgreSQL >= 7.4 required.",
         PQprotocolVersion(driver->conn_ptr));
   } else {
@@ -98,8 +96,7 @@ static VALUE rdo_postgres_driver_prepare(VALUE self, VALUE cmd) {
   Data_Get_Struct(self, RDOPostgresDriver, driver);
 
   if (!(driver->is_open)) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Unable to prepare statement: connection is not open");
+    RDO_ERROR("Unable to prepare statement: connection is not open");
   }
 
   char name[32];
@@ -120,8 +117,7 @@ static VALUE rdo_postgres_driver_quote(VALUE self, VALUE str) {
   Data_Get_Struct(self, RDOPostgresDriver, driver);
 
   if (!(driver->is_open)) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Unable to quote string: connection is not open");
+    RDO_ERROR("Unable to quote string: connection is not open");
   }
 
   char * quoted = malloc(sizeof(char) * RSTRING_LEN(str) * 2 + 1);

data/ext/rdo_postgres/extconf.rb

@@ -14,8 +14,7 @@ def have_build_env
   [
     have_library("pq") || have_library("libpq"),
     have_header("libpq-fe.h"),
-    have_header("postgres.h"),
-    have_header("catalog/pg_type.h")
+    have_header("postgres.h")
   ].all?
 end
 

data/ext/rdo_postgres/rdo_postgres.c

@@ -8,6 +8,7 @@
 #include <stdlib.h>
 #include <ruby.h>
 #include "driver.h"
+#include "arrays.h"
 
 /**
  * Extension initializer.
@@ -15,4 +16,5 @@
 void Init_rdo_postgres(void) {
   rb_require("rdo");
   Init_rdo_postgres_driver();
+  Init_rdo_postgres_arrays();
 }

data/ext/rdo_postgres/statements.c

@@ -12,8 +12,7 @@
 #include "macros.h"
 #include <stdlib.h>
 #include <libpq-fe.h>
-#include <postgres.h>
-#include <catalog/pg_type.h>
+#include "types.h"
 
 /** I don't like magic numbers */
 #define RDO_PG_NO_OIDS 0
@@ -21,6 +20,11 @@
 #define RDO_PG_TEXT_INPUT NULL
 #define RDO_PG_TEXT_OUTPUT 0
 
+/** Wrap a Ruby Array with a RDO::Postgres::Array */
+#define RDO_PG_WRAP_ARRAY(clsname, a) \
+  (rb_funcall(rb_path2class("RDO::Postgres::Array::" clsname), \
+              rb_intern("new"), 1, a))
+
 /** RDO::Postgres::StatementExecutor */
 static VALUE rdo_postgres_cStatementExecutor;
 
@@ -60,8 +64,7 @@ static void rdo_postgres_statement_executor_prepare(VALUE self) {
   Data_Get_Struct(self, RDOPostgresStatementExecutor, executor);
 
   if (!(executor->driver->is_open)) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Unable to prepare statement: connection is not open");
+    RDO_ERROR("Unable to prepare statement: connection is not open");
   }
 
   char           * cmd = rdo_postgres_params_inject_markers(executor->cmd);
@@ -85,8 +88,7 @@ static void rdo_postgres_statement_executor_prepare(VALUE self) {
     char msg[sizeof(char) * (strlen(PQresultErrorMessage(res)) + 1)];
     strcpy(msg, PQresultErrorMessage(res));
     PQclear(res);
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Failed to prepare statement: %s", msg);
+    RDO_ERROR("Failed to prepare statement: %s", msg);
   }
 
   res = PQdescribePrepared(executor->driver->conn_ptr, executor->stmt_name);
@@ -95,8 +97,7 @@ static void rdo_postgres_statement_executor_prepare(VALUE self) {
     char msg[sizeof(char) * (strlen(PQresultErrorMessage(res)) + 1)];
     strcpy(msg, PQresultErrorMessage(res));
     PQclear(res);
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Failed to prepare statement: %s", msg);
+    RDO_ERROR("Failed to prepare statement: %s", msg);
   }
 
   executor->nparams     = PQnparams(res);
@@ -154,12 +155,11 @@ static VALUE rdo_postgres_statement_executor_execute(int argc, VALUE * args,
   Data_Get_Struct(self, RDOPostgresStatementExecutor, executor);
 
   if (!(executor->driver->is_open)) {
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Unable to execute statement: connection is not open");
+    RDO_ERROR("Unable to execute statement: connection is not open");
   }
 
   if (argc != executor->nparams) {
-    rb_raise(rb_path2class("RDO::Exception"),
+    rb_raise(rb_eArgError,
         "Bind parameter count mismatch: wanted %i, got %i",
         executor->nparams, argc);
   }
@@ -173,13 +173,21 @@ static VALUE rdo_postgres_statement_executor_execute(int argc, VALUE * args,
       values[i]  = NULL;
       lengths[i] = 0;
     } else {
+      if (TYPE(args[i]) == T_ARRAY) {
+        if (executor->param_types[i] == RDO_PG_BYTEAARRAYOID) {
+          args[i] = RDO_PG_WRAP_ARRAY("Bytea", args[i]);
+        } else {
+          args[i] = RDO_PG_WRAP_ARRAY("Text", args[i]);
+        }
+      }
+
       if (TYPE(args[i]) != T_STRING) {
         args[i] = RDO_OBJ_TO_S(args[i]);
       }
 
-      if (executor->param_types[i] == BYTEAOID) {
-        values[i] = PQescapeByteaConn(executor->driver->conn_ptr,
-            RSTRING_PTR(args[i]),
+      if (executor->param_types[i] == RDO_PG_BYTEAOID) {
+        values[i] = (char *) PQescapeByteaConn(executor->driver->conn_ptr,
+            (unsigned char *) RSTRING_PTR(args[i]),
             RSTRING_LEN(args[i]),
             &(lengths[i]));
       } else {
@@ -199,7 +207,7 @@ static VALUE rdo_postgres_statement_executor_execute(int argc, VALUE * args,
       RDO_PG_TEXT_OUTPUT);
 
   for (i = 0; i < argc; ++i) {
-    if (executor->param_types[i] == BYTEAOID) {
+    if (executor->param_types[i] == RDO_PG_BYTEAOID) {
       PQfreemem(values[i]);
     }
   }
@@ -208,13 +216,10 @@ static VALUE rdo_postgres_statement_executor_execute(int argc, VALUE * args,
 
   if (status == PGRES_BAD_RESPONSE || status == PGRES_FATAL_ERROR) {
     PQclear(res);
-    rb_raise(rb_path2class("RDO::Exception"),
-        "Failed to execute statement: %s", PQresultErrorMessage(res));
+    RDO_ERROR("Failed to execute statement: %s", PQresultErrorMessage(res));
   }
 
-  return rb_funcall(rb_path2class("RDO::Result"),
-      rb_intern("new"), 2,
-      rdo_postgres_tuple_list_new(res, executor->driver->encoding),
+  return RDO_RESULT(rdo_postgres_tuple_list_new(res, executor->driver->encoding),
       rdo_postgres_result_info_new(res));
 }