module ActiveRecord::ConnectionAdapters::DatabaseStatements

def add_limit!(sql, options)
  add_limit_offset!(sql, options) if options
end

def add_limit_offset!(sql, options)
  if limit = options[:limit]
    sql << " LIMIT #{sanitize_limit(limit)}"
    if offset = options[:offset]
      sql << " OFFSET #{offset.to_i}"
    end
  end
  sql
end

def add_lock!(sql, options)
  case lock = options[:lock]
    when true;   sql << ' FOR UPDATE'
    when String; sql << " #{lock}"
  end
end

def begin_db_transaction()    end

def case_sensitive_equality_operator
  "="
end

def commit_db_transaction()   end

def default_sequence_name(table, column)
  nil
end

def delete(sql, name = nil)
  delete_sql(sql, name)
end

def delete_sql(sql, name = nil)
  update_sql(sql, name)
end

def empty_insert_statement(table_name)
  "INSERT INTO #{quote_table_name(table_name)} VALUES(DEFAULT)"
end

def execute(sql, name = nil, skip_logging = false)
end

def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
  insert_sql(sql, name, pk, id_value, sequence_name)
end

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 insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
  execute(sql, name)
  id_value
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

def outside_transaction?
  nil
end

def reset_sequence!(table, column, sequence = nil)
  # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
end

def rollback_db_transaction() end

def sanitize_limit(limit)
  if limit.to_s =~ /,/
    limit.to_s.split(',').map{ |i| i.to_i }.join(',')
  else
    limit.to_i
  end
end

def select(sql, name = nil)
end

def select_all(sql, name = nil)
  select(sql, name)
end

def select_one(sql, name = nil)
  result = select_all(sql, name)
  result.first if result
end

def select_rows(sql, name = nil)
end

def select_value(sql, name = nil)
  if result = select_one(sql, name)
    result.values.first
  end
end

def select_values(sql, name = nil)
  result = select_rows(sql, name)
  result.map { |v| v[0] }
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
  transaction_open = false
  begin
    if block_given?
      if requires_new || open_transactions == 0
        if open_transactions == 0
          begin_db_transaction
        elsif requires_new
          create_savepoint
        end
        increment_open_transactions
        transaction_open = true
      end
      yield
    end
  rescue Exception => database_transaction_rollback
    if transaction_open && !outside_transaction?
      transaction_open = false
      decrement_open_transactions
      if open_transactions == 0
        rollback_db_transaction
      else
        rollback_to_savepoint
      end
    end
    raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
  end
ensure
  @transaction_joinable = last_transaction_joinable
  if outside_transaction?
    @open_transactions = 0
  elsif transaction_open
    decrement_open_transactions
    begin
      if open_transactions == 0
        commit_db_transaction
      else
        release_savepoint
      end
    rescue Exception => database_transaction_rollback
      if open_transactions == 0
        rollback_db_transaction
      else
        rollback_to_savepoint
      end
      raise
    end
  end
end

def update(sql, name = nil)
  update_sql(sql, name)
end

def update_sql(sql, name = nil)
  execute(sql, name)
end