activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -10,8 +10,7 @@ module ActiveRecord
     class SQLServerDatabaseTasks
       DEFAULT_COLLATION = "SQL_Latin1_General_CP1_CI_AS"
 
-      delegate :connection, :establish_connection, :clear_active_connections!,
-               to: ActiveRecord::Base
+      delegate :with_connection, :establish_connection, to: ActiveRecord::Base
 
       def self.using_database_configurations?
         true
@@ -24,8 +23,10 @@ module ActiveRecord
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration.database, configuration_hash.merge(collation: default_collation)
-        establish_connection configuration
+        with_connection do |connection|
+          connection.create_database(configuration.database, configuration_hash.merge(collation: default_collation))
+        end
+        establish_connection(configuration)
       rescue ActiveRecord::StatementInvalid => e
         if /database .* already exists/i === e.message
           raise DatabaseAlreadyExists
@@ -36,15 +37,15 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration.database
+        with_connection { |connection| connection.drop_database(configuration.database) }
       end
 
       def charset
-        connection.charset
+        with_connection { |connection| connection.charset }
       end
 
       def collation
-        connection.collation
+        with_connection { |connection| connection.collation }
       end
 
       def purge
@@ -53,34 +54,42 @@ module ActiveRecord
         create true
       end
 
-      def structure_dump(filename, extra_flags)
-        server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
-        server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
-        command = [
-          "defncopy-ttds",
-          server_arg,
-          "-D #{Shellwords.escape(configuration_hash[:database])}",
-          "-U #{Shellwords.escape(configuration_hash[:username])}",
-          "-P #{Shellwords.escape(configuration_hash[:password])}",
-          "-o #{Shellwords.escape(filename)}",
-        ]
-        table_args = connection.tables.map { |t| Shellwords.escape(t) }
-        command.concat(table_args)
-        view_args = connection.views.map { |v| Shellwords.escape(v) }
-        command.concat(view_args)
-        raise "Error dumping database" unless Kernel.system(command.join(" "))
-
-        dump = File.read(filename)
-        dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
-        dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
-        dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
-        dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
-        dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
-        File.open(filename, "w") { |file| file.puts dump }
+      def clear_active_connections!
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      end
+
+      def structure_dump(filename, _extra_flags)
+        with_connection do |connection|
+          server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
+          server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
+          command = [
+            "defncopy-ttds",
+            server_arg,
+            "-D #{Shellwords.escape(configuration_hash[:database])}",
+            "-U #{Shellwords.escape(configuration_hash[:username])}",
+            "-P #{Shellwords.escape(configuration_hash[:password])}",
+            "-o #{Shellwords.escape(filename)}",
+          ]
+          table_args = connection.tables.map { |t| Shellwords.escape(t) }
+          command.concat(table_args)
+          view_args = connection.views.map { |v| Shellwords.escape(v) }
+          command.concat(view_args)
+          raise "Error dumping database" unless Kernel.system(command.join(" "))
+
+          dump = File.read(filename)
+          dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
+          dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
+          dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
+          dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
+          dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
+          File.open(filename, "w") { |file| file.puts dump }
+        end
       end
 
-      def structure_load(filename, extra_flags)
-        connection.execute File.read(filename)
+      def structure_load(filename, _extra_flags)
+        with_connection do |connection|
+          connection.execute File.read(filename)
+        end
       end
 
       private

data/lib/arel/visitors/sqlserver.rb

@@ -30,10 +30,46 @@ module Arel
       end
 
       def visit_Arel_Nodes_UpdateStatement(o, collector)
-        if o.orders.any? && o.limit.nil?
-          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
+        if has_join_and_composite_primary_key?(o)
+          update_statement_using_join(o, collector)
+        else
+          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807) if o.orders.any? && o.limit.nil?
+
+          super
         end
-        super
+      end
+
+      def visit_Arel_Nodes_DeleteStatement(o, collector)
+        if has_join_and_composite_primary_key?(o)
+          delete_statement_using_join(o, collector)
+        else
+          super
+        end
+      end
+
+      def has_join_and_composite_primary_key?(o)
+        has_join_sources?(o) && o.relation.left.instance_variable_get(:@klass).composite_primary_key?
+      end
+
+      def delete_statement_using_join(o, collector)
+        collector.retryable = false
+
+        collector << "DELETE "
+        visit o.relation.left, collector
+        collector << " FROM "
+        visit o.relation, collector
+        collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+      end
+
+      def update_statement_using_join(o, collector)
+        collector.retryable = false
+
+        collector << "UPDATE "
+        visit o.relation.left, collector
+        collect_nodes_for o.values, collector, " SET "
+        collector << " FROM "
+        visit o.relation, collector
+        collect_nodes_for o.wheres, collector, " WHERE ", " AND "
       end
 
       def visit_Arel_Nodes_Lock(o, collector)
@@ -67,7 +103,7 @@ module Arel
       def visit_Arel_Nodes_HomogeneousIn(o, collector)
         collector.preparable = false
 
-        collector << quote_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+        visit o.left, collector
 
         if o.type == :in
           collector << " IN ("
@@ -77,46 +113,45 @@ module Arel
 
         values = o.casted_values
 
+        # Monkey-patch start.
+        column_name = o.attribute.name
+        column_type = o.attribute.relation.type_for_attribute(column_name)
+        column_type = column_type.cast_type if column_type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType) # Use cast_type on encrypted attributes. Don't encrypt them again
+
         if values.empty?
           collector << @connection.quote(nil)
-        elsif @connection.prepared_statements
-          # Monkey-patch start. Add query attribute bindings rather than just values.
-          column_name = o.column_name
-          column_type = o.attribute.relation.type_for_attribute(o.column_name)
+        elsif @connection.prepared_statements && !column_type.serialized?
+          # Add query attribute bindings rather than just values.
           attrs = values.map { |value| ActiveRecord::Relation::QueryAttribute.new(column_name, value, column_type) }
-
           collector.add_binds(attrs, &bind_block)
-          # Monkey-patch end.
         else
-          collector.add_binds(values, &bind_block)
+          collector.add_binds(values, o.proc_for_binds, &bind_block)
         end
+        # Monkey-patch end.
 
         collector << ")"
-        collector
       end
 
       def visit_Arel_Nodes_SelectStatement(o, collector)
         @select_statement = o
+        optimizer_hints = nil
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
           collector = visit o.with, collector
           collector << " "
         end
-        collector = o.cores.inject(collector) { |c, x|
-          visit_Arel_Nodes_SelectCore(x, c)
-        }
+        collector = o.cores.inject(collector) do |collect, core|
+          optimizer_hints = core.optimizer_hints if core.optimizer_hints
+          visit_Arel_Nodes_SelectCore(core, collect)
+        end
         collector = visit_Orders_And_Let_Fetch_Happen o, collector
         collector = visit_Make_Fetch_Happen o, collector
+        collector = maybe_visit optimizer_hints, collector
         collector
       ensure
         @select_statement = nil
       end
 
-      def visit_Arel_Nodes_SelectCore(o, collector)
-        collector = super
-        maybe_visit o.optimizer_hints, collector
-      end
-
       def visit_Arel_Nodes_OptimizerHints(o, collector)
         hints = o.expr.map { |v| sanitize_as_option_clause(v) }.join(", ")
         collector << "OPTION (#{hints})"
@@ -128,10 +163,12 @@ module Arel
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
         table_name =
           begin
-            if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
-              remote_server_table_name(o)
-            else
-              quote_table_name(o.name)
+            o.class.engine.with_connection do |connection|
+              if connection.respond_to?(:sqlserver?) && connection.database_prefix_remote_server?
+                remote_server_table_name(o)
+              else
+                quote_table_name(o.name)
+              end
             end
           rescue Exception
             quote_table_name(o.name)
@@ -200,6 +237,11 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_WithRecursive(o, collector)
+        collector << "WITH "
+        collect_ctes(o.children, collector)
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock(collector, options = {})
@@ -212,7 +254,7 @@ module Arel
 
       def visit_Orders_And_Let_Fetch_Happen(o, collector)
         make_Fetch_Possible_And_Deterministic o
-        unless o.orders.empty?
+        if o.orders.any?
           collector << " ORDER BY "
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
@@ -260,15 +302,14 @@ module Arel
 
       def make_Fetch_Possible_And_Deterministic(o)
         return if o.limit.nil? && o.offset.nil?
+        return if o.orders.any?
 
         t = table_From_Statement o
         pk = primary_Key_From_Table t
         return unless pk
 
-        if o.orders.empty?
-          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
-          o.orders = [pk.asc]
-        end
+        # Prefer deterministic vs a simple `(SELECT NULL)` expr.
+        o.orders = [pk.asc]
       end
 
       def distinct_One_As_One_Is_So_Not_Fetch(o)
@@ -315,14 +356,16 @@ module Arel
       end
 
       def remote_server_table_name(o)
-        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
-          "#{o.class.engine.connection.database_prefix}#{o.name}"
-        ).quoted
+        o.class.engine.with_connection do |connection|
+          ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+            "#{connection.database_prefix}#{o.name}"
+          ).quoted
+        end
       end
 
-      # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer
+      # Need to remove ordering from sub-queries unless TOP/OFFSET also used. Otherwise, SQLServer
       # returns error "The ORDER BY clause is invalid in views, inline functions, derived tables,
-      # subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
+      # sub-queries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
       def remove_invalid_ordering_from_select_statement(node)
         return unless Arel::Nodes::SelectStatement === node
 

data/test/cases/active_schema_test_sqlserver.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
+  describe "indexes" do
+    before do
+      connection.create_table :schema_test_table, force: true, id: false do |t|
+        t.column :foo, :string, limit: 100
+        t.column :state, :string
+      end
+    end
+
+    after do
+      connection.drop_table :schema_test_table rescue nil
+    end
+
+    it 'default index' do
+      assert_queries_match('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo"
+      end
+    end
+
+    it 'unique index' do
+      assert_queries_match('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", unique: true
+      end
+    end
+
+    it 'where condition on index' do
+      assert_queries_match("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
+        connection.add_index :schema_test_table, "foo", where: "state = 'active'"
+      end
+    end
+
+    it 'if index does not exist' do
+      assert_queries_match("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
+                 "CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
+        connection.add_index :schema_test_table, "foo", if_not_exists: true
+      end
+    end
+
+    it 'clustered index' do
+      assert_queries_match('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :clustered
+      end
+    end
+
+    it 'nonclustered index' do
+      assert_queries_match('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+        connection.add_index :schema_test_table, "foo", type: :nonclustered
+      end
+    end
+  end
+
+  describe 'collation' do
+    it "create column with NOT NULL and COLLATE" do
+      assert_nothing_raised do
+        connection.create_table :not_null_with_collation_table, force: true, id: false do |t|
+          t.text :not_null_text_with_collation, null: false, collation: "Latin1_General_CS_AS"
+        end
+      end
+    ensure
+      connection.drop_table :not_null_with_collation_table rescue nil
+    end
+  end
+
+  describe 'datetimeoffset precision' do
+    it 'valid precisions are correct' do
+      assert_nothing_raised do
+        connection.create_table :datetimeoffset_precisions do |t|
+          t.datetimeoffset :precision_default
+          t.datetimeoffset :precision_5, precision: 5
+          t.datetimeoffset :precision_7, precision: 7
+        end
+      end
+
+      columns = connection.columns("datetimeoffset_precisions")
+
+      assert_equal columns.find { |column| column.name == "precision_default" }.precision, 7
+      assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
+      assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
+    ensure
+      connection.drop_table :datetimeoffset_precisions rescue nil
+    end
+
+    it 'invalid precision raises exception' do
+      assert_raise(ActiveRecord::ActiveRecordError) do
+        connection.create_table :datetimeoffset_precisions do |t|
+          t.datetimeoffset :precision_8, precision: 8
+        end
+      end
+    ensure
+      connection.drop_table :datetimeoffset_precisions rescue nil
+    end
+  end
+
+  describe 'time precision' do
+    it 'valid precisions are correct' do
+      assert_nothing_raised do
+        connection.create_table :time_precisions do |t|
+          t.time :precision_default
+          t.time :precision_5, precision: 5
+          t.time :precision_7, precision: 7
+        end
+      end
+
+      columns = connection.columns("time_precisions")
+
+      assert_equal columns.find { |column| column.name == "precision_default" }.precision, 7
+      assert_equal columns.find { |column| column.name == "precision_5" }.precision, 5
+      assert_equal columns.find { |column| column.name == "precision_7" }.precision, 7
+    ensure
+      connection.drop_table :time_precisions rescue nil
+    end
+
+    it 'invalid precision raises exception' do
+      assert_raise(ActiveRecord::ActiveRecordError) do
+        connection.create_table :time_precisions do |t|
+          t.time :precision_8, precision: 8
+        end
+      end
+    ensure
+      connection.drop_table :time_precisions rescue nil
+    end
+  end
+end