activerecord-jdbcsqlserver-adapter 50.0.0

data/lib/active_record/connection_adapters/sqlserver/type/varchar_max.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Type
+        class VarcharMax < Varchar
+
+          def initialize(*args)
+            super
+            @limit = 2_147_483_647
+          end
+
+          def type
+            :varchar_max
+          end
+
+          def sqlserver_type
+            'varchar(max)'.freeze
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+require 'strscan'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Utils
+
+        QUOTED_STRING_PREFIX = 'N'
+
+        # Value object to return identifiers from SQL Server names http://bit.ly/1CZ3EiL
+        # Inspiried from Rails PostgreSQL::Name adapter object in their own Utils.
+        #
+        class Name
+
+          SEPARATOR = "."
+          UNQUOTED_SCANNER = /\]?\./
+          QUOTED_SCANNER   = /\A\[.*?\]\./
+          QUOTED_CHECKER   = /\A\[/
+
+          attr_reader :server, :database, :schema, :object
+          attr_reader :raw_name
+
+          def initialize(name)
+            @raw_name = name.to_s
+            parse_raw_name
+          end
+
+          def object_quoted
+            quote object
+          end
+
+          def schema_quoted
+            schema ? quote(schema) : schema
+          end
+
+          def database_quoted
+            database ? quote(database) : database
+          end
+
+          def server_quoted
+            server ? quote(server) : server
+          end
+
+          def fully_qualified_database_quoted
+            [server_quoted, database_quoted].compact.join(SEPARATOR)
+          end
+
+          def fully_qualified?
+            parts.compact.size == 4
+          end
+
+          def to_s
+            quoted
+          end
+
+          def quoted
+            parts.map{ |p| quote(p) if p }.join SEPARATOR
+          end
+
+          def quoted_raw
+            quote @raw_name
+          end
+
+          def ==(o)
+            o.class == self.class && o.parts == parts
+          end
+          alias_method :eql?, :==
+
+          def hash
+            parts.hash
+          end
+
+          protected
+
+          def parse_raw_name
+            @parts = []
+            return if raw_name.blank?
+            scanner = StringScanner.new(raw_name)
+            matched = scanner.exist?(QUOTED_CHECKER) ? scanner.scan_until(QUOTED_SCANNER) : scanner.scan_until(UNQUOTED_SCANNER)
+            while matched
+              part = matched[0..-2]
+              @parts << (part.blank? ? nil : unquote(part))
+              matched = scanner.exist?(QUOTED_CHECKER) ? scanner.scan_until(QUOTED_SCANNER) : scanner.scan_until(UNQUOTED_SCANNER)
+            end
+            case @parts.length
+            when 3
+              @server, @database, @schema = @parts
+            when 2
+              @database, @schema = @parts
+            when 1
+              @schema = @parts.first
+            end
+            rest = scanner.rest
+            rest = rest.starts_with?('.') ? rest[1..-1] : rest[0..-1]
+            @object = unquote(rest)
+            @parts << @object
+          end
+
+          def quote(part)
+            part =~ /\A\[.*\]\z/ ? part : "[#{part.to_s.gsub(']', ']]')}]"
+          end
+
+          def unquote(part)
+            if part && part.start_with?('[')
+              part[1..-2]
+            else
+              part
+            end
+          end
+
+          def parts
+            @parts
+          end
+
+        end
+
+        extend self
+
+        def quote_string(s)
+          s.to_s.gsub /\'/, "''"
+        end
+
+        def quote_string_single(s)
+          "'#{quote_string(s)}'"
+        end
+
+        def quote_string_single_national(s)
+          "#{QUOTED_STRING_PREFIX}'#{quote_string(s)}'"
+        end
+
+        def quoted_raw(name)
+          SQLServer::Utils::Name.new(name).quoted_raw
+        end
+
+        def unquote_string(s)
+          s.to_s.gsub(/\'\'/, "'")
+        end
+
+        def extract_identifiers(name)
+          SQLServer::Utils::Name.new(name)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Version
+
+        VERSION = File.read(File.expand_path("../../../../../VERSION", __FILE__)).chomp
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,445 @@
+require 'base64'
+require 'active_record'
+require 'arel_sqlserver'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/sqlserver/core_ext/active_record'
+require 'active_record/connection_adapters/sqlserver/core_ext/explain' unless defined? JRUBY_VERSION
+require 'active_record/connection_adapters/sqlserver/core_ext/explain_subscriber'
+require 'active_record/connection_adapters/sqlserver/core_ext/attribute_methods'
+require 'active_record/connection_adapters/sqlserver/version'
+require 'active_record/connection_adapters/sqlserver/type'
+require 'active_record/connection_adapters/sqlserver/database_limits'
+require 'active_record/connection_adapters/sqlserver/database_statements'
+require 'active_record/connection_adapters/sqlserver/database_tasks'
+require 'active_record/connection_adapters/sqlserver/transaction'
+require 'active_record/connection_adapters/sqlserver/errors'
+require 'active_record/connection_adapters/sqlserver/schema_creation'
+require 'active_record/connection_adapters/sqlserver/schema_dumper'
+require 'active_record/connection_adapters/sqlserver/schema_statements'
+require 'active_record/connection_adapters/sqlserver/sql_type_metadata'
+require 'active_record/connection_adapters/sqlserver/showplan'
+require 'active_record/connection_adapters/sqlserver/table_definition'
+require 'active_record/connection_adapters/sqlserver/quoting'
+require 'active_record/connection_adapters/sqlserver/utils'
+require 'active_record/sqlserver_base'
+require 'active_record/connection_adapters/sqlserver_column'
+require 'active_record/tasks/sqlserver_database_tasks'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLServerAdapter < AbstractAdapter
+
+      include SQLServer::Version,
+              SQLServer::Quoting,
+              SQLServer::DatabaseStatements,
+              SQLServer::Showplan,
+              SQLServer::SchemaDumper,
+              SQLServer::SchemaStatements,
+              SQLServer::DatabaseLimits,
+              SQLServer::DatabaseTasks
+
+      USING_JDBC_DRIVER = defined? JRUBY_VERSION
+
+      if USING_JDBC_DRIVER
+        include ArJdbc::Abstract::ConnectionManagement
+        include ArJdbc::Util::QuotedCache
+        prepend ArJdbc::Abstract::Core
+        prepend ArJdbc::Abstract::DatabaseStatements
+        prepend ArJdbc::Abstract::StatementCache
+        prepend ArJdbc::Abstract::TransactionSupport
+        prepend SQLServer::JDBCOverrides
+      end
+
+      ADAPTER_NAME = 'SQLServer'.freeze
+
+      attr_reader :spid
+
+      cattr_accessor :cs_equality_operator, instance_accessor: false
+      cattr_accessor :use_output_inserted, 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
+
+      def initialize(connection, logger = nil, config = {})
+        super(connection, logger, config)
+        # Our Responsibility
+        @connection_options = config
+        connect
+        initialize_dateformatter
+        use_database
+      end
+
+      # === Abstract Adapter ========================================== #
+
+      def arel_visitor
+        Arel::Visitors::SQLServer.new self
+      end
+
+      def valid_type?(type)
+        !native_database_types[type].nil?
+      end
+
+      def schema_creation
+        SQLServer::SchemaCreation.new self
+      end
+
+      def supports_migrations?
+        true
+      end
+
+      def supports_primary_key?
+        true
+      end
+
+      def supports_ddl_transactions?
+        true
+      end
+
+      def supports_bulk_alter?
+        false
+      end
+
+      def supports_advisory_locks?
+        false
+      end
+
+      def supports_index_sort_order?
+        true
+      end
+
+      def supports_partial_index?
+        true
+      end
+
+      def supports_expression_index?
+        false
+      end
+
+      def supports_explain?
+        true
+      end
+
+      def supports_transaction_isolation?
+        true
+      end
+
+      def supports_indexes_in_create?
+        false
+      end
+
+      def supports_foreign_keys?
+        true
+      end
+
+      def supports_views?
+        true
+      end
+
+      def supports_datetime_with_precision?
+        true
+      end
+
+      def supports_json?
+        @version_year >= 2016
+      end
+
+      def supports_comments?
+        false
+      end
+
+      def supports_comments_in_create?
+        false
+      end
+
+      def supports_in_memory_oltp?
+        @version_year >= 2014
+      end
+
+      def disable_referential_integrity
+        tables = tables_with_referential_integrity
+        tables.each { |t| do_execute "ALTER TABLE #{t} NOCHECK CONSTRAINT ALL" }
+        yield
+      ensure
+        tables.each { |t| do_execute "ALTER TABLE #{t} CHECK CONSTRAINT ALL" }
+      end
+
+      # === Abstract Adapter (Connection Management) ================== #
+
+      def active?
+        return false unless @connection
+        raw_connection_do 'SELECT 1'
+        true
+      rescue *connection_errors
+        false
+      end unless USING_JDBC_DRIVER # Core takes care of this
+
+      def reconnect!
+        super
+        disconnect! unless USING_JDBC_DRIVER # Don't need to disconnect in JDBC
+        connect
+      end
+
+      def disconnect!
+        super
+        case @connection_options[:mode]
+        when :dblib
+          @connection.close rescue nil
+        end
+        @connection = nil unless USING_JDBC_DRIVER
+        @spid = nil
+        @collation = nil
+      end
+
+      def clear_cache!
+        @view_information = nil
+        super
+      end
+
+      def reset!
+        reset_transaction
+        do_execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
+      end
+
+      # === Abstract Adapter (Misc Support) =========================== #
+
+      def tables_with_referential_integrity
+        schemas_and_tables = select_rows <<-SQL.strip_heredoc
+          SELECT s.name AS schema_name, o.name AS table_name
+          FROM sys.foreign_keys i
+          INNER JOIN sys.objects o ON i.parent_object_id = o.OBJECT_ID
+          INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+        SQL
+        schemas_and_tables.map do |schema_table|
+          schema, table = schema_table
+          "#{SQLServer::Utils.quoted_raw(schema)}.#{SQLServer::Utils.quoted_raw(table)}"
+        end
+      end
+
+      def pk_and_sequence_for(table_name)
+        pk = primary_key(table_name)
+        pk ? [pk, nil] : nil
+      end
+
+      # === SQLServer Specific (DB Reflection) ======================== #
+
+      def sqlserver?
+        true
+      end
+
+      def sqlserver_azure?
+        @sqlserver_azure ||= !!(select_value('SELECT @@version', 'SCHEMA') =~ /Azure/i)
+      end
+
+      def database_prefix_remote_server?
+        return false if database_prefix.blank?
+        name = SQLServer::Utils.extract_identifiers(database_prefix)
+        name.fully_qualified? && name.object.blank?
+      end
+
+      def database_prefix
+        @connection_options[:database_prefix]
+      end
+
+      def version
+        self.class::VERSION
+      end
+
+      def inspect
+        "#<#{self.class} version: #{version}, mode: #{@connection_options[:mode]}, azure: #{sqlserver_azure?.inspect}>"
+      end
+
+      def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
+        result = from_clause + join_clause + where_clause + having_clause
+        result << offset if offset
+        result << limit if limit
+        result
+      end
+
+
+      protected
+
+      # === Abstract Adapter (Misc Support) =========================== #
+
+      def initialize_type_map(m)
+        m.register_type              %r{.*},            SQLServer::Type::UnicodeString.new
+        # Exact Numerics
+        register_class_with_limit m, 'bigint(8)',         SQLServer::Type::BigInteger
+        m.alias_type                 'bigint',            'bigint(8)'
+        register_class_with_limit m, 'int(4)',            SQLServer::Type::Integer
+        m.alias_type                 'integer',           'int(4)'
+        m.alias_type                 'int',               'int(4)'
+        register_class_with_limit m, 'smallint(2)',       SQLServer::Type::SmallInteger
+        m.alias_type                 'smallint',          'smallint(2)'
+        register_class_with_limit m, 'tinyint(1)',        SQLServer::Type::TinyInteger
+        m.alias_type                 'tinyint',           'tinyint(1)'
+        m.register_type              'bit',               SQLServer::Type::Boolean.new
+        m.register_type              %r{\Adecimal}i do |sql_type|
+          scale = extract_scale(sql_type)
+          precision = extract_precision(sql_type)
+          SQLServer::Type::Decimal.new precision: precision, scale: scale
+        end
+        m.alias_type                 %r{\Anumeric}i,      'decimal'
+        m.register_type              'money',             SQLServer::Type::Money.new
+        m.register_type              'smallmoney',        SQLServer::Type::SmallMoney.new
+        # Approximate Numerics
+        m.register_type              'float',             SQLServer::Type::Float.new
+        m.register_type              'real',              SQLServer::Type::Real.new
+        # Date and Time
+        m.register_type              'date',              SQLServer::Type::Date.new
+        m.register_type              %r{\Adatetime} do |sql_type|
+          precision = extract_precision(sql_type)
+          if precision
+            SQLServer::Type::DateTime2.new precision: precision
+          else
+            SQLServer::Type::DateTime.new
+          end
+        end
+        m.register_type              %r{\Adatetimeoffset}i do |sql_type|
+          precision = extract_precision(sql_type)
+          SQLServer::Type::DateTimeOffset.new precision: precision
+        end
+        m.register_type              'smalldatetime',     SQLServer::Type::SmallDateTime.new
+        m.register_type              %r{\Atime}i do |sql_type|
+          scale = extract_scale(sql_type)
+          precision = extract_precision(sql_type)
+          SQLServer::Type::Time.new precision: precision
+        end
+        # Character Strings
+        register_class_with_limit m, %r{\Achar}i,         SQLServer::Type::Char
+        register_class_with_limit m, %r{\Avarchar}i,      SQLServer::Type::Varchar
+        m.register_type              'varchar(max)',      SQLServer::Type::VarcharMax.new
+        m.register_type              'text',              SQLServer::Type::Text.new
+        # Unicode Character Strings
+        register_class_with_limit m, %r{\Anchar}i,        SQLServer::Type::UnicodeChar
+        register_class_with_limit m, %r{\Anvarchar}i,     SQLServer::Type::UnicodeVarchar
+        m.alias_type                 'string',            'nvarchar(4000)'
+        m.register_type              'nvarchar(max)',     SQLServer::Type::UnicodeVarcharMax.new
+        m.register_type              'nvarchar(max)',     SQLServer::Type::UnicodeVarcharMax.new
+        m.register_type              'ntext',             SQLServer::Type::UnicodeText.new
+        # Binary Strings
+        register_class_with_limit m, %r{\Abinary}i,       SQLServer::Type::Binary
+        register_class_with_limit m, %r{\Avarbinary}i,    SQLServer::Type::Varbinary
+        m.register_type              'varbinary(max)',    SQLServer::Type::VarbinaryMax.new
+        # Other Data Types
+        m.register_type              'uniqueidentifier',  SQLServer::Type::Uuid.new
+        m.register_type              'timestamp',         SQLServer::Type::Timestamp.new
+      end
+
+      def translate_exception(e, message)
+        case message
+        when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
+          RecordNotUnique.new(message)
+        when /conflicted with the foreign key constraint/i
+          InvalidForeignKey.new(message)
+        when /has been chosen as the deadlock victim/i
+          DeadlockVictim.new(message)
+        when /database .* does not exist/i
+          NoDatabaseError.new(message)
+        when /data would be truncated/
+          ValueTooLong.new(message)
+        else
+          super
+        end
+      end
+
+      # === SQLServer Specific (Connection Management) ================ #
+
+      def connect
+        config = @connection_options
+        @connection = case config[:mode]
+                      when :dblib
+                        dblib_connect(config)
+                      end
+        @spid = _raw_select('SELECT @@SPID', fetch: :rows).first.first
+        @version_year = version_year
+        configure_connection
+      end
+
+      def connection_errors
+        @connection_errors ||= [].tap do |errors|
+          errors << TinyTds::Error if defined?(TinyTds::Error)
+        end
+      end
+
+      def dblib_connect(config)
+        TinyTds::Client.new(
+          dataserver: config[:dataserver],
+          host: config[:host],
+          port: config[:port],
+          username: config[:username],
+          password: config[:password],
+          database: config[:database],
+          tds_version: config[:tds_version] || '7.3',
+          appname: config_appname(config),
+          login_timeout: config_login_timeout(config),
+          timeout: config_timeout(config),
+          encoding:  config_encoding(config),
+          azure: config[:azure],
+          contained: config[:contained]
+        ).tap do |client|
+          if config[:azure]
+            client.execute('SET ANSI_NULLS ON').do
+            client.execute('SET ANSI_NULL_DFLT_ON ON').do
+            client.execute('SET ANSI_PADDING ON').do
+            client.execute('SET ANSI_WARNINGS ON').do
+          else
+            client.execute('SET ANSI_DEFAULTS ON').do
+          end
+          client.execute('SET QUOTED_IDENTIFIER ON').do
+          client.execute('SET CURSOR_CLOSE_ON_COMMIT OFF').do
+          client.execute('SET IMPLICIT_TRANSACTIONS OFF').do
+          client.execute('SET TEXTSIZE 2147483647').do
+          client.execute('SET CONCAT_NULL_YIELDS_NULL ON').do
+        end
+      end
+
+      def config_appname(config)
+        config[:appname] || configure_application_name || Rails.application.class.name.split('::').first rescue nil
+      end
+
+      def config_login_timeout(config)
+        config[:login_timeout].present? ? config[:login_timeout].to_i : nil
+      end
+
+      def config_timeout(config)
+        config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
+      end
+
+      def config_encoding(config)
+        config[:encoding].present? ? config[:encoding] : nil
+      end
+
+      def configure_connection ; end
+
+      def configure_application_name ; end
+
+      def initialize_dateformatter
+        @database_dateformat = user_options_dateformat
+        a, b, c = @database_dateformat.each_char.to_a
+        [a, b, c].each { |f| f.upcase! if f == 'y' }
+        dateformat = "%#{a}-%#{b}-%#{c}"
+        ::Date::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
+        ::Time::DATE_FORMATS[:_sqlserver_dateformat]     = dateformat
+        ::Time::DATE_FORMATS[:_sqlserver_time]           = '%H:%M:%S'
+        ::Time::DATE_FORMATS[:_sqlserver_datetime]       = "#{dateformat} %H:%M:%S"
+        ::Time::DATE_FORMATS[:_sqlserver_datetimeoffset] = lambda { |time|
+          time.strftime "#{dateformat} %H:%M:%S.%9N #{time.formatted_offset}"
+        }
+      end
+
+      def version_year
+        return @version_year if defined?(@version_year)
+        @version_year = begin
+          vstring = _raw_select('SELECT @@version', fetch: :rows).first.first.to_s
+          return 2016 if vstring =~ /vNext/
+          /SQL Server (\d+)/.match(vstring).to_a.last.to_s.to_i
+        rescue Exception => e
+          2016
+        end
+      end
+
+    end
+  end
+end