rdo-postgres 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.so
+*.bundle
+*.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rdo-postgres.gemspec
+gemspec
+
+# allow a local version of RDO to be used during dev
+if ENV["RDO_PATH"]
+  gem 'rdo', path: ENV["RDO_PATH"]
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright © 2012 Chris Corbyn.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# RDO PostgreSQL Driver
+
+This is the PostgreSQL driver for [RDO—Ruby Data Objects]
+(https://github.com/d11wtq/rdo).
+
+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.
+
+## Installation
+
+Via rubygems:
+
+    $ gem install rdo-postgres
+
+Or add the following line to your application's Gemfile:
+
+    gem "rdo-postgres"
+
+And install with Bundler:
+
+    $ bundle install
+
+## Usage
+
+The registered URI schemes are postgres:// and postgresql://
+
+``` ruby
+require "rdo"
+require "rdo-postgres"
+
+conn = RDO.connect("postgres://user:pass@localhost/dbname?encoding=utf-8")
+```
+
+Alternatively, give the driver name as "postgres" or "postgresql" in an
+options Hash.
+
+``` ruby
+conn = RDO.connect(
+  driver:    "postgresql",
+  host:      "localhost",
+  user:      "user",
+  passsword: "pass",
+  database:  "dbname",
+  encoding:  "utf-8"
+)
+```
+
+### Bind parameters support
+
+PostgreSQL uses $1, $2 etc for bind parameters. RDO uses '?'. You can use
+either, but you **cannot** mix both styles in the same query, or you will
+get errors.
+
+These are ok:
+
+``` ruby
+conn.execute("SELECT * FROM users WHERE banned = ? AND created_at > ?", true, 1.week.ago)
+conn.execute("SELECT * FROM users WHERE banned = $1 AND created_at > $2", true, 1.week.ago)
+```
+
+This is **not ok**:
+
+``` ruby
+conn.execute("SELECT * FROM users WHERE banned = $1 AND created_at > ?", true, 1.week.ago)
+```
+
+## 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.
+
+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.
+
+Contributors will be credited in this README.
+
+## Copyright & Licensing
+
+Written by Chris Corbyn.
+
+Licensed under the MIT license. See the LICENSE file for full details.

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('rdo_postgres') do |ext|
+  ext.lib_dir = File.join('lib', 'rdo')
+end
+
+desc "Run the full RSpec suite"
+RSpec::Core::RakeTask.new('spec') do |t|
+  t.pattern     = 'spec/'
+end
+
+Rake::Task['spec'].prerequisites << :compile

data/ext/rdo_postgres/casts.c

@@ -0,0 +1,134 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "casts.h"
+#include <stdlib.h>
+#include <postgres.h>
+#include <catalog/pg_type.h>
+#include "macros.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')
+
+/** Lookup table for fast conversion of bytea hex strings to binary data */
+static char * RDOPostgres_HexLookup;
+
+/** Cast from a bytea to a String according to the new (PG 9.0) hex format */
+static VALUE rdo_postgres_cast_bytea_hex(char * hex, size_t len) {
+  if ((len % 2) != 0) {
+    rb_raise(rb_eRuntimeError,
+        "Bad hex value provided for bytea (length not divisible by 2)");
+  }
+
+  size_t   buflen = (len - 2) / 2;
+  char   * buffer = malloc(sizeof(char) * buflen);
+  char   * s      = hex + 2;
+  char   * b      = buffer;
+
+  if (buffer == NULL) {
+    rb_raise(rb_eRuntimeError,
+        "Failed to allocate %ld bytes for bytea conversion", buflen);
+  }
+
+  for (; *s; s += 2, ++b)
+    *b = (RDOPostgres_HexLookup[*s] << 4) + (RDOPostgres_HexLookup[*(s + 1)]);
+
+  VALUE str = rb_str_new(buffer, buflen);
+  free(buffer);
+
+  return str;
+}
+
+/** 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);
+
+  if (buffer == NULL) {
+    rb_raise(rb_eRuntimeError,
+        "Failed to allocate memory for PQunescapeBytea() conversion");
+  }
+
+  VALUE str = rb_str_new(buffer, len);
+  PQfreemem(buffer);
+
+  return str;
+}
+
+/** 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)) {
+    return Qnil;
+  }
+
+  char * value  = PQgetvalue(res, row, col);
+  int    length = PQgetlength(res, row, col);
+
+  switch (PQftype(res, col)) {
+    case INT2OID:
+    case INT4OID:
+    case INT8OID:
+      return RDO_FIXNUM(value);
+
+    case FLOAT4OID:
+    case FLOAT8OID:
+      return RDO_FLOAT(value);
+
+    case NUMERICOID:
+      return RDO_DECIMAL(value);
+
+    case 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 DATEOID:
+      return RDO_DATE(value);
+
+    case TIMESTAMPOID:
+      return RDO_DATE_TIME_WITHOUT_ZONE(value);
+
+    case TIMESTAMPTZOID:
+      return RDO_DATE_TIME_WITH_ZONE(value);
+
+    case TEXTOID:
+    case CHAROID:
+    case VARCHAROID:
+    case BPCHAROID:
+      return RDO_STRING(value, length, enc);
+
+    default:
+      return RDO_BINARY_STRING(value, length);
+  }
+}
+
+/* Initialize hex decoding lookup table */
+void Init_rdo_postgres_casts(void) {
+  RDOPostgres_HexLookup = malloc(sizeof(char) * 128);
+
+  if (RDOPostgres_HexLookup == NULL) {
+    rb_raise(rb_eRuntimeError,
+        "Failed to allocate 128 bytes for internal lookup table");
+  }
+
+  char c;
+
+  for (c = '\0'; c < '\x7f'; ++c)
+    RDOPostgres_HexLookup[c] = 0;
+
+  for (c = '0'; c <= '9'; ++c)
+    RDOPostgres_HexLookup[c] = c - '0';
+
+  for (c = 'a'; c <= 'f'; ++c)
+    RDOPostgres_HexLookup[c] = 10 + c - 'a';
+
+  for (c = 'A'; c <= 'F'; ++c)
+    RDOPostgres_HexLookup[c] = 10 + c - 'A';
+}

data/ext/rdo_postgres/casts.h

@@ -0,0 +1,16 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <ruby.h>
+#include <libpq-fe.h>
+
+/** Cast the given value from the result to a ruby type */
+VALUE rdo_postgres_cast_value(PGresult * res, int row, int col, int enc);
+
+/** Initialize the casting framework */
+void Init_rdo_postgres_casts(void);

data/ext/rdo_postgres/driver.c

@@ -0,0 +1,169 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "driver.h"
+#include "statements.h"
+#include "macros.h"
+#include <ruby.h>
+#include <stdlib.h>
+#include <postgres.h>
+
+/** During GC, free any stranded connection */
+static void rdo_postgres_driver_free(RDOPostgresDriver * driver) {
+  PQfinish(driver->conn_ptr);
+  free(driver);
+}
+
+/** Postgres outputs notices (e.g. auto-generating sequence...) unless overridden */
+static void rdo_postgres_driver_notice_processor(void * arg, const char * msg) {}
+
+/** Allocate memory for the connection struct */
+static VALUE rdo_postgres_driver_allocate(VALUE klass) {
+  RDOPostgresDriver * driver = malloc(sizeof(RDOPostgresDriver));
+
+  driver->conn_ptr   = NULL;
+  driver->is_open    = 0;
+  driver->stmt_count = 0;
+  driver->encoding   = -1;
+
+  VALUE self = Data_Wrap_Struct(klass, 0,
+      rdo_postgres_driver_free, driver);
+
+  return self;
+}
+
+/** Connect to the postgres server */
+static VALUE rdo_postgres_driver_open(VALUE self) {
+  RDOPostgresDriver * driver;
+  Data_Get_Struct(self, RDOPostgresDriver, driver);
+
+  if (driver->is_open) {
+    return Qtrue;
+  }
+
+  driver->conn_ptr = PQconnectdb(
+      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",
+        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). "
+        "PostgreSQL >= 7.4 required.",
+        PQprotocolVersion(driver->conn_ptr));
+  } else {
+    PQsetNoticeProcessor(driver->conn_ptr, &rdo_postgres_driver_notice_processor, NULL);
+    driver->is_open    = 1;
+    driver->stmt_count = 0;
+    driver->encoding   = rb_enc_find_index(
+        RSTRING_PTR(rb_funcall(self, rb_intern("encoding"), 0)));
+    rb_funcall(self, rb_intern("after_open"), 0);
+  }
+
+  return Qtrue;
+}
+
+/** Disconnect from the postgres server, and release memory */
+static VALUE rdo_postgres_driver_close(VALUE self) {
+  RDOPostgresDriver * driver;
+  Data_Get_Struct(self, RDOPostgresDriver, driver);
+
+  PQfinish(driver->conn_ptr);
+  driver->conn_ptr   = NULL;
+  driver->is_open    = 0;
+  driver->stmt_count = 0;
+  driver->encoding   = -1;
+
+  return Qtrue;
+}
+
+/** Preciate test if connection is open */
+static VALUE rdo_postgres_driver_open_p(VALUE self) {
+  RDOPostgresDriver * driver;
+  Data_Get_Struct(self, RDOPostgresDriver, driver);
+  return driver->is_open ? Qtrue : Qfalse;
+}
+
+/** Prepare a statement for execution */
+static VALUE rdo_postgres_driver_prepare(VALUE self, VALUE cmd) {
+  Check_Type(cmd, T_STRING);
+
+  RDOPostgresDriver * driver;
+  Data_Get_Struct(self, RDOPostgresDriver, driver);
+
+  if (!(driver->is_open)) {
+    rb_raise(rb_path2class("RDO::Exception"),
+        "Unable to prepare statement: connection is not open");
+  }
+
+  char name[32];
+  sprintf(name, "rdo_stmt_%i", ++driver->stmt_count);
+
+  return RDO_STATEMENT(rdo_postgres_statement_executor_new(
+        self, cmd, rb_str_new2(name)));
+}
+
+/** Quote a string literal for safe insertion in a statement */
+static VALUE rdo_postgres_driver_quote(VALUE self, VALUE str) {
+  if (TYPE(str) == T_NIL) {
+    return rb_str_new2("NULL");
+  } else if (TYPE(str) != T_STRING) {
+    str = RDO_OBJ_TO_S(str);
+  }
+
+  RDOPostgresDriver * driver;
+  Data_Get_Struct(self, RDOPostgresDriver, driver);
+
+  if (!(driver->is_open)) {
+    rb_raise(rb_path2class("RDO::Exception"),
+        "Unable to quote string: connection is not open");
+  }
+
+  char * quoted = malloc(sizeof(char) * RSTRING_LEN(str) * 4);
+  PQescapeStringConn(driver->conn_ptr, quoted,
+      RSTRING_PTR(str), RSTRING_LEN(str), NULL);
+
+  VALUE newstr = rb_str_new2(quoted);
+
+  free(quoted);
+
+  return newstr;
+}
+
+void Init_rdo_postgres_driver(void) {
+  rb_require("rdo/postgres/driver");
+
+  VALUE cPostgresConnection = rb_path2class("RDO::Postgres::Driver");
+
+  rb_define_alloc_func(
+      cPostgresConnection,
+      rdo_postgres_driver_allocate);
+
+  rb_define_method(
+      cPostgresConnection,
+      "open", rdo_postgres_driver_open, 0);
+
+  rb_define_method(
+      cPostgresConnection,
+      "close", rdo_postgres_driver_close, 0);
+
+  rb_define_method(
+      cPostgresConnection,
+      "open?", rdo_postgres_driver_open_p, 0);
+
+  rb_define_method(
+      cPostgresConnection,
+      "prepare", rdo_postgres_driver_prepare, 1);
+
+  rb_define_method(
+      cPostgresConnection,
+      "quote", rdo_postgres_driver_quote, 1);
+
+  Init_rdo_postgres_statements();
+}