Active Record SQLite3
Adapter
The SQLite3
adapter works with the sqlite3-ruby drivers (available as gem from rubygems.org/gems/sqlite3).
Options:
-
:database
- Path to the database file.
- A
- C
- D
- E
- F
- N
- R
- S
-
- strict_strings_by_default,
- supports_check_constraints?,
- supports_common_table_expressions?,
- supports_concurrent_connections?,
- supports_datetime_with_precision?,
- supports_ddl_transactions?,
- supports_deferrable_constraints?,
- supports_explain?,
- supports_expression_index?,
- supports_foreign_keys?,
- supports_index_sort_order?,
- supports_insert_conflict_target?,
- supports_insert_on_conflict?,
- supports_insert_on_duplicate_skip?,
- supports_insert_on_duplicate_update?,
- supports_insert_returning?,
- supports_json?,
- supports_lazy_transactions?,
- supports_partial_index?,
- supports_savepoints?,
- supports_transaction_isolation?,
- supports_views?,
- supports_virtual_columns?
- V
Constants
ADAPTER_NAME | = | "SQLite" |
COLLATE_REGEX | = | /.*"(\w+)".*collate\s+"(\w+)".*/i |
DEFAULT_PRAGMAS | = | { "foreign_keys" => true, "journal_mode" => :wal, "synchronous" => :normal, "mmap_size" => 134217728, # 128 megabytes "journal_size_limit" => 67108864, # 64 megabytes "cache_size" => 2000 } |
DEFERRABLE_REGEX | = | /DEFERRABLE INITIALLY (\w+)/ |
EXTENDED_TYPE_MAPS | = | Concurrent::Map.new |
FINAL_CLOSE_PARENS_REGEX | = | /\);*\z/ |
FK_REGEX | = | /.*FOREIGN KEY\s+\("([^"]+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/ |
GENERATED_ALWAYS_AS_REGEX | = | /.*"(\w+)".+GENERATED ALWAYS AS \((.+)\) (?:STORED|VIRTUAL)/i |
NATIVE_DATABASE_TYPES | = | { primary_key: "integer PRIMARY KEY AUTOINCREMENT NOT NULL", string: { name: "varchar" }, text: { name: "text" }, integer: { name: "integer" }, float: { name: "float" }, decimal: { name: "decimal" }, datetime: { name: "datetime" }, time: { name: "time" }, date: { name: "date" }, binary: { name: "blob" }, boolean: { name: "boolean" }, json: { name: "json" }, } |
PRIMARY_KEY_AUTOINCREMENT_REGEX | = | /.*"(\w+)".+PRIMARY KEY AUTOINCREMENT/i |
TYPE_MAP | = | Type::TypeMap.new.tap { |m| initialize_type_map(m) } |
UNQUOTED_OPEN_PARENS_REGEX | = | /\((?![^'"]*['"][^'"]*$)/ |
VIRTUAL_TABLE_REGEX | = | /USING\s+(\w+)\s*\((.+)\)/i |
Class Public methods
dbconsole(config, options = {}) Link
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 44 def dbconsole(config, options = {}) args = [] args << "-#{options[:mode]}" if options[:mode] args << "-header" if options[:header] args << File.expand_path(config.database, Rails.respond_to?(:root) ? Rails.root : nil) find_cmd_and_exec(ActiveRecord.database_cli[:sqlite], *args) end
new(...) Link
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 102 def initialize(...) super @memory_database = false case @config[:database].to_s when "" raise ArgumentError, "No database file specified. Missing argument: database" when ":memory:" @memory_database = true when /\Afile:/ else # Otherwise we have a path relative to Rails.root @config[:database] = File.expand_path(@config[:database], Rails.root) if defined?(Rails.root) dirname = File.dirname(@config[:database]) unless File.directory?(dirname) begin FileUtils.mkdir_p(dirname) rescue SystemCallError raise ActiveRecord::NoDatabaseError.new(connection_pool: @pool) end end end @last_affected_rows = nil @previous_read_uncommitted = nil @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict) @connection_parameters = @config.merge( database: @config[:database].to_s, results_as_hash: true, default_transaction_mode: :immediate, ) end
new_client(config) Link
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 34 def new_client(config) ::SQLite3::Database.new(config[:database].to_s, config) rescue Errno::ENOENT => error if error.message.include?("No such file or directory") raise ActiveRecord::NoDatabaseError else raise end end
strict_strings_by_default Link
Configure the SQLite3Adapter
to be used in a strict strings mode. This will disable double-quoted string literals, because otherwise typos can silently go unnoticed. For example, it is possible to create an index for a non existing column. If you wish to enable this mode you can add the following line to your application.rb file:
config.active_record.sqlite3_adapter_strict_strings_by_default = true
Instance Public methods
add_timestamps(table_name, **options) Link
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 392 def add_timestamps(table_name, **options) options[:null] = false if options[:null].nil? if !options.key?(:precision) options[:precision] = 6 end alter_table(table_name) do |definition| definition.column :created_at, :datetime, **options definition.column :updated_at, :datetime, **options end end
create_virtual_table(table_name, module_name, values) Link
Creates a virtual table
Example:
create_virtual_table :emails, :fts5, ['sender', 'title',' body']
database_exists?() Link
disconnect!() Link
Disconnects from the database if already connected. Otherwise, this method does nothing.
drop_virtual_table(table_name, module_name, values, **options) Link
Drops a virtual table
Although this command ignores module_name
and values
, it can be helpful to provide these in a migration’s change
method so it can be reverted. In that case, module_name
, values
and options
will be used by create_virtual_table
.
encoding() Link
Returns the current database encoding format as a string, e.g. ‘UTF-8’
foreign_keys(table_name) Link
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 412 def foreign_keys(table_name) # SQLite returns 1 row for each column of composite foreign keys. fk_info = internal_exec_query("PRAGMA foreign_key_list(#{quote(table_name)})", "SCHEMA") # Deferred or immediate foreign keys can only be seen in the CREATE TABLE sql fk_defs = table_structure_sql(table_name) .select do |column_string| column_string.start_with?("CONSTRAINT") && column_string.include?("FOREIGN KEY") end .to_h do |fk_string| _, from, table, to = fk_string.match(FK_REGEX).to_a _, mode = fk_string.match(DEFERRABLE_REGEX).to_a deferred = mode&.downcase&.to_sym || false [[table, from, to], deferred] end grouped_fk = fk_info.group_by { |row| row["id"] }.values.each { |group| group.sort_by! { |row| row["seq"] } } grouped_fk.map do |group| row = group.first options = { on_delete: extract_foreign_key_action(row["on_delete"]), on_update: extract_foreign_key_action(row["on_update"]), deferrable: fk_defs[[row["table"], row["from"], row["to"]]] } if group.one? options[:column] = row["from"] options[:primary_key] = row["to"] else options[:column] = group.map { |row| row["from"] } options[:primary_key] = group.map { |row| row["to"] } end ForeignKeyDefinition.new(table_name, row["table"], options) end end
rename_table(table_name, new_name, **options) Link
Renames a table.
Example:
rename_table('octopuses', 'octopi')
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 325 def rename_table(table_name, new_name, **options) validate_table_length!(new_name) unless options[:_uses_legacy_table_name] schema_cache.clear_data_source_cache!(table_name.to_s) schema_cache.clear_data_source_cache!(new_name.to_s) exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}" rename_table_indexes(table_name, new_name, **options) end
requires_reloading?() Link
supports_check_constraints?() Link
supports_common_table_expressions?() Link
supports_concurrent_connections?() Link
supports_datetime_with_precision?() Link
supports_ddl_transactions?() Link
supports_deferrable_constraints?() Link
supports_explain?() Link
supports_expression_index?() Link
supports_foreign_keys?() Link
supports_index_sort_order?() Link
supports_insert_on_conflict?() Link
supports_insert_returning?() Link
supports_json?() Link
supports_lazy_transactions?() Link
supports_partial_index?() Link
supports_savepoints?() Link
supports_transaction_isolation?() Link
supports_views?() Link
supports_virtual_columns?() Link
virtual_tables() Link
Returns a list of defined virtual tables
# File activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb, line 292 def virtual_tables query = <<~SQL SELECT name, sql FROM sqlite_master WHERE sql LIKE 'CREATE VIRTUAL %'; SQL exec_query(query, "SCHEMA").cast_values.each_with_object({}) do |row, memo| table_name, sql = row[0], row[1] _, module_name, arguments = sql.match(VIRTUAL_TABLE_REGEX).to_a memo[table_name] = [module_name, arguments] end.to_a end