rdo 0.0.7 → 0.0.8

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.so
+*.bundle

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.2
+  - 1.9.3
+notifications:
+  email: chris@w3style.co.uk

data/README.md

@@ -6,7 +6,9 @@ interface. Where a feature is not natively supported by the DBMS—for example,
 prepared statements—it is seamlessly emulated, so you don't need to code
 around it.
 
-It targets **Ruby version 1.9** and newer.
+It targets **Ruby 1.9** and newer.
+
+[![Build Status](https://secure.travis-ci.org/d11wtq/rdo.png?branch=master)](http://travis-ci.org/d11wtq/rdo)
 
 ``` ruby
 require "rdo"
@@ -103,21 +105,27 @@ And then execute:
       <td>sqlite, sqlite3</td>
       <td><a href="https://github.com/d11wtq/rdo-sqlite">rdo-sqlite</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
-      <td>Published</td>
+      <td>
+        <img src="https://secure.travis-ci.org/d11wtq/rdo-sqlite.png?branch=master"
+          alt="Build Status" title="Build Status" />
+      </td>
     </tr>
     <tr>
       <th>PostgreSQL</th>
       <td>postgresql, postgres</td>
       <td><a href="https://github.com/d11wtq/rdo-postgres">rdo-postgres</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
-      <td>Published</td>
+      <td>
+        <img src="https://secure.travis-ci.org/d11wtq/rdo-postgres.png?branch=master"
+          alt="Build Status" title="Build Status" />
+      </td>
     </tr>
     <tr>
       <th>MySQL</th>
       <td>mysql</td>
       <td><a href="https://github.com/d11wtq/rdo-mysql">rdo-mysql</a></td>
       <td><a href="https://github.com/d11wtq">d11wtq</a></td>
-      <td>Pending development</td>
+      <td>In development</td>
     </tr>
   </tbody>
 </table>
@@ -165,7 +173,7 @@ p conn.open? #=> true
 ### One-time use connections
 
 If you pass a block to RDO.connect, RDO yields the connection into the block,
-returns the result of the block, the closes the connection.
+returns the result of the block, then closes the connection.
 
 ``` ruby
 puts RDO.open("sqlite:some.db") do |c|
@@ -254,8 +262,8 @@ include any error messaage provided by the DBMS.
 ### Tread carefully, there be danger ahead
 
 While driver developers are expected to provide a suitable implementation,
-it is generally riskier to use #quote and interpolate inputs directly into
-the SQL, than it is to use bind parameters. There are times where you might
+it is generally riskier to escape and interpolate inputs directly into the
+SQL than it is to use bind parameters. There are times where you might
 need to escape some input yourself, however. For that, you can call #quote.
 
 ``` ruby
@@ -300,6 +308,10 @@ 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.
 
+I haven't looked at what I need to change to have the drivers compile on
+Windows yet, but I will do. If anybody beats me to it, pull requests will
+be gladly accepted! I'll probably add some thin JDBC wrappers for jRuby.
+
 ### Writing a driver for RDO
 
 The more drivers that RDO has support for, the better. Writing drivers for

data/Rakefile

@@ -1,2 +1,14 @@
-#!/usr/bin/env rake
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('rdo') 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/extconf.rb

@@ -0,0 +1,7 @@
+require "mkmf"
+
+if ENV["CC"]
+  RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+create_makefile("rdo/rdo")

data/ext/rdo/rdo.c

@@ -0,0 +1,175 @@
+/*
+ * RDO—Ruby Data Objects.
+ * Copyright © 2012 Chris Corbyn.
+ *
+ * See LICENSE file for details.
+ */
+
+#include <ruby.h>
+#include <stdio.h>
+#include <string.h>
+
+/** Quote parameters in params array */
+static char ** rdo_driver_quote_params(VALUE self, VALUE * args, int argc, long * len) {
+  char ** quoted = malloc(sizeof(char *) * argc);
+  int  idx = 0;
+  VALUE tmp;
+
+  *len = 0;
+
+  for (; idx < argc; ++idx) {
+    switch (TYPE(args[idx])) {
+      case T_NIL:
+        quoted[idx] = strdup("NULL");
+        *len += 4;
+        break;
+
+      case T_FIXNUM:
+      case T_FLOAT:
+        tmp = rb_funcall(args[idx], rb_intern("to_s"), 0);
+        Check_Type(tmp, T_STRING);
+
+        quoted[idx] = strdup(RSTRING_PTR(tmp));
+        *len += RSTRING_LEN(tmp);
+        break;
+
+      default:
+        tmp = rb_funcall(self, rb_intern("quote"), 1, args[idx]);
+        Check_Type(tmp, T_STRING);
+
+        quoted[idx] = malloc(sizeof(char) * (RSTRING_LEN(tmp) + 3));
+        sprintf(quoted[idx], "'%s'", RSTRING_PTR(tmp));
+        *len += 2 + RSTRING_LEN(tmp);
+        break;
+    }
+  }
+
+  return quoted;
+}
+
+/** Release heap memory allocated for quoted params */
+static void rdo_driver_free_params(char ** quoted, int len) {
+  int i;
+  for (i = 0; i < len; ++i) free(quoted[i]);
+  free(quoted);
+}
+
+/**
+ * Takes String stmt, which contains ? markers and interpolates the values in Array params.
+ *
+ * Each value in Array params that is not NilClass, Fixnum or Float is passed
+ * to #quote on the Driver.
+ *
+ * Non-numeric values are surrounded by String quote.
+ *
+ * @param VALUE (String) stmt
+ *   SQL, possibly containining '?' markers.
+ *
+ * @param VALUE (Array) params
+ *   arguments to interpolate in place of the ? markers
+ *
+ * @return VALUE (String)
+ *   the same SQL with the parameters interpolated.
+ */
+static VALUE rdo_driver_interpolate(VALUE self, VALUE stmt, VALUE params) {
+  Check_Type(stmt,   T_STRING);
+  Check_Type(params, T_ARRAY);
+
+  int  argc   = RARRAY_LEN(params);
+  long buflen = 0;
+  char ** quoted_params = rdo_driver_quote_params(
+      self,
+      RARRAY_PTR(params), argc,
+      &buflen);
+  char buffer[buflen + RSTRING_LEN(stmt) + 1];
+
+  char * b = buffer;
+  char * s = RSTRING_PTR(stmt);
+  int    n = 0;
+
+  int insquote = 0;
+  int indquote = 0;
+  int inmlcmt  = 0;
+  int inslcmt  = 0;
+
+  // this loop is intentionally kept procedural (for performance)
+  for (; *s; ++s, ++b) {
+    switch (*s) {
+      case '?':
+        if (insquote || indquote || inmlcmt || inslcmt) {
+          *b = *s;
+        } else {
+          if (n < argc) {
+            strcpy(b, quoted_params[n]);
+            b += strlen(quoted_params[n]) - 1;
+          } else {
+            *b = *s;
+          }
+          ++n;
+        }
+        break;
+
+      case '-':
+        if (!insquote && !indquote && !inmlcmt && *(s + 1) == '-') {
+          inslcmt = 1;
+          *(b++) = *(s++);
+        }
+        *b = *s;
+        break;
+
+      case '\r':
+      case '\n':
+        inslcmt = 0;
+        *b = *s;
+        break;
+
+      case '/':
+        if (!insquote && !indquote && !inslcmt && *(s + 1) == '*') {
+          ++inmlcmt;
+          *(b++) = *(s++);
+        }
+        *b = *s;
+        break;
+
+      case '*':
+        if (inmlcmt && *(s + 1) == '/') {
+          --inmlcmt;
+          *(b++) = *(s++);
+        }
+        *b = *s;
+        break;
+
+      case '\'':
+        if (!indquote && !inmlcmt && !inslcmt) insquote = !insquote;
+        *b = *s;
+        break;
+
+      case '"':
+        if (!insquote && !inmlcmt && !inslcmt) indquote = !indquote;
+        *b = *s;
+        break;
+
+      default:
+        *b = *s;
+    }
+  }
+
+  *b = '\0';
+
+  rdo_driver_free_params(quoted_params, argc);
+
+  if (n != argc) {
+    rb_raise(rb_eArgError,
+        "Bind parameter mismatch (%i for %i) in query %s",
+        argc, n, RSTRING_PTR(stmt));
+  }
+
+  return rb_str_new2(buffer);
+}
+
+/** Extension initializer */
+void Init_rdo(void) {
+  rb_require("rdo/driver");
+  VALUE cDriver = rb_path2class("RDO::Driver");
+  rb_define_method(cDriver, "interpolate", rdo_driver_interpolate, 2);
+}

data/lib/rdo.rb

@@ -14,6 +14,9 @@ require "rdo/emulated_statement_executor"
 require "rdo/result"
 require "rdo/util"
 
+# c extension
+require "rdo/rdo"
+
 module RDO
   class << self
     # Establish a connection to the RDBMS.

data/lib/rdo/driver.rb

@@ -99,6 +99,9 @@ module RDO
 
     # Escape a given value for safe interpolation into a statement.
     #
+    # The value may be any type of Object and will be formatted to a String
+    # as needed.
+    #
     # This should be avoided where the driver natively supports bind parameters.
     #
     # Drivers MUST override this with a RDBMS-specific solution.
@@ -111,6 +114,33 @@ module RDO
     def quote(value)
     end
 
+    protected
+
+    # Replace the values in params with the '?' markers in sql.
+    #
+    # This method exists for drivers that don't natively support bind
+    # parameters, or don't fully support them (e.g. MySQL). The
+    # implementation is done in C, since the scanning routine is
+    # considerably faster.
+    #
+    # Each value in params is processed according to its type:
+    #
+    #   - NilClass, Fixnum, Float, inserted as literals (NULL or a number)
+    #   - String passed through #quote, then wrapped in single quotes
+    #   - All other objects converted to String then processed as a String
+    #
+    # @param [String] sql
+    #   a String of SQL including '?' markers
+    #
+    # @param [Array] params
+    #   an Array of objects to interpolate
+    #
+    # @return [String]
+    #   the SQL to be executed
+    def interpolate(sql, params)
+      # implemented in ext/rdo/rdo.c
+    end
+
     private
 
     def emulated_statement_executor(stmt)

data/lib/rdo/version.rb

@@ -6,5 +6,5 @@
 ##
 
 module RDO
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/rdo.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |gem|
     * Type casting to Ruby types
     * Time zone handling (via the DBMS, not via some crazy time logic in Ruby)
     * Native bind values parameterization of queries, where supported by the DBMS
-    * Buffered result sets (i.e. cursors, to avoid exhausting memory)
     * Retrieve query info from executed commands (e.g. affected rows)
     * Access RETURNING values just like any read query
     * Native prepared statements where supported, emulated where not
@@ -48,6 +47,8 @@ Gem::Specification.new do |gem|
   gem.name          = "rdo"
   gem.require_paths = ["lib"]
   gem.version       = RDO::VERSION
+  gem.extensions    = ["ext/rdo/extconf.rb"]
 
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake-compiler"
 end

data/spec/rdo/driver_spec.rb

@@ -26,4 +26,100 @@ describe RDO::Driver do
       stmt.execute(true).should be_a_kind_of(RDO::Result)
     end
   end
+
+  describe "#interpolate" do
+    let(:driver) { RDO::DriverWithBackwardsQuote.new }
+
+    it "interpolates nil as literal NULL" do
+      driver.send(:interpolate, "SELECT ?", [nil]).should == "SELECT NULL"
+    end
+
+    it "interpolates a Fixnum as a literal integer" do
+      driver.send(:interpolate, "SELECT ? * 4", [123456789]).should == "SELECT 123456789 * 4"
+    end
+
+    it "interpolates a Float as a literal float" do
+      driver.send(:interpolate, "SELECT ? * 4", [12.34]).should == "SELECT 12.34 * 4"
+    end
+
+    it "interpolates a String as a quoted String" do
+      driver.send(:interpolate, "SELECT ?", ["string"]).should == "SELECT 'gnirts'"
+    end
+
+    it "interpolates an Object as a quoted String" do
+      driver.send(:interpolate, "SELECT ?", [Date.new(2012, 9, 22)]).should == "SELECT '22-90-2102'"
+    end
+
+    it "interpolates multiple params" do
+      driver.send(
+        :interpolate,
+        "SELECT ?, ?, ?",
+        ["test", 42, nil]
+      ).should == "SELECT 'tset', 42, NULL"
+    end
+
+    context "with not enough params" do
+      it "raises an ArgumentError" do
+        expect {
+          driver.send(
+            :interpolate,
+            "SELECT ?, ?, ?",
+            ["test", 42]
+          )
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with too many params" do
+      it "raises an ArgumentError" do
+        expect {
+          driver.send(
+            :interpolate,
+            "SELECT ?, ?",
+            ["test", 42, nil]
+          )
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with marks placed inside single quotes" do
+      it "ignores the quoted marks" do
+        driver.send(
+          :interpolate,
+          "SELECT 'quoted?', ?, ?",
+          ["test", 42]
+        ).should == "SELECT 'quoted?', 'tset', 42"
+      end
+    end
+
+    context "with marks placed inside double quotes" do
+      it "ignores the quoted marks" do
+        driver.send(
+          :interpolate,
+          "SELECT \"quoted?\", ?, ?",
+          ["test", 42]
+        ).should == "SELECT \"quoted?\", 'tset', 42"
+      end
+    end
+
+    context "with marks placed inside multiline comments" do
+      it "ignores the comments marks" do
+        driver.send(
+          :interpolate,
+          "SELECT /* commented? */ ?, ?",
+          ["test", 42]
+        ).should == "SELECT /* commented? */ 'tset', 42"
+      end
+    end
+
+    context "with marks placed inside line comments" do
+      it "ignores the comments marks" do
+        driver.send(
+          :interpolate,
+          "SELECT\n  -- commented?\n  ?, ?",
+          ["test", 42]
+        ).should == "SELECT\n  -- commented?\n  'tset', 42"
+      end
+    end
+  end
 end

data/spec/support/driver_with_backwards_quote.rb

@@ -0,0 +1,29 @@
+require "rdo"
+
+module RDO
+  class DriverWithBackwardsQuote < Driver
+    def open
+      @open = true
+    end
+
+    def open?
+      !!@open
+    end
+
+    def close
+      @open = false
+      true
+    end
+
+    def execute(stmt, *args)
+      Result.new([])
+    end
+
+    def quote(obj)
+      obj.to_s.reverse
+    end
+  end
+
+  Connection.register_driver(:rdo_with_backwards_quote, DriverWithBackwardsQuote)
+end
+

data/spec/support/driver_with_everything.rb

@@ -17,7 +17,8 @@ module RDO
     end
 
     def close
-      !(@open = false)
+      @open = false
+      true
     end
 
     def execute(stmt, *args)

data/spec/support/driver_without_statements.rb

@@ -11,7 +11,8 @@ module RDO
     end
 
     def close
-      !(@open = false)
+      @open = false
+      true
     end
 
     def execute(stmt, *args)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdo
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-27 00:00:00.000000000 Z
+date: 2012-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! "== Ruby Data Objects\n\nIf you're building something in Ruby that
   needs access to a database, you may\nopt to use an ORM like ActiveRecord, DataMapper
   or Sequel. But if your needs\ndon't fit well with an ORM—maybe you're even writing
@@ -36,27 +52,30 @@ description: ! "== Ruby Data Objects\n\nIf you're building something in Ruby tha
   library:\n\n  * Consistent API to connect to various DBMS's\n  * Type casting to
   Ruby types\n  * Time zone handling (via the DBMS, not via some crazy time logic
   in Ruby)\n  * Native bind values parameterization of queries, where supported by
-  the DBMS\n  * Buffered result sets (i.e. cursors, to avoid exhausting memory)\n
-  \ * Retrieve query info from executed commands (e.g. affected rows)\n  * Access
-  RETURNING values just like any read query\n  * Native prepared statements where
-  supported, emulated where not\n  * Results given using simple core Ruby data types\n\n==
-  RDBMS Support\n\nSupport for each RDBMS is provided in separate gems, so as to minimize
-  the\ninstallation requirements and to facilitate the maintenace of each driver.
-  Many\ngems are maintained by separate users who work more closely with those RDBMS's.\n\nDue
-  to the nature of this gem, most of the nitty-gritty code is actually\nwritten in
-  C.\n\nSee the official README for full details."
+  the DBMS\n  * Retrieve query info from executed commands (e.g. affected rows)\n
+  \ * Access RETURNING values just like any read query\n  * Native prepared statements
+  where supported, emulated where not\n  * Results given using simple core Ruby data
+  types\n\n== RDBMS Support\n\nSupport for each RDBMS is provided in separate gems,
+  so as to minimize the\ninstallation requirements and to facilitate the maintenace
+  of each driver. Many\ngems are maintained by separate users who work more closely
+  with those RDBMS's.\n\nDue to the nature of this gem, most of the nitty-gritty code
+  is actually\nwritten in C.\n\nSee the official README for full details."
 email:
 - chris@w3style.co.uk
 executables: []
-extensions: []
+extensions:
+- ext/rdo/extconf.rb
 extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- ext/rdo/extconf.rb
+- ext/rdo/rdo.c
 - lib/rdo.rb
 - lib/rdo/connection.rb
 - lib/rdo/driver.rb
@@ -75,6 +94,7 @@ files:
 - spec/rdo/statement_spec.rb
 - spec/rdo/util_spec.rb
 - spec/spec_helper.rb
+- spec/support/driver_with_backwards_quote.rb
 - spec/support/driver_with_everything.rb
 - spec/support/driver_without_statements.rb
 - util/macros.h
@@ -111,5 +131,6 @@ test_files:
 - spec/rdo/statement_spec.rb
 - spec/rdo/util_spec.rb
 - spec/spec_helper.rb
+- spec/support/driver_with_backwards_quote.rb
 - spec/support/driver_with_everything.rb
 - spec/support/driver_without_statements.rb