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

#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.



347
348
349
350
351
352
353
 
# File 'lib/sqlite3/pragmas.rb', line 347

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

#page_count ⇒ Object 



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

def page_count
  get_int_pragma "page_count"
end

#page_size ⇒ Object 



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

def page_size
  get_int_pragma "page_size"
end

#page_size=(size) ⇒ Object 



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

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

#parser_trace=(mode) ⇒ Object 



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

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

#query_only ⇒ Object 



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

def query_only
  get_boolean_pragma "query_only"
end

#query_only=(mode) ⇒ Object 



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

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

#quick_check(*num_errors, &block) ⇒ Object

:yields: row



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

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

#read_uncommitted ⇒ Object 



383
384
385
 
# File 'lib/sqlite3/pragmas.rb', line 383

def read_uncommitted
  get_boolean_pragma "read_uncommitted"
end

#read_uncommitted=(mode) ⇒ Object 



387
388
389
 
# File 'lib/sqlite3/pragmas.rb', line 387

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

#recursive_triggers ⇒ Object 



391
392
393
 
# File 'lib/sqlite3/pragmas.rb', line 391

def recursive_triggers
  get_boolean_pragma "recursive_triggers"
end

#recursive_triggers=(mode) ⇒ Object 



395
396
397
 
# File 'lib/sqlite3/pragmas.rb', line 395

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

#reverse_unordered_selects ⇒ Object 



399
400
401
 
# File 'lib/sqlite3/pragmas.rb', line 399

def reverse_unordered_selects
  get_boolean_pragma "reverse_unordered_selects"
end

#reverse_unordered_selects=(mode) ⇒ Object 



403
404
405
 
# File 'lib/sqlite3/pragmas.rb', line 403

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

#schema_cookie ⇒ Object 



407
408
409
 
# File 'lib/sqlite3/pragmas.rb', line 407

def schema_cookie
  get_int_pragma "schema_cookie"
end

#schema_cookie=(cookie) ⇒ Object 



411
412
413
 
# File 'lib/sqlite3/pragmas.rb', line 411

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

#schema_version ⇒ Object 



415
416
417
 
# File 'lib/sqlite3/pragmas.rb', line 415

def schema_version
  get_int_pragma "schema_version"
end

#schema_version=(version) ⇒ Object 



419
420
421
 
# File 'lib/sqlite3/pragmas.rb', line 419

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

#secure_delete ⇒ Object 



423
424
425
 
# File 'lib/sqlite3/pragmas.rb', line 423

def secure_delete
  get_boolean_pragma "secure_delete"
end

#secure_delete=(mode) ⇒ Object 



427
428
429
 
# File 'lib/sqlite3/pragmas.rb', line 427

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 



431
432
433
 
# File 'lib/sqlite3/pragmas.rb', line 431

def short_column_names
  get_boolean_pragma "short_column_names"
end

#short_column_names=(mode) ⇒ Object 



435
436
437
 
# File 'lib/sqlite3/pragmas.rb', line 435

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

#shrink_memory ⇒ Object 



439
440
441
 
# File 'lib/sqlite3/pragmas.rb', line 439

def shrink_memory
  execute("PRAGMA shrink_memory")
end

#soft_heap_limit ⇒ Object 



443
444
445
 
# File 'lib/sqlite3/pragmas.rb', line 443

def soft_heap_limit
  get_int_pragma "soft_heap_limit"
end

#soft_heap_limit=(mode) ⇒ Object 



447
448
449
 
# File 'lib/sqlite3/pragmas.rb', line 447

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

#stats(&block) ⇒ Object

:yields: row



451
452
453
 
# File 'lib/sqlite3/pragmas.rb', line 451

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

#synchronous ⇒ Object 



455
456
457
 
# File 'lib/sqlite3/pragmas.rb', line 455

def synchronous
  get_enum_pragma "synchronous"
end

#synchronous=(mode) ⇒ Object 



459
460
461
 
# File 'lib/sqlite3/pragmas.rb', line 459

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.



538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
 
# File 'lib/sqlite3/pragmas.rb', line 538

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 



463
464
465
 
# File 'lib/sqlite3/pragmas.rb', line 463

def temp_store
  get_enum_pragma "temp_store"
end

#temp_store=(mode) ⇒ Object 



467
468
469
 
# File 'lib/sqlite3/pragmas.rb', line 467

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

#threads ⇒ Object 



471
472
473
 
# File 'lib/sqlite3/pragmas.rb', line 471

def threads
  get_int_pragma "threads"
end

#threads=(count) ⇒ Object 



475
476
477
 
# File 'lib/sqlite3/pragmas.rb', line 475

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

#user_cookie ⇒ Object 



479
480
481
 
# File 'lib/sqlite3/pragmas.rb', line 479

def user_cookie
  get_int_pragma "user_cookie"
end

#user_cookie=(cookie) ⇒ Object 



483
484
485
 
# File 'lib/sqlite3/pragmas.rb', line 483

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

#user_version ⇒ Object 



487
488
489
 
# File 'lib/sqlite3/pragmas.rb', line 487

def user_version
  get_int_pragma "user_version"
end

#user_version=(version) ⇒ Object 



491
492
493
 
# File 'lib/sqlite3/pragmas.rb', line 491

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

#vdbe_addoptrace=(mode) ⇒ Object 



495
496
497
 
# File 'lib/sqlite3/pragmas.rb', line 495

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

#vdbe_debug=(mode) ⇒ Object 



499
500
501
 
# File 'lib/sqlite3/pragmas.rb', line 499

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

#vdbe_listing=(mode) ⇒ Object 



503
504
505
 
# File 'lib/sqlite3/pragmas.rb', line 503

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

#vdbe_trace ⇒ Object 



507
508
509
 
# File 'lib/sqlite3/pragmas.rb', line 507

def vdbe_trace
  get_boolean_pragma "vdbe_trace"
end

#vdbe_trace=(mode) ⇒ Object 



511
512
513
 
# File 'lib/sqlite3/pragmas.rb', line 511

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

#wal_autocheckpoint ⇒ Object 



515
516
517
 
# File 'lib/sqlite3/pragmas.rb', line 515

def wal_autocheckpoint
  get_int_pragma "wal_autocheckpoint"
end

#wal_autocheckpoint=(mode) ⇒ Object 



519
520
521
 
# File 'lib/sqlite3/pragmas.rb', line 519

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

#wal_checkpoint ⇒ Object 



523
524
525
 
# File 'lib/sqlite3/pragmas.rb', line 523

def wal_checkpoint
  get_enum_pragma "wal_checkpoint"
end

#wal_checkpoint=(mode) ⇒ Object 



527
528
529
 
# File 'lib/sqlite3/pragmas.rb', line 527

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

#writable_schema=(mode) ⇒ Object 



531
532
533
 
# File 'lib/sqlite3/pragmas.rb', line 531

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