class Sequel::Fdbsql::Database

Database class for the FoundationDB SQL Layer used with Sequel and the pg driver

Constants

DatasetClass

Public Instance Methods

connect(server) click to toggle source

Connects to the database. In addition to the standard database options, :connect_timeout is a connection timeout in seconds, :sslmode sets whether to use ssl, and :notice_receiver handles server notices in a proc.

# File lib/sequel/adapters/fdbsql.rb, line 21
def connect(server)
  opts = server_opts(server)
  Connection.new(self, opts)
end
execute(sql, opts = {}) { |res| ... } click to toggle source

Execute the given SQL with the given args on an available connection.

# File lib/sequel/adapters/fdbsql.rb, line 27
def execute(sql, opts = {}, &block)
  res = nil
  synchronize(opts[:server]) do |conn|
    res = check_database_errors do
      if sql.is_a?(Symbol)
        execute_prepared_statement(conn, sql, opts, &block)
      else
        log_yield(sql) do
          conn.query(sql, opts[:arguments])
        end
      end
    end
    yield res if block_given?
    res.cmd_tuples
  end
end
server_version() click to toggle source
# File lib/sequel/adapters/fdbsql.rb, line 44
def server_version
  return @server_version if @server_version

  version = get{VERSION{}}
  unless ver = version.match(/(\d+)\.(\d+)\.(\d+)/)
    raise Error, "No match when checking FDB SQL Layer version: #{version}"
  end

  @server_version = (100 * ver[1].to_i + ver[2].to_i) * 100 + ver[3].to_i
end

Private Instance Methods

database_exception_sqlstate(exception, opts) click to toggle source
# File lib/sequel/adapters/fdbsql.rb, line 57
def database_exception_sqlstate(exception, opts)
  if exception.respond_to?(:result) && (result = exception.result)
    result.error_field(::PGresult::PG_DIAG_SQLSTATE)
  end
end
execute_prepared_statement(conn, name, opts=OPTS, &block) click to toggle source
# File lib/sequel/adapters/fdbsql.rb, line 63
def execute_prepared_statement(conn, name, opts=OPTS, &block)
  statement = prepared_statement(name)
  sql = statement.prepared_sql
  ps_name = name.to_s
  if args = opts[:arguments]
    args = args.map{|arg| bound_variable_arg(arg, conn)}
  end
  begin
    # create prepared statement if it doesn't exist, or has new sql
    unless conn.prepared_statements[ps_name] == sql
      conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
      log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}
      conn.prepared_statements[ps_name] = sql
    end

    log_sql = "EXECUTE #{ps_name}"
    if statement.log_sql
      log_sql << " ("
      log_sql << sql
      log_sql << ")"
    end
    log_yield(sql, args) do
      conn.execute_prepared_statement(ps_name, args)
    end
  rescue PGError => e
    if (database_exception_sqlstate(e, opts) == STALE_STATEMENT_SQLSTATE)
      conn.prepared_statements[ps_name] = nil
      retry
    end
  end
end