activerecord-jdbcsqlserver-adapter 50.0.0

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -0,0 +1,28 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLServerColumn < Column
+
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+        @sqlserver_options = sqlserver_options || {}
+        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
+      end
+
+      def is_identity?
+        @sqlserver_options[:is_identity]
+      end
+
+      def is_primary?
+        @sqlserver_options[:is_primary]
+      end
+
+      def is_utf8?
+        sql_type =~ /nvarchar|ntext|nchar/i
+      end
+
+      def case_sensitive?
+        collation && collation.match(/_CS/)
+      end
+
+    end
+  end
+end

data/lib/active_record/jdbc_sqlserver_connection_methods.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module ConnectionHandling
+
+    def sqlserver_connection(config)
+      config[:adapter_spec] ||= ::ArJdbc::MSSQL
+      config[:mode] ||= :jdbc
+
+      unless jndi_config?(config)
+
+        config[:host] ||= 'localhost'
+        config[:driver] ||= 'com.microsoft.sqlserver.jdbc.SQLServerDriver'
+        config[:connection_alive_sql] ||= 'SELECT 1'
+
+        config[:url] ||= begin
+          url = ["jdbc:sqlserver://#{config[:host]}"]
+          url << (config[:port] ? ":#{config[:port]};" : ';')
+          url << "databaseName=#{config[:database]};" if config[:database]
+          url << "instanceName=#{config[:instance]};" if config[:instance]
+          app = config[:appname] || config[:application]
+          url << "applicationName=#{app};" if app
+          isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
+          url << "integratedSecurity=#{isc};" unless isc.nil?
+          url.join('')
+        end
+      end
+
+      ConnectionAdapters::SQLServerAdapter.new(nil, nil, config)
+    end
+
+  end
+end

data/lib/active_record/sqlserver_base.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module ConnectionHandling
+    def sqlserver_connection(config) #:nodoc:
+      config = config.symbolize_keys
+      config.reverse_merge! mode: :dblib
+      mode = config[:mode].to_s.downcase.underscore.to_sym
+      case mode
+      when :dblib
+        require 'tiny_tds'
+      else
+        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+      end
+      ConnectionAdapters::SQLServerAdapter.new(nil, nil, config.merge(mode: mode))
+    end
+  end
+end

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -0,0 +1,131 @@
+require 'active_record/tasks/database_tasks'
+require 'shellwords'
+require 'ipaddr'
+require 'socket'
+
+module ActiveRecord
+  module Tasks
+
+    class SQLServerDatabaseTasks
+
+      DEFAULT_COLLATION = 'SQL_Latin1_General_CP1_CI_AS'
+
+      delegate :connection, :establish_connection, :clear_active_connections!,
+               to: ActiveRecord::Base
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def create(master_established = false)
+        establish_master_connection unless master_established
+        connection.create_database configuration['database'], configuration.merge('collation' => default_collation)
+        establish_connection configuration
+      rescue ActiveRecord::StatementInvalid => error
+        if /database .* already exists/i === error.message
+          raise DatabaseAlreadyExists
+        else
+          raise
+        end
+      end
+
+      def drop
+        establish_master_connection
+        connection.drop_database configuration['database']
+      end
+
+      def charset
+        connection.charset
+      end
+
+      def collation
+        connection.collation
+      end
+
+      def purge
+        clear_active_connections!
+        drop
+        create true
+      end
+
+      def structure_dump(filename)
+        command = [
+          "defncopy",
+          "-S #{Shellwords.escape(configuration['host'])}",
+          "-D #{Shellwords.escape(configuration['database'])}",
+          "-U #{Shellwords.escape(configuration['username'])}",
+          "-P #{Shellwords.escape(configuration['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
+
+      def structure_load(filename)
+        connection.execute File.read(filename)
+      end
+
+
+      private
+
+      def configuration
+        @configuration
+      end
+
+      def default_collation
+        configuration['collation'] || DEFAULT_COLLATION
+      end
+
+      def establish_master_connection
+        establish_connection configuration.merge('database' => 'master')
+      end
+
+    end
+
+    module DatabaseTasksSQLServer
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        LOCAL_IPADDR = [
+          IPAddr.new('192.168.0.0/16'),
+          IPAddr.new('10.0.0.0/8'),
+          IPAddr.new('172.16.0.0/12')
+        ]
+
+        private
+
+        def local_database?(configuration)
+          super || local_ipaddr?(configuration_host_ip(configuration))
+        end
+
+        def configuration_host_ip(configuration)
+          return nil unless configuration['host']
+          Socket::getaddrinfo(configuration['host'], 'echo', Socket::AF_INET)[0][3]
+        end
+
+        def local_ipaddr?(host_ip)
+          return false unless host_ip
+          LOCAL_IPADDR.any? { |ip| ip.include?(host_ip) }
+        end
+
+      end
+
+    end
+
+    DatabaseTasks.register_task %r{sqlserver}, SQLServerDatabaseTasks
+    DatabaseTasks.send :include, DatabaseTasksSQLServer
+
+  end
+end

data/lib/activerecord-jdbcsqlserver-adapter.rb

@@ -0,0 +1,24 @@
+# Our core date/time overrides to support prepared statements
+require 'active_record/connection_adapters/sqlserver/core_ext/date_time'
+
+# Load the jar file for the jdbc driver
+require 'jdbc/mssql'
+
+# Standadard arjdbc functionality
+require 'arjdbc/abstract/connection_management'
+require 'arjdbc/abstract/core'
+require 'arjdbc/abstract/database_statements'
+require 'arjdbc/abstract/statement_cache'
+require 'arjdbc/abstract/transaction_support'
+require 'arjdbc/util/quoted_cache'
+
+# A module for prepending functionality
+require 'active_record/connection_adapters/sqlserver/jdbc_overrides'
+
+# Load the actual adapter
+require_relative './activerecord-sqlserver-adapter'
+
+# Load overrides and java specifics
+require 'arjdbc'
+ArJdbc.load_java_part :MSSQL
+require 'active_record/jdbc_sqlserver_connection_methods'

data/lib/activerecord-sqlserver-adapter.rb

@@ -0,0 +1 @@
+require 'active_record/connection_adapters/sqlserver_adapter'

data/lib/arel/visitors/sqlserver.rb

@@ -0,0 +1,205 @@
+module Arel
+  module Visitors
+    class SQLServer < Arel::Visitors::ToSql
+
+      OFFSET = " OFFSET "
+      ROWS = " ROWS"
+      FETCH = " FETCH NEXT "
+      FETCH0 = " FETCH FIRST (SELECT 0) "
+      ROWS_ONLY = " ROWS ONLY"
+
+
+      private
+
+      # SQLServer ToSql/Visitor (Overides)
+
+      def visit_Arel_Nodes_BindParam o, collector
+        collector.add_bind(o) { |i| "@#{i-1}" }
+      end unless defined? JRUBY_VERSION # converts bind argument markers "?" to "@n", but JDBC wants "?"
+
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
+        collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
+      end
+
+      def visit_Arel_Nodes_UpdateStatement(o, a)
+        if o.orders.any? && o.limit.nil?
+          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
+        end
+        super
+      end
+
+      def visit_Arel_Nodes_Lock o, collector
+        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
+        collector << SPACE
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_Offset o, collector
+        collector << OFFSET
+        visit o.expr, collector
+        collector << ROWS
+      end
+
+      def visit_Arel_Nodes_Limit o, collector
+        if node_value(o) == 0
+          collector << FETCH0
+          collector << ROWS_ONLY
+        else
+          collector << FETCH
+          visit o.expr, collector
+          collector << ROWS_ONLY
+        end
+      end
+
+      def visit_Arel_Nodes_SelectStatement o, collector
+        @select_statement = o
+        distinct_One_As_One_Is_So_Not_Fetch o
+        if o.with
+          collector = visit o.with, collector
+          collector << SPACE
+        end
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        }
+        collector = visit_Orders_And_Let_Fetch_Happen o, collector
+        collector = visit_Make_Fetch_Happen o, collector
+        collector
+      ensure
+        @select_statement = nil
+      end
+
+      def visit_Arel_Table o, collector
+        # Apparently, o.engine.connection can actually be a different adapter
+        # than sqlserver. Can be removed if fixed in ActiveRecord. See:
+        # 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)
+          end
+        rescue Exception => e
+          quote_table_name(o.name)
+        end
+        if o.table_alias
+          collector << "#{table_name} #{quote_table_name o.table_alias}"
+        else
+          collector << table_name
+        end
+      end
+
+      def visit_Arel_Nodes_JoinSource o, collector
+        if o.left
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
+        end
+        if o.right.any?
+          collector << " " if o.left
+          collector = inject_join o.right, collector, ' '
+        end
+        collector
+      end
+
+      def visit_Arel_Nodes_OuterJoin o, collector
+        collector << "LEFT OUTER JOIN "
+        collector = visit o.left, collector
+        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+        collector << " "
+        visit o.right, collector
+      end
+
+      # SQLServer ToSql/Visitor (Additions)
+
+      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
+        if select_statement_lock?
+          collector = visit @select_statement.lock, collector
+          collector << SPACE if options[:space]
+        end
+        collector
+      end
+
+      def visit_Orders_And_Let_Fetch_Happen o, collector
+        make_Fetch_Possible_And_Deterministic o
+        unless o.orders.empty?
+          collector << SPACE
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index { |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          }
+        end
+        collector
+      end
+
+      def visit_Make_Fetch_Happen o, collector
+        o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
+        collector = visit o.offset, collector if o.offset
+        collector = visit o.limit, collector if o.limit
+        collector
+      end
+
+      # SQLServer Helpers
+
+      def node_value(node)
+        return nil unless node
+        case node.expr
+        when NilClass then nil
+        when Numeric then node.expr
+        when Arel::Nodes::Unary then node.expr.expr
+        end
+      end
+
+      def select_statement_lock?
+        @select_statement && @select_statement.lock
+      end
+
+      def make_Fetch_Possible_And_Deterministic o
+        return if o.limit.nil? && o.offset.nil?
+        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
+      end
+
+      def distinct_One_As_One_Is_So_Not_Fetch o
+        core = o.cores.first
+        distinct = Nodes::Distinct === core.set_quantifier
+        oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
+        limitone = [nil, 0, 1].include? node_value(o.limit)
+        if distinct && oneasone && limitone && !o.offset
+          core.projections = [Arel.sql("TOP(1) 1 AS [one]")]
+          o.limit = nil
+        end
+      end
+
+      def table_From_Statement o
+        core = o.cores.first
+        if Arel::Table === core.from
+          core.from
+        elsif Arel::Nodes::SqlLiteral === core.from
+          Arel::Table.new(core.from)
+        elsif Arel::Nodes::JoinSource === core.source
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+        end
+      end
+
+      def primary_Key_From_Table t
+        return unless t
+        column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.try(:second).try(:name)
+        column_name ? t[column_name] : nil
+      end
+
+      def remote_server_table_name o
+        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+          "#{o.class.engine.connection.database_prefix}#{o.name}"
+        ).quoted
+      end
+
+    end
+  end
+end

data/lib/arel_sqlserver.rb

@@ -0,0 +1,3 @@
+require 'arel'
+require 'arel/visitors/bind_visitor'
+require 'arel/visitors/sqlserver'