activerecord-sqlserver-adapter 4.2.18 → 5.0.0

data/VERSION

@@ -1 +1 @@
-4.2.18
+5.0.0

data/activerecord-sqlserver-adapter.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.add_dependency 'activerecord', '~> 4.2.1'
+  spec.add_dependency 'activerecord', '~> 5.0.0'
 end

data/appveyor.yml

@@ -12,8 +12,6 @@ install:
   - ruby --version
   - gem --version
   - bundle install
-  - gem uninstall bcrypt
-  - gem install bcrypt --platform=ruby
 build: off
 test_script:
   - powershell -File "%APPVEYOR_BUILD_FOLDER%\test\appveyor\dbsetup.ps1"

data/lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb

@@ -4,11 +4,14 @@ module ActiveRecord
       module CoreExt
         module Explain
 
-          SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '
-          SQLSERVER_PARAM_MATCHER = /@\d+ =/
+          SQLSERVER_STATEMENT_PREFIX = 'EXEC sp_executesql '.freeze
+          SQLSERVER_PARAM_MATCHER = /@\d+ = (.*)/
+          SQLSERVER_NATIONAL_STRING_MATCHER = /N'(.*)'/m
 
           def exec_explain(queries)
-            unprepared_queries = queries.map { |sql, bind| [unprepare_sqlserver_statement(sql), bind] }
+            unprepared_queries = queries.map do |(sql, binds)|
+              [unprepare_sqlserver_statement(sql), binds]
+            end
             super(unprepared_queries)
           end
 
@@ -20,11 +23,15 @@ module ActiveRecord
           def unprepare_sqlserver_statement(sql)
             if sql.starts_with?(SQLSERVER_STATEMENT_PREFIX)
               executesql = sql.from(SQLSERVER_STATEMENT_PREFIX.length)
-              executesql_args = executesql.split(', ')
-              found_args = executesql_args.reject! { |arg| arg =~ SQLSERVER_PARAM_MATCHER }
-              executesql_args.pop if found_args && executesql_args.many?
-              executesql = executesql_args.join(', ').strip.match(/N'(.*)'/m)[1]
-              Utils.unquote_string(executesql)
+              args = executesql.split(', ')
+              unprepared_sql = args.shift.strip.match(SQLSERVER_NATIONAL_STRING_MATCHER)[1]
+              unprepared_sql = Utils.unquote_string(unprepared_sql)
+              args = args.from(args.length / 2)
+              args.each_with_index do |arg, index|
+                value = arg.match(SQLSERVER_PARAM_MATCHER)[1]
+                unprepared_sql.sub! "@#{index}", value
+              end
+              unprepared_sql
             else
               sql
             end

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -15,15 +15,13 @@ module ActiveRecord
           end
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], sqlserver_options = {})
-          sp_executesql(sql, name, binds)
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          sp_executesql(sql, name, binds, prepare: prepare)
         end
 
-        def exec_insert(sql, name, binds, _pk = nil, _sequence_name = nil)
-          id_insert = binds_have_identity_column?(binds)
-          id_table  = table_name_from_binds(binds) if id_insert
-          if id_insert && id_table
-            with_identity_insert_enabled(id_table) { exec_query(sql, name, binds) }
+        def exec_insert(sql, name, binds, pk = nil, _sequence_name = nil)
+          if pk && id_insert_table_name = query_requires_identity_insert?(sql)
+            with_identity_insert_enabled(id_insert_table_name) { exec_query(sql, name, binds) }
           else
             exec_query(sql, name, binds)
           end
@@ -81,26 +79,18 @@ module ActiveRecord
         def release_savepoint(name = current_savepoint_name)
         end
 
-        def case_sensitive_modifier(node, table_attribute)
-          node = Arel::Nodes.build_quoted node, table_attribute
-          Arel::Nodes::Bin.new(node)
-        end
-
         def case_sensitive_comparison(table, attribute, column, value)
-          if column.case_sensitive?
-            table[attribute].eq(value)
+          if value && value.acts_like?(:string)
+            table[attribute].eq(Arel::Nodes::Bin.new(Arel::Nodes::BindParam.new))
           else
             super
           end
         end
 
-        def case_insensitive_comparison(table, attribute, column, value)
-          if column.case_sensitive?
-            super
-          else
-            table[attribute].eq(value)
-          end
+        def can_perform_case_insensitive_comparison_for?(column)
+          column.type == :string
         end
+        private :can_perform_case_insensitive_comparison_for?
 
         # === SQLServer Specific ======================================== #
 
@@ -122,24 +112,12 @@ module ActiveRecord
                 yield(r) if block_given?
               end
               result.each.map { |row| row.is_a?(Hash) ? row.with_indifferent_access : row }
-            when :odbc
-              results = []
-              raw_connection_run(sql) do |handle|
-                get_rows = lambda do
-                  rows = handle_to_names_and_values handle, fetch: :all
-                  rows.each_with_index { |r, i| rows[i] = r.with_indifferent_access }
-                  results << rows
-                end
-                get_rows.call
-                get_rows.call while handle_more_results?(handle)
-              end
-              results.many? ? results : results.first
             end
           end
         end
 
         def with_identity_insert_enabled(table_name)
-          table_name = quote_table_name(table_name_or_views_table_name(table_name))
+          table_name = quote_table_name(table_name)
           set_identity_insert(table_name, true)
           yield
         ensure
@@ -154,9 +132,7 @@ module ActiveRecord
 
         def user_options
           return {} if sqlserver_azure?
-          rows = select_rows('DBCC USEROPTIONS WITH NO_INFOMSGS', 'SCHEMA')
-          rows = rows.first if rows.size == 2 && rows.last.empty?
-          rows.reduce(HashWithIndifferentAccess.new) do |values, row|
+          select_rows('dbcc useroptions', 'SCHEMA').reduce(HashWithIndifferentAccess.new) do |values, row|
             if row.instance_of? Hash
               set_option = row.values[0].gsub(/\s+/, '_')
               user_value = row.values[1]
@@ -213,36 +189,22 @@ module ActiveRecord
 
         protected
 
-        def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds)
-        end
-
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-          sql = if pk && self.class.use_output_inserted && !database_prefix_remote_server?
-            quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-            sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
-          else
-            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          if pk.nil?
+            table_name = query_requires_identity_insert?(sql)
+            pk = primary_key(table_name)
           end
+          sql = if pk && self.class.use_output_inserted && !database_prefix_remote_server?
+                  quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
+                  sql.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                else
+                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+                end
           super
         end
 
         # === SQLServer Specific ======================================== #
 
-        def binds_have_identity_column?(binds)
-          binds.any? do |column_value|
-            column, value = column_value
-            SQLServerColumn === column && column.is_identity?
-          end
-        end
-
-        def table_name_from_binds(binds)
-          binds.detect { |column_value|
-            column, value = column_value
-            SQLServerColumn === column
-          }.try(:first).try(:table_name)
-        end
-
         def set_identity_insert(table_name, enable = true)
           do_execute "SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}"
         rescue Exception
@@ -257,27 +219,39 @@ module ActiveRecord
 
         def sp_executesql(sql, name, binds, options = {})
           options[:ar_result] = true if options[:fetch] != :rows
-          types, params = sp_executesql_types_and_parameters(binds)
-          sql = sp_executesql_sql(sql, types, params, name)
+          unless without_prepared_statement?(binds)
+            types, params = sp_executesql_types_and_parameters(binds)
+            sql = sp_executesql_sql(sql, types, params, name)
+          end
           raw_select sql, name, binds, options
         end
 
         def sp_executesql_types_and_parameters(binds)
           types, params = [], []
-          binds.each_with_index do |(column, value), index|
-            types << "@#{index} #{sp_executesql_sql_type(column, value)}"
-            params << quote(value, column)
+          binds.each_with_index do |attr, index|
+            types << "@#{index} #{sp_executesql_sql_type(attr)}"
+            params << sp_executesql_sql_param(attr)
           end
           [types, params]
         end
 
-        def sp_executesql_sql_type(column, value)
-          return column.sql_type_for_statement if SQLServerColumn === column
-          if value.is_a?(Numeric)
-            'int'
-          # We can do more here later.
+        def sp_executesql_sql_type(attr)
+          return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
+          case value = attr.value_for_database
+          when Numeric
+            'int'.freeze
+          else
+            'nvarchar(max)'.freeze
+          end
+        end
+
+        def sp_executesql_sql_param(attr)
+          case attr.value_for_database
+          when Type::Binary::Data,
+               ActiveRecord::Type::SQLServer::Data
+            quote(attr.value_for_database)
           else
-            'nvarchar(max)'
+            quote(type_cast(attr.value_for_database))
           end
         end
 
@@ -285,7 +259,7 @@ module ActiveRecord
           if name == 'EXPLAIN'
             params.each.with_index do |param, index|
               substitute_at_finder = /(@#{index})(?=(?:[^']|'[^']*')*$)/ # Finds unquoted @n values.
-              sql.sub! substitute_at_finder, param
+              sql.sub! substitute_at_finder, param.to_s
             end
           else
             types = quote(types.join(', '))
@@ -300,8 +274,6 @@ module ActiveRecord
           case @connection_options[:mode]
           when :dblib
             @connection.execute(sql).do
-          when :odbc
-            @connection.do(sql)
           end
         ensure
           @update_sql = false
@@ -324,16 +296,12 @@ module ActiveRecord
           case @connection_options[:mode]
           when :dblib
             @connection.execute(sql)
-          when :odbc
-            block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
           end
         end
 
         def handle_more_results?(handle)
           case @connection_options[:mode]
           when :dblib
-          when :odbc
-            handle.more_results
           end
         end
 
@@ -341,8 +309,6 @@ module ActiveRecord
           case @connection_options[:mode]
           when :dblib
             handle_to_names_and_values_dblib(handle, options)
-          when :odbc
-            handle_to_names_and_values_odbc(handle, options)
           end
         end
 
@@ -356,28 +322,10 @@ module ActiveRecord
           options[:ar_result] ? ActiveRecord::Result.new(columns, results) : results
         end
 
-        def handle_to_names_and_values_odbc(handle, options = {})
-          @connection.use_utc = ActiveRecord::Base.default_timezone == :utc
-          if options[:ar_result]
-            columns = lowercase_schema_reflection ? handle.columns(true).map { |c| c.name.downcase } : handle.columns(true).map { |c| c.name }
-            rows = handle.fetch_all || []
-            ActiveRecord::Result.new(columns, rows)
-          else
-            case options[:fetch]
-            when :all
-              handle.each_hash || []
-            when :rows
-              handle.fetch_all || []
-            end
-          end
-        end
-
         def finish_statement_handle(handle)
           case @connection_options[:mode]
           when :dblib
             handle.cancel if handle
-          when :odbc
-            handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
           end
           handle
         end

data/lib/active_record/connection_adapters/sqlserver/database_tasks.rb

@@ -24,10 +24,9 @@ module ActiveRecord
         end
 
         def collation
-          select_value "SELECT DATABASEPROPERTYEX(DB_NAME(), 'Collation')"
+          @collation ||= select_value "SELECT DATABASEPROPERTYEX(DB_NAME(), 'Collation')"
         end
 
-
         private
 
         def create_database_options(options={})

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -3,23 +3,44 @@ module ActiveRecord
     module SQLServer
       module Quoting
 
-        QUOTED_TRUE  = '1'
-        QUOTED_FALSE = '0'
-        QUOTED_STRING_PREFIX = 'N'
+        QUOTED_TRUE  = '1'.freeze
+        QUOTED_FALSE = '0'.freeze
+        QUOTED_STRING_PREFIX = 'N'.freeze
+
+        def fetch_type_metadata(sql_type, sqlserver_options = {})
+          cast_type = lookup_cast_type(sql_type)
+          SQLServer::SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+            sqlserver_options: sqlserver_options
+          )
+        end
 
         def quote_string(s)
           SQLServer::Utils.quote_string(s)
         end
 
+        def quote_string_single(s)
+          SQLServer::Utils.quote_string_single(s)
+        end
+
+        def quote_string_single_national(s)
+          SQLServer::Utils.quote_string_single_national(s)
+        end
+
         def quote_column_name(name)
           SQLServer::Utils.extract_identifiers(name).quoted
         end
 
-        def quote_default_value(value, column)
-          if column.type == :uuid && value =~ /\(\)/
+        def quote_default_expression(value, column)
+          cast_type = lookup_cast_type(column.sql_type)
+          if cast_type.type == :uuid && value =~ /\(\)/
             value
           else
-            quote(value, column)
+            super
           end
         end
 
@@ -41,9 +62,9 @@ module ActiveRecord
 
         def quoted_date(value)
           if value.acts_like?(:date)
-            Type::Date.new.type_cast_for_database(value)
+            Type::Date.new.serialize(value)
           else value.acts_like?(:time)
-            Type::DateTime.new.type_cast_for_database(value)
+            Type::DateTime.new.serialize(value)
           end
         end
 
@@ -54,7 +75,7 @@ module ActiveRecord
           case value
           when Type::Binary::Data
             "0x#{value.hex}"
-          when ActiveRecord::Type::SQLServer::Char::Data
+          when ActiveRecord::Type::SQLServer::Data
             value.quoted
           when String, ActiveSupport::Multibyte::Chars
             "#{QUOTED_STRING_PREFIX}#{super}"
@@ -65,7 +86,7 @@ module ActiveRecord
 
         def _type_cast(value)
           case value
-          when ActiveRecord::Type::SQLServer::Char::Data
+          when ActiveRecord::Type::SQLServer::Data
             value.to_s
           else
             super

data/lib/active_record/connection_adapters/sqlserver/schema_creation.rb

@@ -5,15 +5,6 @@ module ActiveRecord
 
         private
 
-        def visit_ColumnDefinition(o)
-          sql = super
-          if o.primary_key? && o.type == :uuid
-            sql << ' PRIMARY KEY '
-            add_column_options!(sql, column_options(o))
-          end
-          sql
-        end
-
         def visit_TableDefinition(o)
           if o.as
             table_name = quote_table_name(o.temporary ? "##{o.name}" : o.name)
@@ -25,15 +16,6 @@ module ActiveRecord
           end
         end
 
-        def add_column_options!(sql, options)
-          column = options.fetch(:column) { return super }
-          if (column.type == :uuid || column.type == :uniqueidentifier) && options[:default] =~ /\(\)/
-            sql << " DEFAULT #{options.delete(:default)}"
-          else
-            super
-          end
-        end
-
         def action_sql(action, dependency)
           case dependency
           when :restrict

data/lib/active_record/connection_adapters/sqlserver/schema_dumper.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module SchemaDumper
+
+        private
+
+        def schema_collation(column)
+          return unless column.collation
+          column.collation if column.collation != collation
+        end
+
+      end
+    end
+  end
+end