activerecord-jdbc-adapter 1.2.8 → 1.2.9

data/lib/arjdbc/jdbc/extension.rb

@@ -26,7 +26,7 @@ module ArJdbc
   #         true
   #       end
   #     end
-  def self.extension(name,&block)
+  def self.extension(name, &block)
     if const_defined?(name)
       mod = const_get(name)
     else

data/lib/arjdbc/mssql.rb

@@ -1,3 +1,6 @@
 require 'arjdbc/jdbc'
 require 'arjdbc/mssql/adapter'
 require 'arjdbc/mssql/connection_methods'
+module ArJdbc
+  MsSQL = MSSQL # compatibility with 1.2
+end

data/lib/arjdbc/mssql/adapter.rb

@@ -1,17 +1,18 @@
 require 'strscan'
-require 'arjdbc/mssql/tsql_helper'
+require 'arjdbc/mssql/utils'
+require 'arjdbc/mssql/tsql_methods'
 require 'arjdbc/mssql/limit_helpers'
 require 'arjdbc/mssql/lock_helpers'
 require 'arjdbc/jdbc/serialized_attributes_helper'
 
 module ArJdbc
-  module MsSQL
+  module MSSQL
+    include Utils
     include TSqlMethods
-    include LimitHelpers
 
     @@_lob_callback_added = nil
     
-    def self.extended(mod)
+    def self.extended(base)
       unless @@_lob_callback_added
         ActiveRecord::Base.class_eval do
           def after_save_with_mssql_lob
@@ -31,51 +32,51 @@ module ArJdbc
         ActiveRecord::Base.after_save :after_save_with_mssql_lob
         @@_lob_callback_added = true
       end
-      mod.add_version_specific_add_limit_offset
+      
+      if ( version = base.sqlserver_version ) == '2000'
+        extend LimitHelpers::SqlServer2000AddLimitOffset
+      else
+        extend LimitHelpers::SqlServerAddLimitOffset
+      end
+      base.config[:sqlserver_version] ||= version
     end
 
     def self.column_selector
-      [/sqlserver|tds|Microsoft SQL/i, lambda {|cfg,col| col.extend(::ArJdbc::MsSQL::Column)}]
+      [ /sqlserver|tds|Microsoft SQL/i, lambda { |cfg, column| column.extend(::ArJdbc::MSSQL::Column) } ]
     end
 
     def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::MssqlJdbcConnection
+      ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
     end
 
     def self.arel2_visitors(config)
       require 'arel/visitors/sql_server'
-      visitor_class = config[:sqlserver_version] == "2000" ? ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
-      {}.tap {|v| %w(mssql sqlserver jdbcmssql).each {|x| v[x] = visitor_class } }
+      visitors = config[:sqlserver_version] == '2000' ? 
+        ::Arel::Visitors::SQLServer2000 : ::Arel::Visitors::SQLServer
+      { 'mssql' => visitors, 'jdbcmssql' => visitors, 'sqlserver' => visitors }
     end
 
     def sqlserver_version
-      @sqlserver_version ||= select_value("select @@version")[/Microsoft SQL Server\s+(\d{4})/, 1]
-    end
-
-    def add_version_specific_add_limit_offset
-      config[:sqlserver_version] = version = sqlserver_version
-      if version == "2000"
-        extend LimitHelpers::SqlServer2000AddLimitOffset
-      else
-        extend LimitHelpers::SqlServerAddLimitOffset
+      @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]
       end
     end
 
-    def modify_types(tp) #:nodoc:
-      super(tp)
-      tp[:string] = {:name => "NVARCHAR", :limit => 255}
-
-      if sqlserver_version == "2000"
-        tp[:text] = {:name => "NTEXT"}
+    def modify_types(types) #:nodoc:
+      super(types)
+      types[:string] = { :name => "NVARCHAR", :limit => 255 }
+      if sqlserver_2000?
+        types[:text] = { :name => "NTEXT" }
       else
-        tp[:text] = {:name => "NVARCHAR(MAX)"}
+        types[:text] = { :name => "NVARCHAR(MAX)" }
       end
-
-      tp[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
-      tp[:integer][:limit] = nil
-      tp[:boolean] = {:name => "bit"}
-      tp[:binary] = {:name => "image"}
-      tp
+      types[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
+      types[:integer][:limit] = nil
+      types[:boolean] = { :name => "bit" }
+      types[:binary] = { :name => "image" }
+      types
     end
 
     def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
@@ -88,12 +89,12 @@ module ArJdbc
       # MSSQL Server 2000 is skipped here because I don't know how it will behave.
       #
       # See: http://msdn.microsoft.com/en-us/library/ms186939.aspx
-      if type.to_s == 'string' and limit == 1073741823 and sqlserver_version != "2000"
+      if type.to_s == 'string' && limit == 1073741823 && ! sqlserver_2000?
         'NVARCHAR(MAX)'
       elsif %w( boolean date datetime ).include?(type.to_s)
-        super(type)   # cannot specify limit/precision/scale with these types
+        super(type) # cannot specify limit/precision/scale with these types
       else
-        super
+        super # TSqlMethods#type_to_sql
       end
     end
 
@@ -207,52 +208,47 @@ module ArJdbc
       # column, so we include Integer here.
       when String, ActiveSupport::Multibyte::Chars, Integer
         value = value.to_s
-        if column && column.type == :binary
-          "'#{quote_string(ArJdbc::MsSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
-        elsif column && [:integer, :float].include?(column.type)
-          value = column.type == :integer ? value.to_i : value.to_f
-          value.to_s
-        elsif !column.respond_to?(:is_utf8?) || column.is_utf8?
+        column_type = column && column.type
+        if column_type == :binary
+          "'#{quote_string(ArJdbc::MSSQL::Column.string_to_binary(value))}'" # ' (for ruby-mode)
+        elsif column_type == :integer
+          value.to_i.to_s
+        elsif column_type == :float
+          value.to_f.to_s
+        elsif ! column.respond_to?(:is_utf8?) || column.is_utf8?
           "N'#{quote_string(value)}'" # ' (for ruby-mode)
         else
           super
         end
       when TrueClass  then '1'
       when FalseClass then '0'
-      else            super
+      else super
       end
     end
 
-    def quote_string(string)
-      string.gsub(/\'/, "''")
-    end
-
     def quote_table_name(name)
       quote_column_name(name)
     end
 
     def quote_column_name(name)
-      "[#{name}]"
-    end
-
-    def quoted_true
-      quote true
-    end
-
-    def quoted_false
-      quote false
+      name.to_s.split('.').map do |n| # "[#{name}]"
+        n =~ /^\[.*\]$/ ? n : "[#{n.gsub(']', ']]')}]"
+      end.join('.')
     end
 
-    def adapter_name #:nodoc:
-      'MsSQL'
+    ADAPTER_NAME = 'MSSQL'
+    
+    def adapter_name # :nodoc:
+      ADAPTER_NAME
     end
 
     def change_order_direction(order)
+      asc, desc = /\bASC\b/i, /\bDESC\b/i
       order.split(",").collect do |fragment|
         case fragment
-        when  /\bDESC\b/i     then fragment.gsub(/\bDESC\b/i, "ASC")
-        when  /\bASC\b/i      then fragment.gsub(/\bASC\b/i, "DESC")
-        else                  String.new(fragment).split(',').join(' DESC,') + ' DESC'
+        when desc  then fragment.gsub(desc, "ASC")
+        when asc   then fragment.gsub(asc, "DESC")
+        else "#{fragment.split(',').join(' DESC,')} DESC"
         end
       end.join(",")
     end
@@ -271,7 +267,7 @@ module ArJdbc
       execute "DROP DATABASE #{name}"
     end
 
-    def create_database(name, options={})
+    def create_database(name, options = {})
       execute "CREATE DATABASE #{name}"
       execute "USE #{name}"
     end
@@ -331,18 +327,31 @@ module ArJdbc
 
     def remove_default_constraint(table_name, column_name)
       clear_cached_table(table_name)
-      defaults = select "select def.name from sysobjects def, syscolumns col, sysobjects tab where col.cdefault = def.id and col.name = '#{column_name}' and tab.name = '#{table_name}' and col.id = tab.id"
-      defaults.each {|constraint|
-        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["name"]}"
-      }
+      if sqlserver_2000?
+        # NOTE: since SQLServer 2005 these are provided as sys.sysobjects etc.
+        # but only due backwards-compatibility views and should be avoided ...
+        defaults = select_values "SELECT d.name" <<
+          " FROM sysobjects d, syscolumns c, sysobjects t" <<
+          " WHERE c.cdefault = d.id AND c.name = '#{column_name}'" <<
+          " AND t.name = '#{table_name}' AND c.id = t.id"
+      else
+        defaults = select_values "SELECT d.name FROM sys.tables t" <<
+          " JOIN sys.default_constraints d ON d.parent_object_id = t.object_id" <<
+          " JOIN sys.columns c ON c.object_id = t.object_id AND c.column_id = d.parent_column_id" <<
+          " WHERE t.name = '#{table_name}' AND c.name = '#{column_name}'"
+      end
+      defaults.each do |def_name|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{def_name}"
+      end
     end
 
     def remove_check_constraints(table_name, column_name)
       clear_cached_table(table_name)
-      # TODO remove all constraints in single method
-      constraints = select "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{table_name}' and COLUMN_NAME = '#{column_name}'"
-      constraints.each do |constraint|
-        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint["CONSTRAINT_NAME"]}"
+      constraints = select_values "SELECT constraint_name" <<
+        " FROM information_schema.constraint_column_usage" <<
+        " WHERE table_name = '#{table_name}' AND column_name = '#{column_name}'"
+      constraints.each do |constraint_name|
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint_name}"
       end
     end
 
@@ -350,22 +359,27 @@ module ArJdbc
       execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
     end
 
+    def table_exists?(name)
+      !! ( jdbc_columns(name) rescue nil )
+    end
+    
+    SKIP_COLUMNS_TABLE_NAMES_RE = /^information_schema\./i # :nodoc:
+    
     def columns(table_name, name = nil)
-      # It's possible for table_name to be an empty string, or nil, if something attempts to issue SQL
-      # which doesn't involve a table.  IE. "SELECT 1" or "SELECT * from someFunction()".
+      # It's possible for table_name to be an empty string, or nil, if something 
+      # attempts to issue SQL which doesn't involve a table. 
+      # IE. "SELECT 1" or "SELECT * FROM someFunction()".
       return [] if table_name.blank?
-      table_name = table_name.to_s if table_name.is_a?(Symbol)
-
-      # Remove []'s from around the table name, valid in a select statement, but not when matching metadata.
-      table_name = table_name.gsub(/[\[\]]/, '')
+      
+      table_name = unquote_table_name(table_name)
 
-      return [] if table_name =~ /^information_schema\./i
-      @table_columns ||= {}
-      unless @table_columns[table_name]
+      return [] if table_name =~ SKIP_COLUMNS_TABLE_NAMES_RE
+      
+      unless (@table_columns ||= {})[table_name]
         @table_columns[table_name] = super
-        @table_columns[table_name].each do |col|
-          col.identity = true if col.sql_type =~ /identity/i
-          col.is_special = true if col.sql_type =~ /text|ntext|image|xml/i
+        @table_columns[table_name].each do |column|
+          column.identity = true if column.sql_type =~ /identity/i
+          column.is_special = true if column.sql_type =~ /text|ntext|image|xml/i
         end
       end
       @table_columns[table_name]
@@ -374,7 +388,7 @@ module ArJdbc
     # Turns IDENTITY_INSERT ON for table during execution of the block
     # N.B. This sets the state of IDENTITY_INSERT to OFF after the
     # block has been executed without regard to its previous state
-    def with_identity_insert_enabled(table_name, &block)
+    def with_identity_insert_enabled(table_name)
       set_identity_insert(table_name, true)
       yield
     ensure
@@ -384,16 +398,17 @@ module ArJdbc
     def set_identity_insert(table_name, enable = true)
       execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
     rescue Exception => e
-      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+      raise ActiveRecord::ActiveRecordError, "IDENTITY_INSERT could not be turned" + 
+            " #{enable ? 'ON' : 'OFF'} for table #{table_name} due : #{e.inspect}"
     end
 
     def identity_column(table_name)
-      columns(table_name).each do |col|
-        return col.name if col.identity
+      for column in columns(table_name)
+        return column.name if column.identity
       end
-      return nil
+      nil
     end
-
+    
     def query_requires_identity_insert?(sql)
       table_name = get_table_name(sql)
       id_column = identity_column(table_name)
@@ -402,32 +417,7 @@ module ArJdbc
         return table_name if insert_columns.include?(id_column)
       end
     end
-
-    def unquote_column_name(name)
-      if name =~ /^\[.*\]$/
-        name[1..-2]
-      else
-        name
-      end
-    end
-
-    def get_special_columns(table_name)
-      special = []
-      columns(table_name).each do |col|
-        special << col.name if col.is_special
-      end
-      special
-    end
-
-    def repair_special_columns(sql)
-      special_cols = get_special_columns(get_table_name(sql))
-      for col in special_cols.to_a
-        sql.gsub!(Regexp.new(" #{col.to_s} = "), " #{col.to_s} LIKE ")
-        sql.gsub!(/ORDER BY #{col.to_s}/i, '')
-      end
-      sql
-    end
-
+    
     def determine_order_clause(sql)
       return $1 if sql =~ /ORDER BY (.*)$/
       table_name = get_table_name(sql)
@@ -437,7 +427,8 @@ module ArJdbc
     def determine_primary_key(table_name)
       primary_key = columns(table_name).detect { |column| column.primary || column.identity }
       return primary_key.name if primary_key
-      # Look for an id column.  Return it, without changing case, to cover dbs with a case-sensitive collation.
+      # Look for an id column and return it, 
+      # without changing case, to cover DBs with a case-sensitive collation :
       columns(table_name).each { |column| return column.name if column.name =~ /^id$/i }
       # Give up and provide something which is going to crash almost certainly
       columns(table_name)[0].name
@@ -448,11 +439,15 @@ module ArJdbc
     end
 
     def reset_column_information
-      @table_columns = nil
+      @table_columns = nil if defined? @table_columns
     end
     
     private
     
+    def sqlserver_2000?
+      sqlserver_version <= '2000'
+    end
+    
     def _execute(sql, name = nil)
       # Match the start of the SQL to determine appropriate behavior.
       # Be aware of multi-line SQL which might begin with 'create stored_proc' 
@@ -469,13 +464,35 @@ module ArJdbc
           @connection.execute_insert(sql)
         end
       elsif sql.lstrip =~ /\A\(?\s*(select|show)/i # self.class.select?(sql)
-        repair_special_columns(sql)
+        sql = repair_special_columns(sql)
         @connection.execute_query(sql)
       else # sql.lstrip =~ /\A(create|exec)/i
         @connection.execute_update(sql)
       end
     end
     
+    def repair_special_columns(sql)
+      qualified_table_name = get_table_name(sql, true)
+      special_columns = get_special_columns(qualified_table_name)
+      for column in special_columns.to_a
+        sql.gsub!(Regexp.new(" #{column} = "), " #{column} LIKE ")
+        sql.gsub!(/ORDER BY #{column.to_s}/i, '')
+      end if special_columns
+      sql
+    end
+
+    def get_special_columns(qualified_table_name)
+      special = []
+      columns(qualified_table_name).each do |column|
+        special << column.name if column.is_special
+      end
+      special
+    end
+    
+    def sqlserver_2000?
+      sqlserver_version <= '2000'
+    end
+    
   end
 end
 

data/lib/arjdbc/mssql/connection_methods.rb

@@ -13,7 +13,7 @@ class ActiveRecord::Base
       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[:url] ||= begin
         url = "jdbc:jtds:sqlserver://#{config[:host]}:#{config[:port]}/#{config[:database]}"

data/lib/arjdbc/mssql/limit_helpers.rb

@@ -1,48 +1,57 @@
-module ::ArJdbc
-  module MsSQL
+module ArJdbc
+  module MSSQL
     module LimitHelpers
-      module_function
-      def get_table_name(sql)
-        if sql =~ /^\s*insert\s+into\s+([^\(\s,]+)\s*|^\s*update\s+([^\(\s,]+)\s*/i
-          $1
-        elsif sql =~ /\bfrom\s+([^\(\s,]+)\s*/i
-          $1
-        else
-          nil
+      
+      FIND_SELECT = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im # :nodoc:
+      
+      module SqlServerReplaceLimitOffset
+        
+        module_function
+        
+        def replace_limit_offset!(sql, limit, offset, order)
+          if limit
+            offset ||= 0
+            start_row = offset + 1
+            end_row = offset + limit.to_i
+            _, select, rest_of_query = FIND_SELECT.match(sql).to_a
+            rest_of_query.strip!
+            if rest_of_query[0...1] == "1" && rest_of_query !~ /1 AS/i
+              rest_of_query[0] = "*"
+            end
+            if rest_of_query[0...1] == "*"
+              from_table = Utils.get_table_name(rest_of_query, true)
+              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}"
+            sql.replace(new_sql)
+          end
+          sql
         end
       end
 
-      def get_primary_key(order, table_name)
-        if order =~ /(\w*id\w*)/i
-          $1
-        else
-          table_name[/\[+(.*)\]+/i]
-
-          # rails 2 vs rails 3
-          if ActiveRecord::VERSION::MAJOR >= 3
-            models = ActiveRecord::Base.descendants
-          else
-            models = ActiveRecord::Base.send(:subclasses)
-          end
-
-          model = models.select{|model| model.table_name == $1}.first
-          if model then
-            model.primary_key
-          else
-           'id'
+      module SqlServerAddLimitOffset
+        
+        def add_limit_offset!(sql, options)
+          if options[:limit]
+            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
+            sql.sub!(/ ORDER BY.*$/i, '')
+            SqlServerReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
           end
         end
+        
       end
-
+      
       module SqlServer2000ReplaceLimitOffset
+        
         module_function
+        
         def replace_limit_offset!(sql, limit, offset, order)
           if limit
             offset ||= 0
             start_row = offset + 1
             end_row = offset + limit.to_i
-            find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
-            whole, select, rest_of_query = find_select.match(sql).to_a
+            _, select, rest_of_query = FIND_SELECT.match(sql).to_a
             if (start_row == 1) && (end_row ==1)
               new_sql = "#{select} TOP 1 #{rest_of_query}"
               sql.replace(new_sql)
@@ -52,8 +61,8 @@ module ::ArJdbc
               #removing out stuff before the FROM...
               rest = rest_of_query[/FROM/i=~ rest_of_query.. -1]
               #need the table name for avoiding amiguity
-              table_name = LimitHelpers.get_table_name(sql)
-              primary_key = LimitHelpers.get_primary_key(order, table_name)
+              table_name = Utils.get_table_name(sql, true)
+              primary_key = get_primary_key(order, table_name)
               #I am not sure this will cover all bases.  but all the tests pass
               if order[/ORDER/].nil?
                 new_order = "ORDER BY #{order}, #{table_name}.#{primary_key}" if order.index("#{table_name}.#{primary_key}").nil?
@@ -72,52 +81,39 @@ module ::ArJdbc
           end
           sql
         end
-      end
-
-      module SqlServer2000AddLimitOffset
-        def add_limit_offset!(sql, options)
-          if options[:limit]
-            order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
-            sql.sub!(/ ORDER BY.*$/i, '')
-            SqlServer2000ReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
+        
+        def get_primary_key(order, table_name) # table_name might be quoted
+          if order =~ /(\w*id\w*)/i
+            $1
+          else
+            unquoted_name = 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
         end
-      end
 
-      module SqlServerReplaceLimitOffset
-        module_function
-        def replace_limit_offset!(sql, limit, offset, order)
-          if limit
-            offset ||= 0
-            start_row = offset + 1
-            end_row = offset + limit.to_i
-            find_select = /\b(SELECT(?:\s+DISTINCT)?)\b(.*)/im
-            whole, select, rest_of_query = find_select.match(sql).to_a
-            rest_of_query.strip!
-            if rest_of_query[0...1] == "1" && rest_of_query !~ /1 AS/i
-              rest_of_query[0] = "*"
-            end
-            if rest_of_query[0] == "*"
-              from_table = LimitHelpers.get_table_name(rest_of_query)
-              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}"
-            sql.replace(new_sql)
-          end
-          sql
+        private
+        
+        if ActiveRecord::VERSION::MAJOR >= 3
+          def descendants; ::ActiveRecord::Base.descendants; end
+        else
+          def descendants; ::ActiveRecord::Base.send(:subclasses) end
         end
+        
       end
 
-      module SqlServerAddLimitOffset
+      module SqlServer2000AddLimitOffset
+        
         def add_limit_offset!(sql, options)
           if options[:limit]
             order = "ORDER BY #{options[:order] || determine_order_clause(sql)}"
             sql.sub!(/ ORDER BY.*$/i, '')
-            SqlServerReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
+            SqlServer2000ReplaceLimitOffset.replace_limit_offset!(sql, options[:limit], options[:offset], order)
           end
         end
+        
       end
+      
     end
   end
 end