Parent

SQLite3::Driver::DL::Driver

Constants

STATIC
TRANSIENT

Public Class Methods

api_delegate( name ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 227
def self.api_delegate( name )
  define_method( name ) { |*args| API.send( "sqlite3_#{name}", *args ) }
end

Public Instance Methods

aggregate_context( context ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 190
def aggregate_context( context )
  ptr = API.sqlite3_aggregate_context( context, 4 )
  ptr.free = nil
  obj = ( ptr ? ptr.to_object : nil )
  if obj.nil?
    obj = Hash.new
    ptr.set_object obj
  end
  obj
end
bind_blob( stmt, index, value ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 201
def bind_blob( stmt, index, value )
  s = value.to_s
  API.sqlite3_bind_blob( stmt, index, s, s.length, TRANSIENT )
end
bind_text( stmt, index, value, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 206
def bind_text( stmt, index, value, utf16=false )
  s = value.to_s
  method = ( utf16 ? :sqlite3_bind_text16 : :sqlite3_bind_text )
  API.send( method, stmt, index, s, s.length, TRANSIENT )
end
busy_handler( db, data=nil, &block ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 113
def busy_handler( db, data=nil, &block )
  @busy_handler = block

  unless @busy_handler_callback
    @busy_handler_callback = ::DL.callback( "IPI" ) do |cookie, timeout|
      @busy_handler.call( cookie, timeout ) || 0
    end
  end

  API.sqlite3_busy_handler( db, block&&@busy_handler_callback, data )
end
column_blob( stmt, column ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 95
def column_blob( stmt, column )
  blob = API.sqlite3_column_blob( stmt, column )
  blob.free = nil
  blob.to_s( API.sqlite3_column_bytes( stmt, column ) )
end
column_decltype( stmt, column ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 222
def column_decltype( stmt, column )
  result = API.sqlite3_column_decltype( stmt, column )
  result ? result.to_s : nil
end
column_name( stmt, column ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 217
def column_name( stmt, column )
  result = API.sqlite3_column_name( stmt, column )
  result ? result.to_s : nil
end
column_text( stmt, column ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 212
def column_text( stmt, column )
  result = API.sqlite3_column_text( stmt, column )
  result ? result.to_s : nil
end
commit_hook( db, data=nil, &block ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 280
def commit_hook( db, data=nil, &block )
  @commit_hook_handler = block

  unless @commit_hook_handler_callback
    @commit_hook_handler_callback = ::DL.callback( "IP" ) do |cookie|
      @commit_hook_handler.call( cookie )
    end
  end

  API.sqlite3_commit_hook( db, block&&@commit_hook_handler_callback,
    data )
end
complete?( sql, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 67
def complete?( sql, utf16=false )
  API.send( utf16 ? :sqlite3_complete16 : :sqlite3_complete, sql+"\00"" )
end
create_function( db, name, args, text, cookie, func, step, final ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 152
def create_function( db, name, args, text, cookie,
  func, step, final )
# begin
  if @func_handler_callback.nil? && func
    @func_handler_callback = ::DL.callback( "0PIP" ) do |context,nargs,args|
      args = args.to_s(nargs*4).unpack("L*").map {|i| ::DL::PtrData.new(i)}
      data = API.sqlite3_user_data( context ).to_object
      data[:func].call( context, *args )
    end
  end

  if @step_handler_callback.nil? && step
    @step_handler_callback = ::DL.callback( "0PIP" ) do |context,nargs,args|
      args = args.to_s(nargs*4).unpack("L*").map {|i| ::DL::PtrData.new(i)}
      data = API.sqlite3_user_data( context ).to_object
      data[:step].call( context, *args )
    end
  end

  if @final_handler_callback.nil? && final
    @final_handler_callback = ::DL.callback( "0P" ) do |context|
      data = API.sqlite3_user_data( context ).to_object
      data[:final].call( context )
    end
  end

  data = { :cookie => cookie,
           :name => name,
           :func => func,
           :step => step,
           :final => final }

  API.sqlite3_create_function( db, name, args, text, data,
    ( func ? @func_handler_callback : nil ),
    ( step ? @step_handler_callback : nil ),
    ( final ? @final_handler_callback : nil ) )
end
errmsg( db, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 44
def errmsg( db, utf16=false )
  if utf16
    msg = API.sqlite3_errmsg16( db )
    msg.free = nil
    msg.to_s(utf16_length(msg))
  else
    API.sqlite3_errmsg( db )
  end
end
open( filename, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 37
def open( filename, utf16=false )
  handle = ::DL::PtrData.new(0)
  result = API.send( ( utf16 ? :sqlite3_open16 : :sqlite3_open ),
    filename+"\00"", handle.ref )
  [ result, handle ]
end
prepare( db, sql, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 54
def prepare( db, sql, utf16=false )
  handle = ::DL::PtrData.new(0)
  remainder = ::DL::PtrData.new(0)

  result = API.send( ( utf16 ? :sqlite3_prepare16 : :sqlite3_prepare ),
     db, sql+"\00"", sql.length, handle.ref, remainder.ref )

  args = utf16 ? [ utf16_length(remainder) ] : []
  remainder = remainder.to_s( *args )

  [ result, handle, remainder ]
end
progress_handler( db, n, data=nil, &block ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 267
def progress_handler( db, n, data=nil, &block )
  @progress_handler = block

  unless @progress_handler_callback
    @progress_handler_callback = ::DL.callback( "IP" ) do |cookie|
      @progress_handler.call( cookie )
    end
  end

  API.sqlite3_progress_handler( db, n, block&&@progress_handler_callback,
    data )
end
result_text( func, text, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 101
def result_text( func, text, utf16=false )
  method = case utf16
    when false, nil then :sqlite3_result_text
    when :le then :sqlite3_result_text16le
    when :be then :sqlite3_result_text16be
    else :sqlite3_result_text16
  end

  s = text.to_s
  API.send( method, func, s, s.length, TRANSIENT )
end
set_authorizer( db, data=nil, &block ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 125
def set_authorizer( db, data=nil, &block )
  @authorizer_handler = block

  unless @authorizer_handler_callback
    @authorizer_handler_callback = ::DL.callback( "IPIPPPP"
    ) do |cookie,mode,a,b,c,d|
      @authorizer_handler.call( cookie, mode,
        a&&a.to_s, b&&b.to_s, c&&c.to_s, d&&d.to_s ) || 0
    end
  end

  API.sqlite3_set_authorizer( db, block&&@authorizer_handler_callback,
    data )
end
trace( db, data=nil, &block ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 140
def trace( db, data=nil, &block )
  @trace_handler = block

  unless @trace_handler_callback
    @trace_handler_callback = ::DL.callback( "IPS" ) do |cookie,sql|
      @trace_handler.call( cookie ? cookie.to_object : nil, sql ) || 0
    end
  end

  API.sqlite3_trace( db, block&&@trace_handler_callback, data )
end
value_blob( value ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 71
def value_blob( value )
  blob = API.sqlite3_value_blob( value )
  blob.free = nil
  blob.to_s( API.sqlite3_value_bytes( value ) )
end
value_text( value, utf16=false ) click to toggle source
# File lib/sqlite3/driver/dl/driver.rb, line 77
def value_text( value, utf16=false )
  method = case utf16
    when nil, false then :sqlite3_value_text
    when :le then :sqlite3_value_text16le
    when :be then :sqlite3_value_text16be
    else :sqlite3_value_text16
  end

  result = API.send( method, value )
  if utf16
    result.free = nil
    size = API.sqlite3_value_bytes( value )
    result = result.to_s( size )
  end

  result
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.