class SQLite3::Database

def self.arity
  @arity
end

def self.arity
  # this is what sqlite3_obj_method_arity did before
  @template.method(:step).arity
end

def self.finalize( &block )
  define_method(:finalize_with_ctx, &block)
end

def self.name
  @name
end

def self.name
  @name
end

def self.step( &block )
  define_method(:step_with_ctx, &block)
end

def self.template
  @template
end

def authorizer( &block )
  self.authorizer = block
end

def commit
  execute "commit transaction"
  true
end

def create_aggregate( name, arity, step=nil, finalize=nil,
  text_rep=Constants::TextRep::ANY, &block )
  proxy = Class.new do
    def self.step( &block )
      define_method(:step_with_ctx, &block)
    end
    def self.finalize( &block )
      define_method(:finalize_with_ctx, &block)
    end
  end
  if block_given?
    proxy.instance_eval(&block)
  else
    proxy.class_eval do
      define_method(:step_with_ctx, step)
      define_method(:finalize_with_ctx, finalize)
    end
  end
  proxy.class_eval do
    # class instance variables
    @name = name
    @arity = arity
    def self.name
      @name
    end
    def self.arity
      @arity
    end
    def initialize
      @ctx = FunctionProxy.new
    end
    def step( *args )
      step_with_ctx(@ctx, *args)
    end
    def finalize
      finalize_with_ctx(@ctx)
      @ctx.result
    end
  end
  define_aggregator2(proxy, name)
end

def create_aggregate_handler( handler )
  # This is a compatibility shim so the (basically pointless) FunctionProxy
  # "ctx" object is passed as first argument to both step() and finalize().
  # Now its up to the library user whether he prefers to store his
  # temporaries as instance variables or fields in the FunctionProxy.
  # The library user still must set the result value with
  # FunctionProxy.result= as there is no backwards compatible way to
  # change this.
  proxy = Class.new(handler) do
    def initialize
      super
      @fp = FunctionProxy.new
    end
    def step( *args )
      super(@fp, *args)
    end
    def finalize
      super(@fp)
      @fp.result
    end
  end
  define_aggregator2(proxy, proxy.name)
  self
end

def create_function name, arity, text_rep=Constants::TextRep::UTF8, &block
  define_function_with_flags(name, text_rep) do |*args|
    fp = FunctionProxy.new
    block.call(fp, *args)
    fp.result
  end
  self
end

def define_aggregator( name, aggregator )
  # Previously, this has been implemented in C. Now this is just yet
  # another compatibility shim
  proxy = Class.new do
    @template = aggregator
    @name = name
    def self.template
      @template
    end
    def self.name
      @name
    end
    def self.arity
      # this is what sqlite3_obj_method_arity did before
      @template.method(:step).arity
    end
    def initialize
      @klass = self.class.template.clone
    end
    def step(*args)
      @klass.step(*args)
    end
    def finalize
      @klass.finalize
    end
  end
  define_aggregator2(proxy, name)
  self
end

def execute sql, bind_vars = [], *args, &block
  if bind_vars.nil? || !args.empty?
    if args.empty?
      bind_vars = []
    else
      bind_vars = [bind_vars] + args
    end
    warn(<<-eowarn) if $VERBOSE
ller[0]} is calling `SQLite3::Database#execute` with nil or multiple bind params without using an array.  Please switch to passing bind parameters as an array. Support for bind parameters as *args will be removed in 2.0.0.
    eowarn
  end
  prepare( sql ) do |stmt|
    stmt.bind_params(bind_vars)
    stmt    = ResultSet.new self, stmt
    if block_given?
      stmt.each do |row|
        yield row
      end
    else
      stmt.to_a
    end
  end
end

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

def execute_batch( sql, bind_vars = [], *args )
  # FIXME: remove this stuff later
  unless [Array, Hash].include?(bind_vars.class)
    bind_vars = [bind_vars]
    warn(<<-eowarn) if $VERBOSE
ller[0]} is calling `SQLite3::Database#execute_batch` with bind parameters that are not a list of a hash.  Please switch to passing bind parameters as an array or hash. Support for this behavior will be removed in version 2.0.0.
    eowarn
  end
  # FIXME: remove this stuff later
  if bind_vars.nil? || !args.empty?
    if args.empty?
      bind_vars = []
    else
      bind_vars = [nil] + args
    end
    warn(<<-eowarn) if $VERBOSE
ller[0]} is calling `SQLite3::Database#execute_batch` with nil or multiple bind params without using an array.  Please switch to passing bind parameters as an array. Support for this behavior will be removed in version 2.0.0.
    eowarn
  end
  sql = sql.strip
  until sql.empty? do
    prepare( sql ) do |stmt|
      unless stmt.closed?
        # FIXME: this should probably use sqlite3's api for batch execution
        # This implementation requires stepping over the results.
        if bind_vars.length == stmt.bind_parameter_count
          stmt.bind_params(bind_vars)
        end
        stmt.step
      end
      sql = stmt.remainder.strip
    end
  end
  # FIXME: we should not return `nil` as a success return value
  nil
end

def execute_batch2(sql, &block)
  if block_given?
    result = exec_batch(sql, @results_as_hash)
    result.map do |val|
      yield val
    end
  else
    exec_batch(sql, @results_as_hash)
  end
end

def filename db_name = 'main'
  db_filename db_name
end

def finalize
  finalize_with_ctx(@ctx)
  @ctx.result
end

def finalize
  super(@fp)
  @fp.result
end

def finalize
  @klass.finalize
end

def get_first_row( sql, *bind_vars )
  execute( sql, *bind_vars ).first
end

def get_first_value( sql, *bind_vars )
  query( sql, bind_vars ) do |rs|
    if (row = rs.next)
      return @results_as_hash ? row[rs.columns[0]] : row[0]
    end
  end
  nil
end

def initialize file, options = {}, zvfs = nil
  mode = Constants::Open::READWRITE | Constants::Open::CREATE
  file = file.to_path if file.respond_to? :to_path
  if file.encoding == ::Encoding::UTF_16LE || file.encoding == ::Encoding::UTF_16BE || options[:utf16]
    open16 file
  else
    # The three primary flag values for sqlite3_open_v2 are:
    # SQLITE_OPEN_READONLY
    # SQLITE_OPEN_READWRITE
    # SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE -- always used for sqlite3_open and sqlite3_open16
    mode = Constants::Open::READONLY if options[:readonly]
    if options[:readwrite]
      raise "conflicting options: readonly and readwrite" if options[:readonly]
      mode = Constants::Open::READWRITE
    end
    if options[:flags]
      if options[:readonly] || options[:readwrite]
        raise "conflicting options: flags with readonly and/or readwrite"
      end
      mode = options[:flags]
    end
    open_v2 file.encode("utf-8"), mode, zvfs
    if options[:strict]
      disable_quirk_mode
    end
  end
  @tracefunc        = nil
  @authorizer       = nil
  @encoding         = nil
  @busy_handler     = nil
  @collations       = {}
  @functions        = {}
  @results_as_hash  = options[:results_as_hash]
  @type_translation = options[:type_translation]
  @type_translator  = make_type_translator @type_translation
  @readonly         = mode & Constants::Open::READONLY != 0
  if block_given?
    begin
      yield self
    ensure
      close
    end
  end
end

def initialize
  @ctx = FunctionProxy.new
end

def initialize
  super
  @fp = FunctionProxy.new
end

def initialize
  @klass = self.class.template.clone
end

def make_type_translator should_translate
  if should_translate
    lambda { |types, row|
      types.zip(row).map do |type, value|
        translator.translate( type, value )
      end
    }
  else
    NULL_TRANSLATOR
  end
end

def prepare sql
  stmt = SQLite3::Statement.new( self, sql )
  return stmt unless block_given?
  begin
    yield stmt
  ensure
    stmt.close unless stmt.closed?
  end
end

def query( sql, bind_vars = [], *args )
  if bind_vars.nil? || !args.empty?
    if args.empty?
      bind_vars = []
    else
      bind_vars = [bind_vars] + args
    end
    warn(<<-eowarn) if $VERBOSE
ller[0]} is calling `SQLite3::Database#query` with nil or multiple bind params without using an array.  Please switch to passing bind parameters as an array. Support for this will be removed in version 2.0.0.
    eowarn
  end
  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 readonly?
  @readonly
end

def rollback
  execute "rollback transaction"
  true
end

def step( *args )
  step_with_ctx(@ctx, *args)
end

def step( *args )
  super(@fp, *args)
end

def step(*args)
  @klass.step(*args)
end

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

def translate_from_db types, row
  @type_translator.call types, row
end

def translator
  @translator ||= Translator.new
end

def type_translation= value # :nodoc:
  warn(<<-eowarn) if $VERBOSE
ller[0]} is calling `SQLite3::Database#type_translation=` which is deprecated and will be removed in version 2.0.0.
  eowarn
  @type_translator  = make_type_translator value
  @type_translation = value
end