Class/Module Index [+]

Quicksearch

Sequel::JDBC::Database

JDBC Databases offer a fairly uniform interface that does not change much based on the sub adapter.

Attributes

convert_types[RW]

Whether to convert some Java types to ruby types when retrieving rows. True by default, can be set to false to roughly double performance when fetching rows.

database_type[R]

The type of database we are connecting to

driver[R]

The Java database driver we are using

Public Instance Methods

call_sproc(name, opts = {}) click to toggle source

Execute the given stored procedure with the give name. If a block is given, the stored procedure should return rows.

# File lib/sequel/adapters/jdbc.rb, line 182
def call_sproc(name, opts = {})
  args = opts[:args] || []
  sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
  synchronize(opts[:server]) do |conn|
    cps = conn.prepareCall(sql)

    i = 0
    args.each{|arg| set_ps_arg(cps, arg, i+=1)}

    begin
      if block_given?
        yield log_yield(sql){cps.executeQuery}
      else
        case opts[:type]
        when :insert
          log_yield(sql){cps.executeUpdate}
          last_insert_id(conn, opts)
        else
          log_yield(sql){cps.executeUpdate}
        end
      end
    rescue NativeException, JavaSQL::SQLException => e
      raise_error(e)
    ensure
      cps.close
    end
  end
end
connect(server) click to toggle source

Connect to the database using JavaSQL::DriverManager.getConnection.

# File lib/sequel/adapters/jdbc.rb, line 212
def connect(server)
  opts = server_opts(server)
  conn = if jndi?
    get_connection_from_jndi
  else
    args = [uri(opts)]
    args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
    begin
      JavaSQL::DriverManager.setLoginTimeout(opts[:login_timeout]) if opts[:login_timeout]
      JavaSQL::DriverManager.getConnection(*args)
    rescue JavaSQL::SQLException, NativeException, StandardError => e
      raise e unless driver
      # If the DriverManager can't get the connection - use the connect
      # method of the driver. (This happens under Tomcat for instance)
      props = java.util.Properties.new
      if opts && opts[:user] && opts[:password]
        props.setProperty("user", opts[:user])
        props.setProperty("password", opts[:password])
      end
      opts[:jdbc_properties].each{|k,v| props.setProperty(k.to_s, v)} if opts[:jdbc_properties]
      begin
        c = driver.new.connect(args[0], props)
        raise(Sequel::DatabaseError, 'driver.new.connect returned nil: probably bad JDBC connection string') unless c
        c
      rescue JavaSQL::SQLException, NativeException, StandardError => e2
        unless e2.message == e.message
          e2.message << "\n#{e.class.name}: #{e.message}"
        end
        raise e2
      end
    end
  end
  setup_connection(conn)
end
disconnect_connection(c) click to toggle source

Close given adapter connections, and delete any related prepared statements.

# File lib/sequel/adapters/jdbc.rb, line 248
def disconnect_connection(c)
  @connection_prepared_statements_mutex.synchronize{@connection_prepared_statements.delete(c)}
  c.close
end
execute(sql, opts={}, &block) click to toggle source

Execute the given SQL. If a block is given, if should be a SELECT statement or something else that returns rows.

# File lib/sequel/adapters/jdbc.rb, line 255
def execute(sql, opts={}, &block)
  return call_sproc(sql, opts, &block) if opts[:sproc]
  return execute_prepared_statement(sql, opts, &block) if [Symbol, Dataset].any?{|c| sql.is_a?(c)}
  synchronize(opts[:server]) do |conn|
    statement(conn) do |stmt|
      if block
        yield log_yield(sql){stmt.executeQuery(sql)}
      else
        case opts[:type]
        when :ddl
          log_yield(sql){stmt.execute(sql)}
        when :insert
          log_yield(sql){execute_statement_insert(stmt, sql)}
          last_insert_id(conn, opts.merge(:stmt=>stmt))
        else
          log_yield(sql){stmt.executeUpdate(sql)}
        end
      end
    end
  end
end
Also aliased as: execute_dui
execute_ddl(sql, opts={}) click to toggle source

Execute the given DDL SQL, which should not return any values or rows.

# File lib/sequel/adapters/jdbc.rb, line 280
def execute_ddl(sql, opts={})
  execute(sql, {:type=>:ddl}.merge(opts))
end
execute_dui(sql, opts={}, &block) click to toggle source
Alias for: execute
execute_insert(sql, opts={}) click to toggle source

Execute the given INSERT SQL, returning the last inserted row id.

# File lib/sequel/adapters/jdbc.rb, line 286
def execute_insert(sql, opts={})
  execute(sql, {:type=>:insert}.merge(opts))
end
indexes(table, opts={}) click to toggle source

Use the JDBC metadata to get the index information for the table.

# File lib/sequel/adapters/jdbc.rb, line 291
def indexes(table, opts={})
  m = output_identifier_meth
  im = input_identifier_meth
  schema, table = schema_and_table(table)
  schema ||= opts[:schema]
  schema = im.call(schema) if schema
  table = im.call(table)
  indexes = {}
  metadata(:getIndexInfo, nil, schema, table, false, true) do |r|
    next unless name = r[:column_name]
    next if respond_to?(:primary_key_index_re, true) and r[:index_name] =~ primary_key_index_re 
    i = indexes[m.call(r[:index_name])] ||= {:columns=>[], :unique=>[false, 0].include?(r[:non_unique])}
    i[:columns] << m.call(name)
  end
  indexes
end
Also aliased as: jdbc_indexes
jdbc_indexes(table, opts={}) click to toggle source
Alias for: indexes
jdbc_tables(opts={}) click to toggle source
Alias for: tables
jdbc_views(opts={}) click to toggle source
Alias for: views
jndi?() click to toggle source

Whether or not JNDI is being used for this connection.

# File lib/sequel/adapters/jdbc.rb, line 309
def jndi?
  !!(uri =~ JNDI_URI_REGEXP)
end
tables(opts={}) click to toggle source

All tables in this database

# File lib/sequel/adapters/jdbc.rb, line 314
def tables(opts={})
  get_tables('TABLE', opts)
end
Also aliased as: jdbc_tables
uri(opts={}) click to toggle source

The uri for this connection. You can specify the uri using the :uri, :url, or :database options. You don't need to worry about this if you use Sequel.connect with the JDBC connectrion strings.

# File lib/sequel/adapters/jdbc.rb, line 322
def uri(opts={})
  opts = @opts.merge(opts)
  ur = opts[:uri] || opts[:url] || opts[:database]
  ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
end
views(opts={}) click to toggle source

All views in this database

# File lib/sequel/adapters/jdbc.rb, line 329
def views(opts={})
  get_tables('VIEW', opts)
end
Also aliased as: jdbc_views

[Validate]

Generated with the Darkfish Rdoc Generator 2.