module ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements

def begin_db_transaction # :nodoc:

:nodoc:
Begins a transaction. 
def begin_db_transaction # :nodoc:
  execute("BEGIN", "TRANSACTION")
end

def begin_isolated_db_transaction(isolation) # :nodoc:

:nodoc: 
def begin_isolated_db_transaction(isolation) # :nodoc:
  begin_db_transaction
  execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
end

def build_truncate_statements(table_names) 

def build_truncate_statements(table_names)
  ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
end

def commit_db_transaction # :nodoc:

:nodoc:
Commits a transaction. 
def commit_db_transaction # :nodoc:
  execute("COMMIT", "TRANSACTION")
end

def exec_delete(sql, name = nil, binds = []) # :nodoc:

:nodoc: 
def exec_delete(sql, name = nil, binds = []) # :nodoc:
  execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
end

def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :nodoc:

:nodoc: 
def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :nodoc:
  if use_insert_returning? || pk == false
    super
  else
    result = exec_query(sql, name, binds)
    unless sequence_name
      table_ref = extract_table_ref_from_insert_sql(sql)
      if table_ref
        pk = primary_key(table_ref) if pk.nil?
        pk = suppress_composite_primary_key(pk)
        sequence_name = default_sequence_name(table_ref, pk)
      end
      return result unless sequence_name
    end
    last_insert_id_result(sequence_name)
  end
end

def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:

:nodoc: 
def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
  execute_and_clear(sql, name, binds, prepare: prepare, async: async) do |result|
    types = {}
    fields = result.fields
    fields.each_with_index do |fname, i|
      ftype = result.ftype i
      fmod  = result.fmod i
      types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
    end
    build_result(columns: fields, rows: result.values, column_types: types)
  end
end

def exec_rollback_db_transaction # :nodoc:

:nodoc:
Aborts a transaction. 
def exec_rollback_db_transaction # :nodoc:
  execute("ROLLBACK", "TRANSACTION")
end

def execute(sql, name = nil)

need it specifically, you may want consider the exec_query wrapper.
Note: the PG::Result object is manually memory managed; if you don't
or raising a PG::Error exception otherwise.
Executes an SQL statement, returning a PG::Result object on success 
def execute(sql, name = nil)
  sql = transform_query(sql)
  check_if_write_query(sql)
  materialize_transactions
  mark_transaction_written_if_write(sql)
  log(sql, name) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      @connection.async_exec(sql)
    end
  end
end

def execute_batch(statements, name = nil) 

def execute_batch(statements, name = nil)
  execute(combine_multi_statements(statements))
end

def explain(arel, binds = []) 

def explain(arel, binds = [])
  sql = "EXPLAIN #{to_sql(arel, binds)}"
  PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", binds))
end

def high_precision_current_timestamp 

def high_precision_current_timestamp
  HIGH_PRECISION_CURRENT_TIMESTAMP
end

def last_insert_id_result(sequence_name)

Returns the current ID of a table's sequence. 
def last_insert_id_result(sequence_name)
  exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
end

def query(sql, name = nil) # :nodoc:

:nodoc:
Queries the database and returns the results in an Array-like object 
def query(sql, name = nil) # :nodoc:
  materialize_transactions
  mark_transaction_written_if_write(sql)
  log(sql, name) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      @connection.async_exec(sql).map_types!(@type_map_for_results).values
    end
  end
end

def sql_for_insert(sql, pk, binds) # :nodoc:

:nodoc: 
def sql_for_insert(sql, pk, binds) # :nodoc:
  if pk.nil?
    # Extract the table from the insert sql. Yuck.
    table_ref = extract_table_ref_from_insert_sql(sql)
    pk = primary_key(table_ref) if table_ref
  end
  if pk = suppress_composite_primary_key(pk)
    sql = "#{sql} RETURNING #{quote_column_name(pk)}"
  end
  super
end

def suppress_composite_primary_key(pk) 

def suppress_composite_primary_key(pk)
  pk unless pk.is_a?(Array)
end

def write_query?(sql) # :nodoc:

:nodoc: 
def write_query?(sql) # :nodoc:
  !READ_QUERY.match?(sql)
rescue ArgumentError # Invalid encoding
  !READ_QUERY.match?(sql.b)
end