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_idObject


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

def application_id
  get_int_pragma "application_id"
end

#application_id=(integer) ⇒ Object


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

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

#auto_vacuumObject


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

def auto_vacuum
  get_enum_pragma "auto_vacuum"
end

#auto_vacuum=(mode) ⇒ Object


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

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

#automatic_indexObject


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

def automatic_index
  get_boolean_pragma "automatic_index"
end

#automatic_index=(mode) ⇒ Object


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

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

#busy_timeoutObject


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

def busy_timeout
  get_int_pragma "busy_timeout"
end

#busy_timeout=(milliseconds) ⇒ Object


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

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

#cache_sizeObject


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

def cache_size
  get_int_pragma "cache_size"
end

#cache_size=(size) ⇒ Object


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

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

#cache_spillObject


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

def cache_spill
  get_boolean_pragma "cache_spill"
end

#cache_spill=(mode) ⇒ Object


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

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

#case_sensitive_like=(mode) ⇒ Object


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

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

#cell_size_checkObject


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

def cell_size_check
  get_boolean_pragma "cell_size_check"
end

#cell_size_check=(mode) ⇒ Object


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

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

#checkpoint_fullfsyncObject


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

def checkpoint_fullfsync
  get_boolean_pragma "checkpoint_fullfsync"
end

#checkpoint_fullfsync=(mode) ⇒ Object


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

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

#collation_list(&block) ⇒ Object

:yields: row


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

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

#compile_options(&block) ⇒ Object

:yields: row


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

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

#count_changesObject


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

def count_changes
  get_boolean_pragma "count_changes"
end

#count_changes=(mode) ⇒ Object


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

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

#data_versionObject


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

def data_version
  get_int_pragma "data_version"
end

#database_list(&block) ⇒ Object

:yields: row


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

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

#default_cache_sizeObject


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

def default_cache_size
  get_int_pragma "default_cache_size"
end

#default_cache_size=(size) ⇒ Object


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

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

#default_synchronousObject


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

def default_synchronous
  get_enum_pragma "default_synchronous"
end

#default_synchronous=(mode) ⇒ Object


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

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

#default_temp_storeObject


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

def default_temp_store
  get_enum_pragma "default_temp_store"
end

#default_temp_store=(mode) ⇒ Object


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

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

#defer_foreign_keysObject


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

def defer_foreign_keys
  get_boolean_pragma "defer_foreign_keys"
end

#defer_foreign_keys=(mode) ⇒ Object


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

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

#encodingObject


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

def encoding
  get_enum_pragma "encoding"
end

#encoding=(mode) ⇒ Object


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

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

#foreign_key_check(*table, &block) ⇒ Object

:yields: row


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

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


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

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

#foreign_keysObject


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

def foreign_keys
  get_boolean_pragma "foreign_keys"
end

#foreign_keys=(mode) ⇒ Object


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

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

#freelist_countObject


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

def freelist_count
  get_int_pragma "freelist_count"
end

#full_column_namesObject


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

def full_column_names
  get_boolean_pragma "full_column_names"
end

#full_column_names=(mode) ⇒ Object


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

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

#fullfsyncObject


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

def fullfsync
  get_boolean_pragma "fullfsync"
end

#fullfsync=(mode) ⇒ Object


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

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.


55
56
57
# File 'lib/sqlite3/pragmas.rb', line 55

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.


72
73
74
# File 'lib/sqlite3/pragmas.rb', line 72

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

#get_query_pragma(name, *parms, &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.


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

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

#ignore_check_constraints=(mode) ⇒ Object


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

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

#incremental_vacuum(pages, &block) ⇒ Object

:yields: row


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

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

#index_info(index, &block) ⇒ Object

:yields: row


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

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

#index_list(table, &block) ⇒ Object

:yields: row


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

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

#index_xinfo(index, &block) ⇒ Object

:yields: row


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

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

#integrity_check(*num_errors, &block) ⇒ Object

:yields: row


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

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

#journal_modeObject


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

def journal_mode
  get_enum_pragma "journal_mode"
end

#journal_mode=(mode) ⇒ Object


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

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

#journal_size_limitObject


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

def journal_size_limit
  get_int_pragma "journal_size_limit"
end

#journal_size_limit=(size) ⇒ Object


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

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

#legacy_file_formatObject


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

def legacy_file_format
  get_boolean_pragma "legacy_file_format"
end

#legacy_file_format=(mode) ⇒ Object


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

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

#locking_modeObject


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

def locking_mode
  get_enum_pragma "locking_mode"
end

#locking_mode=(mode) ⇒ Object


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

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

#max_page_countObject


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

def max_page_count
  get_int_pragma "max_page_count"
end

#max_page_count=(size) ⇒ Object


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

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

#mmap_sizeObject


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

def mmap_size
  get_int_pragma "mmap_size"
end

#mmap_size=(size) ⇒ Object


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

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

#page_countObject


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

def page_count
  get_int_pragma "page_count"
end

#page_sizeObject


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

def page_size
  get_int_pragma "page_size"
end

#page_size=(size) ⇒ Object


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

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

#parser_trace=(mode) ⇒ Object


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

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

#query_onlyObject


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

def query_only
  get_boolean_pragma "query_only"
end

#query_only=(mode) ⇒ Object


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

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

#quick_check(*num_errors, &block) ⇒ Object

:yields: row


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

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

#read_uncommittedObject


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

def read_uncommitted
  get_boolean_pragma "read_uncommitted"
end

#read_uncommitted=(mode) ⇒ Object


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

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

#recursive_triggersObject


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

def recursive_triggers
  get_boolean_pragma "recursive_triggers"
end

#recursive_triggers=(mode) ⇒ Object


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

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

#reverse_unordered_selectsObject


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

def reverse_unordered_selects
  get_boolean_pragma "reverse_unordered_selects"
end

#reverse_unordered_selects=(mode) ⇒ Object


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

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

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

def schema_cookie
  get_int_pragma "schema_cookie"
end

#schema_cookie=(cookie) ⇒ Object


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

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

#schema_versionObject


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

def schema_version
  get_int_pragma "schema_version"
end

#schema_version=(version) ⇒ Object


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

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

#secure_deleteObject


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

def secure_delete
  get_boolean_pragma "secure_delete"
end

#secure_delete=(mode) ⇒ Object


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

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
39
40
# 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"; mode = "'ON'"
      when "off", "no", "false", "n", "f"; mode = "'OFF'"
      else
          raise Exception,
            "unrecognized pragma parameter #{mode.inspect}"
      end
  when true, 1
      mode = "ON"
  when false, 0, nil
      mode = "OFF"
  else
      raise 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.

Raises:


64
65
66
67
68
69
# File 'lib/sqlite3/pragmas.rb', line 64

def set_enum_pragma( name, mode, enums )
  match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
  raise Exception,
    "unrecognized #{name} #{mode.inspect}" unless match
  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.


78
79
80
# File 'lib/sqlite3/pragmas.rb', line 78

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

#short_column_namesObject


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

def short_column_names
  get_boolean_pragma "short_column_names"
end

#short_column_names=(mode) ⇒ Object


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

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

#shrink_memoryObject


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

def shrink_memory
  execute( "PRAGMA shrink_memory" )
end

#soft_heap_limitObject


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

def soft_heap_limit
  get_int_pragma "soft_heap_limit"
end

#soft_heap_limit=(mode) ⇒ Object


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

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

#stats(&block) ⇒ Object

:yields: row


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

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

#synchronousObject


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

def synchronous
  get_enum_pragma "synchronous"
end

#synchronous=(mode) ⇒ Object


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

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.


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
554
555
# File 'lib/sqlite3/pragmas.rb', line 527

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 = Hash[columns.zip(row)]

    # FIXME: This should be removed but is required for older versions
    # of rails
    if(Object.const_defined?(:ActiveRecord))
      new_row['notnull'] = new_row['notnull'].to_s
    end

    tweak_default(new_row) if needs_tweak_default

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

  result
end

#temp_storeObject


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

def temp_store
  get_enum_pragma "temp_store"
end

#temp_store=(mode) ⇒ Object


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

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

#threadsObject


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

def threads
  get_int_pragma "threads"
end

#threads=(count) ⇒ Object


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

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

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

def user_cookie
  get_int_pragma "user_cookie"
end

#user_cookie=(cookie) ⇒ Object


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

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

#user_versionObject


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

def user_version
  get_int_pragma "user_version"
end

#user_version=(version) ⇒ Object


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

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

#vdbe_addoptrace=(mode) ⇒ Object


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

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

#vdbe_debug=(mode) ⇒ Object


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

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

#vdbe_listing=(mode) ⇒ Object


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

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

#vdbe_traceObject


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

def vdbe_trace
  get_boolean_pragma "vdbe_trace"
end

#vdbe_trace=(mode) ⇒ Object


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

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

#wal_autocheckpointObject


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

def wal_autocheckpoint
  get_int_pragma "wal_autocheckpoint"
end

#wal_autocheckpoint=(mode) ⇒ Object


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

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

#wal_checkpointObject


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

def wal_checkpoint
  get_enum_pragma "wal_checkpoint"
end

#wal_checkpoint=(mode) ⇒ Object


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

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

#writable_schema=(mode) ⇒ Object


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

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