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 



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_vacuum ⇒ Object 



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_index ⇒ Object 



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_timeout ⇒ Object 



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_size ⇒ Object 



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_spill ⇒ Object 



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_check ⇒ Object 



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_fullfsync ⇒ Object 



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_changes ⇒ Object 



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_version ⇒ Object 



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_size ⇒ Object 



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_synchronous ⇒ Object 



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_store ⇒ Object 



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_keys ⇒ Object 



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

#encoding ⇒ Object 



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_keys ⇒ Object 



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_count ⇒ Object 



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

def freelist_count
  get_int_pragma "freelist_count"
end

#full_column_names ⇒ Object 



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

#fullfsync ⇒ Object 



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, *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.



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

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 



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_mode ⇒ Object 



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_limit ⇒ Object 



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_format ⇒ Object 



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_mode ⇒ Object 



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_count ⇒ Object 



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_size ⇒ Object 



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_count ⇒ Object 



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

def page_count
  get_int_pragma "page_count"
end

#page_size ⇒ Object 



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_only ⇒ Object 



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_uncommitted ⇒ Object 



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_triggers ⇒ Object 



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_selects ⇒ Object 



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

#schema_cookie ⇒ Object 



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_version ⇒ Object 



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_delete ⇒ Object 



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_names ⇒ Object 



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_memory ⇒ Object 



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

def shrink_memory
  execute( "PRAGMA shrink_memory" )
end

#soft_heap_limit ⇒ Object 



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

#synchronous ⇒ Object 



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
556
557
558
559
560
561
562
 
# 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

    # 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 



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

#threads ⇒ Object 



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

#user_cookie ⇒ Object 



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_version ⇒ Object 



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_trace ⇒ Object 



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_autocheckpoint ⇒ Object 



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_checkpoint ⇒ Object 



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