rdo-postgres 0.0.1

data/ext/rdo_postgres/statements.h

@@ -0,0 +1,15 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <ruby.h>
+
+/** Factory to create a new StatementExecutor */
+VALUE rdo_postgres_statement_executor_new(VALUE driver, VALUE cmd, VALUE name);
+
+/** Initializer for the statements framework */
+void Init_rdo_postgres_statements(void);

data/ext/rdo_postgres/tuples.c

@@ -0,0 +1,85 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include "tuples.h"
+#include "casts.h"
+#include <stdlib.h>
+
+/** Wrapper for the TupleList class */
+typedef struct {
+  PGresult * res;
+  int        encoding;
+} RDOPostgresTupleList;
+
+/** class RDO::Postgres::TupleList */
+static VALUE rdo_postgres_cTupleList;
+
+/** Used to free the struct wrapped by TupleList during GC */
+static void rdo_postgres_tuple_list_free(RDOPostgresTupleList * list) {
+  PQclear(list->res);
+  free(list);
+}
+
+/** Factory to return a new instance of TupleList for a result */
+VALUE rdo_postgres_tuple_list_new(PGresult * res, int encoding) {
+  RDOPostgresTupleList * list = malloc(sizeof(RDOPostgresTupleList));
+  list->res      = res;
+  list->encoding = encoding;
+
+  VALUE obj = Data_Wrap_Struct(rdo_postgres_cTupleList, 0,
+      rdo_postgres_tuple_list_free, list);
+
+  rb_obj_call_init(obj, 0, NULL);
+
+  return obj;
+}
+
+/** Allow iteration over all tuples, yielding Hashes into a block */
+static VALUE rdo_postgres_tuple_list_each(VALUE self) {
+  if (!rb_block_given_p()) {
+    return self;
+  }
+
+  RDOPostgresTupleList * list;
+  Data_Get_Struct(self, RDOPostgresTupleList, list);
+
+  int i     = 0;
+  int ntups = PQntuples(list->res);
+
+  for (; i < ntups; ++i) {
+    VALUE hash  = rb_hash_new();
+    int j       = 0;
+    int nfields = PQnfields(list->res);
+
+    for (; j < nfields; ++j) {
+      rb_hash_aset(hash,
+          ID2SYM(rb_intern(PQfname(list->res, j))),
+          rdo_postgres_cast_value(list->res, i, j, list->encoding));
+    }
+
+    rb_yield(hash);
+  }
+
+  return self;
+}
+
+/**
+ * Invoked during driver initialization to set up the TupleList.
+ */
+void Init_rdo_postgres_tuples(void) {
+  VALUE mPostgres = rb_path2class("RDO::Postgres");
+
+  rdo_postgres_cTupleList = rb_define_class_under(mPostgres,
+      "TupleList", rb_cObject);
+
+  rb_define_method(rdo_postgres_cTupleList,
+      "each", rdo_postgres_tuple_list_each, 0);
+
+  rb_include_module(rdo_postgres_cTupleList, rb_mEnumerable);
+
+  Init_rdo_postgres_casts();
+}

data/ext/rdo_postgres/tuples.h

@@ -0,0 +1,20 @@
+/*
+ * RDO Postgres Driver.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <stdio.h>
+#include <ruby.h>
+#include <libpq-fe.h>
+
+/**
+ * Create a new RDO::Postgres::TupleList.
+ */
+VALUE rdo_postgres_tuple_list_new(PGresult * res, int encoding);
+
+/**
+ * Called during driver initialization to define needed tuple classes.
+ */
+void Init_rdo_postgres_tuples(void);

data/lib/rdo-postgres.rb

@@ -0,0 +1 @@
+require "rdo/postgres"

data/lib/rdo/postgres.rb

@@ -0,0 +1,16 @@
+##
+# RDO PostgreSQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+require "rdo"
+require "rdo/postgres/version"
+require "rdo/postgres/driver"
+require "rdo/rdo_postgres" # c ext
+
+# Register name variants for postgresql schemes
+%w[postgres postgresql].each do |name|
+  RDO::Connection.register_driver(name, RDO::Postgres::Driver)
+end

data/lib/rdo/postgres/driver.rb

@@ -0,0 +1,68 @@
+##
+# RDO PostgreSQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module Postgres
+    # Driver for the Postgres server.
+    #
+    # All default behaviour is overloaded.
+    class Driver < RDO::Driver
+      # most implementation defined by C extension
+
+      # Internally this driver uses prepared statements.
+      #
+      # @param [String] stmt
+      #   the statement to execute
+      #
+      # @param [Object...] *args
+      #   bind parameters to execute with
+      #
+      # @return [RDO::Result]
+      #   a result containing any tuples and query info
+      def execute(stmt, *args)
+        prepare(stmt).execute(*args)
+      end
+
+      private
+
+      # Passed to PQconnectdb().
+      #
+      # e.g. "host=localhost user=bob password=secret dbname=bobs_db"
+      def connect_db_string
+        {
+          host:            options[:host],
+          port:            options[:port],
+          dbname:          options[:database],
+          user:            options[:user],
+          password:        options[:password],
+          connect_timeout: options[:connect_timeout]
+        }.reject{|k,v| v.nil?}.map{|pair| pair.join("=")}.join(" ")
+      end
+
+      def after_open
+        set_time_zone
+        set_encoding
+      end
+
+      def set_time_zone
+        if options[:time_zone]
+          execute("SET TIME ZONE '#{quote(options[:time_zone])}'")
+        else
+          execute("SET TIME ZONE interval '#{quote(RDO::Util.system_time_zone)}' hour to minute")
+        end
+      end
+
+      def set_encoding
+        execute("SET NAMES '#{quote(encoding)}'")
+      end
+
+      def encoding
+        options.fetch(:encoding, "utf-8")
+      end
+    end
+  end
+end

data/lib/rdo/postgres/version.rb

@@ -0,0 +1,12 @@
+##
+# RDO PostgreSQL driver.
+# Copyright © 2012 Chris Corbyn.
+#
+# See LICENSE file for details.
+##
+
+module RDO
+  module Postgres
+    VERSION = "0.0.1"
+  end
+end

data/rdo-postgres.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rdo/postgres/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["d11wtq"]
+  gem.email         = ["chris@w3style.co.uk"]
+  gem.description   = "Provides access to PostgreSQL using the RDO interface"
+  gem.summary       = "PostgreSQL Adapter for RDO"
+  gem.homepage      = "https://github.com/d11wtq/rdo-postgres"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rdo-postgres"
+  gem.require_paths = ["lib"]
+  gem.version       = RDO::Postgres::VERSION
+  gem.extensions    = ["ext/rdo_postgres/extconf.rb"]
+
+  gem.add_runtime_dependency "rdo", ">= 0.0.1"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake-compiler"
+end

data/spec/postgres/bind_params_spec.rb

@@ -0,0 +1,902 @@
+require "spec_helper"
+require "bigdecimal"
+require "date"
+
+describe RDO::Postgres::Driver, "bind parameter support" do
+  let(:connection) { RDO.connect(connection_uri) }
+  let(:table)      { "" }
+
+  before(:each) do
+    connection.execute("DROP SCHEMA IF EXISTS rdo_test CASCADE")
+    connection.execute("CREATE SCHEMA rdo_test")
+    connection.execute("SET search_path = rdo_test")
+    connection.execute(table)
+  end
+
+  after(:each) do
+    begin
+      connection.execute("DROP SCHEMA IF EXISTS rdo_test CASCADE")
+    rescue RDO::Exception => e
+      # accept that tests may fail for other reasons, don't also fail on cleanup
+    ensure
+      connection.close rescue nil
+    end
+  end
+
+  describe "String param" do
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          "Fern Cotton"
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: "Fern Cotton"}
+      end
+    end
+
+    context "against an integer field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, age integer)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (age) VALUES (?) RETURNING *", "32").first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, age: 32}
+      end
+    end
+
+    context "against a boolean field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, rad boolean)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (rad) VALUES (?) RETURNING *", "true").first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, rad: true}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score float)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (score) VALUES (?) RETURNING *", "85.4").first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: 85.4}
+      end
+    end
+
+    context "against a decimal field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score decimal)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (score) VALUES (?) RETURNING *", "85.4").first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: BigDecimal("85.4")}
+      end
+    end
+
+    context "against a date field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, dob date)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (dob) VALUES (?) RETURNING *", "1983-05-03").first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, dob: Date.new(1983, 5, 3)}
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamp)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          "2012-09-22 10:00:05"
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(2012, 9, 22, 10, 0, 5, DateTime.now.zone)}
+      end
+    end
+
+    context "against a timestamptz field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamptz)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          "2012-09-22 10:00:05 -5"
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(2012, 9, 22, 10, 0, 5, "-5")}
+      end
+    end
+
+    context "against a bytea field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, salt bytea)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (salt) VALUES (?) RETURNING *", "\x00\x01\x02"
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, salt: "\x00\x01\x02"}
+      end
+
+      context "that is empty" do
+        let(:table) { "CREATE TABLE test (id serial primary key, salt bytea)" }
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (salt) VALUES (?) RETURNING *", ""
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, salt: ""}
+        end
+      end
+    end
+  end
+
+  describe "Fixnum param" do
+    context "against an integer field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, age integer)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (age) VALUES (?) RETURNING *",
+          42
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, age: 42}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          42
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: "42"}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score float)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (score) VALUES (?) RETURNING *",
+          42
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: 42.0}
+      end
+    end
+
+    context "agsinst a decimal field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score decimal)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (score) VALUES (?) RETURNING *",
+          42
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: BigDecimal("42")}
+      end
+    end
+
+    context "against a boolean field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, rad boolean)" }
+
+      context "when it is 0" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (rad) VALUES (?) RETURNING *",
+            0
+          ).first
+        end
+
+        it "is inferred correctly (false)" do
+          tuple.should == {id: 1, rad: false}
+        end
+      end
+
+      context "when it is 1" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (rad) VALUES (?) RETURNING *",
+            1
+          ).first
+        end
+
+        it "is inferred correctly (true)" do
+          tuple.should == {id: 1, rad: true}
+        end
+      end
+    end
+
+    context "against a bytea field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, salt bytea)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (salt) VALUES (?) RETURNING *",
+          42
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, salt: "42"}
+      end
+    end
+  end
+
+  describe "Float param" do
+    context "against a float field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score float)" }
+
+      context "when it is NaN" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            Float::NAN
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, score: Float::NAN}
+        end
+      end
+
+      context "when it is Infinity" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            Float::INFINITY
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, score: Float::INFINITY}
+        end
+      end
+
+      context "when it is -Infinity" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            -Float::INFINITY
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, score: -Float::INFINITY}
+        end
+      end
+
+      context "when it is a real number" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            12.5
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, score: 12.5}
+        end
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          12.5
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: "12.5"}
+      end
+    end
+
+    context "against a decimal field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score decimal)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (score) VALUES (?) RETURNING *",
+          12.2
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: BigDecimal("12.2")}
+      end
+    end
+  end
+
+  describe "BigDecimal param" do
+    context "against a decimal field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score decimal)" }
+
+      context "when it is NaN" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            BigDecimal("NaN")
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple[:score].should be_a_kind_of(BigDecimal)
+          tuple[:score].should be_nan
+        end
+      end
+
+      context "when it is a real number" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (score) VALUES (?) RETURNING *",
+            BigDecimal("12.2")
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, score: BigDecimal("12.2")}
+        end
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          BigDecimal("12.7")
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: BigDecimal("12.7").to_s}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score float)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (score) VALUES (?) RETURNING *",
+          BigDecimal("12.7")
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: 12.7}
+      end
+    end
+  end
+
+  describe "Date param" do
+    context "against a Date field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, dob date)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (dob) VALUES (?) RETURNING *",
+          Date.new(1983, 5, 3)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, dob: Date.new(1983, 5, 3)}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          Date.new(1983, 5, 3)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: "1983-05-03"}
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamp)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          Date.new(1983, 5, 3)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(1983, 5, 3, 0, 0, 0, DateTime.now.zone)}
+      end
+    end
+
+    context "against a timestamptz field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamptz)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          Date.new(1983, 5, 3)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(1983, 5, 3, 0, 0, 0, DateTime.now.zone)}
+      end
+    end
+  end
+
+  describe "Time param" do
+    context "against a timestamp field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamp)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          Time.new(2012, 9, 22, 5, 16, 58)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(2012, 9, 22, 5, 16, 58, DateTime.now.zone)}
+      end
+    end
+
+    context "against a timestamptz field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamptz)" }
+
+      context "without a timezone given" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+            Time.new(2012, 9, 22, 5, 16, 58)
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, created_at: DateTime.new(2012, 9, 22, 5, 16, 58, DateTime.now.zone)}
+        end
+      end
+
+      context "with a timezone given" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+            Time.new(2012, 9, 22, 5, 16, 58, "-07:00")
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, created_at: DateTime.new(2012, 9, 22, 5, 16, 58, "-07:00")}
+        end
+      end
+    end
+
+    context "against a date field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, dob date)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (dob) VALUES (?) RETURNING *",
+          Time.new(1983, 5, 3, 6, 13, 0)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, dob: Date.new(1983, 5, 3)}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          Time.new(2012, 9, 22, 5, 16, 58)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: Time.new(2012, 9, 22, 5, 16, 58).to_s}
+      end
+    end
+  end
+
+  describe "DateTime param" do
+    context "against a timestamp field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamp)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+          DateTime.new(1983, 5, 3, 6, 13, 0)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: DateTime.new(1983, 5, 3, 6, 13, 0, DateTime.now.zone)}
+      end
+    end
+
+    context "against a timestamptz field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamptz)" }
+
+      context "with a time zone given" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+            DateTime.new(1983, 5, 3, 6, 13, 0, "-07:00")
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, created_at: DateTime.new(1983, 5, 3, 6, 13, 0, "-07:00")}
+        end
+      end
+
+      context "without a time zone given" do
+        let(:tuple) do
+          connection.execute(
+            "INSERT INTO test (created_at) VALUES (?) RETURNING *",
+            DateTime.new(1983, 5, 3, 6, 13, 0)
+          ).first
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, created_at: DateTime.new(1983, 5, 3, 6, 13, 0)}
+        end
+      end
+    end
+
+    context "against a date field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, dob date)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (dob) VALUES (?) RETURNING *",
+          DateTime.new(1983, 5, 3, 6, 13, 0)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, dob: Date.new(1983, 5, 3)}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute(
+          "INSERT INTO test (name) VALUES (?) RETURNING *",
+          DateTime.new(1983, 5, 3, 6, 13, 0)
+        ).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: DateTime.new(1983, 5, 3, 6, 13, 0).to_s}
+      end
+    end
+  end
+
+  describe "nil param" do
+    context "against a text field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (name) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, name: nil}
+      end
+    end
+
+    context "against an integer field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, age integer)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (age) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, age: nil}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score float)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (score) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: nil}
+      end
+    end
+
+    context "against a decimal field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, score decimal)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (score) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, score: nil}
+      end
+    end
+
+    context "against a boolean field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, rad boolean)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (rad) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, rad: nil}
+      end
+    end
+
+    context "against a date field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, dob date)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (dob) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, dob: nil}
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamp)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (created_at) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: nil}
+      end
+    end
+
+    context "against a timestamptz field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, created_at timestamptz)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (created_at) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, created_at: nil}
+      end
+    end
+
+    context "against a bytea field" do
+      let(:table) { "CREATE TABLE test (id serial primary key, salt bytea)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (salt) VALUES (?) RETURNING *", nil).first
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, salt: nil}
+      end
+    end
+  end
+
+  describe "arbitrary Object param" do
+    context "against a text field" do
+      let(:value) { Object.new }
+      let(:table) { "CREATE TABLE test (id serial primary key, name text)" }
+      let(:tuple) do
+        connection.execute("INSERT INTO test (name) VALUES (?) RETURNING *", value).first
+      end
+
+      it "is inferred correctly (via #to_s)" do
+        tuple.should == {id: 1, name: value.to_s}
+      end
+    end
+  end
+
+  describe "multiple params" do
+    let(:table) do
+      <<-SQL
+      CREATE TABLE test (
+        id         serial primary key,
+        name       text,
+        age        integer,
+        admin      boolean,
+        created_at timestamptz
+      )
+      SQL
+    end
+
+    let(:tuple) do
+      connection.execute(<<-SQL, "bob", 17, false, Time.new(2012, 9, 22, 6, 34)).first
+      INSERT INTO test (
+        name, age, admin, created_at
+      ) VALUES (
+        ?, ?, ?, ?
+      ) RETURNING *
+      SQL
+    end
+
+    it "interprets them individually" do
+      tuple.should == {
+        id:         1,
+        name:       "bob",
+        age:        17,
+        admin:      false,
+        created_at: DateTime.new(2012, 9, 22, 6, 34, 0, DateTime.now.zone)
+      }
+    end
+  end
+
+  describe "when a bind marker is contained in a string literal" do
+    let(:table) do
+      <<-SQL
+      CREATE TABLE test (
+        id   serial primary key,
+        name text,
+        age  integer
+      )
+      SQL
+    end
+
+    context "without quoted apostrophes" do
+      let(:tuple) do
+        connection.execute(<<-SQL, 17).first
+        INSERT INTO test (
+          name, age
+        ) VALUES (
+          '?', ?
+        ) RETURNING *
+        SQL
+      end
+
+      it "does not consider the quoted marker" do
+        tuple.should == {id: 1, name: "?", age: 17}
+      end
+    end
+
+    context "with quoted apostrophes" do
+      let(:tuple) do
+        connection.execute(<<-SQL, 17).first
+        INSERT INTO test (
+          name, age
+        ) VALUES (
+          'you say ''hello?''', ?
+        ) RETURNING *
+        SQL
+      end
+
+      it "does not consider the quoted marker" do
+        tuple.should == {id: 1, name: "you say 'hello?'", age: 17}
+      end
+    end
+  end
+
+  describe "when a bind marker is contained in a multi-line comment" do
+    let(:table) do
+      <<-SQL
+      CREATE TABLE test (
+        id   serial primary key,
+        name text,
+        age  integer
+      )
+      SQL
+    end
+
+    context "without nesting" do
+      let(:tuple) do
+        connection.execute(<<-SQL, "jim", 17).first
+        INSERT INTO test (
+          name, age
+        ) VALUES (
+          /*
+          Are these are the values you're looking for?
+          */
+          ?, ?
+        ) RETURNING *
+        SQL
+      end
+
+      it "does not consider the commented marker" do
+        tuple.should == {id: 1, name: "jim", age: 17}
+      end
+    end
+
+    context "with nesting" do
+      let(:tuple) do
+        connection.execute(<<-SQL, "jim", 17).first
+        INSERT INTO test (
+          name, age
+        ) VALUES (
+          /*
+          Are these the /* nested */ values you're looking for?
+          */
+          ?, ?
+        ) RETURNING *
+        SQL
+      end
+
+      it "does not consider the commented marker" do
+        tuple.should == {id: 1, name: "jim", age: 17}
+      end
+    end
+  end
+
+  context "when a bind marker is contained in a single line comment" do
+    let(:table) do
+      <<-SQL
+      CREATE TABLE test (
+        id   serial primary key,
+        name text,
+        age  integer
+      )
+      SQL
+    end
+
+    let(:tuple) do
+      connection.execute(<<-SQL, "jim", 17).first
+      INSERT INTO test (
+        name, age
+      ) VALUES (
+        -- Are these are the values you're looking for? choker! /*
+        ?, ?
+      ) RETURNING *
+      SQL
+    end
+
+    it "does not consider the commented marker" do
+      tuple.should == {id: 1, name: "jim", age: 17}
+    end
+  end
+
+  context "when a bind parameter is quoted as an identifier" do
+    let(:table) do
+      <<-SQL
+      CREATE TABLE test (
+        id       serial primary key,
+        name     text,
+        age      integer,
+        "admin?" boolean
+      )
+      SQL
+    end
+
+    let(:tuple) do
+      connection.execute(<<-SQL, "jim", 17, true).first
+      INSERT INTO test (
+        name, age, "admin?"
+      ) VALUES (
+        ?, ?, ?
+      ) RETURNING *
+      SQL
+    end
+
+    it "does not confuse the quoted identifier" do
+      tuple.should == {id: 1, name: "jim", age: 17, admin?: true}
+    end
+  end
+end