rdo-postgres 0.0.1

data/ext/rdo_postgres/driver.h

@@ -0,0 +1,20 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <libpq-fe.h>
+
+/** Struct that RDO::Postgres::Driver wraps */
+typedef struct {
+  PGconn * conn_ptr;
+  int      is_open;
+  int      stmt_count;
+  int      encoding;
+} RDOPostgresDriver;
+
+/** Initializer called during extension init */
+void Init_rdo_postgres_driver(void);

data/ext/rdo_postgres/extconf.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require "mkmf"
+
+if ENV["CC"]
+  RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+def config_value(type)
+  IO.popen("pg_config --#{type}").readline.chomp rescue nil
+end
+
+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")
+  ].all?
+end
+
+dir_config(
+  "pgsql-server",
+  config_value("includedir-server"),
+  config_value("libdir")
+)
+
+dir_config(
+  "pgsql-client",
+  config_value("includedir"),
+  config_value("libdir")
+)
+
+unless have_build_env
+  puts "Unable to find postgresql libraries and headers. Not building."
+  exit(1)
+end
+
+create_makefile("rdo_postgres/rdo_postgres")

data/ext/rdo_postgres/macros.h

@@ -0,0 +1,180 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+/** -------------------------------------------------------------------------
+ * These macros are for use by RDO driver developers.
+ *
+ * They simplify the logic needed when converting types provided by the RDBMS
+ * into their equivalent Ruby types.
+ *
+ * All of these macros take a C string and return a Ruby VALUE.
+ *
+ * The actual logic for many of the conversions is handled in RDO::Util, which
+ * is written in Ruby.
+ * --------------------------------------------------------------------------
+ */
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+/**
+ * Convert a C string to a ruby String.
+ *
+ * @param (char *) s
+ *   a C string that is valid in the default encoding
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_STRING(s, len, enc) ( \
+    rb_enc_associate_index(rb_str_new(s, len), enc > 0 ? enc : 0) \
+    )
+
+/**
+ * Convert a C string to a ruby String, assuming possible NULL bytes.
+ *
+ * @param (char *) s
+ *   a C string, possibly containing nulls
+ *
+ * @param (size_t) len
+ *   the length of the string
+ *
+ * @return VALUE (String)
+ *   a Ruby String
+ */
+#define RDO_BINARY_STRING(s, len) (rb_str_new(s, len))
+
+/**
+ * Convert a C string to a Fixnum.
+ */
+#define RDO_FIXNUM(s) (rb_cstr2inum(s, 10))
+
+/**
+ * Convert a C string to a Float.
+ *
+ * This supports Infinity and NaN.
+ *
+ * @param (char *) s
+ *   a C string representing a float (e.g. "1.234")
+ *
+ * @return VALUE (Float)
+ *   a ruby Float
+ */
+#define RDO_FLOAT(s) ( \
+    rb_funcall(rb_path2class("RDO::Util"), \
+      rb_intern("float"), 1, \
+      rb_str_new2(s)) \
+    )
+
+/**
+ * Convert a C string representing a precision decimal into a BigDecimal.
+ *
+ * @param (char *) s
+ *   a C string representing a decimal ("1.245")
+ *
+ * @return VALUE (BigDecimal)
+ *   a BigDecimal representation of this string
+ *
+ * @example
+ *   RDO_DECIMAL("1.234")
+ *   => #<BigDecimal:7feb42b2b6e8,'0.1234E1',18(18)>
+ */
+#define RDO_DECIMAL(s) ( \
+    rb_funcall(rb_path2class("RDO::Util"), \
+      rb_intern("decimal"), 1, \
+      rb_str_new2(s)) \
+    )
+
+/**
+ * Convert a C string representing a date into a Date.
+ *
+ * @param (char *) s
+ *   the C string with a parseable date
+ *
+ * @return VALUE (Date)
+ *   a Date, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE("431-09-22 BC")
+ *   #<Date: -0430-09-22 ((1564265j,0s,0n),+0s,2299161j)>
+ */
+#define RDO_DATE(s) ( \
+    rb_funcall(rb_path2class("RDO::Util"), \
+      rb_intern("date"), 1, \
+      rb_str_new2(s)) \
+    )
+
+/**
+ * Convert a C string representing a date & time with no time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, assuming the system time zone
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITHOUT_ZONE(s) ( \
+    rb_funcall(rb_path2class("RDO::Util"), \
+      rb_intern("date_time_without_zone"), 1, \
+      rb_str_new2(s)) \
+    )
+
+/**
+ * Convert a C string representing a date & time that includes a time zone into a DateTime.
+ *
+ * @param (char *) s
+ *   the C string with the date & time provided, including the time zone
+ *
+ * @return VALUE (DateTime)
+ *   a DateTime, exactly as was specified in the input
+ *
+ * @example
+ *   RDO_DATE_TIME_WITHOUT_ZONE("2012-09-22 04:36:12+10:00")
+ *   #<DateTime: 2012-09-22T04:36:12+10:00 ((2456192j,66972s,0n),+36000s,2299161j)>
+ */
+#define RDO_DATE_TIME_WITH_ZONE(s) ( \
+    rb_funcall(rb_path2class("RDO::Util"), \
+      rb_intern("date_time_with_zone"), 1, \
+      rb_str_new2(s)) \
+    )
+
+/**
+ * Convert a boolean string to TrueClass/FalseClass.
+ *
+ * @param (char *) s
+ *   a C string that is either 't', 'true', 'f' or 'false'
+ *
+ * @return VALUE (TrueClass, FalseClass)
+ *   the boolean representation
+ */
+#define RDO_BOOL(s) ((s[0] == 't') ? Qtrue : Qfalse)
+
+/**
+ * Wrap the given StatementExecutor in a RDO::Statement.
+ *
+ * @param VALUE
+ *   any object that responds to #command and #execute
+ *
+ * @return VALUE
+ *   an RDO::Statement
+ */
+#define RDO_STATEMENT(executor) ( \
+    rb_funcall(rb_path2class("RDO::Statement"), \
+      rb_intern("new"), 1, executor) \
+    )
+
+/**
+ * Convenience to call #to_s on any Ruby object.
+ */
+#define RDO_OBJ_TO_S(obj) (rb_funcall(obj, rb_intern("to_s"), 0))

data/ext/rdo_postgres/params.c

@@ -0,0 +1,106 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "params.h"
+#include <stdlib.h>
+#include <string.h>
+
+/** Get the strlen of the marker (e.g. $2) based on its index */
+#define RDO_PG_MARKER_LEN(n) (n >= 100 ? 4 : (n >= 10 ? 3 : 2))
+
+/**
+ * Replace e.g. "SELECT ? WHERE ?" with "SELECT $1 WHERE $2".
+ *
+ * Handles string literals and comments.
+ *
+ * This function is deliberately not broken apart, since it needs to be extremely fast.
+ */
+char * rdo_postgres_params_inject_markers(char * stmt) {
+  char * buf     = malloc(sizeof(char) * strlen(stmt) * 4);
+  char * s       = stmt;
+  char * b       = buf;
+  int    n       = 0;
+  int    instr   = 0;
+  int    inident = 0;
+  int    inslcmt = 0;
+  int    inmlcmt = 0;
+
+  for (; *s; ++s, ++b) {
+    switch (*s) {
+      case '/':
+        if (!instr && !inident && !inslcmt && *(s + 1) == '*') {
+          ++inmlcmt;
+          *b = *s;
+          *(++b) = *(++s);
+        } else {
+          *b = *s;
+        }
+        break;
+
+      case '*':
+        if (inmlcmt && *(s + 1) == '/') {
+          --inmlcmt;
+          *b = *s;
+          *(++b) = *(++s);
+        } else {
+          *b = *s;
+        }
+        break;
+
+      case '-':
+        if (!instr && !inident && !inmlcmt && *(s + 1) == '-') {
+          inslcmt = 1;
+          *b = *s;
+          *(++b) = *(++s);
+        } else {
+          *b = *s;
+        }
+        break;
+
+      case '\n':
+      case '\r':
+        inslcmt = 0;
+        *b = *s;
+        break;
+
+      case '\'':
+        if (!inident && !inmlcmt && !inslcmt) {
+          instr = !instr;
+          *b = *s;
+        } else {
+          *b = *s;
+        }
+        break;
+
+      case '"':
+        if (!instr && !inmlcmt && !inslcmt) {
+          inident = !inident;
+          *b = *s;
+        } else {
+          *b = *s;
+        }
+        break;
+
+      case '?':
+        if (!instr && !inident && !inmlcmt && !inslcmt) {
+          sprintf(b, "$%i", ++n);
+          b += RDO_PG_MARKER_LEN(n -1) - 1;
+        } else {
+          *b= *s;
+        }
+        break;
+
+      default:
+        *b = *s;
+        break;
+    }
+  }
+
+  *b = '\0';
+
+  return buf;
+}

data/ext/rdo_postgres/params.h

@@ -0,0 +1,15 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+
+/**
+ * Make a copy of the string sql, replacing '?' markers with numbered $1, $2 etc.
+ *
+ * Memory must be released with free() once the new string is no longer in use.
+ */
+char * rdo_postgres_params_inject_markers(char * sql);

data/ext/rdo_postgres/rdo_postgres.c

@@ -0,0 +1,18 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdlib.h>
+#include <ruby.h>
+#include "driver.h"
+
+/**
+ * Extension initializer.
+ */
+void Init_rdo_postgres(void) {
+  rb_require("rdo");
+  Init_rdo_postgres_driver();
+}

data/ext/rdo_postgres/statements.c

@@ -0,0 +1,237 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "statements.h"
+#include "driver.h"
+#include "params.h"
+#include "tuples.h"
+#include "macros.h"
+#include <stdlib.h>
+#include <libpq-fe.h>
+#include <postgres.h>
+#include <catalog/pg_type.h>
+
+/** I don't like magic numbers */
+#define RDO_PG_NO_OIDS 0
+#define RDO_PG_INFER_TYPES NULL
+#define RDO_PG_TEXT_INPUT NULL
+#define RDO_PG_TEXT_OUTPUT 0
+
+/** RDO::Postgres::StatementExecutor */
+static VALUE rdo_postgres_cStatementExecutor;
+
+/** Struct that the StatementExecutor is wrapped around */
+typedef struct {
+  char              * stmt_name;
+  char              * cmd;
+  int                 nparams;
+  Oid               * param_types;
+  RDOPostgresDriver * driver;
+} RDOPostgresStatementExecutor;
+
+/** Free memory associated with the StatementExecutor during GC */
+static void rdo_postgres_statement_executor_free(
+    RDOPostgresStatementExecutor * executor) {
+  free(executor->stmt_name);
+  free(executor->cmd);
+  free(executor->param_types);
+  free(executor);
+}
+
+/** Extract information about the result into a ruby Hash */
+static VALUE rdo_postgres_result_info_new(PGresult * res) {
+  VALUE info = rb_hash_new();
+  rb_hash_aset(info, ID2SYM(rb_intern("count")), INT2NUM(PQntuples(res)));
+  if (strlen(PQcmdTuples(res)) > 0) {
+    rb_hash_aset(info,
+        ID2SYM(rb_intern("affected_rows")),
+        rb_cstr2inum(PQcmdTuples(res), 10));
+  }
+  return info;
+}
+
+/** Actually issue the PQprepare() command */
+static void rdo_postgres_statement_executor_prepare(VALUE self) {
+  RDOPostgresStatementExecutor * executor;
+  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");
+  }
+
+  char           * cmd = rdo_postgres_params_inject_markers(executor->cmd);
+  PGresult       * res;
+  ExecStatusType   status;
+
+  res = PQprepare(
+      executor->driver->conn_ptr,
+      executor->stmt_name,
+      cmd,
+      RDO_PG_NO_OIDS,
+      RDO_PG_INFER_TYPES);
+
+  free(cmd);
+
+  status = PQresultStatus(res);
+
+  if (status != PGRES_BAD_RESPONSE && status != PGRES_FATAL_ERROR) {
+    PQclear(res);
+  } else {
+    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);
+  }
+
+  res = PQdescribePrepared(executor->driver->conn_ptr, executor->stmt_name);
+
+  if (status != PGRES_COMMAND_OK) {
+    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);
+  }
+
+  executor->nparams     = PQnparams(res);
+  executor->param_types = malloc(sizeof(Oid) * executor->nparams);
+
+  int i = 0;
+  for (; i < executor->nparams; ++i) {
+    executor->param_types[i] = PQparamtype(res, i);
+  }
+
+  PQclear(res);
+}
+
+/** Factory method to return a new StatementExecutor */
+VALUE rdo_postgres_statement_executor_new(VALUE driver, VALUE cmd, VALUE name) {
+  Check_Type(cmd,  T_STRING);
+  Check_Type(name, T_STRING);
+
+  RDOPostgresStatementExecutor * executor =
+    malloc(sizeof(RDOPostgresStatementExecutor));
+
+  Data_Get_Struct(driver, RDOPostgresDriver, executor->driver);
+  executor->stmt_name   = strdup(RSTRING_PTR(name));
+  executor->cmd         = strdup(RSTRING_PTR(cmd));
+  executor->nparams     = 0;
+  executor->param_types = NULL;
+
+  VALUE self = Data_Wrap_Struct(rdo_postgres_cStatementExecutor, 0,
+      rdo_postgres_statement_executor_free, executor);
+
+  rb_obj_call_init(self, 1, &driver);
+
+  return self;
+}
+
+/** Initialize the StatementExecutor with the given driver and command */
+static VALUE rdo_postgres_statement_executor_initialize(VALUE self, VALUE driver) {
+  rb_iv_set(self, "driver", driver); // GC safety
+  rdo_postgres_statement_executor_prepare(self);
+  return self;
+}
+
+/** Accessor for the @command ivar */
+static VALUE rdo_postgres_statement_executor_command(VALUE self) {
+  RDOPostgresStatementExecutor * executor;
+  Data_Get_Struct(self, RDOPostgresStatementExecutor, executor);
+  return rb_str_new2(executor->cmd);
+}
+
+/** Execute with PQexecPrepared() and return a Result */
+static VALUE rdo_postgres_statement_executor_execute(int argc, VALUE * args,
+    VALUE self) {
+
+  RDOPostgresStatementExecutor * executor;
+  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");
+  }
+
+  if (argc != executor->nparams) {
+    rb_raise(rb_path2class("RDO::Exception"),
+        "Bind parameter count mismatch: wanted %i, got %i",
+        executor->nparams, argc);
+  }
+
+  char * values[argc];
+  size_t lengths[argc];
+  int    i;
+
+  for (i = 0; i < argc; ++i) {
+    if (TYPE(args[i]) == T_NIL) {
+      values[i]  = NULL;
+      lengths[i] = 0;
+    } else {
+      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]),
+            RSTRING_LEN(args[i]),
+            &(lengths[i]));
+      } else {
+        values[i]  = RSTRING_PTR(args[i]);
+        lengths[i] = RSTRING_LEN(args[i]);
+      }
+    }
+  }
+
+  PGresult * res = PQexecPrepared(
+      executor->driver->conn_ptr,
+      executor->stmt_name,
+      argc,
+      (const char **) values,
+      (const int *) lengths,
+      RDO_PG_TEXT_INPUT,
+      RDO_PG_TEXT_OUTPUT);
+
+  for (i = 0; i < argc; ++i) {
+    if (executor->param_types[i] == BYTEAOID) {
+      PQfreemem(values[i]);
+    }
+  }
+
+  ExecStatusType status = PQresultStatus(res);
+
+  if (status == PGRES_BAD_RESPONSE || status == PGRES_FATAL_ERROR) {
+    rb_raise(rb_path2class("RDO::Exception"),
+        "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),
+      rdo_postgres_result_info_new(res));
+}
+
+/** Statements framework initializer, called during extension init */
+void Init_rdo_postgres_statements(void) {
+  VALUE mPostgres = rb_path2class("RDO::Postgres");
+
+  rdo_postgres_cStatementExecutor = rb_define_class_under(
+      mPostgres, "StatementExecutor", rb_cObject);
+
+  rb_define_method(rdo_postgres_cStatementExecutor,
+      "initialize", rdo_postgres_statement_executor_initialize, 1);
+
+  rb_define_method(rdo_postgres_cStatementExecutor,
+      "command", rdo_postgres_statement_executor_command, 0);
+
+  rb_define_method(rdo_postgres_cStatementExecutor,
+      "execute", rdo_postgres_statement_executor_execute, -1);
+
+  Init_rdo_postgres_tuples();
+}