Optimize #select_one.

Author: metaskills

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -2,9 +2,14 @@ module ActiveRecord
   module ConnectionAdapters
     module Sqlserver
       module DatabaseStatements
-
+        
+        def select_one(sql, name = nil)
+          result = raw_select sql, name, :fetch => :one
+          (result && result.first.present?) ? result.first : nil
+        end
+        
         def select_rows(sql, name = nil)
-          raw_select sql, name, true
+          raw_select sql, name, :fetch => :rows
         end
 
         def execute(sql, name = nil, skip_logging = false)
@@ -70,7 +75,7 @@ def execute_procedure(proc_name, *variables)
           log(sql,'Execute Procedure') do
             raw_connection_run(sql) do |handle|
               get_rows = lambda {
-                rows = handle_to_names_and_values(handle,false)
+                rows = handle_to_names_and_values handle, :fetch => :all
                 rows.each_with_index { |r,i| rows[i] = r.with_indifferent_access }
                 results << rows
               }
@@ -162,7 +167,7 @@ def charset
         protected
 
         def select(sql, name = nil)
-          raw_select(sql,name)
+          raw_select sql, name, :fetch => :all
         end
 
         def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
@@ -200,11 +205,11 @@ def raw_connection_do(sql)
 
         # === SQLServer Specific (Selecting) ============================ #
 
-        def raw_select(sql, name=nil, rows_only=false)
+        def raw_select(sql, name=nil, options={})
           log(sql,name) do
             begin
               handle = raw_connection_run(sql)
-              handle_to_names_and_values(handle, rows_only)
+              handle_to_names_and_values(handle, options)
             ensure
               finish_statement_handle(handle)
             end
@@ -231,45 +236,52 @@ def handle_more_results?(handle)
           end
         end
 
-        def handle_to_names_and_values(handle, rows_only)
+        def handle_to_names_and_values(handle, options={})
           case connection_mode
           when :odbc
-            handle_to_names_and_values_odbc(handle, rows_only)
+            handle_to_names_and_values_odbc(handle, options)
           when :adonet
-            handle_to_names_and_values_adonet(handle, rows_only)
+            handle_to_names_and_values_adonet(handle, options)
           end
         end
 
-        def handle_to_names_and_values_odbc(handle, rows_only)
-          rows = handle.fetch_all || []
-          if rows_only
+        def handle_to_names_and_values_odbc(handle, options={})
+          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]
-                row[i] = v.to_sqlserver_string if v.respond_to?(:to_sqlserver_string)
+                h[names[i]] = v.respond_to?(:to_sqlserver_string) ? v.to_sqlserver_string : v
                 i += 1
               end
+              names_and_values << h
             end
-            rows
-          else
-            names = handle.columns(true).map{ |c| c.name }
-            names_and_values = []
+            names_and_values
+          when :rows
+            rows = handle.fetch_all || []
             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
+                row[i] = v.to_sqlserver_string if v.respond_to?(:to_sqlserver_string)
                 i += 1
               end
-              names_and_values << h
             end
-            names_and_values
+            rows
           end
         end
 
-        def handle_to_names_and_values_adonet(handle, rows_only)
+        def handle_to_names_and_values_adonet(handle, options={})
           if handle.has_rows
             fields = []
             rows = []

lib/active_record/connection_adapters/sqlserver/query_cache.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sqlserver
+      module QueryCache
+        
+        def select_one(*args)
+          if @query_cache_enabled
+            cache_sql(args.first) { super }
+          else
+            super
+          end
+        end
+        
+      end
+    end
+  end
+end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -4,6 +4,7 @@
 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/query_cache'
 require 'active_record/connection_adapters/sqlserver/schema_statements'
 require 'active_record/connection_adapters/sqlserver/quoting'
 require 'active_support/core_ext/kernel/requires'
@@ -172,6 +173,7 @@ class SQLServerAdapter < AbstractAdapter
       include Sqlserver::DatabaseStatements
       include Sqlserver::SchemaStatements
       include Sqlserver::DatabaseLimits
+      include Sqlserver::QueryCache
       include Sqlserver::Errors
 
       ADAPTER_NAME                = 'SQLServer'.freeze

test/cases/sqlserver_helper.rb

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

test/profile/connection.rb

@@ -17,6 +17,13 @@ def test_select
     end
   end
 
+  def test_select_one
+    select_statement = "SELECT [topics].* FROM [topics]"
+    ruby_profile :connection_select_one do
+      3000.times { @connection.select_one(select_statement) }
+    end
+  end
+  
 
 end