Class: SLDB::AbstractSLDB

Inherits:

Object

• Object
• SLDB::AbstractSLDB

Includes:

Util

Defined in:

lib/sldb.rb,
lib/sldb-0.2.0.rb

Instance Method Summary

• #execute(sql, &block) ⇒ Object
• #field_names(table_name = nil) ⇒ Object (also: #fieldnames, #fields, #fields_for)
• #h2t(h, table_name = nil) ⇒ Object
• #initialize(*args) ⇒ AbstractSLDB constructor

  A new instance of AbstractSLDB.

• #integrity_check ⇒ Object
• #lock(opts = {}) ⇒ Object (also: #write_lock)
• #read_lock(opts = {}, &block) ⇒ Object (also: #rlock)
• #ro_transaction(opts = {}, &block) ⇒ Object (also: #read_only_transaction)
• #t2h(tuple) ⇒ Object
• #table_names ⇒ Object (also: #tablenames)
• #transaction(opts = {}) ⇒ Object
• #tuple(table_name = nil) ⇒ Object (also: #tuple_for)
• #vacuum ⇒ Object

Methods included from Util

append_features, #env_boolean, #env_float, #env_floatlist, #env_int, #env_intlist, #erreq, #escape, #escape!, export, #fork, #getopt, #hashify, #host, #hostname, #optfilter, #quote, #stamptime, #system, #timestamp, #tmpnam, #uncache

Constructor Details

#initialize(*args) ⇒ AbstractSLDB

Returns a new instance of AbstractSLDB.

Raises:

• (ArgumentError)

# File 'lib/sldb.rb', line 552

def initialize(*args)
#--{{{
  @args, @opts = Util::optfilter args
  @path = @args.first || __getopt('path')
  raise ArgumentError, 'no path' unless @path

  @dirname             = @path
  @dbpath              = File::join @dirname, 'db'
  @schema              = File::join @dirname, '.schema' 
  @waiting_w           = File::join @dirname, ".#{ Util::hostname }.#{ $$ }.waiting.w"
  @waiting_r           = File::join @dirname, ".#{ Util::hostname }.#{ $$ }.waiting.r"
  @lock_w              = File::join @dirname, ".#{ Util::hostname }.#{ $$ }.lock.w"
  @lock_r              = File::join @dirname, ".#{ Util::hostname }.#{ $$ }.lock.r"
  @lockfile            = File::join @dirname, '.lock'
  @lockf               = Lockfile::new(File::join(@dirname, '.lockf'))
  @in_transaction      = false
  @in_ro_transaction   = false
  @db                  = nil
  @synchronizing       = false
  @lockd_recover       = File::join(File::dirname(@dirname), ".#{ File::basename(@dirname) }.lockd_recover")
  @lockd_recover_lockf = Lockfile::new "#{ @lockd_recover }.lock"
  @lockd_recovered     = false

  @sync = Sync::new

  @logger                         = __getopt 'logger', SLDB::default_logger
  @sql_debug                      = __getopt 'sql_debug'
  @busy_sc                        = __getopt 'busy_sc'
  @transaction_retries            = __getopt 'transaction_retries'
  @aquire_lock_sc                 = __getopt 'aquire_lock_sc'
  @transaction_retries_sc         = __getopt 'transaction_retries_sc'
  @attempt_lockd_recovery         = __getopt 'attempt_lockd_recovery'
  @lockd_recover_wait             = __getopt 'lockd_recover_wait'
  @aquire_lock_lockfile_stale_age = __getopt 'aquire_lock_lockfile_stale_age'
  @aquire_lock_refresh_rate       = __getopt 'aquire_lock_refresh_rate'
  @refresher                      = __getopt 'refresher'
  @administrator                  = __getopt 'administrator'

  __bootstrap
#--}}}
end

Instance Method Details

#execute(sql, &block) ⇒ Object

# File 'lib/sldb.rb', line 650

def execute sql, &block
#--{{{
  raise 'not in transaction' unless @in_transaction or @in_ro_transaction
  raise 'not connected' unless @connected
  __logger << "sql_debug:\n#{ sql }\n" if @sql_debug
  begin
    @db.execute sql, &block
  rescue SQLite::SQLException => e
    error{ "bad sql!\n#{ sql }" }
    raise
  end
#--}}}
end

#field_names(table_name = nil) ⇒ Object Also known as: fieldnames, fields, fields_for

# File 'lib/sldb.rb', line 744

def field_names table_name = nil
#--{{{
  fields = Hash::new{|h,k| h[k] = []}
  ro_transaction do
    tnames = (table_name ? [table_name] : table_names)
    tnames.each do |tname|
      tuples = execute "pragma table_info('#{ tname }')"
      tuples.each{|t| fields[tname] << t['name']}
    end
  end
  table_name ? fields[table_name] : fields
#--}}}
end

#h2t(h, table_name = nil) ⇒ Object

Raises:

• (ArgumentError)

# File 'lib/sldb.rb', line 770

def h2t h, table_name = nil
#--{{{
  table_name = table_names.first
  raise ArgumentError, "no table_name" unless table_name
  fields = field_names table_name
  t = tuple
  fields.each{|f| t[f] = h[f]}
  t
#--}}}
end

#integrity_check ⇒ Object

# File 'lib/sldb.rb', line 690

def integrity_check
#--{{{
  debug{ "running integrity_check on <#{ @dbpath }>" }
  ret = nil
  __synchronizing do
    if @in_transaction
      ret = yield 
    else
      __busy_catch do
        __transaction do
          __lockd_recover_wrap(opts) do
            __transaction_wrap(opts) do
              __aquire_lock(opts) do
                __connect(opts) do
                  tuple = execute 'PRAGMA integrity_check;'
                  ret = (tuple and tuple.first and (tuple.first["integrity_check"] =~ /^\s*ok\s*$/io))
                end
              end
            end
          end
        end
      end
    end
  end
  ret
#--}}}
end

#lock(opts = {}) ⇒ Object Also known as: write_lock

# File 'lib/sldb.rb', line 718

def lock opts = {} 
#--{{{
  __lockd_recover_wrap(opts){ __aquire_lock(opts){ yield }}
#--}}}
end

#read_lock(opts = {}, &block) ⇒ Object Also known as: rlock

# File 'lib/sldb.rb', line 726

def read_lock(opts = {}, &block)
#--{{{
  opts['read_only'] = true
  lock opts, &block
#--}}}
end

#ro_transaction(opts = {}, &block) ⇒ Object Also known as: read_only_transaction

# File 'lib/sldb.rb', line 594

def ro_transaction(opts = {}, &block)
#--{{{
  ret = nil
  opts['read_only'] = true
  __synchronizing do
    if @in_ro_transaction or @in_transaction
      ret = yield 
    else
      __busy_catch do
        __ro_transaction do
          __lockd_recover_wrap(opts) do
            __transaction_wrap(opts) do
              __aquire_lock(opts) do
                __connect(opts) do
                  ret = yield 
                end
              end
            end
          end
        end
      end
    end
  end
  ret
#--}}}
end

#t2h(tuple) ⇒ Object

# File 'lib/sldb.rb', line 761

def t2h tuple
#--{{{
  h = {}
  fields = tuple.fields
  fields.each{|f| h[f] = tuple[f]}
  h
#--}}}
end

#table_names ⇒ Object Also known as: tablenames

# File 'lib/sldb.rb', line 734

def table_names
#--{{{
  ro_transaction do
    tuples = execute "select name from sqlite_master where type = 'table' and name notnull"
    tuples.map{|t| t['name']}
  end
#--}}}
end

#transaction(opts = {}) ⇒ Object

# File 'lib/sldb.rb', line 622

def transaction opts = {} 
#--{{{
  ret = nil
  __synchronizing do
    if @in_transaction
      ret = yield 
    else
      __busy_catch do
        __transaction do
          __lockd_recover_wrap(opts) do
            __transaction_wrap(opts) do
              __aquire_lock(opts) do
                __connect(opts) do
                  execute 'begin'
                  ret = yield 
                  execute 'commit'
                end
              end
            end
          end
        end
      end
    end
  end
  ret
#--}}}
end

#tuple(table_name = nil) ⇒ Object Also known as: tuple_for

Raises:

• (ArgumentError)

# File 'lib/sldb.rb', line 781

def tuple table_name = nil
#--{{{
  table_name = table_names.first
  raise ArgumentError, "no table_name" unless table_name
  fields = field_names table_name
  t = Array::new fields.size
  t.fields = fields 
  t
#--}}}
end

#vacuum ⇒ Object

# File 'lib/sldb.rb', line 664

def vacuum
#--{{{
  ret = false 
  __synchronizing do
    if @in_transaction
      ret = yield 
    else
      __busy_catch do
        __transaction do
          __lockd_recover_wrap(opts) do
            __transaction_wrap(opts) do
              __aquire_lock(opts) do
                __connect(opts) do
                  ret = execute 'vacuum'
                end
              end
            end
          end
        end
      end
    end
  end
  ret
#--}}}
end