Identity Inserts with Triggers

The adapter uses `OUTPUT INSERTED` so that we can select any data type key, for example UUID tables. However, this poses a problem with tables that use triggers. The solution requires that we use a more complex insert statement which uses a temporary table to select the inserted identity. To use this format you must declare your table exempt from the simple output inserted style with the table name into a concurrent hash. Optionally, you can set the data type of the table's primary key to return.

```ruby
adapter = ActiveRecord::ConnectionAdapters::SQLServerAdapter

adapter.exclude_output_inserted_table_names['my_table_name'] = true

adapter.exclude_output_inserted_table_names['my_uuid_table_name'] = 'uniqueidentifier'
```

Author: metaskills

CHANGELOG.md

@@ -3,6 +3,7 @@
 #### Fixed
 
 * Patched `Relation#build_count_subquery`. Fixes #613.
+* Inserts to tables with triggers using default `OUTPUT INSERTED` style. Fixes #595.
 
 
 ## v5.1.2

README.md

@@ -18,7 +18,6 @@ The SQL Server adapter for ActiveRecord v5.1 using SQL Server 2012 or higher.
 
 Interested in older versions? We follow a rational versioning policy that tracks Rails. That means that our 5.0.x version of the adapter is only for the latest 5.0 version of Rails. If you need the adapter for SQL Server 2008 or 2005, you are still in the right spot. Just install the latest 3.2.x to 4.1.x version of the adapter that matches your Rails version. We also have stable branches for each major/minor release of ActiveRecord.
 
-
 #### Native Data Type Support
 
 We support every data type supported by FreeTDS. All simplified Rails types in migrations will coorespond to a matching SQL Server national (unicode) data type. Always check the `initialize_native_database_types` [(here)](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/master/lib/active_record/connection_adapters/sqlserver/schema_statements.rb#L243) for an updated list.
@@ -28,6 +27,21 @@ The following types (date, datetime2, datetimeoffset, time) all require TDS vers
 The Rails v5 adapter supports ActiveRecord's `datetime_with_precision` setting. This means that passing `:precision` to a datetime column is supported. Using a pecision with the `:datetime` type will signal the adapter to use the `datetime2` type under the hood.
 
 
+#### Identity Inserts with Triggers
+
+The adapter uses `OUTPUT INSERTED` so that we can select any data type key, for example UUID tables. However, this poses a problem with tables that use triggers. The solution requires that we use a more complex insert statement which uses a temporary table to select the inserted identity. To use this format you must declare your table exempt from the simple output inserted style with the table name into a concurrent hash. Optionally, you can set the data type of the table's primary key to return.
+
+```ruby
+adapter = ActiveRecord::ConnectionAdapters::SQLServerAdapter
+
+# Will assume `bigint` as the id key temp table type.
+adapter.exclude_output_inserted_table_names['my_table_name'] = true
+
+# Explicitly set the data type for the temporary key table.
+adapter.exclude_output_inserted_table_names['my_uuid_table_name'] = 'uniqueidentifier'
+```
+
+
 #### Force Schema To Lowercase
 
 Although it is not necessary, the Ruby convention is to use lowercase method names. If your database schema is in upper or mixed case, we can force all table and column names during the schema reflection process to be lowercase. Add this to your config/initializers file for the adapter.

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -192,9 +192,19 @@ def sql_for_insert(sql, pk, id_value, sequence_name, binds)
             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?
+          sql = if pk && use_output_inserted? && !database_prefix_remote_server?
                   quoted_pk = SQLServer::Utils.extract_identifiers(pk).quoted
-                  sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+                  if exclude_output_inserted
+                    id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? 'bigint' : exclude_output_inserted
+                    <<-SQL.strip_heredoc
+                      DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                      SELECT CAST(#{quoted_pk} AS #{id_sql_type}) FROM @ssaIdInsertTable
+                    SQL
+                  else
+                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                  end
                 else
                   "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
                 end
@@ -279,6 +289,21 @@ def raw_connection_do(sql)
 
         # === SQLServer Specific (Identity Inserts) ===================== #
 
+        def use_output_inserted?
+          self.class.use_output_inserted
+        end
+
+        def exclude_output_inserted_table_names?
+          !self.class.exclude_output_inserted_table_names.empty?
+        end
+
+        def exclude_output_inserted_table_name?(table_name, sql)
+          return false unless exclude_output_inserted_table_names?
+          table_name ||= get_table_name(sql)
+          return false unless table_name
+          self.class.exclude_output_inserted_table_names[table_name]
+        end
+
         def exec_insert_requires_identity?(sql, pk, binds)
           query_requires_identity_insert?(sql) if pk && binds.map(&:name).include?(pk)
         end
@@ -287,7 +312,8 @@ def query_requires_identity_insert?(sql)
           if insert_sql?(sql)
             table_name = get_table_name(sql)
             id_column = identity_columns(table_name).first
-            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+            # id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? quote_table_name(table_name) : false
+            id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? table_name : false
           else
             false
           end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -45,11 +45,13 @@ class SQLServerAdapter < AbstractAdapter
 
       cattr_accessor :cs_equality_operator, instance_accessor: false
       cattr_accessor :use_output_inserted, instance_accessor: false
+      cattr_accessor :exclude_output_inserted_table_names, instance_accessor: false
       cattr_accessor :showplan_option, instance_accessor: false
       cattr_accessor :lowercase_schema_reflection
 
       self.cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
       self.use_output_inserted = true
+      self.exclude_output_inserted_table_names = Concurrent::Map.new { false }
 
       def initialize(connection, logger = nil, config = {})
         super(connection, logger, config)

test/cases/adapter_test_sqlserver.rb

@@ -140,12 +140,12 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column' do
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql)
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted)
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered)
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_sp)
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted_sp)
-      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered_sp)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_sp)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted_sp)
+      assert_equal 'funny_jokes', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered_sp)
     end
 
     it 'return false to #query_requires_identity_insert? for normal SQL' do

test/cases/trigger_test_sqlserver.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+require 'cases/helper_sqlserver'
+
+class SQLServerTriggerTest < ActiveRecord::TestCase
+  after  { exclude_output_inserted_table_names.clear }
+
+  let(:exclude_output_inserted_table_names) do
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.exclude_output_inserted_table_names
+  end
+
+  it 'can insert into a table with output inserted - with a true setting for table name' do
+    exclude_output_inserted_table_names['sst_table_with_trigger'] = true
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTrigger.create! event_name: 'test trigger'
+    ['Fixnum', 'Integer'].must_include obj.id.class.name
+    obj.event_name.must_equal 'test trigger'
+    obj.id.must_be :present?
+    obj.id.to_s.must_equal SSTestTriggerHistory.first.id_source
+  end
+
+  it 'can insert into a table with output inserted - with a uniqueidentifier value' do
+    exclude_output_inserted_table_names['sst_table_with_uuid_trigger'] = 'uniqueidentifier'
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTriggerUuid.create! event_name: 'test uuid trigger'
+    obj.id.class.name.must_equal 'String'
+    obj.event_name.must_equal 'test uuid trigger'
+    obj.id.must_be :present?
+    obj.id.to_s.must_equal SSTestTriggerHistory.first.id_source
+  end
+end

test/models/sqlserver/trigger.rb

@@ -0,0 +1,7 @@
+class SSTestTrigger < ActiveRecord::Base
+  self.table_name = 'sst_table_with_trigger'
+end
+
+class SSTestTriggerUuid < ActiveRecord::Base
+  self.table_name = 'sst_table_with_uuid_trigger'
+end

test/models/sqlserver/trigger_history.rb

@@ -0,0 +1,3 @@
+class SSTestTriggerHistory < ActiveRecord::Base
+  self.table_name = 'sst_table_with_trigger_history'
+end

test/schema/sqlserver_specific_schema.rb

@@ -177,6 +177,44 @@
       FROM sst_string_defaults
   STRINGDEFAULTSBIGVIEW
 
+  # Trigger
+
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_table_with_trigger') DROP TABLE sst_table_with_trigger"
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_table_with_trigger_history') DROP TABLE sst_table_with_trigger_history"
+  execute <<-SQL
+    CREATE TABLE sst_table_with_trigger(
+      id bigint IDENTITY NOT NULL PRIMARY KEY,
+      event_name nvarchar(255)
+    )
+    CREATE TABLE sst_table_with_trigger_history(
+      id bigint IDENTITY NOT NULL PRIMARY KEY,
+      id_source nvarchar(36),
+      event_name nvarchar(255)
+    )
+  SQL
+  execute <<-SQL
+    CREATE TRIGGER sst_table_with_trigger_t ON sst_table_with_trigger
+    FOR INSERT
+    AS
+    INSERT INTO sst_table_with_trigger_history (id_source, event_name)
+    SELECT id AS id_source, event_name FROM INSERTED
+  SQL
+
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_table_with_uuid_trigger') DROP TABLE sst_table_with_uuid_trigger"
+  execute <<-SQL
+    CREATE TABLE sst_table_with_uuid_trigger(
+      id uniqueidentifier DEFAULT NEWID() PRIMARY KEY,
+      event_name nvarchar(255)
+    )
+  SQL
+  execute <<-SQL
+    CREATE TRIGGER sst_table_with_uuid_trigger_t ON sst_table_with_uuid_trigger
+    FOR INSERT
+    AS
+    INSERT INTO sst_table_with_trigger_history (id_source, event_name)
+    SELECT id AS id_source, event_name FROM INSERTED
+  SQL
+
   # Another schema.
 
   create_table :sst_schema_columns, force: true do |t|