2007-01-22 14:43:50 +01:00
|
|
|
module ActiveRecord
|
|
|
|
module ConnectionAdapters # :nodoc:
|
|
|
|
module DatabaseStatements
|
|
|
|
# Returns an array of record hashes with the column names as keys and
|
|
|
|
# column values as values.
|
|
|
|
def select_all(sql, name = nil)
|
2007-02-09 09:04:31 +01:00
|
|
|
select(sql, name)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
# Returns a record hash with the column names as keys and column values
|
|
|
|
# as values.
|
|
|
|
def select_one(sql, name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
result = select_all(sql, name)
|
2007-02-09 09:04:31 +01:00
|
|
|
result.first if result
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
# Returns a single value from a record
|
|
|
|
def select_value(sql, name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
if result = select_one(sql, name)
|
|
|
|
result.values.first
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
|
|
|
|
# Returns an array of the values of the first column in a select:
|
|
|
|
# select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
|
|
|
|
def select_values(sql, name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
result = select_rows(sql, name)
|
|
|
|
result.map { |v| v[0] }
|
|
|
|
end
|
|
|
|
|
|
|
|
# Returns an array of arrays containing the field values.
|
2008-06-02 08:35:38 +02:00
|
|
|
# Order is the same as that returned by +columns+.
|
2007-12-21 08:48:59 +01:00
|
|
|
def select_rows(sql, name = nil)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
undef_method :select_rows
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
# Executes the SQL statement in the context of this connection.
|
2009-02-04 21:26:08 +01:00
|
|
|
def execute(sql, name = nil, skip_logging = false)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
undef_method :execute
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
# Returns the last auto-generated ID from the affected table.
|
2007-02-09 09:04:31 +01:00
|
|
|
def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
insert_sql(sql, name, pk, id_value, sequence_name)
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
# Executes the update statement and returns the number of rows affected.
|
2007-02-09 09:04:31 +01:00
|
|
|
def update(sql, name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
update_sql(sql, name)
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
# Executes the delete statement and returns the number of rows affected.
|
2007-02-09 09:04:31 +01:00
|
|
|
def delete(sql, name = nil)
|
2007-12-21 08:48:59 +01:00
|
|
|
delete_sql(sql, name)
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
|
|
|
|
# Checks whether there is currently no transaction active. This is done
|
|
|
|
# by querying the database driver, and does not use the transaction
|
|
|
|
# house-keeping information recorded by #increment_open_transactions and
|
|
|
|
# friends.
|
|
|
|
#
|
|
|
|
# Returns true if there is no transaction active, false if there is a
|
|
|
|
# transaction active, and nil if this information is unknown.
|
|
|
|
#
|
|
|
|
# Not all adapters supports transaction state introspection. Currently,
|
|
|
|
# only the PostgreSQL adapter supports this.
|
|
|
|
def outside_transaction?
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
|
|
|
# Runs the given block in a database transaction, and returns the result
|
|
|
|
# of the block.
|
|
|
|
#
|
|
|
|
# == Nested transactions support
|
|
|
|
#
|
|
|
|
# Most databases don't support true nested transactions. At the time of
|
|
|
|
# writing, the only database that supports true nested transactions that
|
|
|
|
# we're aware of, is MS-SQL.
|
|
|
|
#
|
|
|
|
# In order to get around this problem, #transaction will emulate the effect
|
|
|
|
# of nested transactions, by using savepoints:
|
|
|
|
# http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
|
|
|
|
# Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
|
|
|
|
#
|
|
|
|
# It is safe to call this method if a database transaction is already open,
|
|
|
|
# i.e. if #transaction is called within another #transaction block. In case
|
|
|
|
# of a nested call, #transaction will behave as follows:
|
|
|
|
#
|
|
|
|
# - The block will be run without doing anything. All database statements
|
|
|
|
# that happen within the block are effectively appended to the already
|
|
|
|
# open database transaction.
|
|
|
|
# - However, if +:requires_new+ is set, the block will be wrapped in a
|
|
|
|
# database savepoint acting as a sub-transaction.
|
|
|
|
#
|
|
|
|
# === Caveats
|
|
|
|
#
|
|
|
|
# MySQL doesn't support DDL transactions. If you perform a DDL operation,
|
|
|
|
# then any created savepoints will be automatically released. For example,
|
|
|
|
# if you've created a savepoint, then you execute a CREATE TABLE statement,
|
|
|
|
# then the savepoint that was created will be automatically released.
|
|
|
|
#
|
|
|
|
# This means that, on MySQL, you shouldn't execute DDL operations inside
|
|
|
|
# a #transaction call that you know might create a savepoint. Otherwise,
|
|
|
|
# #transaction will raise exceptions when it tries to release the
|
|
|
|
# already-automatically-released savepoints:
|
|
|
|
#
|
|
|
|
# Model.connection.transaction do # BEGIN
|
|
|
|
# Model.connection.transaction(:requires_new => true) do # CREATE SAVEPOINT active_record_1
|
|
|
|
# Model.connection.create_table(...)
|
|
|
|
# # active_record_1 now automatically released
|
|
|
|
# end # RELEASE SAVEPOINT active_record_1 <--- BOOM! database error!
|
|
|
|
# end
|
|
|
|
def transaction(options = {})
|
|
|
|
options.assert_valid_keys :requires_new, :joinable
|
|
|
|
|
|
|
|
last_transaction_joinable = @transaction_joinable
|
|
|
|
if options.has_key?(:joinable)
|
|
|
|
@transaction_joinable = options[:joinable]
|
|
|
|
else
|
|
|
|
@transaction_joinable = true
|
|
|
|
end
|
|
|
|
requires_new = options[:requires_new] || !last_transaction_joinable
|
2007-01-22 14:43:50 +01:00
|
|
|
|
|
|
|
transaction_open = false
|
|
|
|
begin
|
|
|
|
if block_given?
|
2009-02-04 21:26:08 +01:00
|
|
|
if requires_new || open_transactions == 0
|
|
|
|
if open_transactions == 0
|
|
|
|
begin_db_transaction
|
|
|
|
elsif requires_new
|
|
|
|
create_savepoint
|
|
|
|
end
|
|
|
|
increment_open_transactions
|
2007-01-22 14:43:50 +01:00
|
|
|
transaction_open = true
|
|
|
|
end
|
|
|
|
yield
|
|
|
|
end
|
|
|
|
rescue Exception => database_transaction_rollback
|
2009-02-04 21:26:08 +01:00
|
|
|
if transaction_open && !outside_transaction?
|
2007-01-22 14:43:50 +01:00
|
|
|
transaction_open = false
|
2009-02-04 21:26:08 +01:00
|
|
|
decrement_open_transactions
|
|
|
|
if open_transactions == 0
|
|
|
|
rollback_db_transaction
|
|
|
|
else
|
|
|
|
rollback_to_savepoint
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
ensure
|
2009-02-04 21:26:08 +01:00
|
|
|
@transaction_joinable = last_transaction_joinable
|
|
|
|
|
|
|
|
if outside_transaction?
|
|
|
|
@open_transactions = 0
|
|
|
|
elsif transaction_open
|
|
|
|
decrement_open_transactions
|
2007-12-21 08:48:59 +01:00
|
|
|
begin
|
2009-02-04 21:26:08 +01:00
|
|
|
if open_transactions == 0
|
|
|
|
commit_db_transaction
|
|
|
|
else
|
|
|
|
release_savepoint
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
rescue Exception => database_transaction_rollback
|
2009-02-04 21:26:08 +01:00
|
|
|
if open_transactions == 0
|
|
|
|
rollback_db_transaction
|
|
|
|
else
|
|
|
|
rollback_to_savepoint
|
|
|
|
end
|
2007-12-21 08:48:59 +01:00
|
|
|
raise
|
|
|
|
end
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
# Begins the transaction (and turns off auto-committing).
|
|
|
|
def begin_db_transaction() end
|
|
|
|
|
|
|
|
# Commits the transaction (and turns on auto-committing).
|
|
|
|
def commit_db_transaction() end
|
|
|
|
|
|
|
|
# Rolls back the transaction (and turns on auto-committing). Must be
|
|
|
|
# done if the transaction block raises an exception or returns false.
|
|
|
|
def rollback_db_transaction() end
|
|
|
|
|
2008-06-02 08:35:38 +02:00
|
|
|
# Alias for <tt>add_limit_offset!</tt>.
|
2007-01-22 14:43:50 +01:00
|
|
|
def add_limit!(sql, options)
|
|
|
|
add_limit_offset!(sql, options) if options
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
# Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
|
|
|
|
# fragment that has the same semantics as LIMIT and OFFSET.
|
|
|
|
#
|
|
|
|
# +options+ must be a Hash which contains a +:limit+ option (required)
|
|
|
|
# and an +:offset+ option (optional).
|
|
|
|
#
|
2007-01-22 14:43:50 +01:00
|
|
|
# This method *modifies* the +sql+ parameter.
|
2008-10-27 07:47:01 +01:00
|
|
|
#
|
2007-01-22 14:43:50 +01:00
|
|
|
# ===== Examples
|
|
|
|
# add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
|
|
|
|
# generates
|
|
|
|
# SELECT * FROM suppliers LIMIT 10 OFFSET 50
|
|
|
|
def add_limit_offset!(sql, options)
|
|
|
|
if limit = options[:limit]
|
2008-06-02 08:35:38 +02:00
|
|
|
sql << " LIMIT #{sanitize_limit(limit)}"
|
2007-01-22 14:43:50 +01:00
|
|
|
if offset = options[:offset]
|
2008-06-02 08:35:38 +02:00
|
|
|
sql << " OFFSET #{offset.to_i}"
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
2008-06-02 08:35:38 +02:00
|
|
|
sql
|
|
|
|
end
|
|
|
|
|
2007-12-21 08:48:59 +01:00
|
|
|
# Appends a locking clause to an SQL statement.
|
|
|
|
# This method *modifies* the +sql+ parameter.
|
2007-02-09 09:04:31 +01:00
|
|
|
# # SELECT * FROM suppliers FOR UPDATE
|
|
|
|
# add_lock! 'SELECT * FROM suppliers', :lock => true
|
|
|
|
# add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
|
|
|
|
def add_lock!(sql, options)
|
|
|
|
case lock = options[:lock]
|
2007-12-21 08:48:59 +01:00
|
|
|
when true; sql << ' FOR UPDATE'
|
|
|
|
when String; sql << " #{lock}"
|
2007-02-09 09:04:31 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2007-01-22 14:43:50 +01:00
|
|
|
def default_sequence_name(table, column)
|
|
|
|
nil
|
|
|
|
end
|
|
|
|
|
|
|
|
# Set the sequence to the max value of the table's column.
|
|
|
|
def reset_sequence!(table, column, sequence = nil)
|
|
|
|
# Do nothing by default. Implement for PostgreSQL, Oracle, ...
|
|
|
|
end
|
2007-02-09 09:04:31 +01:00
|
|
|
|
2007-12-21 08:48:59 +01:00
|
|
|
# Inserts the given fixture into the table. Overridden in adapters that require
|
|
|
|
# something beyond a simple insert (eg. Oracle).
|
|
|
|
def insert_fixture(fixture, table_name)
|
|
|
|
execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
|
|
|
|
end
|
|
|
|
|
|
|
|
def empty_insert_statement(table_name)
|
|
|
|
"INSERT INTO #{quote_table_name(table_name)} VALUES(DEFAULT)"
|
|
|
|
end
|
|
|
|
|
2008-10-27 07:47:01 +01:00
|
|
|
def case_sensitive_equality_operator
|
|
|
|
"="
|
|
|
|
end
|
|
|
|
|
|
|
|
def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
|
|
|
|
"WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
|
|
|
|
end
|
|
|
|
|
2007-02-09 09:04:31 +01:00
|
|
|
protected
|
|
|
|
# Returns an array of record hashes with the column names as keys and
|
|
|
|
# column values as values.
|
|
|
|
def select(sql, name = nil)
|
|
|
|
end
|
2009-02-04 21:26:08 +01:00
|
|
|
undef_method :select
|
2007-12-21 08:48:59 +01:00
|
|
|
|
|
|
|
# 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
|
2008-10-27 07:47:01 +01:00
|
|
|
|
|
|
|
# Sanitizes the given LIMIT parameter in order to prevent SQL injection.
|
|
|
|
#
|
|
|
|
# +limit+ may be anything that can evaluate to a string via #to_s. It
|
|
|
|
# should look like an integer, or a comma-delimited list of integers.
|
|
|
|
#
|
|
|
|
# Returns the sanitized limit parameter, either as an integer, or as a
|
|
|
|
# string which contains a comma-delimited list of integers.
|
|
|
|
def sanitize_limit(limit)
|
|
|
|
if limit.to_s =~ /,/
|
|
|
|
limit.to_s.split(',').map{ |i| i.to_i }.join(',')
|
|
|
|
else
|
|
|
|
limit.to_i
|
|
|
|
end
|
|
|
|
end
|
2007-01-22 14:43:50 +01:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|