diff options
Diffstat (limited to 'activerecord/lib/active_record')
11 files changed, 169 insertions, 175 deletions
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb index effb36faf1..4303d66451 100644 --- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb +++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb @@ -10,14 +10,15 @@ module ActiveRecord # Returns a record hash with the column names as keys and column values # as values. def select_one(sql, name = nil) - result = select(sql, name) + result = select_all(sql, name) result.first if result end # Returns a single value from a record def select_value(sql, name = nil) - result = select_one(sql, name) - result.nil? ? nil : result.values.first + if result = select_one(sql, name) + result.values.first + end end # Returns an array of the values of the first column in a select: @@ -29,7 +30,9 @@ module ActiveRecord # Returns an array of arrays containing the field values. # Order is the same as that returned by #columns. - def select_rows(sql, name = nil) end + def select_rows(sql, name = nil) + raise NotImplementedError, "select_rows is an abstract method" + end # Executes the SQL statement in the context of this connection. def execute(sql, name = nil) @@ -38,17 +41,17 @@ module ActiveRecord # Returns the last auto-generated ID from the affected table. def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) - raise NotImplementedError, "insert is an abstract method" + insert_sql(sql, name, pk, id_value, sequence_name) end # Executes the update statement and returns the number of rows affected. def update(sql, name = nil) - execute(sql, name) + update_sql(sql, name) end # Executes the delete statement and returns the number of rows affected. def delete(sql, name = nil) - update(sql, name) + delete_sql(sql, name) end # Wrap a block in a transaction. Returns result of block. @@ -133,7 +136,7 @@ module ActiveRecord # Inserts the given fixture into the table. Overriden in adapters that require # something beyond a simple insert (eg. Oracle). def insert_fixture(fixture, table_name) - execute "INSERT INTO #{table_name} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert' + insert "INSERT INTO #{table_name} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert' end protected @@ -142,6 +145,22 @@ module ActiveRecord def select(sql, name = nil) raise NotImplementedError, "select is an abstract method" end + + # Returns the last auto-generated ID from the affected table. + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) + execute(sql, name) + id_value + end + + # Executes the update statement and returns the number of rows affected. + def update_sql(sql, name = nil) + execute(sql, name) + end + + # Executes the delete statement and returns the number of rows affected. + def delete_sql(sql, name = nil) + update_sql(sql, name) + end end end end diff --git a/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb new file mode 100644 index 0000000000..42ff1d7d54 --- /dev/null +++ b/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb @@ -0,0 +1,90 @@ +module ActiveRecord + module ConnectionAdapters # :nodoc: + module QueryCache + class << self + def included(base) + base.class_eval do + attr_accessor :query_cache_enabled + alias_method_chain :columns, :query_cache + alias_method_chain :select_all, :query_cache + end + + dirties_query_cache base, :insert, :update, :delete + end + + def dirties_query_cache(base, *method_names) + method_names.each do |method_name| + base.class_eval <<-end_code, __FILE__, __LINE__ + def #{method_name}_with_query_dirty(*args) + clear_query_cache if @query_cache_enabled + #{method_name}_without_query_dirty(*args) + end + + alias_method_chain :#{method_name}, :query_dirty + end_code + end + end + end + + # Enable the query cache within the block. + def cache + old, @query_cache_enabled = @query_cache_enabled, true + @query_cache ||= {} + yield + ensure + clear_query_cache + @query_cache_enabled = old + end + + # Disable the query cache within the block. + def uncached + old, @query_cache_enabled = @query_cache_enabled, false + yield + ensure + @query_cache_enabled = old + end + + def clear_query_cache + @query_cache.clear if @query_cache + end + + def select_all_with_query_cache(*args) + if @query_cache_enabled + cache_sql(args.first) { select_all_without_query_cache(*args) } + else + select_all_without_query_cache(*args) + end + end + + def columns_with_query_cache(*args) + if @query_cache_enabled + @query_cache["SHOW FIELDS FROM #{args.first}"] ||= columns_without_query_cache(*args) + else + columns_without_query_cache(*args) + end + end + + private + def cache_sql(sql) + result = + if @query_cache.has_key?(sql) + log_info(sql, "CACHE", 0.0) + @query_cache[sql] + else + @query_cache[sql] = yield + end + + case result + when Array + result.collect { |row| row.dup } + when nil, Fixnum, Float, true, false + result + else + result.dup + end + rescue TypeError + result + end + end + end +end diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb index fc29f11e15..8ca23ccdaf 100755 --- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb @@ -8,6 +8,7 @@ require 'active_record/connection_adapters/abstract/schema_statements' require 'active_record/connection_adapters/abstract/database_statements' require 'active_record/connection_adapters/abstract/quoting' require 'active_record/connection_adapters/abstract/connection_specification' +require 'active_record/connection_adapters/abstract/query_cache' module ActiveRecord module ConnectionAdapters # :nodoc: @@ -22,6 +23,7 @@ module ActiveRecord # SchemaStatements#remove_column are very useful. class AbstractAdapter include Quoting, DatabaseStatements, SchemaStatements + include QueryCache @@row_even = true def initialize(connection, logger = nil) #:nodoc: diff --git a/activerecord/lib/active_record/connection_adapters/db2_adapter.rb b/activerecord/lib/active_record/connection_adapters/db2_adapter.rb index c496132fc0..b7c939d7d3 100644 --- a/activerecord/lib/active_record/connection_adapters/db2_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/db2_adapter.rb @@ -63,9 +63,8 @@ begin rows end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) - execute(sql, name = nil) - id_value || last_insert_id + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) + super || last_insert_id end def execute(sql, name = nil) diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb index 7cf8f478d7..20028ffcfd 100755 --- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb @@ -266,13 +266,13 @@ module ActiveRecord end end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc: - execute(sql, name = nil) + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc: + super sql, name id_value || @connection.insert_id end - def update(sql, name = nil) #:nodoc: - execute(sql, name) + def update_sql(sql, name = nil) #:nodoc: + super @connection.affected_rows end diff --git a/activerecord/lib/active_record/connection_adapters/oracle_adapter.rb b/activerecord/lib/active_record/connection_adapters/oracle_adapter.rb index 58544f4cb2..99e22ca3f3 100644 --- a/activerecord/lib/active_record/connection_adapters/oracle_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/oracle_adapter.rb @@ -223,11 +223,6 @@ begin id end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc: - execute(sql, name) - id_value - end - def begin_db_transaction #:nodoc: @connection.autocommit = false end diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb index b14acc1e68..6a2b32a370 100644 --- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb @@ -374,10 +374,9 @@ module ActiveRecord end # Executes an INSERT query and returns the new record's ID - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) - execute(sql, name) + def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) table = sql.split(" ", 4)[2] - id_value || last_insert_id(table, sequence_name || default_sequence_name(table, pk)) + super || last_insert_id(table, sequence_name || default_sequence_name(table, pk)) end # Queries the database and returns the results in an Array or nil otherwise. @@ -404,8 +403,8 @@ module ActiveRecord end # Executes an UPDATE query and returns the number of affected tuples. - def update(sql, name = nil) - execute(sql, name).cmdtuples + def update_sql(sql, name = nil) + super.cmdtuples end # Begins a transaction. diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb index 57eefbf1d6..62d7e5364c 100644 --- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb @@ -132,37 +132,18 @@ module ActiveRecord catch_schema_changes { log(sql, name) { @connection.execute(sql) } } end - def update(sql, name = nil) #:nodoc: - execute(sql, name) + def update_sql(sql, name = nil) #:nodoc: + super @connection.changes end - def delete(sql, name = nil) #:nodoc: + def delete_sql(sql, name = nil) #:nodoc: sql += " WHERE 1=1" unless sql =~ /WHERE/i - execute(sql, name) - @connection.changes + super sql, name end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc: - execute(sql, name = nil) - id_value || @connection.last_insert_row_id - end - - def select_all(sql, name = nil) #:nodoc: - execute(sql, name).map do |row| - record = {} - row.each_key do |key| - if key.is_a?(String) - record[key.sub(/^\w+\./, '')] = row[key] - end - end - record - end - end - - def select_one(sql, name = nil) #:nodoc: - result = select_all(sql, name) - result.nil? ? nil : result.first + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc: + super || @connection.last_insert_row_id end def select_rows(sql, name = nil) @@ -267,6 +248,18 @@ module ActiveRecord protected + def select(sql, name = nil) #:nodoc: + execute(sql, name).map do |row| + record = {} + row.each_key do |key| + if key.is_a?(String) + record[key.sub(/^\w+\./, '')] = row[key] + end + end + record + end + end + def table_structure(table_name) returning structure = execute("PRAGMA table_info(#{table_name})") do raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty? diff --git a/activerecord/lib/active_record/connection_adapters/sqlserver_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlserver_adapter.rb index 4799c69b83..113e187766 100644 --- a/activerecord/lib/active_record/connection_adapters/sqlserver_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/sqlserver_adapter.rb @@ -314,18 +314,15 @@ module ActiveRecord columns end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) - execute(sql, name) - id_value || select_one("SELECT @@IDENTITY AS Ident")["Ident"] + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) + super || select_value("SELECT @@IDENTITY AS Ident") end - def update(sql, name = nil) + def update_sql(sql, name = nil) execute(sql, name) do |handle| handle.rows - end || select_one("SELECT @@ROWCOUNT AS AffectedRows")["AffectedRows"] + end || select_value("SELECT @@ROWCOUNT AS AffectedRows") end - - alias_method :delete, :update def execute(sql, name = nil) if sql =~ /^\s*INSERT/i && (table_name = query_requires_identity_insert?(sql)) diff --git a/activerecord/lib/active_record/connection_adapters/sybase_adapter.rb b/activerecord/lib/active_record/connection_adapters/sybase_adapter.rb index c43e9435b4..d8ff88b287 100644 --- a/activerecord/lib/active_record/connection_adapters/sybase_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/sybase_adapter.rb @@ -176,7 +176,7 @@ module ActiveRecord 30 end - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) + def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) begin table_name = get_table_name(sql) col = get_identity_column(table_name) @@ -194,9 +194,7 @@ module ActiveRecord end log(sql, name) do - execute(sql, name) - ident = select_one("SELECT @@IDENTITY AS last_id")["last_id"] - id_value || ident + super || select_value("SELECT @@IDENTITY AS last_id") end ensure if ii_enabled @@ -219,7 +217,7 @@ module ActiveRecord def rollback_db_transaction() raw_execute "ROLLBACK TRAN" end def current_database - select_one("select DB_NAME() as name")["name"] + select_value("select DB_NAME() as name") end def tables(name = nil) diff --git a/activerecord/lib/active_record/query_cache.rb b/activerecord/lib/active_record/query_cache.rb index 2cb9b97f8f..a8af89fcb9 100644 --- a/activerecord/lib/active_record/query_cache.rb +++ b/activerecord/lib/active_record/query_cache.rb @@ -1,119 +1,21 @@ module ActiveRecord - class QueryCache #:nodoc: - def initialize(connection) - @connection = connection - @query_cache = {} - end - - def clear_query_cache - @query_cache.clear - end - - def select_all(sql, name = nil) - cache(sql) { @connection.select_all(sql, name) } - end - - def select_one(sql, name = nil) - cache(sql) { @connection.select_one(sql, name) } - end - - def select_values(sql, name = nil) - cache(sql) { @connection.select_values(sql, name) } - end - - def select_value(sql, name = nil) - cache(sql) { @connection.select_value(sql, name) } - end - - def execute(sql, name = nil) - clear_query_cache - @connection.execute(sql, name) - end - - def columns(table_name, name = nil) - @query_cache["SHOW FIELDS FROM #{table_name}"] ||= @connection.columns(table_name, name) - end - - def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) - clear_query_cache - @connection.insert(sql, name, pk, id_value, sequence_name) - end - - def update(sql, name = nil) - clear_query_cache - @connection.update(sql, name) - end - - def delete(sql, name = nil) - clear_query_cache - @connection.delete(sql, name) - end - - private - def cache(sql) - result = if @query_cache.has_key?(sql) - log_info(sql, "CACHE", 0.0) - @query_cache[sql] - else - @query_cache[sql] = yield - end - - case result - when Array - result.collect { |row| row.dup } - when nil, Fixnum, Float, true, false - result - else - result.dup - end - rescue TypeError - result - end - - def method_missing(method, *arguments, &proc) - @connection.send(method, *arguments, &proc) - end - end - - class Base - # Set the connection for the class with caching on - class << self - alias_method :connection_without_query_cache, :connection - - def query_caches - Thread.current["query_cache_#{connection_without_query_cache.object_id}"] ||= {} - end - - def query_cache - if query_caches[self] - query_caches[self] - elsif superclass.respond_to?(:query_cache) and superclass.respond_to?(:connection) and superclass.connection_without_query_cache == connection_without_query_cache - superclass.query_cache - end - end - - def query_cache=(cache) - query_caches[self] = cache - end - - # Use a query cache within the given block. - def cache - # Don't cache if Active Record is not configured. - if ActiveRecord::Base.configurations.blank? - yield - else - begin - self.query_cache = QueryCache.new(connection_without_query_cache) - yield - ensure - self.query_cache = nil - end - end + module QueryCache + # Enable the query cache within the block if Active Record is configured. + def cache(&block) + if ActiveRecord::Base.configurations.blank? + yield + else + connection.cache(&block) end + end - def connection - query_cache || connection_without_query_cache + # Disable the query cache within the block if Active Record is configured. + def uncached(&block) + if ActiveRecord::Base.configurations.blank? + yield + else + connection.uncached(&block) end end - end + end end |