do_mysql 0.2.4 → 0.9.2

data/ext/extconf.rb

@@ -1,65 +1,66 @@
-if `uname -sr` =~ /^Darwin/
-  ENV["RC_ARCHS"] = `uname -m`.chomp
-  unless File.exists?("/usr/local/mysql/lib/mysql")
-    `sudo ln -s /usr/local/mysql/lib /usr/local/mysql/lib/mysql` rescue nil
-  end
-end
+if RUBY_PLATFORM =~ /darwin/
+  ENV["RC_ARCHS"] = `uname -m`.chomp if `uname -sr` =~ /^Darwin/
 
-# Figure out where mysql_config is
-if !`which mysql_config`.chomp.empty?
-  @mysql_config_bin = "mysql_config"
-elsif !`which mysql_config5`.chomp.empty?
-  @mysql_config_bin = "mysql_config5"  
-else
-  puts "Cannot find mysql_config in your path. Please enter a location: "
-  location = gets.chomp
-  if File.exists?(location)
-    @mysql_config_bin = location
-  else
-    puts "Cannot find that file. Exiting."
-    exit
-  end
+  # On PowerPC the defaults are fine
+  ENV["RC_ARCHS"] = '' if `uname -m` =~ /^Power Macintosh/
 end
 
 require 'mkmf'
 
-def config_value(type)
-  ENV["MYSQL_#{type.upcase}"] || mysql_config(type)
+# All instances of mysql_config on PATH ...
+def mysql_config_paths
+  ENV['PATH'].split(File::PATH_SEPARATOR).collect do |path|
+    [ "#{path}/mysql_config", "#{path}/mysql_config5" ].
+      detect { |bin| File.exist?(bin) }
+  end
 end
 
-@mysql_config = {}
-
-def mysql_config(type)
-  return @mysql_config[type] if @mysql_config[type]
+# The first mysql_config binary on PATH ...
+def default_mysql_config_path
+  mysql_config_paths.compact.first
+end
 
-  sout = `#{@mysql_config_bin} --#{type}`
-  
-  unless $?.success?
-    raise "mysql_config not found"
+def default_prefix
+  if mc = default_mysql_config_path
+    File.dirname(File.dirname(mc))
+  else
+    "/usr/local"
   end
-  
-  @mysql_config[type] = sout.chomp[2..-1]
-  @mysql_config[type]  
 end
 
-$inc, $lib = dir_config('mysql', config_value('include'), config_value('libs_r')) 
-
-def have_build_env
+# Allow overriding path to mysql_config on command line using:
+# ruby extconf.rb --with-mysql-config=/path/to/mysql_config
+if RUBY_PLATFORM =~ /mswin|mingw/
+  dir_config('mysql')
+  have_header 'mysql.h' || exit(1)
+  have_library 'libmysql' || exit(1)
+  have_func('mysql_query', 'mysql.h') || exit(1)
+  have_func('mysql_ssl_set', 'mysql.h')
+elsif mc = with_config('mysql-config', default_mysql_config_path)
+  mc = default_mysql_config_path if mc == true
+  cflags = `#{mc} --cflags`.chomp
+  exit 1 if $? != 0
+  libs = `#{mc} --libs`.chomp
+  exit 1 if $? != 0
+  $CPPFLAGS += ' ' + cflags
+  $libs = libs + " " + $libs
+else
+  inc, lib = dir_config('mysql', default_prefix)
   libs = ['m', 'z', 'socket', 'nsl']
-  while not find_library('mysqlclient', "mysql_query", config_value('libs'), $lib, "#{$lib}/mysql") do
-    exit 1 if libs.empty?
-    have_library(libs.shift)
-  end
-  true
+  lib_dirs =
+    [ lib, "/usr/lib", "/usr/local/lib", "/opt/local/lib" ].collect do |path|
+      [ path, "#{path}/mysql", "#{path}/mysql5/mysql" ]
+    end
+  find_library('mysqlclient', 'mysql_query', *lib_dirs.flatten) || exit(1)
+  find_header('mysql.h', *lib_dirs.flatten.map { |p| p.gsub('/lib', '/include') })
 end
 
-required_libraries = []
-desired_functions = %w(mysql_ssl_set)
+unless RUBY_PLATFORM =~ /mswin|mingw/
+  have_header 'mysql.h'
+  have_library 'mysqlclient' || exit(1)
+  have_func 'mysql_query' || exit(1)
+  have_func 'mysql_ssl_set'
+end
 
-if have_build_env
-  $CFLAGS << ' -Wall '
-  dir_config("mysql_c")
-  create_makefile("mysql_c")
-else
-  puts 'Could not find MySQL build environment (libraries & headers): Makefile not created'
-end
+$CFLAGS << ' -Wall ' unless RUBY_PLATFORM =~ /mswin/
+create_makefile('do_mysql_ext')

data/lib/do_mysql.rb

@@ -1,258 +1,26 @@
-require 'mysql_c'
+require 'rubygems'
 require 'data_objects'
-
-module DataObject
-  module Mysql
-    TYPES = Hash[*Mysql_c.constants.select {|x| x.include?("MYSQL_TYPE")}.map {|x| [Mysql_c.const_get(x), x.gsub(/^MYSQL_TYPE_/, "")]}.flatten]    
-    
-    QUOTE_STRING = "\""
-    QUOTE_COLUMN = "`"
-    
-    class Connection < DataObject::Connection
-      
-      attr_reader :db
-      
-      def initialize(connection_string)        
-        @state = STATE_CLOSED
-        @connection_string = connection_string
-        opts = connection_string.split(" ")
-        opts.each do |opt|
-          k, v = opt.split("=")
-          raise ArgumentError, "you specified an invalid connection component: #{opt}" unless k && v
-          instance_variable_set("@#{k}", v)
-        end
-      end
-      
-      def change_database(database_name)
-        @dbname = database_name
-        @connection_string.gsub(/db_name=[^ ]*/, "db_name=#{database_name}")
-      end
-      
-      def open
-        @db = Mysql_c.mysql_init(nil)
-        raise ConnectionFailed, "could not allocate a MySQL connection" unless @db
-        conn = Mysql_c.mysql_real_connect(@db, @host, @user, @password, @dbname, @port || 0, @socket, @flags || 0)
-        raise ConnectionFailed, "Unable to connect to database with provided connection string. \n#{Mysql_c.mysql_error(@db)}" unless conn
-        @state = STATE_OPEN
-        true
-      end
-      
-      def close
-        if @state == STATE_OPEN
-          Mysql_c.mysql_close(@db)
-          @state = STATE_CLOSED        
-          true
-        else
-          false
-        end
-      end
-      
-      def create_command(text)
-        Command.new(self, text)
-      end
-
-      def begin_transaction
-        Transaction.new(self)
-      end
-      
-    end
-    
-    class Field
-      attr_reader :name, :type
-      
-      def initialize(ptr)
-        @name, @type = ptr.name.to_s, ptr.type.to_s
-      end
-    end
-
-    class Transaction
-
-      attr_reader :connection
-
-      def initialize(conn)
-        @connection = conn
-        exec_sql("BEGIN")
-      end
-
-      # Commits the transaction
-      def commit
-        exec_sql("COMMIT")
-      end
-
-      # Rolls back the transaction
-      def rollback(savepoint = nil)
-        raise NotImplementedError, "MySQL does not support savepoints" if savepoint
-        exec_sql("ROLLBACK")
-      end
-
-      # Creates a savepoint for rolling back later (not commonly supported)
-      def save(name)
-        raise NotImplementedError, "MySQL does not support savepoints"
-      end
-
-      def create_command(*args)
-        @connection.create_command(*args)
-      end
-
-      protected
-
-      def exec_sql(sql)
-        @connection.logger.debug(sql)
-        Mysql_c.mysql_query(@connection.db, sql)
-      end
-
-    end
-    
-    class Reader < DataObject::Reader
-      
-      def initialize(db, reader)        
-        @reader = reader
-        unless @reader
-          if Mysql_c.mysql_field_count(db) == 0
-            @records_affected = Mysql_c.mysql_affected_rows(db)
-            close
-          else
-            raise UnknownError, "An unknown error has occured while trying to process a MySQL query.\n#{Mysql_c.mysql_error(db)}"
-          end
-        else
-          @field_count = @reader.field_count
-          @state = STATE_OPEN
-          
-          @native_fields, @fields = Mysql_c.mysql_c_fetch_field_types(@reader, @field_count), Mysql_c.mysql_c_fetch_field_names(@reader, @field_count)
-
-          raise UnknownError, "An unknown error has occured while trying to process a MySQL query. There were no fields in the resultset\n#{Mysql_c.mysql_error(db)}" if @native_fields.empty?
-          
-          @has_rows = !(@row = Mysql_c.mysql_c_fetch_row(@reader)).nil?
+require 'do_jdbc-support' if RUBY_PLATFORM =~ /java/  # generic, shared JDBC support code
+require 'do_mysql_ext'                                # the C/Java extension for this DO driver
+require 'do_mysql/transaction'
+
+if RUBY_PLATFORM =~ /java/
+  require 'do_jdbc/mysql'   # the JDBC driver, packaged as a gem
+
+  # Another way of loading the JDBC Class. This seems to be more relaible
+  # than Class.forName() within the data_objects.Connection Java class,
+  # which is currently not working as expected.
+  require 'java'
+  import 'com.mysql.jdbc.Driver'
+
+  module DataObjects
+    module Mysql
+      class Connection
+        def self.pool_size
+          20
         end
       end
-      
-      def close
-        if @state == STATE_OPEN
-          Mysql_c.mysql_free_result(@reader)
-          @state = STATE_CLOSED
-          true
-        else
-          false
-        end
-      end
-      
-      def name(col)
-        super
-        @fields[col]
-      end
-      
-      def get_index(name)
-        super
-        @fields.index(name)
-      end
-      
-      def null?(idx)
-        super
-        @row[idx] == nil
-      end
-      
-      def current_row
-        @row
-      end
-      
-      def item(idx)
-        super
-        typecast(@row[idx], idx)
-      end
-      
-      def next
-        super
-        @row = Mysql_c.mysql_c_fetch_row(@reader)
-        close if @row.nil?
-        @row ? true : nil
-      end      
-      
-      def each
-        return unless has_rows?
-        
-        while(true) do
-          yield
-          break unless self.next
-        end
-      end
-      
-      protected
-      def native_type(col)
-        super
-        TYPES[@native_fields[col].type]
-      end
-      
-      def typecast(val, idx)
-        return nil if val.nil? || val == "NULL"
-        field = @native_fields[idx]
-        case TYPES[field]
-          when "NULL"
-            nil
-          when "TINY"
-            val != "0"
-          when "BIT"
-            val.to_i(2)
-          when "SHORT", "LONG", "INT24", "LONGLONG"
-            val == '' ? nil : val.to_i
-          when "DECIMAL", "NEWDECIMAL", "FLOAT", "DOUBLE", "YEAR"
-            val.to_f
-          when "TIMESTAMP", "DATETIME"
-            DateTime.parse(val) rescue nil
-          when "TIME"
-            DateTime.parse(val).to_time rescue nil
-          when "DATE"
-            Date.parse(val) rescue nil
-          else
-            val
-        end
-      end      
-    end
-    
-    class Command < DataObject::Command
-      
-      def execute_reader(*args)
-        super
-        sql = escape_sql(args)
-        @connection.logger.debug { sql }
-        result = Mysql_c.mysql_query(@connection.db, sql)
-        # TODO: Real Error
-        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0
-        reader = Reader.new(@connection.db, Mysql_c.mysql_use_result(@connection.db))
-        if block_given?
-          result = yield(reader)
-          reader.close
-          result
-        else
-          reader
-        end
-      end
-      
-      def execute_non_query(*args)
-        super
-        sql = escape_sql(args)
-        @connection.logger.debug { sql }
-        result = Mysql_c.mysql_query(@connection.db, sql)
-        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0         
-        reader = Mysql_c.mysql_store_result(@connection.db)
-        raise QueryError, "You called execute_non_query on a query: #{@text}" if reader
-        rows_affected = Mysql_c.mysql_affected_rows(@connection.db)
-        Mysql_c.mysql_free_result(reader)
-        return ResultData.new(@connection, rows_affected, Mysql_c.mysql_insert_id(@connection.db))
-      end
-      
-      def quote_time(value)
-        # TIMESTAMP() used for both time and datetime columns
-        quote_datetime(value)
-      end
-      
-      def quote_datetime(value)
-        "TIMESTAMP('#{value.strftime("%Y-%m-%d %H:%M:%S")}')"
-      end
-      
-      def quote_date(value)
-        "DATE('#{value.strftime("%Y-%m-%d")}')"
-      end
     end
-    
   end
+
 end

data/lib/do_mysql/transaction.rb

@@ -0,0 +1,44 @@
+
+module DataObjects
+
+  module Mysql
+
+    class Transaction < DataObjects::Transaction
+
+      def finalize_transaction
+        cmd = "XA END '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def begin
+        cmd = "XA START '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def commit
+        cmd = "XA COMMIT '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback
+        finalize_transaction
+        cmd = "XA ROLLBACK '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def rollback_prepared
+        cmd = "XA ROLLBACK '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+      def prepare
+        finalize_transaction
+        cmd = "XA PREPARE '#{id}'"
+        connection.create_command(cmd).execute_non_query
+      end
+
+    end
+
+  end
+
+end

data/spec/integration/do_mysql_spec.rb

@@ -0,0 +1,241 @@
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+
+describe DataObjects::Mysql do
+  include MysqlSpecHelpers
+
+  before :all do
+    setup_test_environment
+  end
+
+  it "should expose the proper DataObjects classes" do
+    DataObjects::Mysql.const_get('Connection').should_not be_nil
+    DataObjects::Mysql.const_get('Command').should_not be_nil
+    DataObjects::Mysql.const_get('Result').should_not be_nil
+    DataObjects::Mysql.const_get('Reader').should_not be_nil
+  end
+
+  it "should connect successfully via TCP" do
+    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
+    connection = DataObjects::Mysql::Connection.new("mysql://root@127.0.0.1:3306/do_mysql_test")
+    connection.should_not be_using_socket
+  end
+
+#
+#  I comment this out partly to raise the issue for discussion. Socket files are afaik not supported under windows. Does this
+#  mean that we should test for it on unix boxes but not on windows boxes? Or does it mean that it should not be speced at all?
+#  It's not really a requirement, since all architectures that support MySQL also supports TCP connectsion, ne?
+#
+#  it "should connect successfully via the socket file" do
+#    @connection = DataObjects::Mysql::Connection.new("mysql://root@localhost:3306/do_mysql_test/?socket=#{SOCKET_PATH}")
+#    @connection.should be_using_socket
+#  end
+
+  it "should return the current character set" do
+    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
+    connection = DataObjects::Mysql::Connection.new("mysql://root@localhost:3306/do_mysql_test")
+    connection.character_set.should == "utf8"
+  end
+
+  it "should support changing the character set" do
+    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
+    connection = DataObjects::Mysql::Connection.new("mysql://root@localhost:3306/do_mysql_test/?charset=latin1")
+    connection.character_set.should == "latin1"
+
+    @connection = DataObjects::Mysql::Connection.new("mysql://root@localhost:3306/do_mysql_test/?charset=utf8")
+    @connection.character_set.should == "utf8"
+  end
+
+  it "should raise an error when opened with an invalid server uri" do
+    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
+    def connecting_with(uri)
+      lambda { DataObjects::Mysql::Connection.new(uri) }
+    end
+
+    # Missing database name
+    connecting_with("mysql://root@localhost:3306/").should raise_error(MysqlError)
+
+    # Wrong port
+    connecting_with("mysql://root@localhost:666/").should raise_error(MysqlError)
+
+    # Bad Username
+    connecting_with("mysql://baduser@localhost:3306/").should raise_error(MysqlError)
+
+    # Bad Password
+    connecting_with("mysql://root:wrongpassword@localhost:3306/").should raise_error(MysqlError)
+
+    # Bad Database Name
+    connecting_with("mysql://root@localhost:3306/bad_database").should raise_error(MysqlError)
+
+    #
+    # Again, should socket even be speced if we don't support it across all platforms?
+    #
+    # Invalid Socket Path
+    #connecting_with("mysql://root@localhost:3306/do_mysql_test/?socket=/invalid/path/mysql.sock").should raise_error(MysqlError)
+  end
+end
+
+describe DataObjects::Mysql::Connection do
+  include MysqlSpecHelpers
+
+  before :all do
+    setup_test_environment
+  end
+
+  it "should raise an error when attempting to execute a bad query" do
+    lambda { @connection.create_command("INSERT INTO non_existant_table (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError)
+    lambda { @connection.create_command("SELECT * FROM non_existant table").execute_reader }.should raise_error(MysqlError)
+  end
+
+end
+
+describe DataObjects::Mysql::Reader do
+  include MysqlSpecHelpers
+
+  before :all do
+    setup_test_environment
+  end
+
+  it "should raise an error when you pass too many or too few types for the expected result set" do
+    lambda { select("SELECT name, fired_at FROM users", [String, DateTime, Integer]) }.should raise_error(MysqlError)
+  end
+
+  it "shouldn't raise an error when you pass NO types for the expected result set" do
+    lambda { select("SELECT name, fired_at FROM users", nil) }.should_not raise_error(MysqlError)
+  end
+
+  it "should return the proper number of fields" do
+    id = insert("INSERT INTO users (name) VALUES ('Billy Bob')")
+    select("SELECT id, name, fired_at FROM users WHERE id = ?", nil, id) do |reader|
+      reader.fields.size.should == 3
+    end
+  end
+
+  it "should raise an exception if .values is called after reading all available rows" do
+    select("SELECT * FROM widgets LIMIT 2") do |reader|
+      # select already calls next once for us
+      reader.next!
+      reader.next!
+
+      lambda { reader.values }.should raise_error(MysqlError)
+    end
+  end
+
+  it "should fetch the proper number of rows" do
+    ids = [
+      insert("INSERT INTO users (name) VALUES ('Slappy Wilson')"),
+      insert("INSERT INTO users (name) VALUES ('Jumpy Jones')")
+    ]
+
+    select("SELECT * FROM users WHERE id IN ?", nil, ids) do |reader|
+      # select already calls next once for us
+      reader.next!.should == true
+      reader.next!.should be_nil
+    end
+  end
+
+  it "should contain tainted strings" do
+    id = insert("INSERT INTO users (name) VALUES ('Cuppy Canes')")
+
+    select("SELECT name FROM users WHERE id = ?", nil, id) do |reader|
+      reader.values.first.should be_tainted
+    end
+
+  end
+
+  it "should return DB nulls as nil" do
+    id = insert("INSERT INTO users (name) VALUES (NULL)")
+    select("SELECT name from users WHERE name is null") do |reader|
+      reader.values[0].should == nil
+    end
+  end
+
+  it "should not convert empty strings to null" do
+    id = insert("INSERT INTO users (name) VALUES ('')")
+    select("SELECT name FROM users WHERE id = ?", [String], id) do |reader|
+      reader.values.first.should == ''
+    end
+  end
+
+  describe "Date, Time, and DateTime" do
+
+    it "should return DateTimes using the current locale's Time Zone" do
+      date = DateTime.now
+      id = insert("INSERT INTO users (name, fired_at) VALUES (?, ?)", 'Sam', date)
+      select("SELECT fired_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+        reader.values.last.to_s.should == date.to_s
+      end
+      exec("DELETE FROM users WHERE id = ?", id)
+    end
+
+    now = DateTime.now
+
+    dates = [
+      now.new_offset( (-11 * 3600).to_r / 86400), # GMT -11:00
+      now.new_offset( (-9 * 3600 + 10 * 60).to_r / 86400), # GMT -9:10, contrived
+      now.new_offset( (-8 * 3600).to_r / 86400), # GMT -08:00
+      now.new_offset( (+3 * 3600).to_r / 86400), # GMT +03:00
+      now.new_offset( (+5 * 3600 + 30 * 60).to_r / 86400)  # GMT +05:30 (New Delhi)
+    ]
+
+    dates.each do |date|
+      it "should return #{date.to_s} offset to the current locale's Time Zone if they were inserted using a different timezone" do
+        pending "We don't support non-local date input yet"
+
+        dates.each do |date|
+          id = insert("INSERT INTO users (name, fired_at) VALUES (?, ?)", 'Sam', date)
+
+          select("SELECT fired_at FROM users WHERE id = ?", [DateTime], id) do |reader|
+            reader.values.last.to_s.should == now.to_s
+          end
+
+          exec("DELETE FROM users WHERE id = ?", id)
+        end
+      end
+    end
+
+  end
+
+  describe "executing a non-query" do
+    it "should return a Result" do
+      command = @connection.create_command("INSERT INTO invoices (invoice_number) VALUES ('1234')")
+      result = command.execute_non_query
+      result.should be_kind_of(DataObjects::Mysql::Result)
+    end
+
+    it "should be able to determine the affected_rows" do
+      command = @connection.create_command("INSERT INTO invoices (invoice_number) VALUES ('1234')")
+      result = command.execute_non_query
+      result.to_i.should == 1
+    end
+
+    it "should yield the last inserted id" do
+      @connection.create_command("TRUNCATE TABLE invoices").execute_non_query
+
+      result = @connection.create_command("INSERT INTO invoices (invoice_number) VALUES ('1234')").execute_non_query
+      result.insert_id.should == 1
+
+      result = @connection.create_command("INSERT INTO invoices (invoice_number) VALUES ('3456')").execute_non_query
+      result.insert_id.should == 2
+    end
+
+    it "should be able to determine the affected_rows" do
+      [
+        "TRUNCATE TABLE invoices",
+        "INSERT INTO invoices (invoice_number) VALUES ('1234')",
+        "INSERT INTO invoices (invoice_number) VALUES ('1234')"
+      ].each { |q| @connection.create_command(q).execute_non_query }
+
+      result = @connection.create_command("UPDATE invoices SET invoice_number = '3456'").execute_non_query
+      result.to_i.should == 2
+    end
+
+    it "should raise an error when executing an invalid query" do
+      command = @connection.create_command("UPDwhoopsATE invoices SET invoice_number = '3456'")
+
+      lambda { command.execute_non_query }.should raise_error(Exception)
+    end
+
+  end
+
+end