Class: ActiveRecord::ConnectionAdapters::SQLiteAdapter

Inherits:
AbstractAdapter show all
Defined in:
lib/active_record/connection_adapters/sqlite_adapter.rb

Overview

The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby drivers (available both as gems and from rubyforge.org/projects/sqlite-ruby/).

Options:

  • :database - Path to the database file.

Direct Known Subclasses

SQLite3Adapter

Defined Under Namespace

Classes: Version

Instance Attribute Summary

Attributes inherited from AbstractAdapter

#visitor

Attributes included from QueryCache

#query_cache, #query_cache_enabled

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from AbstractAdapter

#active?, #case_sensitive_modifier, #current_savepoint_name, #decrement_open_transactions, #disable_referential_integrity, #increment_open_transactions, #open_transactions, #prefetch_primary_key?, #quote_table_name, #raw_connection, #reconnect!, #reset!, #substitute_at, #supports_bulk_alter?, #transaction_joinable=, #verify!

Methods included from QueryCache

#cache, #clear_query_cache, dirties_query_cache, #disable_query_cache!, #enable_query_cache!, included, #select_all, #uncached

Methods included from DatabaseLimits

#column_name_length, #columns_per_multicolumn_index, #columns_per_table, #in_clause_length, #index_name_length, #indexes_per_table, #joins_per_query, #sql_query_length, #table_alias_length, #table_name_length

Methods included from Quoting

#quote, #quote_table_name, #quoted_false, #quoted_true

Methods included from DatabaseStatements

#add_limit_offset!, #add_transaction_record, #case_sensitive_equality_operator, #default_sequence_name, #delete, #exec_insert, #insert, #insert_fixture, #join_to_update, #limited_update_conditions, #outside_transaction?, #reset_sequence!, #sanitize_limit, #select_all, #select_one, #select_value, #select_values, #to_sql, #transaction, #update

Methods included from SchemaStatements

#add_column_options!, #add_index, #add_timestamps, #assume_migrated_upto_version, #change_table, #column_exists?, #create_table, #distinct, #drop_table, #dump_schema_information, #index_exists?, #index_name, #index_name_exists?, #initialize_schema_migrations_table, #remove_index, #remove_timestamps, #rename_index, #structure_dump, #table_alias_for, #table_exists?, #type_to_sql

Constructor Details

#initialize(connection, logger, config) ⇒ SQLiteAdapter

Returns a new instance of SQLiteAdapter.



51
52
53
54
55
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 51

def initialize(connection, logger, config)
  super(connection, logger)
  @statements = {}
  @config = config
end

Class Method Details

.visitor_for(pool) ⇒ Object

:nodoc:



57
58
59
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 57

def self.visitor_for(pool) # :nodoc:
  Arel::Visitors::SQLite.new(pool)
end

Instance Method Details

#adapter_name ⇒ Object

:nodoc:



61
62
63
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 61

def adapter_name #:nodoc:
  'SQLite'
end

#add_column(table_name, column_name, type, options = {}) ⇒ Object

:nodoc:



322
323
324
325
326
327
328
329
330
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 322

def add_column(table_name, column_name, type, options = {}) #:nodoc:
  if supports_add_column? && valid_alter_table_options( type, options )
    super(table_name, column_name, type, options)
  else
    alter_table(table_name) do |definition|
      definition.column(column_name, type, options)
    end
  end
end

#begin_db_transaction ⇒ Object

:nodoc:



242
243
244
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 242

def begin_db_transaction #:nodoc:
  @connection.transaction
end

#change_column(table_name, column_name, type, options = {}) ⇒ Object

:nodoc:



357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 357

def change_column(table_name, column_name, type, options = {}) #:nodoc:
  alter_table(table_name) do |definition|
    include_default = options_include_default?(options)
    definition[column_name].instance_eval do
      self.type    = type
      self.limit   = options[:limit] if options.include?(:limit)
      self.default = options[:default] if include_default
      self.null    = options[:null] if options.include?(:null)
    end
  end
end

#change_column_default(table_name, column_name, default) ⇒ Object

:nodoc:



342
343
344
345
346
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 342

def change_column_default(table_name, column_name, default) #:nodoc:
  alter_table(table_name) do |definition|
    definition[column_name].default = default
  end
end

#change_column_null(table_name, column_name, null, default = nil) ⇒ Object 



348
349
350
351
352
353
354
355
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 348

def change_column_null(table_name, column_name, null, default = nil)
  unless null || default.nil?
    exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
  end
  alter_table(table_name) do |definition|
    definition[column_name].null = null
  end
end

#clear_cache! ⇒ Object

Clears the prepared statements cache.



109
110
111
112
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 109

def clear_cache!
  @statements.values.each { |hash| hash[:stmt].close }
  @statements.clear
end

#columns(table_name, name = nil) ⇒ Object

Returns an array of SQLiteColumn objects for the table specified by table_name.



269
270
271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 269

def columns(table_name, name = nil) #:nodoc:
  table_structure(table_name).map do |field|
    case field["dflt_value"]
    when /^null$/i
      field["dflt_value"] = nil
    when /^'(.*)'$/
      field["dflt_value"] = $1.gsub(/''/, "'")
    when /^"(.*)"$/
      field["dflt_value"] = $1.gsub(/""/, '"')
    end

    SQLiteColumn.new(field['name'], field['dflt_value'], field['type'], field['notnull'].to_i == 0)
  end
end

#commit_db_transaction ⇒ Object

:nodoc:



246
247
248
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 246

def commit_db_transaction #:nodoc:
  @connection.commit
end

#create_savepoint ⇒ Object 



230
231
232
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 230

def create_savepoint
  execute("SAVEPOINT #{current_savepoint_name}")
end

#delete_sql(sql, name = nil) ⇒ Object

:nodoc:



215
216
217
218
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 215

def delete_sql(sql, name = nil) #:nodoc:
  sql += " WHERE 1=1" unless sql =~ /WHERE/i
  super sql, name
end

#disconnect! ⇒ Object

Disconnects from the database if already connected. Otherwise, this method does nothing.



102
103
104
105
106
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 102

def disconnect!
  super
  clear_cache!
  @connection.close rescue nil
end

#empty_insert_statement_value ⇒ Object 



376
377
378
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 376

def empty_insert_statement_value
  "VALUES(NULL)"
end

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



196
197
198
199
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 196

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

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

DATABASE STATEMENTS ======================================



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 170

def exec_query(sql, name = nil, binds = [])
  log(sql, name, binds) do

    # Don't cache statements without bind values
    if binds.empty?
      stmt    = @connection.prepare(sql)
      cols    = stmt.columns
      records = stmt.to_a
      stmt.close
      stmt = records
    else
      cache = @statements[sql] ||= {
        :stmt => @connection.prepare(sql)
      }
      stmt = cache[:stmt]
      cols = cache[:cols] ||= stmt.columns
      stmt.reset!
      stmt.bind_params binds.map { |col, val|
        type_cast(val, col)
      }
    end

    ActiveRecord::Result.new(cols, stmt.to_a)
  end
end

#execute(sql, name = nil) ⇒ Object

:nodoc:



206
207
208
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 206

def execute(sql, name = nil) #:nodoc:
  log(sql, name) { @connection.execute(sql) }
end

#indexes(table_name, name = nil) ⇒ Object

Returns an array of indexes for the given table.



285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 285

def indexes(table_name, name = nil) #:nodoc:
  exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
    IndexDefinition.new(
      table_name,
      row['name'],
      row['unique'] != 0,
      exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
        col['name']
      })
  end
end

#insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) ⇒ Object Also known as: create

:nodoc:



220
221
222
223
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 220

def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
  super
  id_value || @connection.last_insert_row_id
end

#last_inserted_id(result) ⇒ Object 



202
203
204
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 202

def last_inserted_id(result)
  @connection.last_insert_row_id
end

#native_database_types ⇒ Object

:nodoc:



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 124

def native_database_types #:nodoc:
  {
    :primary_key => default_primary_key_type,
    :string      => { :name => "varchar", :limit => 255 },
    :text        => { :name => "text" },
    :integer     => { :name => "integer" },
    :float       => { :name => "float" },
    :decimal     => { :name => "decimal" },
    :datetime    => { :name => "datetime" },
    :timestamp   => { :name => "datetime" },
    :time        => { :name => "time" },
    :date        => { :name => "date" },
    :binary      => { :name => "blob" },
    :boolean     => { :name => "boolean" }
  }
end

#primary_key(table_name) ⇒ Object

:nodoc:



297
298
299
300
301
302
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 297

def primary_key(table_name) #:nodoc:
  column = table_structure(table_name).find { |field|
    field['pk'] == 1
  }
  column && column['name']
end

#quote_column_name(name) ⇒ Object

:nodoc:



148
149
150
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 148

def quote_column_name(name) #:nodoc:
  %Q("#{name.to_s.gsub('"', '""')}")
end

#quote_string(s) ⇒ Object

QUOTING ==================================================



144
145
146
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 144

def quote_string(s) #:nodoc:
  @connection.class.quote(s)
end

#quoted_date(value) ⇒ Object

Quote date/time values for use in SQL input. Includes microseconds if the value is a Time responding to usec.



154
155
156
157
158
159
160
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 154

def quoted_date(value) #:nodoc:
  if value.respond_to?(:usec)
    "#{super}.#{sprintf("%06d", value.usec)}"
  else
    super
  end
end

#release_savepoint ⇒ Object 



238
239
240
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 238

def release_savepoint
  execute("RELEASE SAVEPOINT #{current_savepoint_name}")
end

#remove_column(table_name, *column_names) ⇒ Object Also known as: remove_columns

:nodoc:

Raises:

  • (ArgumentError) 


332
333
334
335
336
337
338
339
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 332

def remove_column(table_name, *column_names) #:nodoc:
  raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
  column_names.flatten.each do |column_name|
    alter_table(table_name) do |definition|
      definition.columns.delete(definition[column_name])
    end
  end
end

#remove_index!(table_name, index_name) ⇒ Object

:nodoc:



304
305
306
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 304

def remove_index!(table_name, index_name) #:nodoc:
  exec_query "DROP INDEX #{quote_column_name(index_name)}"
end

#rename_column(table_name, column_name, new_column_name) ⇒ Object

:nodoc:



369
370
371
372
373
374
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 369

def rename_column(table_name, column_name, new_column_name) #:nodoc:
  unless columns(table_name).detect{|c| c.name == column_name.to_s }
    raise ActiveRecord::ActiveRecordError, "Missing column #{table_name}.#{column_name}"
  end
  alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s})
end

#rename_table(name, new_name) ⇒ Object

Renames a table.

Example:

rename_table('octopuses', 'octopi')



312
313
314
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 312

def rename_table(name, new_name)
  exec_query "ALTER TABLE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}"
end

#requires_reloading? ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 91

def requires_reloading?
  true
end

#rollback_db_transaction ⇒ Object

:nodoc:



250
251
252
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 250

def rollback_db_transaction #:nodoc:
  @connection.rollback
end

#rollback_to_savepoint ⇒ Object 



234
235
236
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 234

def rollback_to_savepoint
  execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
end

#select_rows(sql, name = nil) ⇒ Object 



226
227
228
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 226

def select_rows(sql, name = nil)
  exec_query(sql, name).rows
end

#supports_add_column? ⇒ Boolean

Returns true if SQLite version is ‘3.1.6’ or greater, false otherwise.

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 96

def supports_add_column?
  sqlite_version >= '3.1.6'
end

#supports_autoincrement? ⇒ Boolean

Returns true if SQLite version is ‘3.1.0’ or greater, false otherwise.

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 120

def supports_autoincrement? #:nodoc:
  sqlite_version >= '3.1.0'
end

#supports_count_distinct? ⇒ Boolean

Returns true if SQLite version is ‘3.2.6’ or greater, false otherwise.

Returns:

  • (Boolean) 


115
116
117
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 115

def supports_count_distinct? #:nodoc:
  sqlite_version >= '3.2.6'
end

#supports_ddl_transactions? ⇒ Boolean

Returns true if SQLite version is ‘2.0.0’ or greater, false otherwise.

Returns:

  • (Boolean) 


66
67
68
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 66

def supports_ddl_transactions?
  sqlite_version >= '2.0.0'
end

#supports_migrations? ⇒ Boolean

Returns true, since this connection adapter supports migrations.

Returns:

  • (Boolean) 


82
83
84
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 82

def supports_migrations? #:nodoc:
  true
end

#supports_primary_key? ⇒ Boolean

Returns true.

Returns:

  • (Boolean) 


87
88
89
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 87

def supports_primary_key? #:nodoc:
  true
end

#supports_savepoints? ⇒ Boolean

Returns true if SQLite version is ‘3.6.8’ or greater, false otherwise.

Returns:

  • (Boolean) 


71
72
73
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 71

def supports_savepoints?
  sqlite_version >= '3.6.8'
end

#supports_statement_cache? ⇒ Boolean

Returns true, since this connection adapter supports prepared statement caching.

Returns:

  • (Boolean) 


77
78
79
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 77

def supports_statement_cache?
  true
end

#tables(name = 'SCHEMA') ⇒ Object

SCHEMA STATEMENTS ========================================



256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 256

def tables(name = 'SCHEMA') #:nodoc:
  sql = <<-SQL
    SELECT name
    FROM sqlite_master
    WHERE type = 'table' AND NOT name = 'sqlite_sequence'
  SQL

  exec_query(sql, name).map do |row|
    row['name']
  end
end

#type_cast(value, column) ⇒ Object

:nodoc:



162
163
164
165
166
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 162

def type_cast(value, column) # :nodoc:
  return super unless BigDecimal === value

  value.to_f
end

#update_sql(sql, name = nil) ⇒ Object

:nodoc:



210
211
212
213
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 210

def update_sql(sql, name = nil) #:nodoc:
  super
  @connection.changes
end

#valid_alter_table_options(type, options) ⇒ Object

See: www.sqlite.org/lang_altertable.html SQLite has an additional restriction on the ALTER TABLE statement



318
319
320
 
# File 'lib/active_record/connection_adapters/sqlite_adapter.rb', line 318

def valid_alter_table_options( type, options)
  type.to_sym != :primary_key
end