activerecord-sqlserver-adapter 3.2.18 → 4.0.0

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

@@ -5,54 +5,52 @@ module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module Showplan
-        
         OPTION_ALL  = 'SHOWPLAN_ALL'
         OPTION_TEXT = 'SHOWPLAN_TEXT'
         OPTION_XML  = 'SHOWPLAN_XML'
         OPTIONS = [OPTION_ALL, OPTION_TEXT, OPTION_XML]
-        
+
         def explain(arel, binds = [])
           sql = to_sql(arel)
           result = with_showplan_on { do_exec_query(sql, 'EXPLAIN', binds) }
           printer = showplan_printer.new(result)
           printer.pp
         end
-        
-        
+
         protected
-        
+
         def with_showplan_on
           set_showplan_option(true)
           yield
         ensure
           set_showplan_option(false)
         end
-        
+
         def set_showplan_option(enable = true)
           sql = "SET #{option} #{enable ? 'ON' : 'OFF'}"
           raw_connection_do(sql)
-        rescue Exception => e
+        rescue Exception
           raise ActiveRecordError, "#{option} could not be turned #{enable ? 'ON' : 'OFF'}, perhaps you do not have SHOWPLAN permissions?"
         end
-        
+
         def 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
         end
-        
+
         def showplan_text?
           option == OPTION_TEXT
         end
-        
+
         def showplan_xml?
           option == OPTION_XML
         end
-        
+
         def showplan_printer
           case option
           when OPTION_XML then PrinterXml
@@ -60,7 +58,6 @@ module ActiveRecord
           else PrinterTable
           end
         end
-        
       end
     end
   end

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

@@ -3,17 +3,16 @@ module ActiveRecord
     module Sqlserver
       module Showplan
         class PrinterTable
-          
           cattr_accessor :max_column_width, :cell_padding
           self.max_column_width = 50
           self.cell_padding = 1
-          
+
           attr_reader :result
-          
+
           def initialize(result)
             @result = result
           end
-          
+
           def pp
             @widths = compute_column_widths
             @separator = build_separator
@@ -27,7 +26,7 @@ module ActiveRecord
             pp << @separator
             pp.join("\n") + "\n"
           end
-          
+
           private
 
           def compute_column_widths
@@ -40,11 +39,11 @@ module ActiveRecord
               end
             end
           end
-          
+
           def build_separator
-            '+' + @widths.map {|w| '-' * (w + (cell_padding*2))}.join('+') + '+'
+            '+' + @widths.map { |w| '-' * (w + (cell_padding * 2)) }.join('+') + '+'
           end
-          
+
           def build_cells(items)
             cells = []
             items.each_with_index do |item, i|
@@ -52,7 +51,7 @@ module ActiveRecord
             end
             "| #{cells.join(' | ')} |"
           end
-          
+
           def cast_item(item)
             case item
             when NilClass then 'NULL'
@@ -60,9 +59,7 @@ module ActiveRecord
             else item.to_s.truncate(max_column_width)
             end
           end
-          
         end
-
       end
     end
   end

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

@@ -3,22 +3,19 @@ module ActiveRecord
     module Sqlserver
       module Showplan
         class PrinterXml
-          
           def initialize(result)
             @result = result
           end
-          
+
           def pp
             xml = @result.rows.first.first
             if defined?(Nokogiri)
-              Nokogiri::XML(xml).to_xml :indent => 2, :encoding => 'UTF-8'
+              Nokogiri::XML(xml).to_xml indent: 2, encoding: 'UTF-8'
             else
               xml
             end
           end
-          
         end
-
       end
     end
   end

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

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        def uuid(name, options = {})
+          column(name, 'uniqueidentifier', options)
+        end
+
+        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 column(name, type = nil, options = {})
+          super
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -2,31 +2,25 @@ module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       class Utils
-        
         class << self
-          
           def unquote_string(string)
             string.to_s.gsub(/\'\'/, "'")
           end
-          
+
           def unqualify_table_name(table_name)
-            table_name.to_s.split('.').last.tr('[]','')
+            table_name.to_s.split('.').last.tr('[]', '')
           end
 
           def unqualify_table_schema(table_name)
-            table_name.to_s.split('.')[-2].gsub(/[\[\]]/,'') rescue nil
+            table_name.to_s.split('.')[-2].gsub(/[\[\]]/, '') rescue nil
           end
 
           def unqualify_db_name(table_name)
             table_names = table_name.to_s.split('.')
-            table_names.length == 3 ? table_names.first.tr('[]','') : nil
+            table_names.length == 3 ? table_names.first.tr('[]', '') : nil
           end
-          
         end
-        
       end
     end
   end
 end
-
-

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -1,12 +1,12 @@
 require 'base64'
-require 'arel/visitors/sqlserver'
+require 'arel/arel_sqlserver'
+require 'arel/visitors/bind_visitor'
 require 'active_record'
 require 'active_record/base'
 require 'active_support/concern'
 require 'active_support/core_ext/string'
 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/database_statements'
 require 'active_record/connection_adapters/sqlserver/core_ext/explain'
 require 'active_record/connection_adapters/sqlserver/core_ext/explain_subscriber'
 require 'active_record/connection_adapters/sqlserver/core_ext/relation'
@@ -14,163 +14,19 @@ require 'active_record/connection_adapters/sqlserver/database_limits'
 require 'active_record/connection_adapters/sqlserver/database_statements'
 require 'active_record/connection_adapters/sqlserver/errors'
 require 'active_record/connection_adapters/sqlserver/schema_cache'
+require 'active_record/connection_adapters/sqlserver/schema_creation'
 require 'active_record/connection_adapters/sqlserver/schema_statements'
 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'
 
-module ActiveRecord
-
-  class Base
-
-    def self.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.has_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
-
-    protected
-
-    def self.did_retry_sqlserver_connection(connection,count)
-      logger.info "CONNECTION RETRY: #{connection.class.name} retry ##{count}."
-    end
-
-    def self.did_lose_sqlserver_connection(connection)
-      logger.info "CONNECTION LOST: #{connection.class.name}"
-    end
-
-  end
+require 'active_record/sqlserver_base'
+require 'active_record/connection_adapters/sqlserver_column'
 
+module ActiveRecord
   module ConnectionAdapters
-
-    class SQLServerColumn < Column
-
-      def initialize(name, default, sql_type = nil, null = true, sqlserver_options = {})
-        @sqlserver_options = sqlserver_options.symbolize_keys
-        super(name, default, sql_type, null)
-        @primary = @sqlserver_options[:is_identity] || @sqlserver_options[:is_primary]
-      end
-
-      class << self
-
-        def string_to_binary(value)
-         "0x#{value.unpack("H*")[0]}"
-        end
-
-        def binary_to_string(value)
-          value =~ /[^[:xdigit:]]/ ? value : [value].pack('H*')
-        end
-
-      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 sql_type_for_statement
-        if is_integer? || is_real?
-          sql_type.sub(/\((\d+)?\)/,'')
-        else
-          sql_type
-        end
-      end
-
-      def default_function
-        @sqlserver_options[:default_function]
-      end
-
-      def table_name
-        @sqlserver_options[:table_name]
-      end
-
-      def table_klass
-        @table_klass ||= begin
-          table_name.classify.constantize
-        rescue StandardError, NameError, LoadError
-          nil
-        end
-        (@table_klass && @table_klass < ActiveRecord::Base) ? @table_klass : nil
-      end
-
-      def database_year
-        @sqlserver_options[:database_year]
-      end
-
-
-      private
-
-      def extract_limit(sql_type)
-        case sql_type
-        when /^smallint/i
-          2
-        when /^int/i
-          4
-        when /^bigint/i
-          8
-        when /\(max\)/, /decimal/, /numeric/
-          nil
-        else
-          super
-        end
-      end
-
-      def simplified_type(field_type)
-        case field_type
-          when /real/i              then :float
-          when /money/i             then :decimal
-          when /image/i             then :binary
-          when /bit/i               then :boolean
-          when /uniqueidentifier/i  then :string
-          when /datetime/i          then simplified_datetime
-          when /varchar\(max\)/     then :text
-          when /timestamp/          then :binary
-          else super
-        end
-      end
-
-      def simplified_datetime
-        if database_year >= 2008
-          :datetime
-        elsif table_klass && table_klass.coerced_sqlserver_date_columns.include?(name)
-          :date
-        elsif table_klass && table_klass.coerced_sqlserver_time_columns.include?(name)
-          :time
-        else
-          :datetime
-        end
-      end
-
-    end #class SQLServerColumn
-
     class SQLServerAdapter < AbstractAdapter
-
       include Sqlserver::Quoting
       include Sqlserver::DatabaseStatements
       include Sqlserver::Showplan
@@ -178,20 +34,22 @@ module ActiveRecord
       include Sqlserver::DatabaseLimits
       include Sqlserver::Errors
 
-      VERSION                     = File.read(File.expand_path("../../../../VERSION",__FILE__)).strip
+      VERSION                     = File.read(File.expand_path('../../../../VERSION', __FILE__)).strip
       ADAPTER_NAME                = 'SQLServer'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+"?(\d{4}|\w+)"?/
-      SUPPORTED_VERSIONS          = [2005,2008,2010,2011,2012,2014,2016,2017]
+      SUPPORTED_VERSIONS          = [2005, 2008, 2010, 2011, 2012]
 
       attr_reader :database_version, :database_year, :spid, :product_level, :product_version, :edition
 
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
-                     :enable_default_unicode_types, :auto_connect, :retry_deadlock_victim,
-                     :cs_equality_operator, :lowercase_schema_reflection, :auto_connect_duration,
-                     :showplan_option
+                     :enable_default_unicode_types, :auto_connect, :cs_equality_operator,
+                     :lowercase_schema_reflection, :auto_connect_duration, :showplan_option
 
       self.enable_default_unicode_types = true
 
+      class BindSubstitution < Arel::Visitors::SQLServer # :nodoc:
+        include Arel::Visitors::BindVisitor
+      end
 
       def initialize(connection, logger, pool, config)
         super(connection, logger, pool)
@@ -207,12 +65,10 @@ module ActiveRecord
                            if @database_version =~ /Azure/i
                              @sqlserver_azure = true
                              @database_version.match(/\s-\s([0-9.]+)/)[1]
-                             year = 2016
-                           elsif @database_version =~ /vNext/i
-                             year = 2016
+                             year = 2012
                            else
                              year = DATABASE_VERSION_REGEXP.match(@database_version)[1]
-                             year == "Denali" ? 2011 : year.to_i
+                             year == 'Denali' ? 2011 : year.to_i
                            end
                          rescue
                            0
@@ -222,7 +78,7 @@ module ActiveRecord
         @edition          = select_value "SELECT CAST(SERVERPROPERTY('edition') AS VARCHAR(128))", 'SCHEMA'
         initialize_dateformatter
         use_database
-        unless (@sqlserver_azure == true || SUPPORTED_VERSIONS.include?(@database_year))
+        unless @sqlserver_azure == true || SUPPORTED_VERSIONS.include?(@database_year)
           raise NotImplementedError, "Currently, only #{SUPPORTED_VERSIONS.to_sentence} are supported. We got back #{@database_version}."
         end
       end
@@ -261,6 +117,10 @@ module ActiveRecord
         true
       end
 
+      def supports_partial_index?
+        @database_year >= 2008
+      end
+
       def supports_explain?
         true
       end
@@ -279,19 +139,21 @@ module ActiveRecord
         when :dblib
           return @connection.active?
         end
-        raw_connection_do("SELECT 1")
+        raw_connection_do('SELECT 1')
         true
       rescue *lost_connection_exceptions
         false
       end
 
       def reconnect!
+        reset_transaction
         disconnect!
         connect
         active?
       end
 
       def disconnect!
+        reset_transaction
         @spid = nil
         case @connection_options[:mode]
         when :dblib
@@ -302,18 +164,22 @@ module ActiveRecord
       end
 
       def reset!
-        remove_database_connections_and_rollback { }
+        remove_database_connections_and_rollback {}
       end
 
       # === Abstract Adapter (Misc Support) =========================== #
 
       def pk_and_sequence_for(table_name)
-        idcol = identity_column(table_name)
-        idcol ? [idcol.name,nil] : nil
+        pk = primary_key(table_name)
+        pk ? [pk, nil] : nil
       end
 
       def primary_key(table_name)
-        identity_column(table_name).try(:name) || schema_cache.columns[table_name].detect(&:is_primary?).try(:name)
+        identity_column(table_name).try(:name) || schema_cache.columns(table_name).find(&:is_primary?).try(:name)
+      end
+
+      def schema_creation
+        Sqlserver::SchemaCreation.new self
       end
 
       # === SQLServer Specific (DB Reflection) ======================== #
@@ -358,11 +224,6 @@ module ActiveRecord
         @@auto_connect_duration ||= 10
       end
 
-      def retry_deadlock_victim
-        @@retry_deadlock_victim.is_a?(FalseClass) ? false : true
-      end
-      alias :retry_deadlock_victim? :retry_deadlock_victim
-
       def native_string_database_type
         @@native_string_database_type || (enable_default_unicode_types ? 'nvarchar' : 'varchar')
       end
@@ -394,13 +255,13 @@ module ActiveRecord
       def translate_exception(e, message)
         case message
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
-          RecordNotUnique.new(message,e)
+          RecordNotUnique.new(message, e)
         when /conflicted with the foreign key constraint/i
-          InvalidForeignKey.new(message,e)
+          InvalidForeignKey.new(message, e)
         when /has been chosen as the deadlock victim/i
-          DeadlockVictim.new(message,e)
+          DeadlockVictim.new(message, e)
         when *lost_connection_messages
-          LostConnection.new(message,e)
+          LostConnection.new(message, e)
         else
           super
         end
@@ -412,64 +273,84 @@ module ActiveRecord
         config = @connection_options
         @connection = case config[:mode]
                       when :dblib
-                        appname = config[:appname] || configure_application_name || Rails.application.class.name.split('::').first rescue nil
-                        login_timeout = config[:login_timeout].present? ? config[:login_timeout].to_i : nil
-                        timeout = config[:timeout].present? ? config[:timeout].to_i/1000 : nil
-                        encoding = config[:encoding].present? ? config[:encoding] : nil
-                        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],
-                          :appname       => appname,
-                          :login_timeout => login_timeout,
-                          :timeout       => timeout,
-                          :encoding      => encoding,
-                          :azure         => config[:azure]
-                        }).tap do |client|
-                          if config[:azure]
-                            client.execute("SET ANSI_NULLS ON").do
-                            client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
-                            client.execute("SET ANSI_NULL_DFLT_ON ON").do
-                            client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
-                            client.execute("SET ANSI_PADDING ON").do
-                            client.execute("SET QUOTED_IDENTIFIER ON")
-                            client.execute("SET ANSI_WARNINGS ON").do
-                          else
-                            client.execute("SET ANSI_DEFAULTS ON").do
-                            client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
-                            client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
-                          end
-                          client.execute("SET TEXTSIZE 2147483647").do
-                          client.execute("SET CONCAT_NULL_YIELDS_NULL ON").do
-                        end
+                        dblib_connect(config)
                       when :odbc
-                        if config[:dsn].include?(';')
-                          driver = ODBC::Driver.new.tap do |d|
-                            d.name = config[:dsn_name] || 'Driver1'
-                            d.attrs = config[:dsn].split(';').map{ |atr| atr.split('=') }.reject{ |kv| kv.size != 2 }.inject({}){ |h,kv| k,v = kv ; h[k] = v ; h }
-                          end
-                          ODBC::Database.new.drvconnect(driver)
-                        else
-                          ODBC.connect config[:dsn], config[:username], config[:password]
-                        end.tap do |c|
-                          begin
-                            c.use_time = true
-                            c.use_utc = ActiveRecord::Base.default_timezone == :utc
-                          rescue Exception => e
-                            warn "Ruby ODBC v0.99992 or higher is required."
-                          end
-                        end
+                        odbc_connect(config)
                       end
-        @spid = _raw_select("SELECT @@SPID", :fetch => :rows).first.first
+        @spid = _raw_select('SELECT @@SPID', fetch: :rows).first.first
         configure_connection
       rescue
         raise unless @auto_connecting
       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],
+                              appname: appname(config),
+                              login_timeout: login_timeout(config),
+                              timeout: timeout(config),
+                              encoding:  encoding(config),
+                              azure: config[:azure]
+                            ).tap do |client|
+                              if config[:azure]
+                                client.execute('SET ANSI_NULLS ON').do
+                                client.execute('SET CURSOR_CLOSE_ON_COMMIT OFF').do
+                                client.execute('SET ANSI_NULL_DFLT_ON ON').do
+                                client.execute('SET IMPLICIT_TRANSACTIONS OFF').do
+                                client.execute('SET ANSI_PADDING ON').do
+                                client.execute('SET QUOTED_IDENTIFIER ON')
+                                client.execute('SET ANSI_WARNINGS ON').do
+                              else
+                                client.execute('SET ANSI_DEFAULTS ON').do
+                                client.execute('SET CURSOR_CLOSE_ON_COMMIT OFF').do
+                                client.execute('SET IMPLICIT_TRANSACTIONS OFF').do
+                              end
+          client.execute('SET TEXTSIZE 2147483647').do
+          client.execute('SET CONCAT_NULL_YIELDS_NULL ON').do
+        end
+      end
+
+      def appname(config)
+       config[:appname] || configure_application_name || Rails.application.class.name.split('::').first rescue nil
+      end
+
+      def login_timeout(config)
+        config[:login_timeout].present? ? config[:login_timeout].to_i : nil
+      end
+
+      def timeout(config)
+        config[:timeout].present? ? config[:timeout].to_i / 1000 : nil
+      end
+
+      def encoding(config)
+        config[:encoding].present? ? config[:encoding] : nil
+      end
+
+      def odbc_connect(config)
+        if config[:dsn].include?(';')
+          driver = ODBC::Driver.new.tap do |d|
+            d.name = config[:dsn_name] || 'Driver1'
+            d.attrs = config[:dsn].split(';').map { |atr| atr.split('=') }.reject { |kv| kv.size != 2 }.reduce({}) { |a, e| k, v = e ; a[k] = v ; a }
+          end
+          ODBC::Database.new.drvconnect(driver)
+        else
+          ODBC.connect config[:dsn], config[:username], config[:password]
+        end.tap do |c|
+          begin
+            c.use_time = true
+            c.use_utc = ActiveRecord::Base.default_timezone == :utc
+          rescue Exception
+            warn 'Ruby ODBC v0.99992 or higher is required.'
+          end
+        end
+      end
+
       # Override this method so every connection can be configured to your needs.
       # For example:
       #    raw_connection_do "SET TEXTSIZE #{64.megabytes}"
@@ -486,32 +367,29 @@ module ActiveRecord
       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' }
+        [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
       end
 
-      def remove_database_connections_and_rollback(database=nil)
+      def remove_database_connections_and_rollback(database = nil)
         database ||= current_database
-        do_execute "ALTER DATABASE #{quote_table_name(database)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
+        do_execute "ALTER DATABASE #{quote_database_name(database)} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
         begin
           yield
         ensure
-          do_execute "ALTER DATABASE #{quote_table_name(database)} SET MULTI_USER"
+          do_execute "ALTER DATABASE #{quote_database_name(database)} SET MULTI_USER"
         end if block_given?
       end
 
       def with_sqlserver_error_handling
-        begin
-          yield
-        rescue Exception => e
-          case translate_exception(e,e.message)
-            when LostConnection; retry if auto_reconnected?
-            when DeadlockVictim; retry if retry_deadlock_victim? && open_transactions == 0
-          end
-          raise
+        yield
+      rescue Exception => e
+        case translate_exception(e, e.message)
+        when LostConnection then retry if auto_reconnected?
         end
+        raise
       end
 
       def disable_auto_reconnect
@@ -527,9 +405,9 @@ module ActiveRecord
         count = 0
         while count <= (auto_connect_duration / 2)
           result = reconnect!
-          ActiveRecord::Base.did_retry_sqlserver_connection(self,count)
+          ActiveRecord::Base.did_retry_sqlserver_connection(self, count)
           return true if result
-          sleep 2** count
+          sleep 2**count
           count += 1
         end
         ActiveRecord::Base.did_lose_sqlserver_connection(self)
@@ -537,10 +415,6 @@ module ActiveRecord
       ensure
         @auto_connecting = false
       end
-
-    end #class SQLServerAdapter < AbstractAdapter
-
-  end #module ConnectionAdapters
-
-end #module ActiveRecord
-
+    end # class SQLServerAdapter < AbstractAdapter
+  end # module ConnectionAdapters
+end # module ActiveRecord