activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

data/lib/arjdbc/jdbc/rake_tasks.rb

@@ -1,10 +1,3 @@
-if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
-  jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
-  if Rake.application.lookup("db:create")
-    # rails tasks already defined; load the override tasks now
-    load jdbc_rakefile
-  else
-    # rails tasks not loaded yet; load as an import
-    Rake.application.add_import(jdbc_rakefile)
-  end
-end
+# @deprecated
+warn "[DEPRECATED] load 'arjdbc/tasks.rb' instead of 'arjdbc/jdbc/rake_tasks.rb'"
+load 'arjdbc/tasks.rb'

data/lib/arjdbc/mssql/adapter.rb

@@ -1,10 +1,11 @@
+ArJdbc.load_java_part :MSSQL
+
 require 'strscan'
 require 'arjdbc/mssql/utils'
 require 'arjdbc/mssql/tsql_methods'
 require 'arjdbc/mssql/limit_helpers'
 require 'arjdbc/mssql/lock_helpers'
 require 'arjdbc/mssql/explain_support'
-require 'arjdbc/jdbc/serialized_attributes_helper'
 
 module ArJdbc
   module MSSQL
@@ -12,39 +13,41 @@ module ArJdbc
     include TSqlMethods
     
     include ExplainSupport
-
-    @@_lob_callback_added = nil
-    
-    def self.extended(base)
-      unless @@_lob_callback_added
-        ActiveRecord::Base.class_eval do
-          def after_save_with_mssql_lob
-            self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |column|
-              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
-              next if value.nil? || (value == '')
-
-              connection.write_large_object(
-                column.type == :binary, column.name, 
-                self.class.table_name, self.class.primary_key, 
-                quote_value(id), value
-              )
-            end
-          end
-        end
-
-        ActiveRecord::Base.after_save :after_save_with_mssql_lob
-        @@_lob_callback_added = true
-      end
+    
+    def self.extended(adapter) # :nodoc:
+      initialize!
       
-      if ( version = base.sqlserver_version ) == '2000'
+      if ( version = adapter.sqlserver_version ) == '2000'
         extend LimitHelpers::SqlServer2000AddLimitOffset
       else
         extend LimitHelpers::SqlServerAddLimitOffset
       end
-      base.config[:sqlserver_version] ||= version
-      base.configure_connection
+      adapter.config[:sqlserver_version] ||= version
     end
 
+    @@_initialized = nil
+    
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+      
+      require 'arjdbc/jdbc/serialized_attributes_helper'
+      ActiveRecord::Base.class_eval do
+        def after_save_with_mssql_lob
+          self.class.columns.select { |c| c.sql_type =~ /image/i }.each do |column|
+            value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
+            next if value.nil? || (value == '')
+
+            self.class.connection.write_large_object(
+              column.type == :binary, column.name, 
+              self.class.table_name, self.class.primary_key, 
+              self.class.connection.quote(id), value
+            )
+          end
+        end
+      end
+      ActiveRecord::Base.after_save :after_save_with_mssql_lob
+    end
+    
     def configure_connection
       use_database # config[:database]
     end
@@ -72,7 +75,7 @@ module ArJdbc
       @sqlserver_version ||= begin
         config_version = config[:sqlserver_version]
         config_version ? config_version.to_s :
-          select_value("SELECT @@version")[/Microsoft SQL Server\s+(\d{4})/, 1]
+          select_value("SELECT @@version")[/(Microsoft SQL Server\s+|Microsoft SQL Azure.+\n.+)(\d{4})/, 2]
       end
     end
 
@@ -310,13 +313,17 @@ module ArJdbc
       quote_column_name(name)
     end
     
+#    def quote_table_name_for_assignment(table, attr)
+#      quote_column_name(attr)
+#    end if ::ActiveRecord::VERSION::MAJOR > 3
+    
     def quote_column_name(name)
       name.to_s.split('.').map do |n| # "[#{name}]"
         n =~ /^\[.*\]$/ ? n : "[#{n.gsub(']', ']]')}]"
       end.join('.')
     end
 
-    ADAPTER_NAME = 'MSSQL'
+    ADAPTER_NAME = 'MSSQL'.freeze
     
     def adapter_name # :nodoc:
       ADAPTER_NAME
@@ -351,12 +358,13 @@ module ArJdbc
     # 
     # http://blogs.msdn.com/b/mssqlisv/archive/2007/03/23/upgrading-to-sql-server-2005-and-default-schema-setting.aspx
     
-    # Returns the default schema (to be used for table resolution) used for 
-    # the {#current_user}.
+    # Returns the default schema (to be used for table resolution) used for the {#current_user}.
     def default_schema
       return current_user if sqlserver_2000?
       @default_schema ||= 
-        select_value("SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER")
+        @connection.execute_query_raw(
+          "SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER"
+        ).first['default_schema_name']
     end
     alias_method :current_schema, :default_schema
 
@@ -372,12 +380,16 @@ module ArJdbc
     
     # `SELECT CURRENT_USER`
     def current_user
-      @current_user ||= select_value("SELECT CURRENT_USER")
+      @current_user ||= @connection.execute_query_raw("SELECT CURRENT_USER").first['']
     end
     
     def charset
       select_value "SELECT SERVERPROPERTY('SqlCharSetName')"
     end
+
+    def collation
+      select_value "SELECT SERVERPROPERTY('Collation')"
+    end
     
     def current_database
       select_value 'SELECT DB_NAME()'
@@ -410,6 +422,10 @@ module ArJdbc
     def create_database(name, options = {})
       execute "CREATE DATABASE #{quote_table_name(name)}"
     end
+
+    def database_exists?(name)
+      select_value "SELECT name FROM sys.databases WHERE name = '#{name}'"
+    end
     
     def rename_table(table_name, new_table_name)
       clear_cached_table(table_name)
@@ -601,7 +617,23 @@ module ArJdbc
       # NOTE: we allow to execute SQL as requested returning a results.
       # e.g. this allows to use SQLServer's EXEC with a result set ...
       sql = repair_special_columns to_sql(sql, binds)
-      log(sql, name || 'SQL') { @connection.execute_query(sql) }
+      if prepared_statements?
+        log(sql, name, binds) { @connection.execute_query(sql, binds) }
+      else
+        sql = suble_binds(sql, binds)
+        log(sql, name) { @connection.execute_query(sql) }
+      end
+    end
+    
+    # @override
+    def exec_query_raw(sql, name = 'SQL', binds = [], &block) # :nodoc:
+      sql = repair_special_columns to_sql(sql, binds)
+      if prepared_statements?
+        log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
+      else
+        sql = suble_binds(sql, binds)
+        log(sql, name) { @connection.execute_query_raw(sql, &block) }
+      end
     end
     
     private
@@ -671,7 +703,49 @@ module ArJdbc
 end
 
 module ActiveRecord::ConnectionAdapters
+  
+  class MSSQLAdapter < JdbcAdapter
+    include ::ArJdbc::MSSQL
+    
+    def initialize(*args)
+      ::ArJdbc::MSSQL.initialize!
+      
+      super # configure_connection happens in super
+      
+      if ( version = self.sqlserver_version ) == '2000'
+        extend LimitHelpers::SqlServer2000AddLimitOffset
+      else
+        extend LimitHelpers::SqlServerAddLimitOffset
+      end
+      config[:sqlserver_version] ||= version
+    end
+    
+    # some QUOTING caching :
+
+    @@quoted_table_names = {}
+
+    def quote_table_name(name)
+      unless quoted = @@quoted_table_names[name]
+        quoted = super
+        @@quoted_table_names[name] = quoted.freeze
+      end
+      quoted
+    end
+
+    @@quoted_column_names = {}
+
+    def quote_column_name(name)
+      unless quoted = @@quoted_column_names[name]
+        quoted = super
+        @@quoted_column_names[name] = quoted.freeze
+      end
+      quoted
+    end
+    
+  end
+  
   class MSSQLColumn < JdbcColumn
     include ArJdbc::MSSQL::Column
   end
+  
 end

data/lib/arjdbc/mssql/connection_methods.rb

@@ -12,7 +12,9 @@ ArJdbc::ConnectionMethods.module_eval do
     config[:host] ||= "localhost"
     config[:port] ||= 1433
     config[:driver] ||= defined?(::Jdbc::JTDS.driver_name) ? ::Jdbc::JTDS.driver_name : 'net.sourceforge.jtds.jdbc.Driver'
-    config[:adapter_spec] = ::ArJdbc::MSSQL
+    config[:adapter_spec] ||= ::ArJdbc::MSSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::MSSQLAdapter unless config.key?(:adapter_class)
+    config[:connection_alive_sql] ||= 'SELECT 1'
 
     config[:url] ||= begin
       url = "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"

data/lib/arjdbc/mssql/limit_helpers.rb

@@ -23,11 +23,12 @@ module ArJdbc
               rest_of_query = from_table + '.' + rest_of_query
             end
             new_sql = "#{select} t.* FROM (SELECT ROW_NUMBER() OVER(#{order}) AS _row_num, #{rest_of_query}"
-            new_sql << ") AS t WHERE t._row_num BETWEEN #{start_row.to_s} AND #{end_row.to_s}"
+            new_sql << ") AS t WHERE t._row_num BETWEEN #{start_row} AND #{end_row}"
             sql.replace(new_sql)
           end
           sql
         end
+        
       end
 
       module SqlServerAddLimitOffset
@@ -116,7 +117,7 @@ module ArJdbc
           if order =~ /(\w*id\w*)/i
             $1
           else
-            unquoted_name = unquote_table_name(table_name)
+            unquoted_name = Utils.unquote_table_name(table_name)
             model = descendants.find { |m| m.table_name == table_name || m.table_name == unquoted_name }
             model ? model.primary_key : 'id'
           end

data/lib/arjdbc/mssql/lock_helpers.rb

@@ -2,6 +2,9 @@ module ArJdbc
   module MSSQL
     module LockHelpers
       module SqlServerAddLock
+        
+        SELECT_FROM_WHERE_RE = /\A(\s*SELECT\s.*?)(\sFROM\s)(.*?)(\sWHERE\s.*|)\Z/mi # :nodoc:
+        
         # Microsoft SQL Server uses its own syntax for SELECT .. FOR UPDATE:
         # SELECT .. FROM table1 WITH(ROWLOCK,UPDLOCK), table2 WITH(ROWLOCK,UPDLOCK) WHERE ..
         #
@@ -14,7 +17,7 @@ module ArJdbc
               add_lock!(subselect, options)
               return sql.replace(prefix + subselect + suffix)
             end
-            unless sql =~ /\A(\s*SELECT\s.*?)(\sFROM\s)(.*?)(\sWHERE\s.*|)\Z/mi
+            unless sql =~ SELECT_FROM_WHERE_RE
               # If you get this error, this driver probably needs to be fixed.
               raise NotImplementedError, "Don't know how to add_lock! to SQL statement: #{sql.inspect}"
             end
@@ -66,6 +69,7 @@ module ArJdbc
           end
           sql
         end
+        
       end
     end
   end

data/lib/arjdbc/mysql/adapter.rb

@@ -1,14 +1,12 @@
+ArJdbc.load_java_part :MySQL
+
 require 'bigdecimal'
 require 'active_record/connection_adapters/abstract/schema_definitions'
 require 'arjdbc/mysql/explain_support'
 
 module ArJdbc
   module MySQL
-
-    def self.extended(adapter)
-      adapter.configure_connection
-    end
-
+    
     def configure_connection
       variables = config[:variables] || {}
       # By default, MySQL 'where id is null' selects the last inserted id. Turn this off.
@@ -57,6 +55,16 @@ module ArJdbc
       config.key?(:strict) ? config[:strict] : ::ActiveRecord::VERSION::MAJOR > 3
     end
     
+    @@emulate_booleans = true
+    
+    # Boolean emulation can be disabled using (or using the adapter method) :
+    # 
+    #   ArJdbc::MySQL.emulate_booleans = false
+    # 
+    # @see ActiveRecord::ConnectionAdapters::MysqlAdapter#emulate_booleans
+    def self.emulate_booleans; @@emulate_booleans; end
+    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+    
     module Column
       
       def extract_default(default)
@@ -79,15 +87,19 @@ module ArJdbc
       end
 
       def simplified_type(field_type)
+        if adapter.respond_to?(:emulate_booleans) && adapter.emulate_booleans 
+          return :boolean if field_type.downcase.index('tinyint(1)')
+        end
+
         case field_type
-        when /tinyint\(1\)|bit/i then :boolean
-        when /enum/i             then :string
-        when /year/i             then :integer
+        when /enum/i, /set/i then :string
+        when /year/i then :integer
+        when /bit/i then :binary
         else
           super
         end
       end
-
+      
       def extract_limit(sql_type)
         case sql_type
         when /blob|text/i
@@ -126,6 +138,9 @@ module ArJdbc
         type != :string && !null && default == ''
       end
       
+      def adapter; end
+      private :adapter
+      
     end
 
     ColumnExtensions = Column # :nodoc: backwards-compatibility
@@ -172,6 +187,16 @@ module ArJdbc
       }
     end
 
+    def new_visitor(config = nil)
+      visitor = ::Arel::Visitors::MySQL
+      ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
+    end if defined? ::Arel::Visitors::MySQL
+    
+    # @see #bind_substitution
+    class BindSubstitution < Arel::Visitors::MySQL # :nodoc:
+      include Arel::Visitors::BindVisitor
+    end if defined? Arel::Visitors::BindVisitor
+    
     def case_sensitive_equality_operator
       "= BINARY"
     end
@@ -289,7 +314,7 @@ module ArJdbc
     
     # SCHEMA STATEMENTS ========================================
     
-    def structure_dump #:nodoc:
+    def structure_dump # :nodoc:
       if supports_views?
         sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
       else
@@ -309,33 +334,53 @@ module ArJdbc
       end
     end
 
-    # based on:
-    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L756
-    # Required for passing rails column caching tests
+    # Returns just a table's primary key
+    def primary_key(table)
+      #pk_and_sequence = pk_and_sequence_for(table)
+      #pk_and_sequence && pk_and_sequence.first
+      @connection.primary_keys(table).first
+    end
+    
     # Returns a table's primary key and belonging sequence.
-    def pk_and_sequence_for(table) #:nodoc:
-      keys = []
-      result = execute("SHOW INDEX FROM #{quote_table_name(table)} WHERE Key_name = 'PRIMARY'", 'SCHEMA')
-      result.each do |h|
-        keys << h["Column_name"]
+    # @note not used only here for potential compatibility with AR's adapter.
+    def pk_and_sequence_for(table)
+      result = execute("SHOW CREATE TABLE #{quote_table_name(table)}", 'SCHEMA').first
+      if result['Create Table'].to_s =~ /PRIMARY KEY\s+(?:USING\s+\w+\s+)?\((.+)\)/
+        keys = $1.split(","); keys.map! { |key| key.gsub(/[`"]/, "") }
+        return keys.length == 1 ? [ keys.first, nil ] : nil
+      else
+        return nil
       end
-      keys.length == 1 ? [keys.first, nil] : nil
     end
-
-    # based on:
-    # https://github.com/rails/rails/blob/3-1-stable/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb#L647
+    
+    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
+    
+    if ::ActiveRecord::VERSION::MAJOR > 3
+      
+    INDEX_TYPES = [ :fulltext, :spatial ]
+    INDEX_USINGS = [ :btree, :hash ]
+    
+    end
+      
     # Returns an array of indexes for the given table.
-    def indexes(table_name, name = nil)#:nodoc:
+    def indexes(table_name, name = nil) # :nodoc:
       indexes = []
       current_index = nil
-      result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name)
+      result = execute("SHOW KEYS FROM #{quote_table_name(table_name)}", name || 'SCHEMA')
       result.each do |row|
-        key_name = row["Key_name"]
+        key_name = row['Key_name']
         if current_index != key_name
-          next if key_name == "PRIMARY" # skip the primary key
+          next if key_name == 'PRIMARY' # skip the primary key
           current_index = key_name
-          indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(
-            row["Table"], key_name, row["Non_unique"] == 0, [], [])
+          indexes <<  
+            if self.class.const_defined?(:INDEX_TYPES) # AR 4.0
+              mysql_index_type = row['Index_type'].downcase.to_sym
+              index_type = INDEX_TYPES.include?(mysql_index_type) ? mysql_index_type : nil
+              index_using = INDEX_USINGS.include?(mysql_index_type) ? mysql_index_type : nil
+              IndexDefinition.new(row['Table'], key_name, row['Non_unique'].to_i == 0, [], [], nil, nil, index_type, index_using)
+            else
+              IndexDefinition.new(row['Table'], key_name, row['Non_unique'].to_i == 0, [], [])
+            end
         end
 
         indexes.last.columns << row["Column_name"]
@@ -343,26 +388,23 @@ module ArJdbc
       end
       indexes
     end
-
-    def jdbc_columns(table_name, name = nil)#:nodoc:
+    
+    def columns(table_name, name = nil) # :nodoc:
       sql = "SHOW FIELDS FROM #{quote_table_name(table_name)}"
-      execute(sql, 'SCHEMA').map do |field|
-        ::ActiveRecord::ConnectionAdapters::MysqlColumn.new(field["Field"], field["Default"], field["Type"], field["Null"] == "YES")
+      column = ::ActiveRecord::ConnectionAdapters::MysqlAdapter::Column
+      result = execute(sql, name || 'SCHEMA')
+      result.map! do |field|
+        column.new(field["Field"], field["Default"], field["Type"], field["Null"] == "YES")
       end
+      result
     end
 
-    # Returns just a table's primary key
-    def primary_key(table)
-      pk_and_sequence = pk_and_sequence_for(table)
-      pk_and_sequence && pk_and_sequence.first
-    end
-
-    def recreate_database(name, options = {}) #:nodoc:
+    def recreate_database(name, options = {}) # :nodoc:
       drop_database(name)
       create_database(name, options)
     end
 
-    def create_database(name, options = {}) #:nodoc:
+    def create_database(name, options = {}) # :nodoc:
       if options[:collation]
         execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
       else
@@ -572,7 +614,7 @@ module ArJdbc
       end
       column
     end
-
+    
     def show_create_table(table)
       select_one("SHOW CREATE TABLE #{quote_table_name(table)}")
     end
@@ -598,29 +640,41 @@ end
 module ActiveRecord
   module ConnectionAdapters
     # Remove any vestiges of core/Ruby MySQL adapter
-    remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
     remove_const(:MysqlAdapter) if const_defined?(:MysqlAdapter)
+    
+    class MysqlAdapter < JdbcAdapter
+      include ::ArJdbc::MySQL
+      include ::ArJdbc::MySQL::ExplainSupport
+      
+      # By default, the MysqlAdapter will consider all columns of type 
+      # <tt>tinyint(1)</tt> as boolean. If you wish to disable this :
+      #
+      #   ActiveRecord::ConnectionAdapters::Mysql[2]Adapter.emulate_booleans = false
+      #
+      def self.emulate_booleans; ::ArJdbc::MySQL.emulate_booleans; end
+      def self.emulate_booleans=(emulate); ::ArJdbc::MySQL.emulate_booleans = emulate; end
+      
+      class Column < JdbcColumn
+        include ::ArJdbc::MySQL::Column
 
-    class MysqlColumn < JdbcColumn
-      include ::ArJdbc::MySQL::Column
+        def initialize(name, *args)
+          if Hash === name
+            super
+          else
+            super(nil, name, *args)
+          end
+        end
 
-      def initialize(name, *args)
-        if Hash === name
-          super
-        else
-          super(nil, name, *args)
+        # @note {#ArJdbc::MySQL::Column} uses this to check for boolean emulation
+        def adapter
+          MysqlAdapter
         end
+        
       end
       
-    end
-
-    class MysqlAdapter < JdbcAdapter
-      include ::ArJdbc::MySQL
-      include ::ArJdbc::MySQL::ExplainSupport
-
       def initialize(*args)
         super
-        configure_connection
+        # configure_connection happens in super
       end
 
       def jdbc_connection_class(spec)
@@ -628,9 +682,8 @@ module ActiveRecord
       end
 
       def jdbc_column_class
-        MysqlColumn
+        Column
       end
-      alias_chained_method :columns, :query_cache, :jdbc_columns
 
       # some QUOTING caching :
 
@@ -655,18 +708,22 @@ module ActiveRecord
       end
       
     end
-  end
-end
-
-# Don't need to load native mysql adapter
-$LOADED_FEATURES << 'active_record/connection_adapters/mysql_adapter.rb'
-$LOADED_FEATURES << 'active_record/connection_adapters/mysql2_adapter.rb'
-
-module Mysql # :nodoc:
-  remove_const(:Error) if const_defined?(:Error)
-  class Error < ::ActiveRecord::JDBCError; end
+    
+    if ActiveRecord::VERSION::MAJOR < 3 ||
+        ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 )
+      remove_const(:MysqlColumn) if const_defined?(:MysqlColumn)
+      MysqlColumn = MysqlAdapter::Column
+    end
 
-  def self.client_version
-    50400 # faked out for AR tests
+    if ActiveRecord::VERSION::MAJOR > 3 ||
+        ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 1 )
+      remove_const(:Mysql2Adapter) if const_defined?(:Mysql2Adapter)
+      Mysql2Adapter = MysqlAdapter
+      if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
+        remove_const(:Mysql2Column) if const_defined?(:Mysql2Column)
+        Mysql2Column = MysqlAdapter::Column
+      end
+    end
+    
   end
 end