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 build_result_set stmt
  if results_as_hash
    HashResultSet.new(self, stmt)
  else
    ResultSet.new(self, stmt)
  end
end

def busy_handler_timeout=(milliseconds)
  timeout_seconds = milliseconds.fdiv(1000)
  busy_handler do |count|
    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
    if count.zero?
      @timeout_deadline = now + timeout_seconds
    elsif now > @timeout_deadline
      next false
    else
      sleep(0.001)
    end
  end
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
    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 encoding
  Encoding.find super
end

def execute sql, bind_vars = [], &block
  prepare(sql) do |stmt|
    stmt.bind_params(bind_vars)
    stmt = build_result_set stmt
    if block
      stmt.each do |row|
        yield row
      end
    else
      stmt.to_a.freeze
    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.each_with_object([stmt.columns]) { |row, arr|
               arr << row
             }
    end
  end
end

def execute_batch(sql, bind_vars = [])
  sql = sql.strip
  result = nil
  until sql.empty?
    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
        result = stmt.step
      end
      sql = stmt.remainder.strip
    end
  end
  result
end

def execute_batch2(sql, &block)
  if block
    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
  @progress_handler = nil
  @collations = {}
  @functions = {}
  @results_as_hash = options[:results_as_hash]
  @readonly = mode & Constants::Open::READONLY != 0
  @default_transaction_mode = options[:default_transaction_mode] || :deferred
  initialize_extensions(options[:extensions])
  ForkSafety.track(self)
  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 initialize_extensions(extensions) # :nodoc:
  return if extensions.nil?
  raise TypeError, "extensions must be an Array" unless extensions.is_a?(Array)
  return if extensions.empty?
  begin
    enable_load_extension(true)
    extensions.each do |extension|
      load_extension(extension)
    end
  ensure
    enable_load_extension(false)
  end
end

def load_extension(extension_specifier)
  if extension_specifier.respond_to?(:to_path)
    extension_specifier = extension_specifier.to_path
  elsif !extension_specifier.is_a?(String)
    raise TypeError, "extension_specifier #{extension_specifier.inspect} is not a String or a valid extension specifier object"
  end
  load_extension_internal(extension_specifier)
end

def open(*args)
  database = new(*args)
  if block_given?
    begin
      yield database
    ensure
      database.close
    end
  else
    database
  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 = [])
  result = prepare(sql).execute(bind_vars)
  if block_given?
    begin
      yield result
    ensure
      result.close
    end
  else
    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 = nil)
  mode = @default_transaction_mode if mode.nil?
  execute "begin #{mode} transaction"
  if block_given?
    abort = false
    begin
      yield self
    rescue
      abort = true
      raise
    ensure
      abort and rollback or commit
    end
  else
    true
  end
end