module ActiveRecord::ConnectionAdapters::DatabaseStatements

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 6
def initialize
  super
  reset_transaction
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 424
def add_transaction_record(record, ensure_finalize = true)
  current_transaction.add_record(record, ensure_finalize)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 429
def begin_db_transaction()    end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 454
def begin_isolated_db_transaction(isolation)
  raise ActiveRecord::TransactionIsolationError, "adapter does not support setting transaction isolation"
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 468
def commit_db_transaction()   end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 490
def default_sequence_name(table, column)
  nil
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 215
def delete(arel, name = nil, binds = [])
  sql, binds = to_sql_and_binds(arel, binds)
  exec_delete(sql, name, binds)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 520
def empty_insert_statement_value(primary_key = nil)
  "DEFAULT VALUES"
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 168
def exec_delete(sql, name = nil, binds = [])
  affected_rows(internal_execute(sql, name, binds))
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 160
def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
  sql, binds = sql_for_insert(sql, pk, binds, returning)
  internal_exec_query(sql, name, binds)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 150
def exec_query(sql, name = "SQL", binds = [], prepare: false)
  internal_exec_query(sql, name, binds, prepare: prepare)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 175
def exec_update(sql, name = nil, binds = [])
  affected_rows(internal_execute(sql, name, binds))
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 139
def execute(sql, name = nil, allow_retry: false)
  internal_execute(sql, name, allow_retry: allow_retry)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 544
def high_precision_current_timestamp
  HIGH_PRECISION_CURRENT_TIMESTAMP
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 198
def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
  sql, binds = to_sql_and_binds(arel, binds)
  value = exec_insert(sql, name, binds, pk, sequence_name, returning: returning)

  return returning_column_values(value) unless returning.nil?

  id_value || last_inserted_id(value)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 504
def insert_fixture(fixture, table_name)
  execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 508
def insert_fixtures_set(fixture_set, tables_to_delete = [])
  fixture_inserts = build_fixture_statements(fixture_set)
  table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
  statements = table_deletes + fixture_inserts

  transaction(requires_new: true) do
    disable_referential_integrity do
      execute_batch(statements, "Fixtures Load")
    end
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 464
def reset_isolation_level
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 495
def reset_sequence!(table, column, sequence = nil)
  # Do nothing by default. Implement for PostgreSQL, Oracle, ...
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 480
def restart_db_transaction
  exec_restart_db_transaction
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 472
def rollback_db_transaction
  exec_rollback_db_transaction
rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::ConnectionFailed
  # Connection's gone; that counts as a rollback
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 486
def rollback_to_savepoint(name = nil)
  exec_rollback_to_savepoint(name)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 72
def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
  arel = arel_from_relation(arel)
  sql, binds, preparable, allow_retry = to_sql_and_binds(arel, binds, preparable, allow_retry)

  select(sql, name, binds,
    prepare: prepared_statements && preparable,
    async: async && FutureResult::SelectAll,
    allow_retry: allow_retry
  )
rescue ::RangeError
  ActiveRecord::Result.empty(async: async)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 87
def select_one(arel, name = nil, binds = [], async: false)
  select_all(arel, name, binds, async: async).then(&:first)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 104
def select_rows(arel, name = nil, binds = [], async: false)
  select_all(arel, name, binds, async: async).then(&:rows)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 92
def select_value(arel, name = nil, binds = [], async: false)
  select_rows(arel, name, binds, async: async).then { |rows| single_value_from_rows(rows) }
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 98
def select_values(arel, name = nil, binds = [])
  select_rows(arel, name, binds).map(&:first)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 12
def to_sql(arel_or_sql_string, binds = [])
  sql, _ = to_sql_and_binds(arel_or_sql_string, binds)
  sql
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 355
def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
  # If we're running inside the single, non-joinable transaction that
  # ActiveRecord::TestFixtures starts around each example (depth == 1),
  # an `isolation:` hint must be validated then ignored so that the
  # adapter isn't asked to change the isolation level mid-transaction.
  if isolation && !requires_new && open_transactions == 1 && !current_transaction.joinable?
    iso = isolation.to_sym

    unless transaction_isolation_levels.include?(iso)
      raise ActiveRecord::TransactionIsolationError,
            "invalid transaction isolation level: #{iso.inspect}"
    end

    current_transaction.isolation = iso
    isolation = nil
  end

  if !requires_new && current_transaction.joinable?
    if isolation && current_transaction.isolation != isolation
      raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
    end
    yield current_transaction.user_transaction
  else
    within_new_transaction(isolation: isolation, joinable: joinable, &block)
  end
rescue ActiveRecord::Rollback
  # rollbacks are silently swallowed
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 447
def transaction_isolation_levels
  TRANSACTION_ISOLATION_LEVELS
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 398
def transaction_open?
  current_transaction.open?
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 221
def truncate(table_name, name = nil)
  execute(build_truncate_statement(table_name), name)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 209
def update(arel, name = nil, binds = [])
  sql, binds = to_sql_and_binds(arel, binds)
  exec_update(sql, name, binds)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 121
def write_query?(sql)
  raise NotImplementedError
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 590
def affected_rows(raw_result)
  raise NotImplementedError
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 747
def arel_from_relation(relation)
  if relation.is_a?(Relation)
    relation.arel
  else
    relation
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 622
def build_fixture_sql(fixtures, table_name)
  columns = schema_cache.columns_hash(table_name).reject { |_, column| supports_virtual_columns? && column.virtual? }

  values_list = fixtures.map do |fixture|
    fixture = fixture.stringify_keys

    unknown_columns = fixture.keys - columns.keys
    if unknown_columns.any?
      raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
    end

    columns.map do |name, column|
      if fixture.key?(name)
        # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
        with_yaml_fallback(column.fetch_cast_type(self).serialize(fixture[name]))
      else
        default_insert_value(column)
      end
    end
  end

  table = Arel::Table.new(table_name)
  manager = Arel::InsertManager.new(table)

  if values_list.size == 1
    values = values_list.shift
    new_values = []
    columns.each_key.with_index { |column, i|
      unless values[i].equal?(DEFAULT_INSERT_VALUE)
        new_values << values[i]
        manager.columns << table[column]
      end
    }
    values_list << new_values
  else
    columns.each_key { |column| manager.columns << table[column] }
  end

  manager.values = manager.create_values_list(values_list)
  visitor.compile(manager.ast)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 664
def build_fixture_statements(fixture_set)
  fixture_set.filter_map do |table_name, fixtures|
    next if fixtures.empty?
    build_fixture_sql(fixtures, table_name)
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 671
def build_truncate_statement(table_name)
  "TRUNCATE TABLE #{quote_table_name(table_name)}"
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 675
def build_truncate_statements(table_names)
  table_names.map do |table_name|
    build_truncate_statement(table_name)
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 586
def cast_result(raw_result)
  raise NotImplementedError
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 681
def combine_multi_statements(total_sql)
  total_sql.join(";\n")
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 616
def execute_batch(statements, name = nil, **kwargs)
  statements.each do |statement|
    raw_execute(statement, name, **kwargs)
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 755
def extract_table_ref_from_insert_sql(sql)
  if sql =~ /into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im
    $1.delete('"').strip
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 582
def handle_warnings(raw_result, sql)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 611
def internal_execute(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, &block)
  sql = preprocess_query(sql)
  raw_execute(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions, &block)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 734
def last_inserted_id(result)
  single_value_from_rows(result.rows)
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 578
def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
  raise NotImplementedError
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 594
def preprocess_query(sql)
  if write_query?(sql)
    ensure_writes_are_allowed(sql)
    mark_transaction_written
  end

  # We call tranformers after the write checks so we don't add extra parsing work.
  # This means we assume no transformer whille change a read for a write
  # but it would be insane to do such a thing.
  ActiveRecord.query_transformers.each do |transformer|
    sql = transformer.call(sql, self)
  end

  sql
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 567
def raw_execute(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
  type_casted_binds = type_casted_binds(binds)
  log(sql, name, binds, type_casted_binds, async: async, allow_retry: allow_retry) do |notification_payload|
    with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
      result = perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
      handle_warnings(result, sql)
      result
    end
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 738
def returning_column_values(result)
  [last_inserted_id(result)]
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 686
def select(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false)
  if async && async_enabled?
    if current_transaction.joinable?
      raise AsynchronousQueryInsideTransactionError, "Asynchronous queries are not allowed inside transactions"
    end

    # We make sure to run query transformers on the original thread
    sql = preprocess_query(sql)
    future_result = async.new(
      pool,
      sql,
      name,
      binds,
      prepare: prepare,
    )
    if supports_concurrent_connections? && !current_transaction.joinable?
      future_result.schedule!(ActiveRecord::Base.asynchronous_queries_session)
    else
      future_result.execute!(self)
    end
    future_result
  else
    result = internal_exec_query(sql, name, binds, prepare: prepare, allow_retry: allow_retry)
    if async
      FutureResult.wrap(result)
    else
      result
    end
  end
end

# File lib/active_record/connection_adapters/abstract/database_statements.rb, line 742
def single_value_from_rows(rows)
  row = rows.first
  row && row.first
end