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]]
TEMP_STORE_MODES =

The enumeration of valid temp store modes.

[["default", 0], ["file", 1], ["memory", 2]]
AUTO_VACUUM_MODES =

The enumeration of valid auto vacuum modes.

[["none", 0], ["full", 1], ["incremental", 2]]
JOURNAL_MODES =

The list of valid journaling modes.

[["delete"], ["truncate"], ["persist"], ["memory"],
["wal"], ["off"]]
LOCKING_MODES =

The list of valid locking modes.

[["normal"], ["exclusive"]]
ENCODINGS =

The list of valid encodings.

[["utf-8"], ["utf-16"], ["utf-16le"], ["utf-16be "]]
WAL_CHECKPOINTS =

The list of valid WAL checkpoints.

[["passive"], ["full"], ["restart"], ["truncate"]]

Instance Method Summary collapse

Instance Method Details

#application_id ⇒ Object 



101
102
103
 
# File 'lib/sqlite3/pragmas.rb', line 101

def application_id
  get_int_pragma "application_id"
end

#application_id=(integer) ⇒ Object 



105
106
107
 
# File 'lib/sqlite3/pragmas.rb', line 105

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

#auto_vacuum ⇒ Object 



109
110
111
 
# File 'lib/sqlite3/pragmas.rb', line 109

def auto_vacuum
  get_enum_pragma "auto_vacuum"
end

#auto_vacuum=(mode) ⇒ Object 



113
114
115
 
# File 'lib/sqlite3/pragmas.rb', line 113

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

#automatic_index ⇒ Object 



117
118
119
 
# File 'lib/sqlite3/pragmas.rb', line 117

def automatic_index
  get_boolean_pragma "automatic_index"
end

#automatic_index=(mode) ⇒ Object 



121
122
123
 
# File 'lib/sqlite3/pragmas.rb', line 121

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

#busy_timeout ⇒ Object 



125
126
127
 
# File 'lib/sqlite3/pragmas.rb', line 125

def busy_timeout
  get_int_pragma "busy_timeout"
end

#busy_timeout=(milliseconds) ⇒ Object 



129
130
131
 
# File 'lib/sqlite3/pragmas.rb', line 129

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

#cache_size ⇒ Object 



133
134
135
 
# File 'lib/sqlite3/pragmas.rb', line 133

def cache_size
  get_int_pragma "cache_size"
end

#cache_size=(size) ⇒ Object 



137
138
139
 
# File 'lib/sqlite3/pragmas.rb', line 137

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

#cache_spill ⇒ Object 



141
142
143
 
# File 'lib/sqlite3/pragmas.rb', line 141

def cache_spill
  get_boolean_pragma "cache_spill"
end

#cache_spill=(mode) ⇒ Object 



145
146
147
 
# File 'lib/sqlite3/pragmas.rb', line 145

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

#case_sensitive_like=(mode) ⇒ Object 



149
150
151
 
# File 'lib/sqlite3/pragmas.rb', line 149

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

#cell_size_check ⇒ Object 



153
154
155
 
# File 'lib/sqlite3/pragmas.rb', line 153

def cell_size_check
  get_boolean_pragma "cell_size_check"
end

#cell_size_check=(mode) ⇒ Object 



157
158
159
 
# File 'lib/sqlite3/pragmas.rb', line 157

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

#checkpoint_fullfsync ⇒ Object 



161
162
163
 
# File 'lib/sqlite3/pragmas.rb', line 161

def checkpoint_fullfsync
  get_boolean_pragma "checkpoint_fullfsync"
end

#checkpoint_fullfsync=(mode) ⇒ Object 



165
166
167
 
# File 'lib/sqlite3/pragmas.rb', line 165

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

#collation_list(&block) ⇒ Object

:yields: row



169
170
171
 
# File 'lib/sqlite3/pragmas.rb', line 169

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

#compile_options(&block) ⇒ Object

:yields: row



173
174
175
 
# File 'lib/sqlite3/pragmas.rb', line 173

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

#count_changes ⇒ Object 



177
178
179
 
# File 'lib/sqlite3/pragmas.rb', line 177

def count_changes
  get_boolean_pragma "count_changes"
end

#count_changes=(mode) ⇒ Object 



181
182
183
 
# File 'lib/sqlite3/pragmas.rb', line 181

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

#data_version ⇒ Object 



185
186
187
 
# File 'lib/sqlite3/pragmas.rb', line 185

def data_version
  get_int_pragma "data_version"
end

#database_list(&block) ⇒ Object

:yields: row



189
190
191
 
# File 'lib/sqlite3/pragmas.rb', line 189

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

#default_cache_size ⇒ Object 



193
194
195
 
# File 'lib/sqlite3/pragmas.rb', line 193

def default_cache_size
  get_int_pragma "default_cache_size"
end

#default_cache_size=(size) ⇒ Object 



197
198
199
 
# File 'lib/sqlite3/pragmas.rb', line 197

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

#default_synchronous ⇒ Object 



201
202
203
 
# File 'lib/sqlite3/pragmas.rb', line 201

def default_synchronous
  get_enum_pragma "default_synchronous"
end

#default_synchronous=(mode) ⇒ Object 



205
206
207
 
# File 'lib/sqlite3/pragmas.rb', line 205

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

#default_temp_store ⇒ Object 



209
210
211
 
# File 'lib/sqlite3/pragmas.rb', line 209

def default_temp_store
  get_enum_pragma "default_temp_store"
end

#default_temp_store=(mode) ⇒ Object 



213
214
215
 
# File 'lib/sqlite3/pragmas.rb', line 213

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

#defer_foreign_keys ⇒ Object 



217
218
219
 
# File 'lib/sqlite3/pragmas.rb', line 217

def defer_foreign_keys
  get_boolean_pragma "defer_foreign_keys"
end

#defer_foreign_keys=(mode) ⇒ Object 



221
222
223
 
# File 'lib/sqlite3/pragmas.rb', line 221

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

#encoding ⇒ Object 



225
226
227
 
# File 'lib/sqlite3/pragmas.rb', line 225

def encoding
  get_enum_pragma "encoding"
end

#encoding=(mode) ⇒ Object 



229
230
231
 
# File 'lib/sqlite3/pragmas.rb', line 229

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

#foreign_key_check(*table, &block) ⇒ Object

:yields: row



233
234
235
 
# File 'lib/sqlite3/pragmas.rb', line 233

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



237
238
239
 
# File 'lib/sqlite3/pragmas.rb', line 237

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

#foreign_keys ⇒ Object 



241
242
243
 
# File 'lib/sqlite3/pragmas.rb', line 241

def foreign_keys
  get_boolean_pragma "foreign_keys"
end

#foreign_keys=(mode) ⇒ Object 



245
246
247
 
# File 'lib/sqlite3/pragmas.rb', line 245

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

#freelist_count ⇒ Object 



249
250
251
 
# File 'lib/sqlite3/pragmas.rb', line 249

def freelist_count
  get_int_pragma "freelist_count"
end

#full_column_names ⇒ Object 



253
254
255
 
# File 'lib/sqlite3/pragmas.rb', line 253

def full_column_names
  get_boolean_pragma "full_column_names"
end

#full_column_names=(mode) ⇒ Object 



257
258
259
 
# File 'lib/sqlite3/pragmas.rb', line 257

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

#fullfsync ⇒ Object 



261
262
263
 
# File 'lib/sqlite3/pragmas.rb', line 261

def fullfsync
  get_boolean_pragma "fullfsync"
end

#fullfsync=(mode) ⇒ Object 



265
266
267
 
# File 'lib/sqlite3/pragmas.rb', line 265

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.



11
12
13
 
# File 'lib/sqlite3/pragmas.rb', line 11

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

#get_enum_pragma(name) ⇒ Object

Return the value of the given pragma.



51
52
53
 
# File 'lib/sqlite3/pragmas.rb', line 51

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.



69
70
71
 
# File 'lib/sqlite3/pragmas.rb', line 69

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.



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

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 



269
270
271
 
# File 'lib/sqlite3/pragmas.rb', line 269

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

#incremental_vacuum(pages, &block) ⇒ Object

:yields: row



273
274
275
 
# File 'lib/sqlite3/pragmas.rb', line 273

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

#index_info(index, &block) ⇒ Object

:yields: row



277
278
279
 
# File 'lib/sqlite3/pragmas.rb', line 277

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

#index_list(table, &block) ⇒ Object

:yields: row



281
282
283
 
# File 'lib/sqlite3/pragmas.rb', line 281

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

#index_xinfo(index, &block) ⇒ Object

:yields: row



285
286
287
 
# File 'lib/sqlite3/pragmas.rb', line 285

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

#integrity_check(*num_errors, &block) ⇒ Object

:yields: row



289
290
291
 
# File 'lib/sqlite3/pragmas.rb', line 289

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

#journal_mode ⇒ Object 



293
294
295
 
# File 'lib/sqlite3/pragmas.rb', line 293

def journal_mode
  get_enum_pragma "journal_mode"
end

#journal_mode=(mode) ⇒ Object 



297
298
299
 
# File 'lib/sqlite3/pragmas.rb', line 297

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

#journal_size_limit ⇒ Object 



301
302
303
 
# File 'lib/sqlite3/pragmas.rb', line 301

def journal_size_limit
  get_int_pragma "journal_size_limit"
end

#journal_size_limit=(size) ⇒ Object 



305
306
307
 
# File 'lib/sqlite3/pragmas.rb', line 305

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

#legacy_file_format ⇒ Object 



309
310
311
 
# File 'lib/sqlite3/pragmas.rb', line 309

def legacy_file_format
  get_boolean_pragma "legacy_file_format"
end

#legacy_file_format=(mode) ⇒ Object 



313
314
315
 
# File 'lib/sqlite3/pragmas.rb', line 313

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

#locking_mode ⇒ Object 



317
318
319
 
# File 'lib/sqlite3/pragmas.rb', line 317

def locking_mode
  get_enum_pragma "locking_mode"
end

#locking_mode=(mode) ⇒ Object 



321
322
323
 
# File 'lib/sqlite3/pragmas.rb', line 321

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

#max_page_count ⇒ Object 



325
326
327
 
# File 'lib/sqlite3/pragmas.rb', line 325

def max_page_count
  get_int_pragma "max_page_count"
end

#max_page_count=(size) ⇒ Object 



329
330
331
 
# File 'lib/sqlite3/pragmas.rb', line 329

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

#mmap_size ⇒ Object 



333
334
335
 
# File 'lib/sqlite3/pragmas.rb', line 333

def mmap_size
  get_int_pragma "mmap_size"
end

#mmap_size=(size) ⇒ Object 



337
338
339
 
# File 'lib/sqlite3/pragmas.rb', line 337

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

#page_count ⇒ Object 



341
342
343
 
# File 'lib/sqlite3/pragmas.rb', line 341

def page_count
  get_int_pragma "page_count"
end

#page_size ⇒ Object 



345
346
347
 
# File 'lib/sqlite3/pragmas.rb', line 345

def page_size
  get_int_pragma "page_size"
end

#page_size=(size) ⇒ Object 



349
350
351
 
# File 'lib/sqlite3/pragmas.rb', line 349

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

#parser_trace=(mode) ⇒ Object 



353
354
355
 
# File 'lib/sqlite3/pragmas.rb', line 353

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

#query_only ⇒ Object 



357
358
359
 
# File 'lib/sqlite3/pragmas.rb', line 357

def query_only
  get_boolean_pragma "query_only"
end

#query_only=(mode) ⇒ Object 



361
362
363
 
# File 'lib/sqlite3/pragmas.rb', line 361

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

#quick_check(*num_errors, &block) ⇒ Object

:yields: row



365
366
367
 
# File 'lib/sqlite3/pragmas.rb', line 365

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

#read_uncommitted ⇒ Object 



369
370
371
 
# File 'lib/sqlite3/pragmas.rb', line 369

def read_uncommitted
  get_boolean_pragma "read_uncommitted"
end

#read_uncommitted=(mode) ⇒ Object 



373
374
375
 
# File 'lib/sqlite3/pragmas.rb', line 373

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

#recursive_triggers ⇒ Object 



377
378
379
 
# File 'lib/sqlite3/pragmas.rb', line 377

def recursive_triggers
  get_boolean_pragma "recursive_triggers"
end

#recursive_triggers=(mode) ⇒ Object 



381
382
383
 
# File 'lib/sqlite3/pragmas.rb', line 381

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

#reverse_unordered_selects ⇒ Object 



385
386
387
 
# File 'lib/sqlite3/pragmas.rb', line 385

def reverse_unordered_selects
  get_boolean_pragma "reverse_unordered_selects"
end

#reverse_unordered_selects=(mode) ⇒ Object 



389
390
391
 
# File 'lib/sqlite3/pragmas.rb', line 389

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

#schema_cookie ⇒ Object 



393
394
395
 
# File 'lib/sqlite3/pragmas.rb', line 393

def schema_cookie
  get_int_pragma "schema_cookie"
end

#schema_cookie=(cookie) ⇒ Object 



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

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

#schema_version ⇒ Object 



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

def schema_version
  get_int_pragma "schema_version"
end

#schema_version=(version) ⇒ Object 



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

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

#secure_delete ⇒ Object 



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

def secure_delete
  get_boolean_pragma "secure_delete"
end

#secure_delete=(mode) ⇒ Object 



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

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.



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

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.



60
61
62
63
64
65
66
 
# File 'lib/sqlite3/pragmas.rb', line 60

def set_enum_pragma(name, mode, enums)
  match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
  unless match
    raise SQLite3::Exception, "unrecognized #{name} #{mode.inspect}"
  end
  execute("PRAGMA #{name}='#{match.first.upcase}'")
end

#set_int_pragma(name, value) ⇒ Object

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



75
76
77
 
# File 'lib/sqlite3/pragmas.rb', line 75

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

#short_column_names ⇒ Object 



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

def short_column_names
  get_boolean_pragma "short_column_names"
end

#short_column_names=(mode) ⇒ Object 



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

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

#shrink_memory ⇒ Object 



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

def shrink_memory
  execute("PRAGMA shrink_memory")
end

#soft_heap_limit ⇒ Object 



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

def soft_heap_limit
  get_int_pragma "soft_heap_limit"
end

#soft_heap_limit=(mode) ⇒ Object 



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

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

#stats(&block) ⇒ Object

:yields: row



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

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

#synchronous ⇒ Object 



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

def synchronous
  get_enum_pragma "synchronous"
end

#synchronous=(mode) ⇒ Object 



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

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.



524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
 
# File 'lib/sqlite3/pragmas.rb', line 524

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 



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

def temp_store
  get_enum_pragma "temp_store"
end

#temp_store=(mode) ⇒ Object 



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

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

#threads ⇒ Object 



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

def threads
  get_int_pragma "threads"
end

#threads=(count) ⇒ Object 



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

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

#user_cookie ⇒ Object 



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

def user_cookie
  get_int_pragma "user_cookie"
end

#user_cookie=(cookie) ⇒ Object 



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

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

#user_version ⇒ Object 



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

def user_version
  get_int_pragma "user_version"
end

#user_version=(version) ⇒ Object 



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

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

#vdbe_addoptrace=(mode) ⇒ Object 



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

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

#vdbe_debug=(mode) ⇒ Object 



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

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

#vdbe_listing=(mode) ⇒ Object 



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

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

#vdbe_trace ⇒ Object 



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

def vdbe_trace
  get_boolean_pragma "vdbe_trace"
end

#vdbe_trace=(mode) ⇒ Object 



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

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

#wal_autocheckpoint ⇒ Object 



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

def wal_autocheckpoint
  get_int_pragma "wal_autocheckpoint"
end

#wal_autocheckpoint=(mode) ⇒ Object 



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

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

#wal_checkpoint ⇒ Object 



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

def wal_checkpoint
  get_enum_pragma "wal_checkpoint"
end

#wal_checkpoint=(mode) ⇒ Object 



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

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

#writable_schema=(mode) ⇒ Object 



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

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