Module: JdbcSpec::SQLite3

Includes:
MissingFunctionalityHelper
Defined in:
lib/jdbc_adapter/jdbc_sqlite3.rb

Defined Under Namespace

Modules: Column

Class Method Summary collapse

Instance Method Summary collapse

Methods included from MissingFunctionalityHelper

#alter_table, #copy_table, #copy_table_contents, #copy_table_indexes, #move_table

Class Method Details

.adapter_matcher(name) ⇒ Object 



37
38
39
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 37

def self.adapter_matcher(name, *)
  name =~ /sqlite/i ? self : false
end

.column_selector ⇒ Object 



41
42
43
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 41

def self.column_selector
  [/sqlite/i, lambda {|cfg,col| col.extend(::JdbcSpec::SQLite3::Column)}]
end

.extended(base) ⇒ Object 



31
32
33
34
35
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 31

def self.extended(base)
  base.class_eval do
    alias_chained_method :insert, :query_dirty, :insert
  end
end

.jdbc_connection_class ⇒ Object 



45
46
47
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 45

def self.jdbc_connection_class
  ::ActiveRecord::ConnectionAdapters::Sqlite3JdbcConnection
end

Instance Method Details

#_execute(sql, name = nil) ⇒ Object 



319
320
321
322
323
324
325
326
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 319

def _execute(sql, name = nil)
  if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
    @connection.execute_query(sql)
  else
    affected_rows = @connection.execute_update(sql)
    ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id(sql.split(" ", 4)[2], nil) : affected_rows
  end
end

#adapter_name ⇒ Object

:nodoc:



144
145
146
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 144

def adapter_name #:nodoc:
  'SQLite'
end

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



213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 213

def add_column(table_name, column_name, type, options = {})
  if option_not_null = options[:null] == false
    option_not_null = options.delete(:null)
  end
  add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
  add_column_options!(add_column_sql, options)
  execute(add_column_sql)
  if option_not_null
    alter_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} NOT NULL"
  end
end

#add_limit_offset!(sql, options) ⇒ Object

:nodoc:



275
276
277
278
279
280
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 275

def add_limit_offset!(sql, options) #:nodoc:
  if options[:limit]
    sql << " LIMIT #{options[:limit]}"
    sql << " OFFSET #{options[:offset]}" if options[:offset]
  end
end

#add_lock!(sql, options) ⇒ Object

SELECT … FOR UPDATE is redundant since the table is locked.



353
354
355
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 353

def add_lock!(sql, options) #:nodoc:
  sql
end

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

:nodoc:



234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 234

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:



246
247
248
249
250
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 246

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

#columns(table_name, name = nil) ⇒ Object

:nodoc:



346
347
348
349
350
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 346

def columns(table_name, name = nil) #:nodoc:        
  table_structure(table_name).map do |field|
    ::ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config, field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
  end
end

#indexes(table_name, name = nil) ⇒ Object 



298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 298

def indexes(table_name, name = nil)
  result = select_rows("SELECT name, sql FROM sqlite_master WHERE tbl_name = '#{table_name}' AND type = 'index'", name)

  result.collect do |row|
    name = row[0]
    index_sql = row[1]
    unique = (index_sql =~ /unique/i)
    cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split
    ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
  end
end

#insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) ⇒ Object

:nodoc:



263
264
265
266
267
268
269
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 263

def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
  log(sql,name) do
    @connection.execute_update(sql)
  end
  table = sql.split(" ", 4)[2]
  id_value || last_insert_id(table, nil)
end

#last_insert_id(table, sequence_name) ⇒ Object 



271
272
273
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 271

def last_insert_id(table, sequence_name)
  Integer(select_value("SELECT SEQ FROM SQLITE_SEQUENCE WHERE NAME = '#{table}'"))
end

#modify_types(tp) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 160

def modify_types(tp)
  tp[:primary_key] = "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL"
  tp[:string] = { :name => "VARCHAR", :limit => 255 }
  tp[:float] = { :name => "REAL" }
  tp[:decimal] = { :name => "REAL" }
  tp[:datetime] = { :name => "DATETIME" }
  tp[:timestamp] = { :name => "DATETIME" }
  tp[:time] = { :name => "TIME" }
  tp[:date] = { :name => "DATE" }
  tp[:boolean] = { :name => "BOOLEAN" }
  tp
end

#primary_key(table_name) ⇒ Object

:nodoc:



310
311
312
313
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 310

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

#quote(value, column = nil) ⇒ Object

:nodoc:



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 173

def quote(value, column = nil) # :nodoc:
  return value.quoted_id if value.respond_to?(:quoted_id)
  case value
  when String
    if column && column.type == :binary
      "'#{quote_string(column.class.string_to_binary(value))}'"
    elsif column && [:integer, :float].include?(column.type)
      (column.type == :integer ? value.to_i : value.to_f).to_s
    elsif column && column.respond_to?(:primary) && column.primary
      value.to_i.to_s
    else
      "'#{quote_string(value)}'"
    end
  else super
  end
end

#quote_column_name(name) ⇒ Object

:nodoc:



190
191
192
193
194
195
196
197
198
199
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 190

def quote_column_name(name) #:nodoc:
  name = name.to_s
  # Did not find reference on values needing quoting, but these
  # happen in AR unit tests
  if name == "references" || name =~ /-/
    %Q("#{name}") 
  else
    name
  end
end

#quote_string(str) ⇒ Object 



201
202
203
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 201

def quote_string(str)
  str.gsub(/'/, "''")
end

#quoted_false ⇒ Object 



209
210
211
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 209

def quoted_false
  %Q{'f'}
end

#quoted_true ⇒ Object 



205
206
207
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 205

def quoted_true
  %Q{'t'}
end

#recreate_database(name) ⇒ Object 



315
316
317
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 315

def recreate_database(name)
  tables.each{ |table| drop_table(table) }
end

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

:nodoc:



225
226
227
228
229
230
231
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 225

def remove_column(table_name, *column_names) #:nodoc:
  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, options = {}) ⇒ Object 



294
295
296
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 294

def remove_index(table_name, options = {})
  execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
end

#rename_column(table_name, column_name, new_column_name) ⇒ Object

:nodoc:



252
253
254
255
256
257
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 252

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 



259
260
261
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 259

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

#select(sql, name = nil) ⇒ Object 



328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 328

def select(sql, name=nil)
  execute(sql, name).map do |row|
    record = {}
    row.each_key do |key|
      if key.is_a?(String)
        record[key.sub(/^"?\w+"?\./, '')] = row[key]
      end
    end
    record
  end
end

#sqlite_version ⇒ Object 



156
157
158
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 156

def sqlite_version
  @sqlite_version ||= select_value('select sqlite_version(*)')
end

#supports_autoincrement? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


152
153
154
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 152

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

#supports_count_distinct? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


148
149
150
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 148

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

#table_structure(table_name) ⇒ Object

Raises:

  • (ActiveRecord::StatementInvalid) 


340
341
342
343
344
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 340

def table_structure(table_name)
  structure = @connection.execute_query("PRAGMA table_info(#{quote_table_name(table_name)})")
  raise ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'" if structure.empty?
  structure
end

#tables(name = nil) ⇒ Object

:nodoc:



282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/jdbc_adapter/jdbc_sqlite3.rb', line 282

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

  select_rows(sql, name).map do |row|
    row[0]
  end
end