Module: SQLite3::Pragmas

Included in:
Database
Defined in:
lib/sqlite3/pragmas.rb

Overview

This module is intended for inclusion solely by the Database class. It defines convenience methods for the various pragmas supported by SQLite3.

For a detailed description of these pragmas, see the SQLite3 documentation at sqlite.org/pragma.html.

Constant Summary collapse

SYNCHRONOUS_MODES =

The enumeration of valid synchronous modes.

{
  "full" => 2,
  "normal" => 1,
  "off" => 0
}.freeze
TEMP_STORE_MODES =

The enumeration of valid temp store modes.

{
  "default" => 0,
  "file" => 1,
  "memory" => 2
}.freeze
AUTO_VACUUM_MODES =

The enumeration of valid auto vacuum modes.

{
  "none" => 0,
  "full" => 1,
  "incremental" => 2
}.freeze
JOURNAL_MODES =

The list of valid journaling modes.

{
  "delete" => "delete",
  "truncate" => "truncate",
  "persist" => "persist",
  "memory" => "memory",
  "wal" => "wal",
  "off" => "off"
}.freeze
LOCKING_MODES =

The list of valid locking modes.

{
  "normal" => "normal",
  "exclusive" => "exclusive"
}.freeze
ENCODINGS =

The list of valid encodings.

{
  "utf-8" => "utf-8",
  "utf-16" => "utf-16",
  "utf-16le" => "utf-16le",
  "utf-16be" => "utf-16be"
}.freeze
WAL_CHECKPOINTS =

The list of valid WAL checkpoints.

{
  "passive" => "passive",
  "full" => "full",
  "restart" => "restart",
  "truncate" => "truncate"
}.freeze

Instance Method Summary collapse

Instance Method Details

#application_id ⇒ Object 



143
144
145
 
# File 'lib/sqlite3/pragmas.rb', line 143

def application_id
  get_int_pragma "application_id"
end

#application_id=(integer) ⇒ Object 



147
148
149
 
# File 'lib/sqlite3/pragmas.rb', line 147

def application_id=(integer)
  set_int_pragma "application_id", integer
end

#auto_vacuum ⇒ Object 



151
152
153
 
# File 'lib/sqlite3/pragmas.rb', line 151

def auto_vacuum
  get_enum_pragma "auto_vacuum"
end

#auto_vacuum=(mode) ⇒ Object 



155
156
157
 
# File 'lib/sqlite3/pragmas.rb', line 155

def auto_vacuum=(mode)
  set_enum_pragma "auto_vacuum", mode, AUTO_VACUUM_MODES
end

#automatic_index ⇒ Object 



159
160
161
 
# File 'lib/sqlite3/pragmas.rb', line 159

def automatic_index
  get_boolean_pragma "automatic_index"
end

#automatic_index=(mode) ⇒ Object 



163
164
165
 
# File 'lib/sqlite3/pragmas.rb', line 163

def automatic_index=(mode)
  set_boolean_pragma "automatic_index", mode
end

#busy_timeout ⇒ Object 



167
168
169
 
# File 'lib/sqlite3/pragmas.rb', line 167

def busy_timeout
  get_int_pragma "busy_timeout"
end

#busy_timeout=(milliseconds) ⇒ Object 



171
172
173
 
# File 'lib/sqlite3/pragmas.rb', line 171

def busy_timeout=(milliseconds)
  set_int_pragma "busy_timeout", milliseconds
end

#cache_size ⇒ Object 



175
176
177
 
# File 'lib/sqlite3/pragmas.rb', line 175

def cache_size
  get_int_pragma "cache_size"
end

#cache_size=(size) ⇒ Object 



179
180
181
 
# File 'lib/sqlite3/pragmas.rb', line 179

def cache_size=(size)
  set_int_pragma "cache_size", size
end

#cache_spill ⇒ Object 



183
184
185
 
# File 'lib/sqlite3/pragmas.rb', line 183

def cache_spill
  get_boolean_pragma "cache_spill"
end

#cache_spill=(mode) ⇒ Object 



187
188
189
 
# File 'lib/sqlite3/pragmas.rb', line 187

def cache_spill=(mode)
  set_boolean_pragma "cache_spill", mode
end

#case_sensitive_like=(mode) ⇒ Object 



191
192
193
 
# File 'lib/sqlite3/pragmas.rb', line 191

def case_sensitive_like=(mode)
  set_boolean_pragma "case_sensitive_like", mode
end

#cell_size_check ⇒ Object 



195
196
197
 
# File 'lib/sqlite3/pragmas.rb', line 195

def cell_size_check
  get_boolean_pragma "cell_size_check"
end

#cell_size_check=(mode) ⇒ Object 



199
200
201
 
# File 'lib/sqlite3/pragmas.rb', line 199

def cell_size_check=(mode)
  set_boolean_pragma "cell_size_check", mode
end

#checkpoint_fullfsync ⇒ Object 



203
204
205
 
# File 'lib/sqlite3/pragmas.rb', line 203

def checkpoint_fullfsync
  get_boolean_pragma "checkpoint_fullfsync"
end

#checkpoint_fullfsync=(mode) ⇒ Object 



207
208
209
 
# File 'lib/sqlite3/pragmas.rb', line 207

def checkpoint_fullfsync=(mode)
  set_boolean_pragma "checkpoint_fullfsync", mode
end

#collation_list(&block) ⇒ Object

:yields: row



211
212
213
 
# File 'lib/sqlite3/pragmas.rb', line 211

def collation_list(&block) # :yields: row
  get_query_pragma "collation_list", &block
end

#compile_options(&block) ⇒ Object

:yields: row



215
216
217
 
# File 'lib/sqlite3/pragmas.rb', line 215

def compile_options(&block) # :yields: row
  get_query_pragma "compile_options", &block
end

#count_changes ⇒ Object 



219
220
221
 
# File 'lib/sqlite3/pragmas.rb', line 219

def count_changes
  get_boolean_pragma "count_changes"
end

#count_changes=(mode) ⇒ Object 



223
224
225
 
# File 'lib/sqlite3/pragmas.rb', line 223

def count_changes=(mode)
  set_boolean_pragma "count_changes", mode
end

#data_version ⇒ Object 



227
228
229
 
# File 'lib/sqlite3/pragmas.rb', line 227

def data_version
  get_int_pragma "data_version"
end

#database_list(&block) ⇒ Object

:yields: row



231
232
233
 
# File 'lib/sqlite3/pragmas.rb', line 231

def database_list(&block) # :yields: row
  get_query_pragma "database_list", &block
end

#default_cache_size ⇒ Object 



235
236
237
 
# File 'lib/sqlite3/pragmas.rb', line 235

def default_cache_size
  get_int_pragma "default_cache_size"
end

#default_cache_size=(size) ⇒ Object 



239
240
241
 
# File 'lib/sqlite3/pragmas.rb', line 239

def default_cache_size=(size)
  set_int_pragma "default_cache_size", size
end

#default_synchronous ⇒ Object 



243
244
245
 
# File 'lib/sqlite3/pragmas.rb', line 243

def default_synchronous
  get_enum_pragma "default_synchronous"
end

#default_synchronous=(mode) ⇒ Object 



247
248
249
 
# File 'lib/sqlite3/pragmas.rb', line 247

def default_synchronous=(mode)
  set_enum_pragma "default_synchronous", mode, SYNCHRONOUS_MODES
end

#default_temp_store ⇒ Object 



251
252
253
 
# File 'lib/sqlite3/pragmas.rb', line 251

def default_temp_store
  get_enum_pragma "default_temp_store"
end

#default_temp_store=(mode) ⇒ Object 



255
256
257
 
# File 'lib/sqlite3/pragmas.rb', line 255

def default_temp_store=(mode)
  set_enum_pragma "default_temp_store", mode, TEMP_STORE_MODES
end

#defer_foreign_keys ⇒ Object 



259
260
261
 
# File 'lib/sqlite3/pragmas.rb', line 259

def defer_foreign_keys
  get_boolean_pragma "defer_foreign_keys"
end

#defer_foreign_keys=(mode) ⇒ Object 



263
264
265
 
# File 'lib/sqlite3/pragmas.rb', line 263

def defer_foreign_keys=(mode)
  set_boolean_pragma "defer_foreign_keys", mode
end

#encoding ⇒ Object 



267
268
269
 
# File 'lib/sqlite3/pragmas.rb', line 267

def encoding
  get_enum_pragma "encoding"
end

#encoding=(mode) ⇒ Object 



271
272
273
 
# File 'lib/sqlite3/pragmas.rb', line 271

def encoding=(mode)
  set_string_pragma "encoding", mode, ENCODINGS
end

#foreign_key_check(*table, &block) ⇒ Object

:yields: row



275
276
277
 
# File 'lib/sqlite3/pragmas.rb', line 275

def foreign_key_check(*table, &block) # :yields: row
  get_query_pragma "foreign_key_check", *table, &block
end

#foreign_key_list(table, &block) ⇒ Object

:yields: row



279
280
281
 
# File 'lib/sqlite3/pragmas.rb', line 279

def foreign_key_list(table, &block) # :yields: row
  get_query_pragma "foreign_key_list", table, &block
end

#foreign_keys ⇒ Object 



283
284
285
 
# File 'lib/sqlite3/pragmas.rb', line 283

def foreign_keys
  get_boolean_pragma "foreign_keys"
end

#foreign_keys=(mode) ⇒ Object 



287
288
289
 
# File 'lib/sqlite3/pragmas.rb', line 287

def foreign_keys=(mode)
  set_boolean_pragma "foreign_keys", mode
end

#freelist_count ⇒ Object 



291
292
293
 
# File 'lib/sqlite3/pragmas.rb', line 291

def freelist_count
  get_int_pragma "freelist_count"
end

#full_column_names ⇒ Object 



295
296
297
 
# File 'lib/sqlite3/pragmas.rb', line 295

def full_column_names
  get_boolean_pragma "full_column_names"
end

#full_column_names=(mode) ⇒ Object 



299
300
301
 
# File 'lib/sqlite3/pragmas.rb', line 299

def full_column_names=(mode)
  set_boolean_pragma "full_column_names", mode
end

#fullfsync ⇒ Object 



303
304
305
 
# File 'lib/sqlite3/pragmas.rb', line 303

def fullfsync
  get_boolean_pragma "fullfsync"
end

#fullfsync=(mode) ⇒ Object 



307
308
309
 
# File 'lib/sqlite3/pragmas.rb', line 307

def fullfsync=(mode)
  set_boolean_pragma "fullfsync", mode
end

#get_boolean_pragma(name) ⇒ Object

Returns true or false depending on the value of the named pragma.



13
14
15
 
# File 'lib/sqlite3/pragmas.rb', line 13

def get_boolean_pragma(name)
  get_first_value("PRAGMA #{name}") != 0
end

#get_enum_pragma(name) ⇒ Object

Return the value of the given pragma.



53
54
55
 
# File 'lib/sqlite3/pragmas.rb', line 53

def get_enum_pragma(name)
  get_first_value("PRAGMA #{name}")
end

#get_int_pragma(name) ⇒ Object

Returns the value of the given pragma as an integer.



80
81
82
 
# File 'lib/sqlite3/pragmas.rb', line 80

def get_int_pragma(name)
  get_first_value("PRAGMA #{name}").to_i
end

#get_query_pragma(name, *params, &block) ⇒ Object

Requests the given pragma (and parameters), and if the block is given, each row of the result set will be yielded to it. Otherwise, the results are returned as an array.



43
44
45
46
47
48
49
50
 
# File 'lib/sqlite3/pragmas.rb', line 43

def get_query_pragma(name, *params, &block) # :yields: row
  if params.empty?
    execute("PRAGMA #{name}", &block)
  else
    args = "'" + params.join("','") + "'"
    execute("PRAGMA #{name}( #{args} )", &block)
  end
end

#ignore_check_constraints=(mode) ⇒ Object 



311
312
313
 
# File 'lib/sqlite3/pragmas.rb', line 311

def ignore_check_constraints=(mode)
  set_boolean_pragma "ignore_check_constraints", mode
end

#incremental_vacuum(pages, &block) ⇒ Object

:yields: row



315
316
317
 
# File 'lib/sqlite3/pragmas.rb', line 315

def incremental_vacuum(pages, &block) # :yields: row
  get_query_pragma "incremental_vacuum", pages, &block
end

#index_info(index, &block) ⇒ Object

:yields: row



319
320
321
 
# File 'lib/sqlite3/pragmas.rb', line 319

def index_info(index, &block) # :yields: row
  get_query_pragma "index_info", index, &block
end

#index_list(table, &block) ⇒ Object

:yields: row



323
324
325
 
# File 'lib/sqlite3/pragmas.rb', line 323

def index_list(table, &block) # :yields: row
  get_query_pragma "index_list", table, &block
end

#index_xinfo(index, &block) ⇒ Object

:yields: row



327
328
329
 
# File 'lib/sqlite3/pragmas.rb', line 327

def index_xinfo(index, &block) # :yields: row
  get_query_pragma "index_xinfo", index, &block
end

#integrity_check(*num_errors, &block) ⇒ Object

:yields: row



331
332
333
 
# File 'lib/sqlite3/pragmas.rb', line 331

def integrity_check(*num_errors, &block) # :yields: row
  get_query_pragma "integrity_check", *num_errors, &block
end

#journal_mode ⇒ Object 



335
336
337
 
# File 'lib/sqlite3/pragmas.rb', line 335

def journal_mode
  get_enum_pragma "journal_mode"
end

#journal_mode=(mode) ⇒ Object 



339
340
341
 
# File 'lib/sqlite3/pragmas.rb', line 339

def journal_mode=(mode)
  set_string_pragma "journal_mode", mode, JOURNAL_MODES
end

#journal_size_limit ⇒ Object 



343
344
345
 
# File 'lib/sqlite3/pragmas.rb', line 343

def journal_size_limit
  get_int_pragma "journal_size_limit"
end

#journal_size_limit=(size) ⇒ Object 



347
348
349
 
# File 'lib/sqlite3/pragmas.rb', line 347

def journal_size_limit=(size)
  set_int_pragma "journal_size_limit", size
end

#legacy_file_format ⇒ Object 



351
352
353
 
# File 'lib/sqlite3/pragmas.rb', line 351

def legacy_file_format
  get_boolean_pragma "legacy_file_format"
end

#legacy_file_format=(mode) ⇒ Object 



355
356
357
 
# File 'lib/sqlite3/pragmas.rb', line 355

def legacy_file_format=(mode)
  set_boolean_pragma "legacy_file_format", mode
end

#locking_mode ⇒ Object 



359
360
361
 
# File 'lib/sqlite3/pragmas.rb', line 359

def locking_mode
  get_enum_pragma "locking_mode"
end

#locking_mode=(mode) ⇒ Object 



363
364
365
 
# File 'lib/sqlite3/pragmas.rb', line 363

def locking_mode=(mode)
  set_string_pragma "locking_mode", mode, LOCKING_MODES
end

#max_page_count ⇒ Object 



367
368
369
 
# File 'lib/sqlite3/pragmas.rb', line 367

def max_page_count
  get_int_pragma "max_page_count"
end

#max_page_count=(size) ⇒ Object 



371
372
373
 
# File 'lib/sqlite3/pragmas.rb', line 371

def max_page_count=(size)
  set_int_pragma "max_page_count", size
end

#mmap_size ⇒ Object 



375
376
377
 
# File 'lib/sqlite3/pragmas.rb', line 375

def mmap_size
  get_int_pragma "mmap_size"
end

#mmap_size=(size) ⇒ Object 



379
380
381
 
# File 'lib/sqlite3/pragmas.rb', line 379

def mmap_size=(size)
  set_int_pragma "mmap_size", size
end

#optimize(bitmask = nil) ⇒ Object

Attempt to optimize the database.

To customize the optimization options, pass bitmask with a combination of the Constants::Optimize masks.

See www.sqlite.org/pragma.html#pragma_optimize for more information.



389
390
391
392
393
394
395
 
# File 'lib/sqlite3/pragmas.rb', line 389

def optimize(bitmask = nil)
  if bitmask
    set_int_pragma "optimize", bitmask
  else
    execute("PRAGMA optimize")
  end
end

#page_count ⇒ Object 



397
398
399
 
# File 'lib/sqlite3/pragmas.rb', line 397

def page_count
  get_int_pragma "page_count"
end

#page_size ⇒ Object 



401
402
403
 
# File 'lib/sqlite3/pragmas.rb', line 401

def page_size
  get_int_pragma "page_size"
end

#page_size=(size) ⇒ Object 



405
406
407
 
# File 'lib/sqlite3/pragmas.rb', line 405

def page_size=(size)
  set_int_pragma "page_size", size
end

#parser_trace=(mode) ⇒ Object 



409
410
411
 
# File 'lib/sqlite3/pragmas.rb', line 409

def parser_trace=(mode)
  set_boolean_pragma "parser_trace", mode
end

#query_only ⇒ Object 



413
414
415
 
# File 'lib/sqlite3/pragmas.rb', line 413

def query_only
  get_boolean_pragma "query_only"
end

#query_only=(mode) ⇒ Object 



417
418
419
 
# File 'lib/sqlite3/pragmas.rb', line 417

def query_only=(mode)
  set_boolean_pragma "query_only", mode
end

#quick_check(*num_errors, &block) ⇒ Object

:yields: row



421
422
423
 
# File 'lib/sqlite3/pragmas.rb', line 421

def quick_check(*num_errors, &block) # :yields: row
  get_query_pragma "quick_check", *num_errors, &block
end

#read_uncommitted ⇒ Object 



425
426
427
 
# File 'lib/sqlite3/pragmas.rb', line 425

def read_uncommitted
  get_boolean_pragma "read_uncommitted"
end

#read_uncommitted=(mode) ⇒ Object 



429
430
431
 
# File 'lib/sqlite3/pragmas.rb', line 429

def read_uncommitted=(mode)
  set_boolean_pragma "read_uncommitted", mode
end

#recursive_triggers ⇒ Object 



433
434
435
 
# File 'lib/sqlite3/pragmas.rb', line 433

def recursive_triggers
  get_boolean_pragma "recursive_triggers"
end

#recursive_triggers=(mode) ⇒ Object 



437
438
439
 
# File 'lib/sqlite3/pragmas.rb', line 437

def recursive_triggers=(mode)
  set_boolean_pragma "recursive_triggers", mode
end

#reverse_unordered_selects ⇒ Object 



441
442
443
 
# File 'lib/sqlite3/pragmas.rb', line 441

def reverse_unordered_selects
  get_boolean_pragma "reverse_unordered_selects"
end

#reverse_unordered_selects=(mode) ⇒ Object 



445
446
447
 
# File 'lib/sqlite3/pragmas.rb', line 445

def reverse_unordered_selects=(mode)
  set_boolean_pragma "reverse_unordered_selects", mode
end

#schema_cookie ⇒ Object 



449
450
451
 
# File 'lib/sqlite3/pragmas.rb', line 449

def schema_cookie
  get_int_pragma "schema_cookie"
end

#schema_cookie=(cookie) ⇒ Object 



453
454
455
 
# File 'lib/sqlite3/pragmas.rb', line 453

def schema_cookie=(cookie)
  set_int_pragma "schema_cookie", cookie
end

#schema_version ⇒ Object 



457
458
459
 
# File 'lib/sqlite3/pragmas.rb', line 457

def schema_version
  get_int_pragma "schema_version"
end

#schema_version=(version) ⇒ Object 



461
462
463
 
# File 'lib/sqlite3/pragmas.rb', line 461

def schema_version=(version)
  set_int_pragma "schema_version", version
end

#secure_delete ⇒ Object 



465
466
467
 
# File 'lib/sqlite3/pragmas.rb', line 465

def secure_delete
  get_boolean_pragma "secure_delete"
end

#secure_delete=(mode) ⇒ Object 



469
470
471
 
# File 'lib/sqlite3/pragmas.rb', line 469

def secure_delete=(mode)
  set_boolean_pragma "secure_delete", mode
end

#set_boolean_pragma(name, mode) ⇒ Object

Sets the given pragma to the given boolean value. The value itself may be true or false, or any other commonly used string or integer that represents truth.



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/sqlite3/pragmas.rb', line 20

def set_boolean_pragma(name, mode)
  case mode
  when String
    case mode.downcase
    when "on", "yes", "true", "y", "t" then mode = "'ON'"
    when "off", "no", "false", "n", "f" then mode = "'OFF'"
    else
      raise SQLite3::Exception, "unrecognized pragma parameter #{mode.inspect}"
    end
  when true, 1
    mode = "ON"
  when false, 0, nil
    mode = "OFF"
  else
    raise SQLite3::Exception, "unrecognized pragma parameter #{mode.inspect}"
  end

  execute("PRAGMA #{name}=#{mode}")
end

#set_enum_pragma(name, mode, enums) ⇒ Object

Set the value of the given pragma to mode. The mode parameter must conform to one of the values in the given enum array. Each entry in the array is another array comprised of elements in the enumeration that have duplicate values. See #synchronous, #default_synchronous, #temp_store, and #default_temp_store for usage examples.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/sqlite3/pragmas.rb', line 62

def set_enum_pragma(name, mode, enums)
  match = if enums.is_a?(Array)
    # maybe deprecate this?
    enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
  elsif mode.is_a?(String)
    enums.fetch(mode.downcase)
  else
    mode
  end

  unless match
    raise SQLite3::Exception, "unrecognized #{name} #{mode.inspect}"
  end

  execute("PRAGMA #{name}='#{match}'")
end

#set_int_pragma(name, value) ⇒ Object

Set the value of the given pragma to the integer value of the value parameter.



86
87
88
 
# File 'lib/sqlite3/pragmas.rb', line 86

def set_int_pragma(name, value)
  execute("PRAGMA #{name}=#{value.to_i}")
end

#short_column_names ⇒ Object 



473
474
475
 
# File 'lib/sqlite3/pragmas.rb', line 473

def short_column_names
  get_boolean_pragma "short_column_names"
end

#short_column_names=(mode) ⇒ Object 



477
478
479
 
# File 'lib/sqlite3/pragmas.rb', line 477

def short_column_names=(mode)
  set_boolean_pragma "short_column_names", mode
end

#shrink_memory ⇒ Object 



481
482
483
 
# File 'lib/sqlite3/pragmas.rb', line 481

def shrink_memory
  execute("PRAGMA shrink_memory")
end

#soft_heap_limit ⇒ Object 



485
486
487
 
# File 'lib/sqlite3/pragmas.rb', line 485

def soft_heap_limit
  get_int_pragma "soft_heap_limit"
end

#soft_heap_limit=(mode) ⇒ Object 



489
490
491
 
# File 'lib/sqlite3/pragmas.rb', line 489

def soft_heap_limit=(mode)
  set_int_pragma "soft_heap_limit", mode
end

#stats(&block) ⇒ Object

:yields: row



493
494
495
 
# File 'lib/sqlite3/pragmas.rb', line 493

def stats(&block) # :yields: row
  get_query_pragma "stats", &block
end

#synchronous ⇒ Object 



497
498
499
 
# File 'lib/sqlite3/pragmas.rb', line 497

def synchronous
  get_enum_pragma "synchronous"
end

#synchronous=(mode) ⇒ Object 



501
502
503
 
# File 'lib/sqlite3/pragmas.rb', line 501

def synchronous=(mode)
  set_enum_pragma "synchronous", mode, SYNCHRONOUS_MODES
end

#table_info(table) ⇒ Object

Returns information about table. Yields each row of table information if a block is provided.



580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
 
# File 'lib/sqlite3/pragmas.rb', line 580

def table_info table
  stmt = prepare "PRAGMA table_info(#{table})"
  columns = stmt.columns

  needs_tweak_default =
    version_compare(SQLite3.libversion.to_s, "3.3.7") > 0

  result = [] unless block_given?
  stmt.each do |row|
    new_row = columns.zip(row).to_h

    tweak_default(new_row) if needs_tweak_default

    # Ensure the type value is downcased.  On Mac and Windows
    # platforms this value is now being returned as all upper
    # case.
    if new_row["type"]
      new_row["type"] = new_row["type"].downcase
    end

    if block_given?
      yield new_row
    else
      result << new_row
    end
  end
  stmt.close

  result
end

#temp_store ⇒ Object 



505
506
507
 
# File 'lib/sqlite3/pragmas.rb', line 505

def temp_store
  get_enum_pragma "temp_store"
end

#temp_store=(mode) ⇒ Object 



509
510
511
 
# File 'lib/sqlite3/pragmas.rb', line 509

def temp_store=(mode)
  set_enum_pragma "temp_store", mode, TEMP_STORE_MODES
end

#threads ⇒ Object 



513
514
515
 
# File 'lib/sqlite3/pragmas.rb', line 513

def threads
  get_int_pragma "threads"
end

#threads=(count) ⇒ Object 



517
518
519
 
# File 'lib/sqlite3/pragmas.rb', line 517

def threads=(count)
  set_int_pragma "threads", count
end

#user_cookie ⇒ Object 



521
522
523
 
# File 'lib/sqlite3/pragmas.rb', line 521

def user_cookie
  get_int_pragma "user_cookie"
end

#user_cookie=(cookie) ⇒ Object 



525
526
527
 
# File 'lib/sqlite3/pragmas.rb', line 525

def user_cookie=(cookie)
  set_int_pragma "user_cookie", cookie
end

#user_version ⇒ Object 



529
530
531
 
# File 'lib/sqlite3/pragmas.rb', line 529

def user_version
  get_int_pragma "user_version"
end

#user_version=(version) ⇒ Object 



533
534
535
 
# File 'lib/sqlite3/pragmas.rb', line 533

def user_version=(version)
  set_int_pragma "user_version", version
end

#vdbe_addoptrace=(mode) ⇒ Object 



537
538
539
 
# File 'lib/sqlite3/pragmas.rb', line 537

def vdbe_addoptrace=(mode)
  set_boolean_pragma "vdbe_addoptrace", mode
end

#vdbe_debug=(mode) ⇒ Object 



541
542
543
 
# File 'lib/sqlite3/pragmas.rb', line 541

def vdbe_debug=(mode)
  set_boolean_pragma "vdbe_debug", mode
end

#vdbe_listing=(mode) ⇒ Object 



545
546
547
 
# File 'lib/sqlite3/pragmas.rb', line 545

def vdbe_listing=(mode)
  set_boolean_pragma "vdbe_listing", mode
end

#vdbe_trace ⇒ Object 



549
550
551
 
# File 'lib/sqlite3/pragmas.rb', line 549

def vdbe_trace
  get_boolean_pragma "vdbe_trace"
end

#vdbe_trace=(mode) ⇒ Object 



553
554
555
 
# File 'lib/sqlite3/pragmas.rb', line 553

def vdbe_trace=(mode)
  set_boolean_pragma "vdbe_trace", mode
end

#wal_autocheckpoint ⇒ Object 



557
558
559
 
# File 'lib/sqlite3/pragmas.rb', line 557

def wal_autocheckpoint
  get_int_pragma "wal_autocheckpoint"
end

#wal_autocheckpoint=(mode) ⇒ Object 



561
562
563
 
# File 'lib/sqlite3/pragmas.rb', line 561

def wal_autocheckpoint=(mode)
  set_int_pragma "wal_autocheckpoint", mode
end

#wal_checkpoint ⇒ Object 



565
566
567
 
# File 'lib/sqlite3/pragmas.rb', line 565

def wal_checkpoint
  get_enum_pragma "wal_checkpoint"
end

#wal_checkpoint=(mode) ⇒ Object 



569
570
571
 
# File 'lib/sqlite3/pragmas.rb', line 569

def wal_checkpoint=(mode)
  set_string_pragma "wal_checkpoint", mode, WAL_CHECKPOINTS
end

#writable_schema=(mode) ⇒ Object 



573
574
575
 
# File 'lib/sqlite3/pragmas.rb', line 573

def writable_schema=(mode)
  set_boolean_pragma "writable_schema", mode
end