rdo-mysql 0.0.1 → 0.0.2

data/README.md

@@ -2,7 +2,7 @@
 
 This is the MySQL driver for [RDO—Ruby Data Objects](https://github.com/d11wtq/rdo).
 
-[![Build Status](https://secure.travis-ci.org/d11wtq/rdo-mysql.png)](http://travis-ci.org/d11wtq/rdo-mysql)
+[![Build Status](https://secure.travis-ci.org/d11wtq/rdo-mysql.png?branch=master)](http://travis-ci.org/d11wtq/rdo-mysql)
 
 Refer to the RDO project [README](https://github.com/d11wtq/rdo) for full usage information.
 

data/ext/rdo_mysql/driver.c

@@ -134,6 +134,25 @@ static VALUE rdo_mysql_driver_quote(VALUE self, VALUE obj) {
   return rb_str_new2(quoted);
 }
 
+/** Find any Time/DateTime arguments and ensure they use the system time zone */
+static void rdo_mysql_driver_normalize_date_times_bang(VALUE * args, int argc) {
+  int i;
+  for (i = 0; i < argc; ++i) {
+    if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_path2class("DateTime"))) {
+      VALUE offset = rb_funcall(
+          rb_funcall(rb_path2class("DateTime"), rb_intern("now"), 0),
+          rb_intern("offset"),
+          0);
+
+      args[i] = rb_funcall(args[i], rb_intern("new_offset"), 1, offset);
+      args[i] = rb_funcall(args[i], rb_intern("strftime"), 1, rb_str_new2("%Y-%m-%d %H:%M:%S"));
+    } else if (rb_funcall(args[i], rb_intern("kind_of?"), 1, rb_cTime)) {
+      args[i] = rb_funcall(args[i], rb_intern("localtime"), 0);
+      args[i] = rb_funcall(args[i], rb_intern("strftime"), 1, rb_str_new2("%Y-%m-%d %H:%M:%S"));
+    }
+  }
+}
+
 /** Execute a statement with possible bind parameters */
 static VALUE rdo_mysql_driver_execute(int argc, VALUE * args, VALUE self) {
   if (argc < 1) {
@@ -147,6 +166,8 @@ static VALUE rdo_mysql_driver_execute(int argc, VALUE * args, VALUE self) {
     RDO_ERROR("Cannot execute query: connection is not open");
   }
 
+  rdo_mysql_driver_normalize_date_times_bang(&args[1], argc - 1);
+
   VALUE stmt = RDO_INTERPOLATE(self, args, argc);
 
   if (mysql_real_query(driver->conn,
@@ -164,6 +185,7 @@ static VALUE rdo_mysql_driver_execute(int argc, VALUE * args, VALUE self) {
 /** Initializer driver during extension initialization */
 void Init_rdo_mysql_driver(void) {
   rb_require("rdo/mysql/driver");
+  rb_require("date");
 
   VALUE cMySQL = rb_path2class("RDO::MySQL::Driver");
 

data/ext/rdo_mysql/tuples.c

@@ -43,6 +43,9 @@ VALUE rdo_mysql_tuple_list_new(MYSQL_RES * res, int encoding) {
 
 /** Cast the given value to a Ruby type */
 static VALUE rdo_mysql_cast_value(char * v, unsigned long len, MYSQL_FIELD f, int enc) {
+  if (v == NULL)
+    return Qnil;
+
   switch (f.type) {
     case MYSQL_TYPE_NULL:
       return Qnil;

data/lib/rdo/mysql/version.rb

@@ -7,6 +7,6 @@
 
 module RDO
   module MySQL
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/spec/mysql/bind_params_spec.rb

@@ -0,0 +1,681 @@
+require "spec_helper"
+require "date"
+require "bigdecimal"
+
+describe RDO::MySQL::Driver, "bind params" do
+  let(:options)    { connection_uri }
+  let(:connection) { RDO.connect(options) }
+
+  let(:table) do
+    "CREATE TABLE test (id INT NOT NULL PRIMARY KEY AUTO_INCREMENT)"
+  end
+
+  let(:tuple) { connection.execute("SELECT * FROM test").first }
+
+  before(:each) do
+    connection.execute("DROP TABLE IF EXISTS test")
+    connection.execute(table)
+    connection.execute(*insert)
+  end
+
+  after(:each) do
+    begin
+      connection.execute("DROP TABLE IF EXISTS test")
+    ensure
+      connection.close
+    end
+  end
+
+  describe "nil param" do
+    context "against a varchar field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value VARCHAR(32)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a char field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value CHAR(3)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TEXT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a blob field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value BLOB
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against an integer field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value INT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value FLOAT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a date field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATE
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a datetime field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATETIME
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TIMESTAMP NULL
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", nil] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: nil}
+      end
+    end
+  end
+
+  describe "String param" do
+    context "against a varchar field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value VARCHAR(32)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "bob"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "bob"}
+      end
+    end
+
+    context "against a char field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value CHAR(3)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "bob"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "bob"}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TEXT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "bob"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "bob"}
+      end
+    end
+
+    context "against a blob field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value BLOB
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "\x00\x11\x22"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "\x00\x11\x22"}
+      end
+    end
+
+    context "against an integer field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value INT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "42"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 42}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value FLOAT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "42.4"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 42.4}
+      end
+    end
+
+    context "against a date field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATE
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "2012-10-03"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: Date.new(2012, 10, 3)}
+      end
+    end
+
+    context "against a datetime field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATETIME
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "2012-10-03 00:09:36"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(2012, 10, 3, 0, 9, 36, DateTime.now.zone)}
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TIMESTAMP
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", "2012-10-03 00:09:36"] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(2012, 10, 3, 0, 9, 36, DateTime.now.zone)}
+      end
+    end
+  end
+
+  describe "Fixnum param" do
+    context "against an integer field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value INT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 42}
+      end
+    end
+
+    context "against a varchar field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value VARCHAR(32)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "42"}
+      end
+    end
+
+    context "against a char field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value CHAR(3)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "42"}
+      end
+    end
+
+    context "against a text field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TEXT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "42"}
+      end
+    end
+
+    context "against a blob field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TEXT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "42"}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value FLOAT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42] }
+
+      it "is inferred correctly" do
+        tuple[:value].should be_a_kind_of(Float)
+        tuple.should == {id: 1, value: 42.0}
+      end
+    end
+  end
+
+  describe "Float param" do
+    context "against a float field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value FLOAT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42.6] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 42.6}
+      end
+    end
+
+    context "against an integer field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value INT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42.2] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 42}
+      end
+    end
+
+    context "against a varchar field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value VARCHAR(32)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", 42.2] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "42.2"}
+      end
+    end
+  end
+
+  describe "BigDecimal param" do
+    context "against a decimal field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DECIMAL(4,2)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", BigDecimal("17.56")] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: BigDecimal("17.56")}
+      end
+    end
+
+    context "against a float field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value FLOAT
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", BigDecimal("17.56")] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: 17.56}
+      end
+    end
+  end
+
+  describe "Date param" do
+    context "against a date field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATE
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", Date.new(1983, 5, 3)] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: Date.new(1983, 5, 3)}
+      end
+    end
+
+    context "against a varchar field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value VARCHAR(32)
+        )
+        SQL
+      end
+      let(:insert) { ["INSERT INTO test (value) VALUES (?)", Date.new(1983, 5, 3)] }
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: "1983-05-03"}
+      end
+    end
+  end
+
+  describe "DateTime param" do
+    context "against a datetime field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATETIME
+        )
+        SQL
+      end
+
+      let(:insert) do
+        [
+          "INSERT INTO test (value) VALUES (?)",
+          DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)
+        ]
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+      end
+
+      context "with a time zone" do
+        let(:insert) do
+          [
+            "INSERT INTO test (value) VALUES (?)",
+            DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone).new_offset(0)
+          ]
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+        end
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TIMESTAMP
+        )
+        SQL
+      end
+
+      let(:insert) do
+        [
+          "INSERT INTO test (value) VALUES (?)",
+          DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)
+        ]
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+      end
+
+      context "with a time zone" do
+        let(:insert) do
+          [
+            "INSERT INTO test (value) VALUES (?)",
+            DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone).new_offset(0)
+          ]
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+        end
+      end
+    end
+  end
+
+  describe "Time param" do
+    context "against a datetime field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value DATETIME
+        )
+        SQL
+      end
+
+      let(:insert) do
+        [
+          "INSERT INTO test (value) VALUES (?)",
+          Time.local(1983, 5, 3, 7, 18, 54)
+        ]
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+      end
+
+      context "with a time zone" do
+        let(:insert) do
+          [
+            "INSERT INTO test (value) VALUES (?)",
+            Time.local(1983, 5, 3, 7, 18, 54).utc
+          ]
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+        end
+      end
+    end
+
+    context "against a timestamp field" do
+      let(:table) do
+        <<-SQL
+        CREATE TABLE test (
+          id    INT PRIMARY KEY AUTO_INCREMENT,
+          value TIMESTAMP
+        )
+        SQL
+      end
+
+      let(:insert) do
+        [
+          "INSERT INTO test (value) VALUES (?)",
+          Time.local(1983, 5, 3, 7, 18, 54)
+        ]
+      end
+
+      it "is inferred correctly" do
+        tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+      end
+
+      context "with a time zone" do
+        let(:insert) do
+          [
+            "INSERT INTO test (value) VALUES (?)",
+            Time.local(1983, 5, 3, 7, 18, 54).utc
+          ]
+        end
+
+        it "is inferred correctly" do
+          tuple.should == {id: 1, value: DateTime.new(1983, 5, 3, 7, 18, 54, DateTime.now.zone)}
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdo-mysql
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-30 00:00:00.000000000 Z
+date: 2012-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdo
@@ -86,6 +86,7 @@ files:
 - lib/rdo/mysql/driver.rb
 - lib/rdo/mysql/version.rb
 - rdo-mysql.gemspec
+- spec/mysql/bind_params_spec.rb
 - spec/mysql/driver_spec.rb
 - spec/mysql/type_cast_spec.rb
 - spec/spec_helper.rb
@@ -114,6 +115,7 @@ signing_key:
 specification_version: 3
 summary: MySQL Driver for RDO
 test_files:
+- spec/mysql/bind_params_spec.rb
 - spec/mysql/driver_spec.rb
 - spec/mysql/type_cast_spec.rb
 - spec/spec_helper.rb