activerecord-sqlserver-adapter_new 4.2.15

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLServerColumn < Column
+
+      def initialize(name, default, cast_type, sql_type = nil, null = true, sqlserver_options = {})
+        super(name, default, cast_type, sql_type, null)
+        @sqlserver_options = sqlserver_options.symbolize_keys
+        @default_function = @sqlserver_options[:default_function]
+      end
+
+      def sql_type_for_statement
+        if is_integer? || is_real?
+          sql_type.sub(/\((\d+)?\)/, '')
+        else
+          sql_type
+        end
+      end
+
+      def table_name
+        @sqlserver_options[:table_name]
+      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 is_integer?
+        @sql_type =~ /int/i
+      end
+
+      def is_real?
+        @sql_type =~ /real/i
+      end
+
+      def collation
+        @sqlserver_options[:collation]
+      end
+
+      def case_sensitive?
+        collation && !collation.match(/_CI/)
+      end
+
+    end
+  end
+end

data/lib/active_record/sqlserver_base.rb

@@ -0,0 +1,20 @@
+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'
+      when :odbc
+        raise ArgumentError, 'Missing :dsn configuration.' unless config.key?(:dsn)
+        require 'odbc'
+        require 'active_record/connection_adapters/sqlserver/core_ext/odbc'
+      else
+        raise ArgumentError, "Unknown connection mode in #{config.inspect}."
+      end
+      ConnectionAdapters::SQLServerAdapter.new(nil, logger, 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-sqlserver-adapter.rb

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

data/lib/arel/visitors/sqlserver.rb

@@ -0,0 +1,214 @@
+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
+
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
+        if o.expr.val.is_a? Numeric
+          collector
+        else
+          collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
+        end
+      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 = if o.engine.connection.respond_to?(:sqlserver?) && o.engine.connection.database_prefix_remote_server?
+          remote_server_table_name(o)
+        else
+          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 = node_value(o.limit) == 1
+        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
+        return t.primary_key if t.primary_key
+        if engine_pk = t.engine.primary_key
+          pk = t.engine.arel_table[engine_pk]
+          return pk if pk
+        end
+        pk = t.engine.connection.schema_cache.primary_keys(t.engine.table_name)
+        return pk if pk
+        column_name = t.engine.columns.first.try(:name)
+        column_name ? t[column_name] : nil
+      end
+
+      def remote_server_table_name o
+        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+          "#{o.engine.connection.database_prefix}#{o.name}"
+        ).quoted
+      end
+
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['sqlserver'] = Arel::Visitors::SQLServer

data/lib/arel_sqlserver.rb

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

data/test/appveyor/dbsetup.ps1

@@ -0,0 +1,27 @@
+
+Write-Output "Setting up..."
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.Smo") | Out-Null
+[reflection.assembly]::LoadWithPartialName("Microsoft.SqlServer.SqlWmiManagement") | Out-Null
+
+Write-Output "Setting variables..."
+$serverName = $env:COMPUTERNAME
+$instances = @('SQL2012SP1', 'SQL2014')
+$smo = 'Microsoft.SqlServer.Management.Smo.'
+$wmi = new-object ($smo + 'Wmi.ManagedComputer')
+
+Write-Output "Configure Instances..."
+foreach ($instance in $instances) {
+  Write-Output "Instance $instance ..."
+  Write-Output "Enable TCP/IP and port 1433..."
+  $uri = "ManagedComputer[@Name='$serverName']/ServerInstance[@Name='$instance']/ServerProtocol[@Name='Tcp']"
+  $tcp = $wmi.GetSmoObject($uri)
+  $tcp.IsEnabled = $true
+  foreach ($ipAddress in $Tcp.IPAddresses) {
+    $ipAddress.IPAddressProperties["TcpDynamicPorts"].Value = ""
+    $ipAddress.IPAddressProperties["TcpPort"].Value = "1433"
+  }
+  $tcp.Alter()
+}
+
+Set-Service SQLBrowser -StartupType Manual
+Start-Service SQLBrowser