activerecord-sqlserver-adapter 4.2.18 → 5.0.0

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

@@ -7,23 +7,38 @@ module ActiveRecord
           @native_database_types ||= initialize_native_database_types.freeze
         end
 
-        def data_sources
-          tables + views
+        def tables(name = nil)
+          ActiveSupport::Deprecation.warn 'Passing arguments to #tables is deprecated without replacement.' if name
+          tables_sql('BASE TABLE')
         end
 
-        def tables(table_type = 'BASE TABLE')
-          select_values "SELECT #{lowercase_schema_reflection_sql('TABLE_NAME')} FROM INFORMATION_SCHEMA.TABLES #{"WHERE TABLE_TYPE = '#{table_type}'" if table_type} ORDER BY TABLE_NAME", 'SCHEMA'
+        def table_exists?(table_name)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            #table_exists? currently checks both tables and views.
+            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
+            Use #data_source_exists? instead.
+          MSG
+          data_source_exists?(table_name)
         end
 
-        def table_exists?(table_name)
+        def data_source_exists?(table_name)
           return false if table_name.blank?
           unquoted_table_name = SQLServer::Utils.extract_identifiers(table_name).object
-          super || tables.include?(unquoted_table_name) || views.include?(unquoted_table_name)
+          super(unquoted_table_name)
+        end
+
+        def views
+          tables_sql('VIEW')
+        end
+
+        def view_exists?(table_name)
+          identifier = SQLServer::Utils.extract_identifiers(table_name)
+          super(identifier.object)
         end
 
-        def create_table(table_name, options = {})
+        def create_table(table_name, comment: nil, **options)
           res = super
-          schema_cache.clear_table_cache!(table_name)
+          clear_cache!
           res
         end
 
@@ -47,17 +62,41 @@ module ActiveRecord
           end
         end
 
-        def columns(table_name, _name = nil)
+        def columns(table_name)
           return [] if table_name.blank?
           column_definitions(table_name).map do |ci|
-            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity, :default_function, :table_name, :collation
-            cast_type = lookup_cast_type(ci[:type])
-            new_column ci[:name], ci[:default_value], cast_type, ci[:type], ci[:null], sqlserver_options
+            sqlserver_options = ci.slice :ordinal_position, :is_primary, :is_identity
+            sql_type_metadata = fetch_type_metadata ci[:type], sqlserver_options
+            new_column(
+              ci[:name],
+              ci[:default_value],
+              sql_type_metadata,
+              ci[:null],
+              ci[:table_name],
+              ci[:default_function],
+              ci[:collation],
+              nil,
+              sqlserver_options
+            )
           end
         end
 
-        def new_column(name, default, cast_type, sql_type = nil, null = true, sqlserver_options={})
-          SQLServerColumn.new name, default, cast_type, sql_type, null, sqlserver_options
+        def new_column(name, default, sql_type_metadata, null, table_name, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+          SQLServerColumn.new(
+            name,
+            default,
+            sql_type_metadata,
+            null, table_name,
+            default_function,
+            collation,
+            comment,
+            sqlserver_options
+          )
+        end
+
+        def primary_keys(table_name)
+          primaries = schema_cache.columns(table_name).select(&:is_primary?).map(&:name)
+          primaries.present? ? primaries : identity_columns(table_name).map(&:name)
         end
 
         def rename_table(table_name, new_name)
@@ -82,11 +121,11 @@ module ActiveRecord
             indexes = indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }
             remove_indexes(table_name, column_name)
           end
-          sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_value(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
+          sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
           sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
           sql_commands[-1] << ' NOT NULL' if !options[:null].nil? && options[:null] == false
           if options_include_default?(options)
-            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_value(options[:default], column_object)} FOR #{quote_column_name(column_name)}"
+            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(options[:default], column_object)} FOR #{quote_column_name(column_name)}"
           end
           # Add any removed indexes back
           indexes.each do |index|
@@ -95,21 +134,22 @@ module ActiveRecord
           sql_commands.each { |c| do_execute(c) }
         end
 
-        def change_column_default(table_name, column_name, default)
-          schema_cache.clear_table_cache!(table_name)
+        def change_column_default(table_name, column_name, default_or_changes)
+          clear_cache!
+          column = column_for(table_name, column_name)
+          return unless column
           remove_default_constraint(table_name, column_name)
-          column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
-          do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_value(default, column_object)} FOR #{quote_column_name(column_name)}"
-          schema_cache.clear_table_cache!(table_name)
+          default = extract_new_default_value(default_or_changes)
+          do_execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(default, column)} FOR #{quote_column_name(column_name)}"
+          clear_cache!
         end
 
         def rename_column(table_name, column_name, new_column_name)
-          schema_cache.clear_table_cache!(table_name)
-          detect_column_for! table_name, column_name
+          clear_cache!
           identifier = SQLServer::Utils.extract_identifiers("#{table_name}.#{column_name}")
           execute_procedure :sp_rename, identifier.quoted, new_column_name, 'COLUMN'
           rename_column_indexes(table_name, column_name, new_column_name)
-          schema_cache.clear_table_cache!(table_name)
+          clear_cache!
         end
 
         def rename_index(table_name, old_name, new_name)
@@ -157,6 +197,16 @@ module ActiveRecord
             when 5..8       then  'bigint'
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
             end
+          when 'datetime2'
+            column_type_sql = super
+            if precision
+              if (0..7) === precision
+                column_type_sql << "(#{precision})"
+              else
+                raise(ActiveRecordError, "The dattime2 type has precision of #{precision}. The allowed range of precision is from 0 to 7")
+              end
+            end
+            column_type_sql
           else
             super
           end
@@ -171,6 +221,10 @@ module ActiveRecord
           [super, *order_columns].join(', ')
         end
 
+        def update_table_definition(table_name, base)
+          SQLServer::Table.new(table_name, base)
+        end
+
         def change_column_null(table_name, column_name, allow_null, default = nil)
           table_id = SQLServer::Utils.extract_identifiers(table_name)
           column_id = SQLServer::Utils.extract_identifiers(column_name)
@@ -183,12 +237,6 @@ module ActiveRecord
           do_execute sql
         end
 
-        # === SQLServer Specific ======================================== #
-
-        def views
-          tables('VIEW')
-        end
-
 
         protected
 
@@ -228,6 +276,12 @@ module ActiveRecord
           }
         end
 
+        def tables_sql(type)
+          tn  = lowercase_schema_reflection_sql 'TABLE_NAME'
+          sql = "SELECT #{tn} FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = '#{type}' ORDER BY TABLE_NAME"
+          select_values sql, 'SCHEMA'
+        end
+
         def column_definitions(table_name)
           identifier = if database_prefix_remote_server?
             SQLServer::Utils.extract_identifiers("#{database_prefix}#{table_name}")
@@ -235,8 +289,8 @@ module ActiveRecord
             SQLServer::Utils.extract_identifiers(table_name)
           end
           database    = identifier.fully_qualified_database_quoted
-          view_exists = schema_cache.view_exists?(table_name)
-          view_tblnm  = table_name_or_views_table_name(table_name) if view_exists
+          view_exists = view_exists?(table_name)
+          view_tblnm  = view_table_name(table_name) if view_exists
           sql = %{
             SELECT DISTINCT
             #{lowercase_schema_reflection_sql('columns.TABLE_NAME')} AS table_name,
@@ -246,7 +300,7 @@ module ActiveRecord
             columns.NUMERIC_SCALE AS numeric_scale,
             columns.NUMERIC_PRECISION AS numeric_precision,
             columns.DATETIME_PRECISION AS datetime_precision,
-            columns.COLLATION_NAME AS collation,
+            columns.COLLATION_NAME AS [collation],
             columns.ordinal_position,
             CASE
               WHEN columns.DATA_TYPE IN ('nchar','nvarchar','char','varchar') THEN columns.CHARACTER_MAXIMUM_LENGTH
@@ -264,7 +318,6 @@ module ActiveRecord
             FROM #{database}.INFORMATION_SCHEMA.COLUMNS columns
             LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC
               ON TC.TABLE_NAME = columns.TABLE_NAME
-              AND TC.TABLE_SCHEMA = columns.TABLE_SCHEMA
               AND TC.CONSTRAINT_TYPE = N'PRIMARY KEY'
             LEFT OUTER JOIN #{database}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU
               ON KCU.COLUMN_NAME = columns.COLUMN_NAME
@@ -282,12 +335,14 @@ module ActiveRecord
             INNER JOIN #{database}.sys.columns AS c
               ON o.object_id = c.object_id
               AND c.name = columns.COLUMN_NAME
-            WHERE columns.TABLE_NAME = @0
-              AND columns.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : '@1'}
+            WHERE columns.TABLE_NAME = #{prepared_statements ? '@0' : quote(identifier.object)}
+              AND columns.TABLE_SCHEMA = #{identifier.schema.blank? ? 'schema_name()' : (prepared_statements ? '@1' : quote(identifier.schema))}
             ORDER BY columns.ordinal_position
-          }.gsub(/[ \t\r\n]+/, ' ')
-          binds = [[info_schema_table_name_column, identifier.object]]
-          binds << [info_schema_table_schema_column, identifier.schema] unless identifier.schema.blank?
+          }.gsub(/[ \t\r\n]+/, ' ').strip
+          binds = []
+          nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
+          binds << Relation::QueryAttribute.new('TABLE_NAME', identifier.object, nv128)
+          binds << Relation::QueryAttribute.new('TABLE_SCHEMA', identifier.schema, nv128) unless identifier.schema.blank?
           results = sp_executesql(sql, 'SCHEMA', binds)
           results.map do |ci|
             ci = ci.symbolize_keys
@@ -348,14 +403,6 @@ module ActiveRecord
           end
         end
 
-        def info_schema_table_name_column
-          @info_schema_table_name_column ||= new_column 'table_name', nil, lookup_cast_type('nvarchar(128)'), 'nvarchar(128)', true
-        end
-
-        def info_schema_table_schema_column
-          @info_schema_table_schema_column ||= new_column 'table_schema', nil, lookup_cast_type('nvarchar(128)'), 'nvarchar(128)', true
-        end
-
         def remove_check_constraints(table_name, column_name)
           constraints = select_values "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'", 'SCHEMA'
           constraints.each do |constraint|
@@ -409,7 +456,7 @@ module ActiveRecord
         # === SQLServer Specific (View Reflection) ====================== #
 
         def view_table_name(table_name)
-          view_info = schema_cache.view_information(table_name)
+          view_info = view_information(table_name)
           view_info ? get_table_name(view_info['VIEW_DEFINITION']) : table_name
         end
 
@@ -430,12 +477,8 @@ module ActiveRecord
           view_info
         end
 
-        def table_name_or_views_table_name(table_name)
-          schema_cache.view_exists?(table_name) ? view_table_name(table_name) : table_name
-        end
-
         def views_real_column_name(table_name, column_name)
-          view_definition = schema_cache.view_information(table_name)[:VIEW_DEFINITION]
+          view_definition = view_information(table_name)[:VIEW_DEFINITION]
           return column_name unless view_definition
           match_data = view_definition.match(/([\w-]*)\s+as\s+#{column_name}/im)
           match_data ? match_data[1] : column_name
@@ -446,7 +489,7 @@ module ActiveRecord
         def query_requires_identity_insert?(sql)
           if insert_sql?(sql)
             table_name = get_table_name(sql)
-            id_column = identity_column(table_name)
+            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
           else
             false
@@ -457,15 +500,15 @@ module ActiveRecord
           !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
 
-        def identity_column(table_name)
-          schema_cache.columns(table_name).find(&:is_identity?)
+        def identity_columns(table_name)
+          columns(table_name).select(&:is_identity?)
         end
 
 
         private
 
-        def create_table_definition(name, temporary, options, as = nil)
-          SQLServer::TableDefinition.new native_database_types, name, temporary, options, as
+        def create_table_definition(*args)
+          SQLServer::TableDefinition.new(*args)
         end
 
       end

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

@@ -28,32 +28,32 @@ module ActiveRecord
         end
 
         def set_showplan_option(enable = true)
-          sql = "SET #{option} #{enable ? 'ON' : 'OFF'}"
+          sql = "SET #{showplan_option} #{enable ? 'ON' : 'OFF'}"
           raw_connection_do(sql)
         rescue Exception
-          raise ActiveRecordError, "#{option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
+          raise ActiveRecordError, "#{showplan_option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
         end
 
-        def option
+        def showplan_option
           (SQLServerAdapter.showplan_option || OPTION_ALL).tap do |opt|
             raise(ArgumentError, "Unknown SHOWPLAN option #{opt.inspect} found.") if OPTIONS.exclude?(opt)
           end
         end
 
         def showplan_all?
-          option == OPTION_ALL
+          showplan_option == OPTION_ALL
         end
 
         def showplan_text?
-          option == OPTION_TEXT
+          showplan_option == OPTION_TEXT
         end
 
         def showplan_xml?
-          option == OPTION_XML
+          showplan_option == OPTION_XML
         end
 
         def showplan_printer
-          case option
+          case showplan_option
           when OPTION_XML then PrinterXml
           when OPTION_ALL, OPTION_TEXT then PrinterTable
           else PrinterTable

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

@@ -0,0 +1,20 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      class SqlTypeMetadata < ActiveRecord::ConnectionAdapters::SqlTypeMetadata
+
+        def initialize(**kwargs)
+          @sqlserver_options = kwargs.extract!(:sqlserver_options)
+          super(**kwargs)
+        end
+
+        protected
+
+        def attributes_for_hash
+          super + [@sqlserver_options]
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,76 +1,100 @@
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
 
-        def primary_key(name, type = :primary_key, options = {})
+      module ColumnMethods
+
+        def primary_key(name, type = :primary_key, **options)
           return super unless type == :uuid
           options[:default] = options.fetch(:default, 'NEWID()')
           options[:primary_key] = true
           column name, type, options
         end
 
-        def real(name, options = {})
-          column(name, :real, options)
+        def real(*args, **options)
+          args.each { |name| column(name, :real, options) }
+        end
+
+        def money(*args, **options)
+          args.each { |name| column(name, :money, options) }
         end
 
-        def money(name, options = {})
-          column(name, :money, options)
+        def datetime(*args, **options)
+          args.each do |name|
+            if options[:precision]
+              datetime2(name, options)
+            else
+              column(name, :datetime, options)
+            end
+          end
         end
 
-        def datetime2(name, options = {})
-          column(name, :datetime2, options)
+        def datetime2(*args, **options)
+          args.each { |name| column(name, :datetime2, options) }
         end
 
-        def datetimeoffset(name, options = {})
-          column(name, :datetimeoffset, options)
+        def datetimeoffset(*args, **options)
+          args.each { |name| column(name, :datetimeoffset, options) }
         end
 
-        def smallmoney(name, options = {})
-          column(name, :smallmoney, options)
+        def smallmoney(*args, **options)
+          args.each { |name| column(name, :smallmoney, options) }
         end
 
-        def char(name, options = {})
-          column(name, :char, options)
+        def char(*args, **options)
+          args.each { |name| column(name, :char, options) }
         end
 
-        def varchar(name, options = {})
-          column(name, :varchar, options)
+        def varchar(*args, **options)
+          args.each { |name| column(name, :varchar, options) }
         end
 
-        def varchar_max(name, options = {})
-          column(name, :varchar_max, options)
+        def varchar_max(*args, **options)
+          args.each { |name| column(name, :varchar_max, options) }
         end
 
-        def text_basic(name, options = {})
-          column(name, :text_basic, options)
+        def text_basic(*args, **options)
+          args.each { |name| column(name, :text_basic, options) }
         end
 
-        def nchar(name, options = {})
-          column(name, :nchar, options)
+        def nchar(*args, **options)
+          args.each { |name| column(name, :nchar, options) }
         end
 
-        def ntext(name, options = {})
-          column(name, :ntext, options)
+        def ntext(*args, **options)
+          args.each { |name| column(name, :ntext, options) }
         end
 
-        def binary_basic(name, options = {})
-          column(name, :binary_basic, options)
+        def binary_basic(*args, **options)
+          args.each { |name| column(name, :binary_basic, options) }
         end
 
-        def varbinary(name, options = {})
-          column(name, :varbinary, options)
+        def varbinary(*args, **options)
+          args.each { |name| column(name, :varbinary, options) }
         end
 
-        def uuid(name, options = {})
-          column(name, :uniqueidentifier, options)
+        def uuid(*args, **options)
+          args.each { |name| column(name, :uniqueidentifier, options) }
         end
 
-        def ss_timestamp(name, options = {})
-          column(name, :ss_timestamp, options)
+        def ss_timestamp(*args, **options)
+          args.each { |name| column(name, :ss_timestamp, options) }
         end
 
       end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, options)
+          type = :datetime2 if type == :datetime && options[:precision]
+          super name, type, options
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
     end
   end
 end