Module: ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements

Included in:
ActiveRecord::ConnectionAdapters::SQLite3Adapter
Defined in:
lib/active_record/connection_adapters/sqlite3/database_statements.rb

Instance Method Summary collapse

Instance Method Details

#begin_db_transaction ⇒ Object

:nodoc:



90
91
92
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 90

def begin_db_transaction #:nodoc:
  log("begin transaction", "TRANSACTION") { @connection.transaction }
end

#begin_isolated_db_transaction(isolation) ⇒ Object

:nodoc

Raises:



81
82
83
84
85
86
87
88
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 81

def begin_isolated_db_transaction(isolation) #:nodoc
  raise TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
  raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?

  Thread.current.thread_variable_set("read_uncommitted", @connection.get_first_value("PRAGMA read_uncommitted"))
  @connection.read_uncommitted = true
  begin_db_transaction
end

#commit_db_transaction ⇒ Object

:nodoc:



94
95
96
97
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 94

def commit_db_transaction #:nodoc:
  log("commit transaction", "TRANSACTION") { @connection.commit }
  reset_read_uncommitted
end

#exec_delete(sql, name = "SQL", binds = []) ⇒ Object Also known as: exec_update 



75
76
77
78
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 75

def exec_delete(sql, name = "SQL", binds = [])
  exec_query(sql, name, binds)
  @connection.changes
end

#exec_query(sql, name = nil, binds = [], prepare: false) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 38

def exec_query(sql, name = nil, binds = [], prepare: false)
  if preventing_writes? && write_query?(sql)
    raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
  end

  materialize_transactions
  mark_transaction_written_if_write(sql)

  type_casted_binds = type_casted_binds(binds)

  log(sql, name, binds, type_casted_binds) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      # Don't cache statements if they are not prepared
      unless prepare
        stmt = @connection.prepare(sql)
        begin
          cols = stmt.columns
          unless without_prepared_statement?(binds)
            stmt.bind_params(type_casted_binds)
          end
          records = stmt.to_a
        ensure
          stmt.close
        end
      else
        stmt = @statements[sql] ||= @connection.prepare(sql)
        cols = stmt.columns
        stmt.reset!
        stmt.bind_params(type_casted_binds)
        records = stmt.to_a
      end

      build_result(columns: cols, rows: records)
    end
  end
end

#exec_rollback_db_transaction ⇒ Object

:nodoc:



99
100
101
102
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 99

def exec_rollback_db_transaction #:nodoc:
  log("rollback transaction", "TRANSACTION") { @connection.rollback }
  reset_read_uncommitted
end

#execute(sql, name = nil) ⇒ Object

:nodoc:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 23

def execute(sql, name = nil) #:nodoc:
  if preventing_writes? && write_query?(sql)
    raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
  end

  materialize_transactions
  mark_transaction_written_if_write(sql)

  log(sql, name) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      @connection.execute(sql)
    end
  end
end

#explain(arel, binds = []) ⇒ Object 



18
19
20
21
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 18

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

#write_query?(sql) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


12
13
14
15
16
 
# File 'lib/active_record/connection_adapters/sqlite3/database_statements.rb', line 12

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