Restructure the low level raw connections to create column name/value hashes so that a ODBC::Statement#columns is only called once.

Author: metaskills

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -4,7 +4,7 @@ module Sqlserver
       module DatabaseStatements
 
         def select_rows(sql, name = nil)
-          raw_select(sql,name).first.last
+          raw_select sql, name, true
         end
 
         def execute(sql, name = nil, skip_logging = false)
@@ -66,13 +66,21 @@ def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
         def execute_procedure(proc_name, *variables)
           vars = variables.map{ |v| quote(v) }.join(', ')
           sql = "EXEC #{proc_name} #{vars}".strip
-          select(sql,'Execute Procedure').inject([]) do |results,row|
-            if row.kind_of?(Array)
-              results << row.inject([]) { |rs,r| rs << r.with_indifferent_access }
-            else
-              results << row.with_indifferent_access
+          results = []
+          log(sql,'Execute Procedure') do
+            raw_connection_run(sql) do |handle|
+              get_rows = lambda {
+                rows = handle_to_names_and_values(handle,false)
+                rows.each_with_index { |r,i| rows[i] = r.with_indifferent_access }
+                results << rows
+              }
+              get_rows.call
+              while handle_more_results?(handle)
+                get_rows.call
+              end
             end
           end
+          results.many? ? results : results.first
         end
 
         def use_database(database=nil)
@@ -154,12 +162,7 @@ def charset
         protected
 
         def select(sql, name = nil)
-          fields_and_row_sets = raw_select(sql,name)
-          final_result_set = fields_and_row_sets.inject([]) do |rs,fields_and_rows|
-            fields, rows = fields_and_rows
-            rs << zip_fields_and_rows(fields,rows)
-          end
-          final_result_set.many? ? final_result_set : final_result_set.first
+          raw_select(sql,name)
         end
 
         def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -177,16 +180,6 @@ def valid_isolation_levels
           ["READ COMMITTED", "READ UNCOMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]
         end
 
-        def zip_fields_and_rows(fields, rows)
-          rows.inject([]) do |results,row|
-            row_hash = {}
-            fields.each_with_index do |f, i|
-              row_hash[f] = row[i]
-            end
-            results << row_hash
-          end
-        end
-        
         # === SQLServer Specific (Executing) ============================ #
 
         def do_execute(sql, name = nil)
@@ -207,26 +200,15 @@ def raw_connection_do(sql)
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name = nil)
-          fields_and_row_sets = []
+        def raw_select(sql, name=nil, rows_only=false)
           log(sql,name) do
             begin
               handle = raw_connection_run(sql)
-              loop do
-                fields_and_rows = case connection_mode
-                                  when :odbc
-                                    handle_to_fields_and_rows_odbc(handle)
-                                  when :adonet
-                                    handle_to_fields_and_rows_adonet(handle)
-                                  end
-                fields_and_row_sets << fields_and_rows
-                break unless handle_more_results?(handle)
-              end
+              handle_to_names_and_values(handle, rows_only)
             ensure
               finish_statement_handle(handle)
             end
           end
-          fields_and_row_sets
         end
 
         def raw_connection_run(sql)
@@ -248,24 +230,46 @@ def handle_more_results?(handle)
             handle.next_result
           end
         end
-
-        def handle_to_fields_and_rows_odbc(handle)
-          fields = handle.columns(true).map { |c| c.name }
-          results = handle.inject([]) do |rows,row|
-            rows << row.inject([]) { |values,value| values << value }
+        
+        def handle_to_names_and_values(handle, rows_only)
+          case connection_mode
+          when :odbc
+            handle_to_names_and_values_odbc(handle, rows_only)
+          when :adonet
+            handle_to_names_and_values_adonet(handle, rows_only)
           end
-          rows = results.inject([]) do |rows,row|
-            row.each_with_index do |value, i|
-              if value.respond_to?(:to_sqlserver_string)
-                row[i] = value.to_sqlserver_string
+        end
+
+        def handle_to_names_and_values_odbc(handle, rows_only)
+          rows = handle.fetch_all || []
+          if rows_only
+            rows.each do |row|
+              i = 0
+              while i < row.size
+                v = row[i]
+                row[i] = v.to_sqlserver_string if v.respond_to?(:to_sqlserver_string)
+                i += 1
               end
             end
-            rows << row
+            rows
+          else
+            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
-          [fields,rows]
         end
 
-        def handle_to_fields_and_rows_adonet(handle)
+        def handle_to_names_and_values_adonet(handle, rows_only)
           if handle.has_rows
             fields = []
             rows = []

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -60,8 +60,8 @@ def columns(table_name, name = nil)
           return [] if table_name.blank?
           cache_key = unqualify_table_name(table_name)
           @sqlserver_columns_cache[cache_key] ||= column_definitions(table_name).collect do |ci|
-            sqlserver_options = ci.except(:name,:default_value,:type,:null).merge(:database_year=>database_year)
-            SQLServerColumn.new ci[:name], ci[:default_value], ci[:type], ci[:null], sqlserver_options
+            sqlserver_options = ci.except('name','default_value','type','null').merge('database_year'=>database_year)
+            SQLServerColumn.new ci['name'], ci['default_value'], ci['type'], ci['null'], sqlserver_options
           end
         end
 
@@ -185,7 +185,7 @@ def column_definitions(table_name)
             CASE
               WHEN columns.IS_NULLABLE = 'YES' THEN 1
               ELSE NULL
-            end as is_nullable,
+            END as is_nullable,
             CASE
               WHEN COLUMNPROPERTY(OBJECT_ID(columns.TABLE_SCHEMA+'.'+columns.TABLE_NAME), columns.COLUMN_NAME, 'IsIdentity') = 0 THEN NULL
               ELSE 1
@@ -196,31 +196,30 @@ def column_definitions(table_name)
           }.gsub(/[ \t\r\n]+/,' ')
           results = info_schema_query { select(sql,nil) }
           results.collect do |ci|
-            ci.symbolize_keys!
-            ci[:type] = case ci[:type]
-                        when /^bit|image|text|ntext|datetime$/
-                          ci[:type]
-                        when /^numeric|decimal$/i
-                          "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
-                        when /^char|nchar|varchar|nvarchar|varbinary|bigint|int|smallint$/
-                          ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
-                        else
-                          ci[:type]
-                        end
-            if ci[:default_value].nil? && views.include?(table_name)
+            ci['type'] = case ci['type']
+                         when /^bit|image|text|ntext|datetime$/
+                           ci['type']
+                         when /^numeric|decimal$/i
+                           "#{ci['type']}(#{ci['numeric_precision']},#{ci['numeric_scale']})"
+                         when /^char|nchar|varchar|nvarchar|varbinary|bigint|int|smallint$/
+                           ci['length'].to_i == -1 ? "#{ci['type']}(max)" : "#{ci['type']}(#{ci['length']})"
+                         else
+                           ci['type']
+                         end
+            if ci['default_value'].nil? && views.include?(table_name)
               real_table_name = table_name_or_views_table_name(table_name)
-              real_column_name = views_real_column_name(table_name,ci[:name])
+              real_column_name = views_real_column_name(table_name,ci['name'])
               col_default_sql = "SELECT c.COLUMN_DEFAULT FROM #{db_name_with_period}INFORMATION_SCHEMA.COLUMNS c WHERE c.TABLE_NAME = '#{real_table_name}' AND c.COLUMN_NAME = '#{real_column_name}'"
-              ci[:default_value] = info_schema_query { select_value(col_default_sql) }
+              ci['default_value'] = info_schema_query { select_value(col_default_sql) }
             end
-            ci[:default_value] = case ci[:default_value]
+            ci['default_value'] = case ci['default_value']
                                  when nil, '(null)', '(NULL)'
                                    nil
                                  else
-                                   match_data = ci[:default_value].match(/\A\(+N?'?(.*?)'?\)+\Z/m)
+                                   match_data = ci['default_value'].match(/\A\(+N?'?(.*?)'?\)+\Z/m)
                                    match_data ? match_data[1] : nil
                                  end
-            ci[:null] = ci[:is_nullable].to_i == 1 ; ci.delete(:is_nullable)
+            ci['null'] = ci['is_nullable'].to_i == 1 ; ci.delete('is_nullable')
             ci
           end
         end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -97,15 +97,15 @@ def type_cast_code(var_name)
       end
 
       def is_identity?
-        @sqlserver_options[:is_identity]
+        @sqlserver_options['is_identity']
       end
 
       def is_utf8?
         sql_type =~ /nvarchar|ntext|nchar/i
       end
 
       def table_name
-        @sqlserver_options[:table_name]
+        @sqlserver_options['table_name']
       end
 
       def table_klass
@@ -118,7 +118,7 @@ def table_klass
       end
 
       def database_year
-        @sqlserver_options[:database_year]
+        @sqlserver_options['database_year']
       end
 
 

test/cases/execute_procedure_test_sqlserver.rb

@@ -20,17 +20,6 @@ def setup
     assert_equal 'TABLE', table_info[:TABLE_TYPE], "Table Info: #{table_info.inspect}"
   end
 
-  should 'quote bind vars correctly' do
-    regex = if quote_values_as_utf8?
-              /EXEC sp_tables N'%sql_server%', NULL, NULL, NULL, 1/
-            else
-              /EXEC sp_tables '%sql_server%', NULL, NULL, NULL, 1/
-            end
-    assert_sql(regex) do
-      @klass.execute_procedure :sp_tables, '%sql_server%', nil, nil, nil, true
-    end
-  end
-  
   should 'allow multiple result sets to be returned' do
     results1, results2 = @klass.execute_procedure('sp_helpconstraint','accounts')
     assert_instance_of Array, results1

test/cases/sqlserver_helper.rb

@@ -80,10 +80,10 @@ def method_added(method)
 end
 
 ActiveRecord::ConnectionAdapters::SQLServerAdapter.class_eval do
-  def raw_select_with_query_record(sql, name = nil)
+  def raw_select_with_query_record(sql, name=nil, rows_only=false)
     $queries_executed ||= []
     $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    raw_select_without_query_record(sql,name)
+    raw_select_without_query_record(sql,name,rows_only)
   end
   alias_method_chain :raw_select, :query_record
 end

test/profile/connection.rb

@@ -11,8 +11,6 @@ def setup
   end
 
   def test_select
-    # Ruby 1.8.7 p302 
-    # 6.180643
     ruby_profile :connection_select do
       1000.times { @connection.send :select, "SELECT [topics].* FROM [topics]" }
     end