activerecord-sqlserver-adapter 3.0.0 → 3.0.1

data/CHANGELOG

@@ -1,5 +1,10 @@
 
-MASTER
+* 3.0.1
+
+* Support DSN'less connections. Resolves ticket 38. 
+
+* Support upcoming ruby odbc 0.99992
+
 
 * 3.0.0
 

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

@@ -203,11 +203,11 @@ module ActiveRecord
         end
         
         def raw_connection_do(sql)
-          case connection_mode
+          case @connection_options[:mode]
           when :odbc
-            raw_connection.do(sql)
+            @connection.do(sql)
           else :adonet
-            raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
+            @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_non_query
           end
         end
         
@@ -226,17 +226,17 @@ module ActiveRecord
         
         def raw_connection_run(sql)
           with_auto_reconnect do
-            case connection_mode
+            case @connection_options[:mode]
             when :odbc
-              block_given? ? raw_connection.run_block(sql) { |handle| yield(handle) } : raw_connection.run(sql)
+              block_given? ? @connection.run_block(sql) { |handle| yield(handle) } : @connection.run(sql)
             else :adonet
-              raw_connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
+              @connection.create_command.tap{ |cmd| cmd.command_text = sql }.execute_reader
             end
           end
         end
         
         def handle_more_results?(handle)
-          case connection_mode
+          case @connection_options[:mode]
           when :odbc
             handle.more_results
           when :adonet
@@ -245,7 +245,7 @@ module ActiveRecord
         end
         
         def handle_to_names_and_values(handle, options={})
-          case connection_mode
+          case @connection_options[:mode]
           when :odbc
             handle_to_names_and_values_odbc(handle, options)
           when :adonet
@@ -254,29 +254,40 @@ module ActiveRecord
         end
 
         def handle_to_names_and_values_odbc(handle, options={})
+          @connection.use_utc = ActiveRecord::Base.default_timezone == :utc if @connection_supports_native_types
           case options[:fetch]
           when :all, :one
-            rows = if options[:fetch] == :all
-                     handle.fetch_all || []
-                   else
-                     row = handle.fetch
-                     row ? [row] : [[]]                     
-                   end
-            names = handle.columns(true).map{ |c| c.name }
-            names_and_values = []
-            rows.each do |row|
-              h = {}
-              i = 0
-              while i < row.size
-                v = row[i]
-                h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
-                i += 1
+            if @connection_supports_native_types
+              if options[:fetch] == :all
+                handle.each_hash || []
+              else
+                row = handle.fetch_hash
+                rows = row ? [row] : [[]]                    
               end
-              names_and_values << h
+            else
+              rows = if options[:fetch] == :all
+                       handle.fetch_all || []
+                     else
+                       row = handle.fetch
+                       row ? [row] : [[]]                     
+                     end
+              names = handle.columns(true).map{ |c| c.name }
+              names_and_values = []
+              rows.each do |row|
+                h = {}
+                i = 0
+                while i < row.size
+                  v = row[i]
+                  h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
+                  i += 1
+                end
+                names_and_values << h
+              end
+              names_and_values
             end
-            names_and_values
           when :rows
             rows = handle.fetch_all || []
+            return rows if @connection_supports_native_types
             rows.each do |row|
               i = 0
               while i < row.size
@@ -291,36 +302,55 @@ module ActiveRecord
 
         def handle_to_names_and_values_adonet(handle, options={})
           if handle.has_rows
-            fields = []
+            names = []
             rows = []
-            fields_named = false
+            fields_named = options[:fetch] == :rows
+            one_row_only = options[:fetch] == :one
             while handle.read
               row = []
               handle.visible_field_count.times do |row_index|
                 value = handle.get_value(row_index)
-                value = if value.is_a? System::String
+                value = case value
+                        when System::String
                           value.to_s
-                        elsif value.is_a? System::DBNull
+                        when System::DBNull
                           nil
-                        elsif value.is_a? System::DateTime
-                          value.to_string("yyyy-MM-dd HH:MM:ss.fff").to_s
+                        when System::DateTime
+                          value.to_string("yyyy-MM-dd HH:mm:ss.fff").to_s
+                        when @@array_of_bytes ||= System::Array[System::Byte]
+                          String.new(value)
                         else
                           value
                         end
                 row << value
-                fields << handle.get_name(row_index).to_s unless fields_named
+                names << handle.get_name(row_index).to_s unless fields_named
+                break if one_row_only
               end
               rows << row
               fields_named = true
             end
           else
-            fields, rows = [], []
+            rows = []
+          end
+          if options[:fetch] != :rows
+            names_and_values = []
+            rows.each do |row|
+              h = {}
+              i = 0
+              while i < row.size
+                h[names[i]] = row[i]
+                i += 1
+              end
+              names_and_values << h
+            end
+            names_and_values
+          else
+            rows
           end
-          [fields,rows]
         end
         
         def finish_statement_handle(handle)
-          case connection_mode
+          case @connection_options[:mode]
           when :odbc
             handle.drop if handle && handle.respond_to?(:drop) && !handle.finished?
           when :adonet

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

@@ -19,12 +19,12 @@ module ActiveRecord
         
         
         def lost_connection_exceptions
-          exceptions = LOST_CONNECTION_EXCEPTIONS[connection_mode]
+          exceptions = LOST_CONNECTION_EXCEPTIONS[@connection_options[:mode]]
           @lost_connection_exceptions ||= exceptions ? exceptions.map{ |e| e.constantize rescue nil }.compact : []
         end
         
         def lost_connection_messages
-          LOST_CONNECTION_MESSAGES[connection_mode]
+          LOST_CONNECTION_MESSAGES[@connection_options[:mode]]
         end
         
       end

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

@@ -3,6 +3,8 @@ module ActiveRecord
     module Sqlserver
       module Quoting
         
+        QUOTED_TRUE, QUOTED_FALSE = '1', '0'
+        
         def quote(value, column = nil)
           case value
           when String, ActiveSupport::Multibyte::Chars
@@ -22,21 +24,21 @@ module ActiveRecord
           string.to_s.gsub(/\'/, "''")
         end
 
-        def quote_column_name(column_name)
-          column_name.to_s.split('.').map{ |name| name =~ /^\[.*\]$/ ? name : "[#{name}]" }.join('.')
+        def quote_column_name(name)
+          @sqlserver_quoted_column_and_table_names[name] ||= 
+            name.to_s.split('.').map{ |n| n =~ /^\[.*\]$/ ? n : "[#{n}]" }.join('.')
         end
 
-        def quote_table_name(table_name)
-          return table_name if table_name =~ /^\[.*\]$/
-          quote_column_name(table_name)
+        def quote_table_name(name)
+          quote_column_name(name)
         end
 
         def quoted_true
-          '1'
+          QUOTED_TRUE
         end
 
         def quoted_false
-          '0'
+          QUOTED_FALSE
         end
 
         def quoted_date(value)

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

@@ -4,27 +4,7 @@ module ActiveRecord
       module SchemaStatements
         
         def native_database_types
-          {
-            :primary_key  => "int NOT NULL IDENTITY(1,1) PRIMARY KEY",
-            :string       => { :name => native_string_database_type, :limit => 255  },
-            :text         => { :name => native_text_database_type },
-            :integer      => { :name => "int", :limit => 4 },
-            :float        => { :name => "float", :limit => 8 },
-            :decimal      => { :name => "decimal" },
-            :datetime     => { :name => "datetime" },
-            :timestamp    => { :name => "datetime" },
-            :time         => { :name => native_time_database_type },
-            :date         => { :name => native_date_database_type },
-            :binary       => { :name => native_binary_database_type },
-            :boolean      => { :name => "bit"},
-            # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
-            :char         => { :name => 'char' },
-            :varchar_max  => { :name => 'varchar(max)' },
-            :nchar        => { :name => "nchar" },
-            :nvarchar     => { :name => "nvarchar", :limit => 255 },
-            :nvarchar_max => { :name => "nvarchar(max)" },
-            :ntext        => { :name => "ntext" }
-          }
+          ActiveRecord::ConnectionAdapters::SQLServerAdapter::NATIVE_DATABASE_TYPES
         end
 
         def tables(name = nil)
@@ -167,6 +147,31 @@ module ActiveRecord
         
         # === SQLServer Specific ======================================== #
         
+        def initialize_native_database_types
+          return if defined?(ActiveRecord::ConnectionAdapters::SQLServerAdapter::NATIVE_DATABASE_TYPES)
+          ActiveRecord::ConnectionAdapters::SQLServerAdapter.const_set(:NATIVE_DATABASE_TYPES,{
+            :primary_key  => "int NOT NULL IDENTITY(1,1) PRIMARY KEY",
+            :string       => { :name => native_string_database_type, :limit => 255  },
+            :text         => { :name => native_text_database_type },
+            :integer      => { :name => "int", :limit => 4 },
+            :float        => { :name => "float", :limit => 8 },
+            :decimal      => { :name => "decimal" },
+            :datetime     => { :name => "datetime" },
+            :timestamp    => { :name => "datetime" },
+            :time         => { :name => native_time_database_type },
+            :date         => { :name => native_date_database_type },
+            :binary       => { :name => native_binary_database_type },
+            :boolean      => { :name => "bit"},
+            # These are custom types that may move somewhere else for good schema_dumper.rb hacking to output them.
+            :char         => { :name => 'char' },
+            :varchar_max  => { :name => 'varchar(max)' },
+            :nchar        => { :name => "nchar" },
+            :nvarchar     => { :name => "nvarchar", :limit => 255 },
+            :nvarchar_max => { :name => "nvarchar(max)" },
+            :ntext        => { :name => "ntext" }
+          })
+        end
+        
         def column_definitions(table_name)
           db_name = unqualify_db_name(table_name)
           db_name_with_period = "#{db_name}." if db_name
@@ -330,6 +335,7 @@ module ActiveRecord
           @sqlserver_columns_cache = {} if reset_columns
           @sqlserver_views_cache = nil
           @sqlserver_view_information_cache = {}
+          @sqlserver_quoted_column_and_table_names = {}
         end
         
         # === SQLServer Specific (Identity Inserts) ===================== #

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -102,7 +102,7 @@ module ActiveRecord
       end
       
       def is_utf8?
-        sql_type =~ /nvarchar|ntext|nchar/i
+        @sql_type =~ /nvarchar|ntext|nchar/i
       end
       
       def default_function
@@ -181,10 +181,13 @@ module ActiveRecord
       include Sqlserver::Errors
       
       ADAPTER_NAME                = 'SQLServer'.freeze
-      VERSION                     = '3.0.0'.freeze
+      VERSION                     = '3.0.1'.freeze
       DATABASE_VERSION_REGEXP     = /Microsoft SQL Server\s+(\d{4})/
       SUPPORTED_VERSIONS          = [2005,2008].freeze
       
+      attr_reader :database_version, :database_year,
+                  :connection_supports_native_types
+      
       cattr_accessor :native_text_database_type, :native_binary_database_type, :native_string_database_type,
                      :log_info_schema_queries, :enable_default_unicode_types, :auto_connect,
                      :cs_equality_operator
@@ -192,10 +195,13 @@ module ActiveRecord
       def initialize(logger,config)
         @connection_options = config
         connect
-        super(raw_connection, logger)
+        super(@connection, logger)
+        @database_version = info_schema_query { select_value('SELECT @@version') }
+        @database_year = DATABASE_VERSION_REGEXP.match(@database_version)[1].to_i rescue 0
+        initialize_native_database_types
         initialize_sqlserver_caches
         use_database
-        unless SUPPORTED_VERSIONS.include?(database_year)
+        unless SUPPORTED_VERSIONS.include?(@database_year)
           raise NotImplementedError, "Currently, only #{SUPPORTED_VERSIONS.to_sentence} are supported."
         end
       end
@@ -249,11 +255,11 @@ module ActiveRecord
       end
 
       def disconnect!
-        case connection_mode
+        case @connection_options[:mode]
         when :odbc
-          raw_connection.disconnect rescue nil
+          @connection.disconnect rescue nil
         else :adonet
-          raw_connection.close rescue nil
+          @connection.close rescue nil
         end
       end
       
@@ -274,24 +280,16 @@ module ActiveRecord
       
       # === SQLServer Specific (DB Reflection) ======================== #
       
-      def database_version
-        @database_version ||= info_schema_query { select_value('SELECT @@version') }
-      end
-      
-      def database_year
-        DATABASE_VERSION_REGEXP.match(database_version)[1].to_i
-      end
-      
       def sqlserver?
         true
       end
       
       def sqlserver_2005?
-        database_year == 2005
+        @database_year == 2005
       end
       
       def sqlserver_2008?
-        database_year == 2008
+        @database_year == 2008
       end
       
       def version
@@ -299,7 +297,7 @@ module ActiveRecord
       end
       
       def inspect
-        "#<#{self.class} version: #{version}, year: #{database_year}, connection_options: #{@connection_options.inspect}>"
+        "#<#{self.class} version: #{version}, year: #{@database_year}, connection_options: #{@connection_options.inspect}>"
       end
       
       def auto_connect
@@ -352,10 +350,24 @@ module ActiveRecord
       
       def connect
         config = @connection_options
-        @connection = case connection_mode
+        @connection = case @connection_options[:mode]
                       when :odbc
                         odbc = ['::ODBC','::ODBC_UTF8','::ODBC_NONE'].detect{ |odbc_ns| odbc_ns.constantize rescue nil }.constantize
-                        odbc.connect config[:dsn], config[:username], config[:password]
+                        if config[:dsn].include?(';')
+                          driver = odbc::Driver.new.tap do |d|
+                            d.name = config[:dsn_name] || 'Driver1'
+                            driver.attrs = 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|
+                          if c.respond_to?(:use_time)
+                            c.use_time = true
+                            c.use_utc = ActiveRecord::Base.default_timezone == :utc
+                            @connection_supports_native_types = true
+                          end
+                        end
                       when :adonet
                         System::Data::SqlClient::SqlConnection.new.tap do |connection|
                           connection.connection_string = System::Data::SqlClient::SqlConnectionStringBuilder.new.tap do |cs|
@@ -411,10 +423,6 @@ module ActiveRecord
       ensure
         @auto_connecting = false
       end
-      
-      def connection_mode
-        @connection_options[:mode]
-      end
             
     end #class SQLServerAdapter < AbstractAdapter
     

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: false
   segments: 
   - 3
   - 0
-  - 0
-  version: 3.0.0
+  - 1
+  version: 3.0.1
 platform: ruby
 authors: 
 - Ken Collins
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-29 00:00:00 -04:00
+date: 2010-09-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency