mysql2 0.1.9 → 0.2.0

data/lib/sequel/adapters/mysql2.rb

@@ -1,237 +0,0 @@
-require 'mysql2' unless defined? Mysql2
-
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
-
-module Sequel
-  # Module for holding all MySQL-related classes and modules for Sequel.
-  module Mysql2
-    # Mapping of type numbers to conversion procs
-    MYSQL_TYPES = {}
-
-    MYSQL2_LITERAL_PROC = lambda{|v| v}
-
-    # Use only a single proc for each type to save on memory
-    MYSQL_TYPE_PROCS = {
-      [0, 246]  => MYSQL2_LITERAL_PROC,                               # decimal
-      [1]  => lambda{|v| convert_tinyint_to_bool ? v != 0 : v},       # tinyint
-      [2, 3, 8, 9, 13, 247, 248]  => MYSQL2_LITERAL_PROC,             # integer
-      [4, 5]  => MYSQL2_LITERAL_PROC,                                 # float
-      [10, 14]  => MYSQL2_LITERAL_PROC,                               # date
-      [7, 12] => MYSQL2_LITERAL_PROC,                                # datetime
-      [11]  => MYSQL2_LITERAL_PROC,                                   # time
-      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}   # blob
-    }
-    MYSQL_TYPE_PROCS.each do |k,v|
-      k.each{|n| MYSQL_TYPES[n] = v}
-    end
-
-    @convert_invalid_date_time = false
-    @convert_tinyint_to_bool = true
-
-    class << self
-      # By default, Sequel raises an exception if in invalid date or time is used.
-      # However, if this is set to nil or :nil, the adapter treats dates
-      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
-      # it returns the strings as is.
-      attr_accessor :convert_invalid_date_time
-
-      # Sequel converts the column type tinyint(1) to a boolean by default when
-      # using the native MySQL adapter.  You can turn off the conversion by setting
-      # this to false.
-      attr_accessor :convert_tinyint_to_bool
-    end
-
-    # Database class for MySQL databases used with Sequel.
-    class Database < Sequel::Database
-      include Sequel::MySQL::DatabaseMethods
-
-      # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
-
-      set_adapter_scheme :mysql2
-
-      # Support stored procedures on MySQL
-      def call_sproc(name, opts={}, &block)
-        args = opts[:args] || []
-        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
-      end
-
-      # Connect to the database.  In addition to the usual database options,
-      # the following options have effect:
-      #
-      # * :auto_is_null - Set to true to use MySQL default behavior of having
-      #   a filter for an autoincrement column equals NULL to return the last
-      #   inserted row.
-      # * :charset - Same as :encoding (:encoding takes precendence)
-      # * :compress - Set to false to not compress results from the server
-      # * :config_default_group - The default group to read from the in
-      #   the MySQL config file.
-      # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
-      #   option on the connection with the given value.
-      # * :encoding - Set all the related character sets for this
-      #   connection (connection, client, database, server, and results).
-      # * :socket - Use a unix socket file instead of connecting via TCP/IP.
-      # * :timeout - Set the timeout in seconds before the server will
-      #   disconnect this connection.
-      def connect(server)
-        opts = server_opts(server)
-        conn = ::Mysql2::Client.new({
-          :host => opts[:host] || 'localhost',
-          :username => opts[:user],
-          :password => opts[:password],
-          :database => opts[:database],
-          :port => opts[:port],
-          :socket => opts[:socket]
-        })
-
-        # increase timeout so mysql server doesn't disconnect us
-        conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
-
-        conn
-      end
-
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        Mysql2::Dataset.new(self, opts)
-      end
-
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
-      end
-
-      # Return the version of the MySQL server two which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.info[:id]})
-      end
-
-      private
-
-      # Execute the given SQL on the given connection.  If the :type
-      # option is :select, yield the result of the query, otherwise
-      # yield the connection if a block is given.
-      def _execute(conn, sql, opts)
-        begin
-          r = log_yield(sql){conn.query(sql)}
-          if opts[:type] == :select
-            yield r if r
-          elsif block_given?
-            yield conn
-          end
-        rescue ::Mysql2::Error => e
-          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
-        end
-      end
-
-      # MySQL connections use the query method to execute SQL without a result
-      def connection_execute_method
-        :query
-      end
-
-      # The MySQL adapter main error class is Mysql::Error
-      def database_error_classes
-        [::Mysql2::Error]
-      end
-
-      # The database name when using the native adapter is always stored in
-      # the :database option.
-      def database_name
-        @opts[:database]
-      end
-
-      # Closes given database connection.
-      def disconnect_connection(c)
-        c.close
-      end
-
-      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
-      def schema_column_type(db_type)
-        Sequel::Mysql2.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
-      end
-    end
-
-    # Dataset class for MySQL datasets accessed via the native driver.
-    class Dataset < Sequel::Dataset
-      include Sequel::MySQL::DatasetMethods
-      include StoredProcedures
-
-      # Methods for MySQL stored procedures using the native driver.
-      module StoredProcedureMethods
-        include Sequel::Dataset::StoredProcedureMethods
-
-        private
-
-        # Execute the database stored procedure with the stored arguments.
-        def execute(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-      end
-
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
-
-      # Yield all rows matching this dataset.  If the dataset is set to
-      # split multiple statements, yield arrays of hashes one per statement
-      # instead of yielding results for all statements as hashes.
-      def fetch_rows(sql, &block)
-        execute(sql) do |r|
-          r.each(:symbolize_keys => true, &block)
-        end
-        self
-      end
-
-      # Don't allow graphing a dataset that splits multiple statements
-      def graph(*)
-        raise(Error, "Can't graph a dataset that splits multiple result sets") if opts[:split_multiple_result_sets]
-        super
-      end
-
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.last_id}
-      end
-
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.last_id}
-      end
-
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
-      end
-
-      private
-
-      # Set the :type option to :select if it hasn't been set.
-      def execute(sql, opts={}, &block)
-        super(sql, {:type=>:select}.merge(opts), &block)
-      end
-
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-
-      # Handle correct quoting of strings using ::Mysql2#escape.
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape(v)}'"}
-      end
-    end
-  end
-end

data/spec/active_record/active_record_spec.rb

@@ -1,149 +0,0 @@
-# encoding: UTF-8
-require 'spec_helper'
-require 'rubygems'
-require 'active_record'
-require 'active_record/connection_adapters/mysql2_adapter'
-
-class Mysql2Test2 < ActiveRecord::Base
-  set_table_name "mysql2_test2"
-end
-
-describe ActiveRecord::ConnectionAdapters::Mysql2Adapter do
-  it "should be able to connect" do
-    lambda {
-      ActiveRecord::Base.establish_connection(:adapter => 'mysql2')
-    }.should_not raise_error(Mysql2::Error)
-  end
-
-  context "once connected" do
-    before(:each) do
-      @connection = ActiveRecord::Base.connection
-    end
-
-    it "should be able to execute a raw query" do
-      @connection.execute("SELECT 1 as one").first['one'].should eql(1)
-      @connection.execute("SELECT NOW() as n").first['n'].class.should eql(Time)
-    end
-  end
-
-  context "columns" do
-    before(:all) do
-      ActiveRecord::Base.default_timezone = 'Pacific Time (US & Canada)'
-      ActiveRecord::Base.time_zone_aware_attributes = true
-      ActiveRecord::Base.establish_connection(:adapter => 'mysql2', :database => 'test')
-      Mysql2Test2.connection.execute %[
-        CREATE TABLE IF NOT EXISTS mysql2_test2 (
-          `id` mediumint(9) NOT NULL AUTO_INCREMENT,
-          `null_test` varchar(10) DEFAULT NULL,
-          `bit_test` bit(64) NOT NULL DEFAULT b'1',
-          `boolean_test` tinyint(1) DEFAULT 0,
-          `tiny_int_test` tinyint(4) NOT NULL DEFAULT '1',
-          `small_int_test` smallint(6) NOT NULL DEFAULT '1',
-          `medium_int_test` mediumint(9) NOT NULL DEFAULT '1',
-          `int_test` int(11) NOT NULL DEFAULT '1',
-          `big_int_test` bigint(20) NOT NULL DEFAULT '1',
-          `float_test` float(10,3) NOT NULL DEFAULT '1.000',
-          `double_test` double(10,3) NOT NULL DEFAULT '1.000',
-          `decimal_test` decimal(10,3) NOT NULL DEFAULT '1.000',
-          `date_test` date NOT NULL DEFAULT '2010-01-01',
-          `date_time_test` datetime NOT NULL DEFAULT '2010-01-01 00:00:00',
-          `timestamp_test` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-          `time_test` time NOT NULL DEFAULT '00:00:00',
-          `year_test` year(4) NOT NULL DEFAULT '2010',
-          `char_test` char(10) NOT NULL DEFAULT 'abcdefghij',
-          `varchar_test` varchar(10) NOT NULL DEFAULT 'abcdefghij',
-          `binary_test` binary(10) NOT NULL DEFAULT 'abcdefghij',
-          `varbinary_test` varbinary(10) NOT NULL DEFAULT 'abcdefghij',
-          `tiny_blob_test` tinyblob NOT NULL,
-          `tiny_text_test` tinytext,
-          `blob_test` blob,
-          `text_test` text,
-          `medium_blob_test` mediumblob,
-          `medium_text_test` mediumtext,
-          `long_blob_test` longblob,
-          `long_text_test` longtext,
-          `enum_test` enum('val1','val2') NOT NULL DEFAULT 'val1',
-          `set_test` set('val1','val2') NOT NULL DEFAULT 'val1,val2',
-          PRIMARY KEY (`id`)
-        )
-      ]
-      Mysql2Test2.connection.execute "INSERT INTO mysql2_test2 (null_test) VALUES (NULL)"
-      @test_result = Mysql2Test2.connection.execute("SELECT * FROM mysql2_test2 ORDER BY id DESC LIMIT 1").first
-    end
-
-    after(:all) do
-      Mysql2Test2.connection.execute("DELETE FROM mysql2_test WHERE id=#{@test_result['id']}")
-    end
-
-    it "default value should be cast to the expected type of the field" do
-      test = Mysql2Test2.new
-      test.null_test.should be_nil
-      test.bit_test.should eql("b'1'")
-      test.boolean_test.should eql(false)
-      test.tiny_int_test.should eql(1)
-      test.small_int_test.should eql(1)
-      test.medium_int_test.should eql(1)
-      test.int_test.should eql(1)
-      test.big_int_test.should eql(1)
-      test.float_test.should eql('1.0000'.to_f)
-      test.double_test.should eql('1.0000'.to_f)
-      test.decimal_test.should eql(BigDecimal.new('1.0000'))
-      test.date_test.should eql(Date.parse('2010-01-01'))
-      test.date_time_test.should eql(DateTime.parse('2010-01-01 00:00:00'))
-      test.timestamp_test.should be_nil
-      test.time_test.class.should eql(DateTime)
-      test.year_test.should eql(2010)
-      test.char_test.should eql('abcdefghij')
-      test.varchar_test.should eql('abcdefghij')
-      test.binary_test.should eql('abcdefghij')
-      test.varbinary_test.should eql('abcdefghij')
-      test.tiny_blob_test.should eql("")
-      test.tiny_text_test.should be_nil
-      test.blob_test.should be_nil
-      test.text_test.should be_nil
-      test.medium_blob_test.should be_nil
-      test.medium_text_test.should be_nil
-      test.long_blob_test.should be_nil
-      test.long_text_test.should be_nil
-      test.long_blob_test.should be_nil
-      test.enum_test.should eql('val1')
-      test.set_test.should eql('val1,val2')
-      test.save
-    end
-
-    it "should have correct values when pulled from a db record" do
-      test = Mysql2Test2.last
-      test.null_test.should be_nil
-      test.bit_test.class.should eql(String)
-      test.boolean_test.should eql(false)
-      test.tiny_int_test.should eql(1)
-      test.small_int_test.should eql(1)
-      test.medium_int_test.should eql(1)
-      test.int_test.should eql(1)
-      test.big_int_test.should eql(1)
-      test.float_test.should eql('1.0000'.to_f)
-      test.double_test.should eql('1.0000'.to_f)
-      test.decimal_test.should eql(BigDecimal.new('1.0000'))
-      test.date_test.should eql(Date.parse('2010-01-01'))
-      test.date_time_test.should eql(Time.utc(2010,1,1,0,0,0))
-      test.timestamp_test.class.should eql(ActiveSupport::TimeWithZone)
-      test.time_test.class.should eql(Time)
-      test.year_test.should eql(2010)
-      test.char_test.should eql('abcdefghij')
-      test.varchar_test.should eql('abcdefghij')
-      test.binary_test.should eql('abcdefghij')
-      test.varbinary_test.should eql('abcdefghij')
-      test.tiny_blob_test.should eql("")
-      test.tiny_text_test.should be_nil
-      test.blob_test.should be_nil
-      test.text_test.should be_nil
-      test.medium_blob_test.should be_nil
-      test.medium_text_test.should be_nil
-      test.long_blob_test.should be_nil
-      test.long_text_test.should be_nil
-      test.long_blob_test.should be_nil
-      test.enum_test.should eql('val1')
-      test.set_test.should eql('val1,val2')
-    end
-  end
-end