class SQLite3::Database

def authorizer(data = nil, &block)
  result = @driver.set_authorizer(@handle, data, &block)
  Error.check(result, self)
end

def busy_handler(data = nil, &block) # :yields: data, retries
  result = @driver.busy_handler(@handle, data, &block)
  Error.check(result, self)
end

def busy_timeout(ms)
  result = @driver.busy_timeout(@handle, ms)
  Error.check(result, self)
end

def changes
  @driver.changes(@handle)
end

def close
  unless @closed
    result = @driver.close(@handle)
    Error.check(result, self)
  end
  @closed = true
end

def closed?
  @closed
end

def commit
  execute "commit transaction"
  @transaction_active = false
  true
end

def complete?(string, utf16 = false)
  @driver.complete?(string, utf16)
end

def create_aggregate(name, arity, step = nil, finalize = nil, text_rep = Constants::TextRep::ANY, &block)
  # begin
  if block
    proxy = AggregateDefinitionProxy.new
    proxy.instance_eval(&block)
    step ||= proxy.step_callback
    finalize ||= proxy.finalize_callback
  end
  step_callback = proc do |func, *args|
    ctx = @driver.aggregate_context(func)
    unless ctx[:__error]
      begin
        step.call(FunctionProxy.new(@driver, func, ctx), *args.map { |v| Value.new(self, v) })
      rescue Exception => e
        ctx[:__error] = e
      end
    end
  end
  finalize_callback = proc do |func|
    ctx = @driver.aggregate_context(func)
    unless ctx[:__error]
      begin
        finalize.call(FunctionProxy.new(@driver, func, ctx))
      rescue Exception => e
        @driver.result_error(func, "#{e.message} (#{e.class})", -1)
      end
    else
      e = ctx[:__error]
      @driver.result_error(func, "#{e.message} (#{e.class})", -1)
    end
  end
  result = @driver.create_function(@handle, name, arity, text_rep, nil, nil, step_callback, finalize_callback)
  Error.check(result, self)
  self
end

def create_aggregate_handler(handler)
  arity = -1
  text_rep = Constants::TextRep::ANY
  arity = handler.arity if handler.respond_to?(:arity)
  text_rep = handler.text_rep if handler.respond_to?(:text_rep)
  name = handler.name
  step = proc do |func,*args|
    ctx = @driver.aggregate_context(func)
    unless ctx[:__error]
      ctx[:handler] ||= handler.new
      begin
        ctx[:handler].step(FunctionProxy.new(@driver, func, ctx), *args.map{|v| Value.new(self,v)})
      rescue Exception, StandardError => e
        ctx[:__error] = e
      end
    end
  end
  finalize = proc do |func|
    ctx = @driver.aggregate_context(func)
    unless ctx[:__error]
      ctx[:handler] ||= handler.new
      begin
        ctx[:handler].finalize(FunctionProxy.new(@driver, func, ctx))
      rescue Exception => e
        ctx[:__error] = e
      end
    end
    if ctx[:__error]
      e = ctx[:__error]
      @driver.sqlite3_result_error(func, "#{e.message} (#{e.class})", -1)
    end
  end
  result = @driver.create_function(@handle, name, arity, text_rep, nil, nil, step, finalize)
  Error.check(result, self)
  self
end

def create_function(name, arity, text_rep = Constants::TextRep::ANY, &block) # :yields: func, *args
  # begin
  callback = proc do |func, *args|
    begin
      block.call(FunctionProxy.new(@driver, func), *args.map { |v| Value.new(self, v) })
    rescue StandardError, Exception => e
      @driver.result_error(func, "#{e.message} (#{e.class})", -1)
    end
  end
  result = @driver.create_function(@handle, name, arity, text_rep, nil, callback, nil, nil)
  Error.check(result, self)
  self
end

def errcode
  @driver.errcode(@handle)
end

def errmsg(utf16 = false)
  @driver.errmsg(@handle, utf16)
end

def execute(sql, *bind_vars)
  prepare(sql) do |stmt|
    result = stmt.execute(*bind_vars)
    if block_given?
      result.each { |row| yield row }
    else
      return result.inject([]) { |arr, row| arr << row; arr }
    end
  end
end

def execute2(sql, *bind_vars)
  prepare(sql) do |stmt|
    result = stmt.execute(*bind_vars)
    if block_given?
      yield result.columns
      result.each { |row| yield row }
    else
      return result.inject([result.columns]) { |arr,row| arr << row; arr }
    end
  end
end

def execute_batch(sql, *bind_vars)
  sql = sql.strip
  until sql.empty? do
    prepare(sql) do |stmt|
      stmt.execute(*bind_vars)
      sql = stmt.remainder.strip
    end
  end
  nil
end

def get_first_row(sql, *bind_vars)
  execute(sql, *bind_vars) { |row| return row }
  nil
end

def get_first_value(sql, *bind_vars)
  execute(sql, *bind_vars) { |row| return row[0] }
  nil
end

def initialize(file_name, options = {})
  utf16 = options.fetch(:utf16, false)
  load_driver(options[:driver])
  @statement_factory = options[:statement_factory] || Statement
  result, @handle = @driver.open(file_name, utf16)
  Error.check(result, self, "could not open database")
  @closed = false
  @results_as_hash = options.fetch(:results_as_hash,false)
  @type_translation = options.fetch(:type_translation,false)
  @translator = nil
  @transaction_active = false
end

def interrupt
  @driver.interrupt(@handle)
end

def last_insert_row_id
  @driver.last_insert_rowid(@handle)
end

def load_driver(driver)
  case driver
  when Class
    # do nothing--use what was given
  when Symbol, String
    require "sqlite3/driver/#{driver.to_s.downcase}/driver"
    driver = SQLite3::Driver.const_get(driver)::Driver
  else
    ["FFI"].each do |d|
      begin
        require "sqlite3/driver/#{d.downcase}/driver"
        driver = SQLite3::Driver.const_get(d)::Driver
        break
      rescue SyntaxError
        raise
      rescue ScriptError, Exception, NameError
      end
    end
    raise "no driver for sqlite3 found" unless driver
  end
  @driver = driver.new
end

def prepare(sql)
  stmt = @statement_factory.new(self, sql)
  if block_given?
    begin
      yield stmt
    ensure
      stmt.close
    end
  else
    return stmt
  end
end

def query(sql, *bind_vars)
  result = prepare(sql).execute(*bind_vars)
  if block_given?
    begin
      yield result
    ensure
      result.close
    end
  else
    return result
  end
end

def quote(string)
  string.gsub(/'/, "''")
end

def rollback
  execute "rollback transaction"
  @transaction_active = false
  true
end

def total_changes
  @driver.total_changes(@handle)
end

def trace(data = nil, &block)
  @driver.trace(@handle, data, &block)
end

def transaction(mode = :deferred)
  execute "begin #{mode.to_s} transaction"
  @transaction_active = true
  if block_given?
    abort = false
    begin
      yield self
    rescue ::Object
      abort = true
      raise
    ensure
      abort and rollback or commit
    end
  end
  true
end

def transaction_active?
  @transaction_active
end

def translator
  @translator ||= Translator.new
end