| Class | Sequel::Database |
| In: |
lib/sequel_core/adapters/jdbc.rb
lib/sequel_core/adapters/do.rb lib/sequel_core/database.rb lib/sequel_core/database/schema.rb |
| Parent: | Sequel::Database |
| ADAPTERS | = | %w'ado db2 dbi do firebird informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym} | Array of supported database adapters | |
| SQL_BEGIN | = | 'BEGIN'.freeze | ||
| SQL_COMMIT | = | 'COMMIT'.freeze | ||
| SQL_ROLLBACK | = | 'ROLLBACK'.freeze |
| converted_exceptions | [RW] | Convert the given exceptions to Sequel:Errors, necessary because DO raises errors specific to database types in certain cases. |
| database_type | [R] | The type of database we are connecting to |
| default_schema | [RW] | The default schema to use |
| loggers | [RW] | Array of SQL loggers to use for this database |
| opts | [R] | The options for this database |
| pool | [R] | The connection pool for this database |
| prepared_statements | [R] | The prepared statement objects for this database, keyed by name |
The Database subclass for the given adapter scheme. Raises Sequel::Error::AdapterNotFound if the adapter could not be loaded.
# File lib/sequel_core/database.rb, line 94
94: def self.adapter_class(scheme)
95: scheme = scheme.to_s.gsub('-', '_').to_sym
96:
97: if (klass = @@adapters[scheme]).nil?
98: # attempt to load the adapter file
99: begin
100: require "sequel_core/adapters/#{scheme}"
101: rescue LoadError => e
102: raise Error::AdapterNotFound, "Could not load #{scheme} adapter:\n #{e.message}"
103: end
104:
105: # make sure we actually loaded the adapter
106: if (klass = @@adapters[scheme]).nil?
107: raise Error::AdapterNotFound, "Could not load #{scheme} adapter"
108: end
109: end
110: return klass
111: end
Connects to a database. See Sequel.connect.
# File lib/sequel_core/database.rb, line 119
119: def self.connect(conn_string, opts = {}, &block)
120: if conn_string.is_a?(String)
121: if conn_string =~ /\Ajdbc:/
122: c = adapter_class(:jdbc)
123: opts = {:uri=>conn_string}.merge(opts)
124: elsif conn_string =~ /\Ado:/
125: c = adapter_class(:do)
126: opts = {:uri=>conn_string}.merge(opts)
127: else
128: uri = URI.parse(conn_string)
129: scheme = uri.scheme
130: scheme = :dbi if scheme =~ /\Adbi-/
131: c = adapter_class(scheme)
132: uri_options = {}
133: uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.blank?
134: opts = c.send(:uri_to_options, uri).merge(uri_options).merge(opts)
135: end
136: else
137: opts = conn_string.merge(opts)
138: c = adapter_class(opts[:adapter] || opts['adapter'])
139: end
140: # process opts a bit
141: opts = opts.inject({}) do |m, kv| k, v = *kv
142: k = :user if k.to_s == 'username'
143: m[k.to_sym] = v
144: m
145: end
146: if block
147: begin
148: yield(db = c.new(opts))
149: ensure
150: db.disconnect if db
151: ::Sequel::DATABASES.delete(db)
152: end
153: nil
154: else
155: c.new(opts)
156: end
157: end
Call the DATABASE_SETUP proc directly after initialization, so the object always uses sub adapter specific code. Also, raise an error immediately if the connection doesn‘t have a uri, since JDBC requires one.
# File lib/sequel_core/adapters/jdbc.rb, line 95
95: def initialize(opts)
96: @opts = opts
97: raise(Error, "No connection string specified") unless uri
98: if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
99: prok.call(self)
100: end
101: super(opts)
102: end
Call the DATABASE_SETUP proc directly after initialization, so the object always uses sub adapter specific code. Also, raise an error immediately if the connection doesn‘t have a uri, since DataObjects requires one.
# File lib/sequel_core/adapters/do.rb, line 53
53: def initialize(opts)
54: @opts = opts
55: @converted_exceptions = []
56: raise(Error, "No connection string specified") unless uri
57: if prok = DATABASE_SETUP[subadapter.to_sym]
58: prok.call(self)
59: end
60: super(opts)
61: end
Constructs a new instance of a database connection with the specified options hash.
Sequel::Database is an abstract class that is not useful by itself.
Takes the following options:
All options given are also passed to the ConnectionPool. If a block is given, it is used as the connection_proc for the ConnectionPool.
# File lib/sequel_core/database.rb, line 70
70: def initialize(opts = {}, &block)
71: @opts ||= opts
72:
73: @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
74: @schemas = nil
75: @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
76: @prepared_statements = {}
77: @transactions = []
78: if opts.include?(:upcase_identifiers)
79: @identifier_input_method = opts[:upcase_identifiers] ? :upcase : ""
80: end
81: @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
82: @pool.connection_proc = proc{|server| connect(server)} unless block
83: @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc]
84:
85: @loggers = Array(opts[:logger]) + Array(opts[:loggers])
86: ::Sequel::DATABASES.push(self)
87: end
Executes the supplied SQL statement. The SQL can be supplied as a string or as an array of strings. If an array is given, comments and excessive white space are removed. See also Array#to_sql.
# File lib/sequel_core/database.rb, line 233
233: def <<(sql)
234: execute_ddl((Array === sql) ? sql.to_sql : sql)
235: end
Returns a dataset from the database. If the first argument is a string, the method acts as an alias for Database#fetch, returning a dataset for arbitrary SQL:
DB['SELECT * FROM items WHERE name = ?', my_name].print
Otherwise, acts as an alias for Database#from, setting the primary table for the dataset:
DB[:items].sql #=> "SELECT * FROM items"
# File lib/sequel_core/database.rb, line 247
247: def [](*args, &block)
248: (String === args.first) ? fetch(*args, &block) : from(*args, &block)
249: end
Adds a column to the specified table. This method expects a column name, a datatype and optionally a hash with additional constraints and options:
DB.add_column :items, :name, :text, :unique => true, :null => false DB.add_column :items, :category, :text, :default => 'ruby'
See alter_table.
# File lib/sequel_core/database/schema.rb, line 10
10: def add_column(table, *args)
11: alter_table(table) {add_column(*args)}
12: end
Adds an index to a table for the given columns:
DB.add_index :posts, :title DB.add_index :posts, [:author, :title], :unique => true
See alter_table.
# File lib/sequel_core/database/schema.rb, line 20
20: def add_index(table, *args)
21: alter_table(table) {add_index(*args)}
22: end
Alters the given table with the specified block. Here are the currently available operations:
DB.alter_table :items do
add_column :category, :text, :default => 'ruby'
drop_column :category
rename_column :cntr, :counter
set_column_type :value, :float
set_column_default :value, :float
add_index [:group, :category]
drop_index [:group, :category]
end
Note that add_column accepts all the options available for column definitions using create_table, and add_index accepts all the options available for index definition.
See Schema::AlterTableGenerator.
# File lib/sequel_core/database/schema.rb, line 42
42: def alter_table(name, generator=nil, &block)
43: remove_cached_schema(name)
44: generator ||= Schema::AlterTableGenerator.new(self, &block)
45: alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
46: end
Call the prepared statement with the given name with the given hash of arguments.
# File lib/sequel_core/database.rb, line 253
253: def call(ps_name, hash={})
254: prepared_statements[ps_name].call(hash)
255: end
Execute the given stored procedure with the give name. If a block is given, the stored procedure should return rows.
# File lib/sequel_core/adapters/jdbc.rb, line 106
106: def call_sproc(name, opts = {})
107: args = opts[:args] || []
108: sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
109: synchronize(opts[:server]) do |conn|
110: cps = conn.prepareCall(sql)
111:
112: i = 0
113: args.each{|arg| set_ps_arg(cps, arg, i+=1)}
114:
115: begin
116: if block_given?
117: yield cps.executeQuery
118: else
119: case opts[:type]
120: when :insert
121: cps.executeUpdate
122: last_insert_id(conn, opts)
123: else
124: cps.executeUpdate
125: end
126: end
127: rescue NativeException, JavaSQL::SQLException => e
128: raise_error(e)
129: ensure
130: cps.close
131: end
132: end
133: end
Connect to the database using JavaSQL::DriverManager.getConnection.
# File lib/sequel_core/adapters/jdbc.rb, line 136
136: def connect(server)
137: setup_connection(JavaSQL::DriverManager.getConnection(uri(server_opts(server))))
138: end
Connects to the database. This method should be overridden by descendants.
# File lib/sequel_core/database.rb, line 258
258: def connect
259: raise NotImplementedError, "#connect should be overridden by adapters"
260: end
Setup a DataObjects::Connection to the database.
# File lib/sequel_core/adapters/do.rb, line 64
64: def connect(server)
65: setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
66: end
Creates a view, replacing it if it already exists:
DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100") DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
# File lib/sequel_core/database/schema.rb, line 73
73: def create_or_replace_view(name, source)
74: remove_cached_schema(name)
75: source = source.sql if source.is_a?(Dataset)
76: execute_ddl("CREATE OR REPLACE VIEW #{quote_identifier(name)} AS #{source}")
77: end
Creates a table with the columns given in the provided block:
DB.create_table :posts do
primary_key :id, :serial
column :title, :text
column :content, :text
index :title
end
See Schema::Generator.
# File lib/sequel_core/database/schema.rb, line 58
58: def create_table(name, options={}, &block)
59: options = {:generator=>options} if options.is_a?(Schema::Generator)
60: create_table_sql_list(name, *((options[:generator] || Schema::Generator.new(self, &block)).create_info << options)).flatten.each {|sql| execute_ddl(sql)}
61: end
Forcibly creates a table. If the table already exists it is dropped.
# File lib/sequel_core/database/schema.rb, line 64
64: def create_table!(name, options={}, &block)
65: drop_table(name) rescue nil
66: create_table(name, options, &block)
67: end
Creates a view based on a dataset or an SQL string:
DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100") DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
# File lib/sequel_core/database/schema.rb, line 83
83: def create_view(name, source)
84: source = source.sql if source.is_a?(Dataset)
85: execute_ddl("CREATE VIEW #{quote_identifier(name)} AS #{source}")
86: end
Return a Sequel::DataObjects::Dataset object for this database.
# File lib/sequel_core/adapters/do.rb, line 69
69: def dataset(opts = nil)
70: DataObjects::Dataset.new(self, opts)
71: end
Return instances of JDBC::Dataset with the given opts.
# File lib/sequel_core/adapters/jdbc.rb, line 141
141: def dataset(opts = nil)
142: JDBC::Dataset.new(self, opts)
143: end
Removes a column from the specified table:
DB.drop_column :items, :category
See alter_table.
# File lib/sequel_core/database/schema.rb, line 93
93: def drop_column(table, *args)
94: alter_table(table) {drop_column(*args)}
95: end
Removes an index for the given table and column/s:
DB.drop_index :posts, :title DB.drop_index :posts, [:author, :title]
See alter_table.
# File lib/sequel_core/database/schema.rb, line 103
103: def drop_index(table, columns)
104: alter_table(table) {drop_index(columns)}
105: end
Drops a view:
DB.drop_view(:cheap_items)
# File lib/sequel_core/database/schema.rb, line 120
120: def drop_view(*names)
121: names.each do |n|
122: remove_cached_schema(n)
123: execute_ddl("DROP VIEW #{quote_identifier(n)}")
124: end
125: end
Execute the given SQL. If a block is given, the DataObjects::Reader created is yielded to it. A block should not be provided unless a a SELECT statement is being used (or something else that returns rows). Otherwise, the return value is the insert id if opts[:type] is :insert, or the number of affected rows, otherwise.
# File lib/sequel_core/adapters/do.rb, line 78
78: def execute(sql, opts={})
79: log_info(sql)
80: synchronize(opts[:server]) do |conn|
81: begin
82: command = conn.create_command(sql)
83: res = block_given? ? command.execute_reader : command.execute_non_query
84: rescue Exception => e
85: raise_error(e, :classes=>@converted_exceptions)
86: end
87: if block_given?
88: begin
89: yield(res)
90: ensure
91: res.close if res
92: end
93: elsif opts[:type] == :insert
94: res.insert_id
95: else
96: res.affected_rows
97: end
98: end
99: end
Execute the given SQL. If a block is given, if should be a SELECT statement or something else that returns rows.
# File lib/sequel_core/adapters/jdbc.rb, line 147
147: def execute(sql, opts={}, &block)
148: return call_sproc(sql, opts, &block) if opts[:sproc]
149: return execute_prepared_statement(sql, opts, &block) if sql.is_one_of?(Symbol, Dataset)
150: log_info(sql)
151: synchronize(opts[:server]) do |conn|
152: stmt = conn.createStatement
153: begin
154: if block_given?
155: yield stmt.executeQuery(sql)
156: else
157: case opts[:type]
158: when :ddl
159: stmt.execute(sql)
160: when :insert
161: stmt.executeUpdate(sql)
162: last_insert_id(conn, opts)
163: else
164: stmt.executeUpdate(sql)
165: end
166: end
167: rescue NativeException, JavaSQL::SQLException => e
168: raise_error(e)
169: ensure
170: stmt.close
171: end
172: end
173: end
Method that should be used when submitting any DDL (Data Definition Language) SQL. By default, calls execute_dui.
# File lib/sequel_core/database.rb, line 280
280: def execute_ddl(sql, opts={}, &block)
281: execute_dui(sql, opts, &block)
282: end
Method that should be used when issuing a INSERT statement. By default, calls execute_dui.
# File lib/sequel_core/database.rb, line 292
292: def execute_insert(sql, opts={}, &block)
293: execute_dui(sql, opts, &block)
294: end
Fetches records for an arbitrary SQL statement. If a block is given, it is used to iterate over the records:
DB.fetch('SELECT * FROM items'){|r| p r}
The method returns a dataset instance:
DB.fetch('SELECT * FROM items').print
Fetch can also perform parameterized queries for protection against SQL injection:
DB.fetch('SELECT * FROM items WHERE name = ?', my_name).print
# File lib/sequel_core/database.rb, line 309
309: def fetch(sql, *args, &block)
310: ds = dataset
311: ds.opts[:sql] = Sequel::SQL::PlaceholderLiteralString.new(sql, args)
312: ds.each(&block) if block
313: ds
314: end
The method to call on identifiers going into the database
# File lib/sequel_core/database.rb, line 336
336: def identifier_input_method
337: case @identifier_input_method
338: when nil
339: @identifier_input_method = @opts.include?(:identifier_input_method) ? @opts[:identifier_input_method] : (@@identifier_input_method.nil? ? identifier_input_method_default : @@identifier_input_method)
340: @identifier_input_method == "" ? nil : @identifier_input_method
341: when ""
342: nil
343: else
344: @identifier_input_method
345: end
346: end
The method to call on identifiers coming from the database
# File lib/sequel_core/database.rb, line 355
355: def identifier_output_method
356: case @identifier_output_method
357: when nil
358: @identifier_output_method = @opts.include?(:identifier_output_method) ? @opts[:identifier_output_method] : (@@identifier_output_method.nil? ? identifier_output_method_default : @@identifier_output_method)
359: @identifier_output_method == "" ? nil : @identifier_output_method
360: when ""
361: nil
362: else
363: @identifier_output_method
364: end
365: end
Returns a string representation of the database object including the class name and the connection URI (or the opts if the URI cannot be constructed).
# File lib/sequel_core/database.rb, line 376
376: def inspect
377: "#<#{self.class}: #{(uri rescue opts).inspect}>"
378: end
Returns true unless the database is using a single-threaded connection pool.
# File lib/sequel_core/database.rb, line 399
399: def multi_threaded?
400: !@single_threaded
401: end
Returns a dataset modified by the given query block. See Dataset#query.
# File lib/sequel_core/database.rb, line 404
404: def query(&block)
405: dataset.query(&block)
406: end
Returns true if the database quotes identifiers.
# File lib/sequel_core/database.rb, line 415
415: def quote_identifiers?
416: return @quote_identifiers unless @quote_identifiers.nil?
417: @quote_identifiers = @opts.include?(:quote_identifiers) ? @opts[:quote_identifiers] : (@@quote_identifiers.nil? ? quote_identifiers_default : @@quote_identifiers)
418: end
Renames a column in the specified table. This method expects the current column name and the new column name:
DB.rename_column :items, :cntr, :counter
See alter_table.
# File lib/sequel_core/database/schema.rb, line 142
142: def rename_column(table, *args)
143: alter_table(table) {rename_column(*args)}
144: end
Renames a table:
DB.tables #=> [:items] DB.rename_table :items, :old_items DB.tables #=> [:old_items]
# File lib/sequel_core/database/schema.rb, line 132
132: def rename_table(*args)
133: execute_ddl(rename_table_sql(*args))
134: end
Default serial primary key options.
# File lib/sequel_core/database.rb, line 426
426: def serial_primary_key_options
427: {:primary_key => true, :type => Integer, :auto_increment => true}
428: end
Sets the default value for the given column in the given table:
DB.set_column_default :items, :category, 'perl!'
See alter_table.
# File lib/sequel_core/database/schema.rb, line 151
151: def set_column_default(table, *args)
152: alter_table(table) {set_column_default(*args)}
153: end
Set the data type for the given column in the given table:
DB.set_column_type :items, :price, :float
See alter_table.
# File lib/sequel_core/database/schema.rb, line 160
160: def set_column_type(table, *args)
161: alter_table(table) {set_column_type(*args)}
162: end
Returns true if the database is using a single-threaded connection pool.
# File lib/sequel_core/database.rb, line 431
431: def single_threaded?
432: @single_threaded
433: end
Return the subadapter type for this database, i.e. sqlite3 for do:sqlite3::memory:.
# File lib/sequel_core/adapters/do.rb, line 115
115: def subadapter
116: uri.split(":").first
117: end
Acquires a database connection, yielding it to the passed block.
# File lib/sequel_core/database.rb, line 436
436: def synchronize(server=nil, &block)
437: @pool.hold(server || :default, &block)
438: end
Returns true if a table with the given name exists. This requires a query to the database unless this database object already has the schema for the given table name.
# File lib/sequel_core/database.rb, line 443
443: def table_exists?(name)
444: if @schemas && @schemas[name]
445: true
446: else
447: begin
448: from(name).first
449: true
450: rescue
451: false
452: end
453: end
454: end
Attempts to acquire a database connection. Returns true if successful. Will probably raise an error if unsuccessful.
# File lib/sequel_core/database.rb, line 458
458: def test_connection(server=nil)
459: synchronize(server){|conn|}
460: true
461: end
A simple implementation of SQL transactions. Nested transactions are not supported - calling transaction within a transaction will reuse the current transaction. Should be overridden for databases that support nested transactions.
# File lib/sequel_core/database.rb, line 467
467: def transaction(server=nil)
468: synchronize(server) do |conn|
469: return yield(conn) if @transactions.include?(Thread.current)
470: log_info(begin_transaction_sql)
471: conn.execute(begin_transaction_sql)
472: begin
473: @transactions << Thread.current
474: yield(conn)
475: rescue Exception => e
476: log_info(rollback_transaction_sql)
477: conn.execute(rollback_transaction_sql)
478: transaction_error(e)
479: ensure
480: unless e
481: log_info(commit_transaction_sql)
482: conn.execute(commit_transaction_sql)
483: end
484: @transactions.delete(Thread.current)
485: end
486: end
487: end
Use DataObject‘s transaction support for transactions. This only supports single level transactions, and it always prepares transactions and commits them immediately after. It‘s wasteful, but required by DataObject‘s API.
# File lib/sequel_core/adapters/do.rb, line 123
123: def transaction(server=nil)
124: th = Thread.current
125: synchronize(server) do |conn|
126: return yield(conn) if @transactions.include?(th)
127: t = ::DataObjects::Transaction.create_for_uri(uri)
128: t.instance_variable_get(:@connection).close
129: t.instance_variable_set(:@connection, conn)
130: begin
131: log_info("Transaction.begin")
132: t.begin
133: @transactions << th
134: yield(conn)
135: rescue Exception => e
136: log_info("Transaction.rollback")
137: t.rollback
138: transaction_error(e)
139: ensure
140: unless e
141: log_info("Transaction.commit")
142: t.prepare
143: t.commit
144: end
145: @transactions.delete(th)
146: end
147: end
148: end
Default transaction method that should work on most JDBC databases. Does not use the JDBC transaction methods, uses SQL BEGIN/ROLLBACK/COMMIT statements instead.
# File lib/sequel_core/adapters/jdbc.rb, line 199
199: def transaction(server=nil)
200: synchronize(server) do |conn|
201: return yield(conn) if @transactions.include?(Thread.current)
202: stmt = conn.createStatement
203: begin
204: log_info(begin_transaction_sql)
205: stmt.execute(begin_transaction_sql)
206: @transactions << Thread.current
207: yield(conn)
208: rescue Exception => e
209: log_info(rollback_transaction_sql)
210: stmt.execute(rollback_transaction_sql)
211: transaction_error(e)
212: ensure
213: unless e
214: log_info(commit_transaction_sql)
215: stmt.execute(commit_transaction_sql)
216: end
217: stmt.close
218: @transactions.delete(Thread.current)
219: end
220: end
221: end
Typecast the value to the given column_type. Can be overridden in adapters to support database specific column types. This method should raise Sequel::Error::InvalidValue if assigned value is invalid.
# File lib/sequel_core/database.rb, line 493
493: def typecast_value(column_type, value)
494: return nil if value.nil?
495: case column_type
496: when :integer
497: begin
498: Integer(value)
499: rescue ArgumentError => e
500: raise Sequel::Error::InvalidValue, e.message.inspect
501: end
502: when :string
503: value.to_s
504: when :float
505: begin
506: Float(value)
507: rescue ArgumentError => e
508: raise Sequel::Error::InvalidValue, e.message.inspect
509: end
510: when :decimal
511: case value
512: when BigDecimal
513: value
514: when String, Float
515: value.to_d
516: when Integer
517: value.to_s.to_d
518: else
519: raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
520: end
521: when :boolean
522: case value
523: when false, 0, "0", /\Af(alse)?\z/i
524: false
525: else
526: value.blank? ? nil : true
527: end
528: when :date
529: case value
530: when Date
531: value
532: when DateTime, Time
533: Date.new(value.year, value.month, value.day)
534: when String
535: value.to_date
536: else
537: raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
538: end
539: when :time
540: case value
541: when Time
542: value
543: when String
544: value.to_time
545: else
546: raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
547: end
548: when :datetime
549: raise(Sequel::Error::InvalidValue, "invalid value for Datetime: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
550: if Sequel.datetime_class === value
551: # Already the correct class, no need to convert
552: value
553: else
554: # First convert it to standard ISO 8601 time, then
555: # parse that string using the time class.
556: (Time === value ? value.iso8601 : value.to_s).to_sequel_time
557: end
558: when :blob
559: value.to_blob
560: else
561: value
562: end
563: end
Set whether to upcase identifiers going into the database.
# File lib/sequel_core/database.rb, line 566
566: def upcase_identifiers=(v)
567: self.identifier_input_method = v ? :upcase : nil
568: end
Returns true if the database upcases identifiers.
# File lib/sequel_core/database.rb, line 571
571: def upcase_identifiers?
572: identifier_input_method == :upcase
573: end
Return the DataObjects URI for the Sequel URI, removing the do: prefix.
# File lib/sequel_core/adapters/do.rb, line 152
152: def uri(opts={})
153: opts = @opts.merge(opts)
154: (opts[:uri] || opts[:url]).sub(/\Ado:/, '')
155: end
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_core/adapters/jdbc.rb, line 227
227: def uri(opts={})
228: opts = @opts.merge(opts)
229: ur = opts[:uri] || opts[:url] || opts[:database]
230: ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
231: end
Returns the URI identifying the database. This method can raise an error if the database used options instead of a connection string.
# File lib/sequel_core/database.rb, line 578
578: def uri
579: uri = URI::Generic.new(
580: self.class.adapter_scheme.to_s,
581: nil,
582: @opts[:host],
583: @opts[:port],
584: nil,
585: "/#{@opts[:database]}",
586: nil,
587: nil,
588: nil
589: )
590: uri.user = @opts[:user]
591: uri.password = @opts[:password] if uri.user
592: uri.to_s
593: end