Class: Sequel::Database

Inherits:
Object show all
Includes:
Schema::SQL
Defined in:
lib/sequel_core/database.rb,
lib/sequel_core/database/schema.rb

Overview

A Database object represents a virtual connection to a database. The Database class is meant to be subclassed by database adapters in order to provide the functionality needed for executing queries.

Constant Summary collapse

ADAPTERS =

Array of supported database adapters

%w'ado db2 dbi do firebird informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
SQL_BEGIN = 
'BEGIN'.freeze
SQL_COMMIT = 
'COMMIT'.freeze
SQL_ROLLBACK = 
'ROLLBACK'.freeze
@@adapters =

Hash of adapters that have been used

Hash.new
@@identifier_input_method =

The identifier input method to use by default

nil
@@identifier_output_method =

The identifier output method to use by default

nil
@@single_threaded =

Whether to use the single threaded connection pool by default

false
@@quote_identifiers =

Whether to quote identifiers (columns and tables) by default

nil

Constants included from Schema::SQL

Schema::SQL::AUTOINCREMENT, Schema::SQL::CASCADE, Schema::SQL::COMMA_SEPARATOR, Schema::SQL::NOT_NULL, Schema::SQL::NO_ACTION, Schema::SQL::NULL, Schema::SQL::PRIMARY_KEY, Schema::SQL::RESTRICT, Schema::SQL::SET_DEFAULT, Schema::SQL::SET_NULL, Schema::SQL::TYPES, Schema::SQL::UNDERSCORE, Schema::SQL::UNIQUE, Schema::SQL::UNSIGNED

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Schema::SQL

#alter_table_sql, #alter_table_sql_list, #auto_increment_sql, #column_definition_sql, #column_list_sql, #column_references_sql, #constraint_definition_sql, #create_table_sql_list, #default_index_name, #drop_index_sql, #drop_table_sql, #filter_expr, #index_definition_sql, #index_list_sql_list, #literal, #on_delete_clause, #quote_identifier, #quote_schema_table, #rename_table_sql, #schema, #schema_utility_dataset

Constructor Details

#initialize(opts = {}, &block) ⇒ Database

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:

  • :default_schema : The default schema to use, should generally be nil

  • :disconnection_proc: A proc used to disconnect the connection.

  • :identifier_input_method: A string method symbol to call on identifiers going into the database

  • :identifier_output_method: A string method symbol to call on identifiers coming from the database

  • :loggers : An array of loggers to use.

  • :quote_identifiers : Whether to quote identifiers

  • :single_threaded : Whether to use a single-threaded connection pool

  • :upcase_identifiers : Whether to upcase identifiers going into the database

All options given are also passed to the ConnectionPool. If a block is given, it is used as the connection_proc for the ConnectionPool.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/sequel_core/database.rb', line 70

def initialize(opts = {}, &block)
  @opts ||= opts
  
  @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
  @schemas = nil
  @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
  @prepared_statements = {}
  @transactions = []
  @identifier_input_method = nil
  @identifier_output_method = nil
  @quote_identifiers = nil
  if opts.include?(:upcase_identifiers)
    @identifier_input_method = opts[:upcase_identifiers] ? :upcase : ""
  end
  @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
  @pool.connection_proc = proc{|server| connect(server)} unless block
  @pool.disconnection_proc = proc{|conn| disconnect_connection(conn)} unless opts[:disconnection_proc]

  @loggers = Array(opts[:logger]) + Array(opts[:loggers])
  ::Sequel::DATABASES.push(self)
end

Instance Attribute Details

#default_schema ⇒ Object

The default schema to use



39
40
41
 
# File 'lib/sequel_core/database.rb', line 39

def default_schema
  @default_schema
end

#loggers ⇒ Object

Array of SQL loggers to use for this database



42
43
44
 
# File 'lib/sequel_core/database.rb', line 42

def loggers
  @loggers
end

#opts ⇒ Object (readonly)

The options for this database



45
46
47
 
# File 'lib/sequel_core/database.rb', line 45

def opts
  @opts
end

#pool ⇒ Object (readonly)

The connection pool for this database



48
49
50
 
# File 'lib/sequel_core/database.rb', line 48

def pool
  @pool
end

#prepared_statements ⇒ Object (readonly)

The prepared statement objects for this database, keyed by name



51
52
53
 
# File 'lib/sequel_core/database.rb', line 51

def prepared_statements
  @prepared_statements
end

Class Method Details

.adapter_class(scheme) ⇒ Object

The Database subclass for the given adapter scheme. Raises Sequel::Error::AdapterNotFound if the adapter could not be loaded.



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/sequel_core/database.rb', line 97

def self.adapter_class(scheme)
  scheme = scheme.to_s.gsub('-', '_').to_sym
  
  if (klass = @@adapters[scheme]).nil?
    # attempt to load the adapter file
    begin
      require "sequel_core/adapters/#{scheme}"
    rescue LoadError => e
      raise Error::AdapterNotFound, "Could not load #{scheme} adapter:\n  #{e.message}"
    end
    
    # make sure we actually loaded the adapter
    if (klass = @@adapters[scheme]).nil?
      raise Error::AdapterNotFound, "Could not load #{scheme} adapter"
    end
  end
  return klass
end

.adapter_scheme ⇒ Object

Returns the scheme for the Database class.



117
118
119
 
# File 'lib/sequel_core/database.rb', line 117

def self.adapter_scheme
  @scheme
end

.connect(conn_string, opts = {}, &block) ⇒ Object

Connects to a database. See Sequel.connect.



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/sequel_core/database.rb', line 122

def self.connect(conn_string, opts = {}, &block)
  if conn_string.is_a?(String)
    if conn_string =~ /\Ajdbc:/
      c = adapter_class(:jdbc)
      opts = {:uri=>conn_string}.merge(opts)
    elsif conn_string =~ /\Ado:/
      c = adapter_class(:do)
      opts = {:uri=>conn_string}.merge(opts)
    else
      uri = URI.parse(conn_string)
      scheme = uri.scheme
      scheme = :dbi if scheme =~ /\Adbi-/
      c = adapter_class(scheme)
      uri_options = {}
      uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v} unless uri.query.blank?
      opts = c.send(:uri_to_options, uri).merge(uri_options).merge(opts)
    end
  else
    opts = conn_string.merge(opts)
    c = adapter_class(opts[:adapter] || opts['adapter'])
  end
  # process opts a bit
  opts = opts.inject({}) do |m, kv| k, v = *kv
    k = :user if k.to_s == 'username'
    m[k.to_sym] = v
    m
  end
  if block
    begin
      yield(db = c.new(opts))
    ensure
      db.disconnect if db
      ::Sequel::DATABASES.delete(db)
    end
    nil
  else
    c.new(opts)
  end
end

.identifier_input_method ⇒ Object

The method to call on identifiers going into the database



163
164
165
 
# File 'lib/sequel_core/database.rb', line 163

def self.identifier_input_method
  @@identifier_input_method
end

.identifier_input_method=(v) ⇒ Object

Set the method to call on identifiers going into the database



168
169
170
 
# File 'lib/sequel_core/database.rb', line 168

def self.identifier_input_method=(v)
  @@identifier_input_method = v || ""
end

.identifier_output_method ⇒ Object

The method to call on identifiers coming from the database



173
174
175
 
# File 'lib/sequel_core/database.rb', line 173

def self.identifier_output_method
  @@identifier_output_method
end

.identifier_output_method=(v) ⇒ Object

Set the method to call on identifiers coming from the database



178
179
180
 
# File 'lib/sequel_core/database.rb', line 178

def self.identifier_output_method=(v)
  @@identifier_output_method = v || ""
end

.quote_identifiers=(value) ⇒ Object

Sets the default quote_identifiers mode for new databases. See Sequel.quote_identifiers=.



184
185
186
 
# File 'lib/sequel_core/database.rb', line 184

def self.quote_identifiers=(value)
  @@quote_identifiers = value
end

.single_threaded=(value) ⇒ Object

Sets the default single_threaded mode for new databases. See Sequel.single_threaded=.



190
191
192
 
# File 'lib/sequel_core/database.rb', line 190

def self.single_threaded=(value)
  @@single_threaded = value
end

.upcase_identifiers=(value) ⇒ Object

Sets the default quote_identifiers mode for new databases. See Sequel.quote_identifiers=.



196
197
198
 
# File 'lib/sequel_core/database.rb', line 196

def self.upcase_identifiers=(value)
  self.identifier_input_method = value ? :upcase : nil
end

Instance Method Details

#<<(sql) ⇒ Object

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.



236
237
238
 
# File 'lib/sequel_core/database.rb', line 236

def <<(sql)
  execute_ddl((Array === sql) ? sql.to_sql : sql)
end

#[](*args, &block) ⇒ Object

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"



250
251
252
 
# File 'lib/sequel_core/database.rb', line 250

def [](*args, &block)
  (String === args.first) ? fetch(*args, &block) : from(*args, &block)
end

#add_column(table, *args) ⇒ Object

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.



10
11
12
 
# File 'lib/sequel_core/database/schema.rb', line 10

def add_column(table, *args)
  alter_table(table) {add_column(*args)}
end

#add_index(table, *args) ⇒ Object

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.



20
21
22
 
# File 'lib/sequel_core/database/schema.rb', line 20

def add_index(table, *args)
  alter_table(table) {add_index(*args)}
end

#alter_table(name, generator = nil, &block) ⇒ Object

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.



42
43
44
45
46
 
# File 'lib/sequel_core/database/schema.rb', line 42

def alter_table(name, generator=nil, &block)
  remove_cached_schema(name)
  generator ||= Schema::AlterTableGenerator.new(self, &block)
  alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
end

#call(ps_name, hash = {}) ⇒ Object

Call the prepared statement with the given name with the given hash of arguments.



256
257
258
 
# File 'lib/sequel_core/database.rb', line 256

def call(ps_name, hash={})
  prepared_statements[ps_name].call(hash)
end

#connect ⇒ Object

Connects to the database. This method should be overridden by descendants.

Raises:

  • (NotImplementedError) 


261
262
263
 
# File 'lib/sequel_core/database.rb', line 261

def connect
  raise NotImplementedError, "#connect should be overridden by adapters"
end

#create_or_replace_view(name, source) ⇒ Object

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'))



73
74
75
76
77
 
# File 'lib/sequel_core/database/schema.rb', line 73

def create_or_replace_view(name, source)
  remove_cached_schema(name)
  source = source.sql if source.is_a?(Dataset)
  execute_ddl("CREATE OR REPLACE VIEW #{quote_identifier(name)} AS #{source}")
end

#create_table(name, options = {}, &block) ⇒ Object

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.



58
59
60
61
 
# File 'lib/sequel_core/database/schema.rb', line 58

def create_table(name, options={}, &block)
  options = {:generator=>options} if options.is_a?(Schema::Generator)
  create_table_sql_list(name, *((options[:generator] || Schema::Generator.new(self, &block)).create_info << options)).flatten.each {|sql| execute_ddl(sql)}
end

#create_table!(name, options = {}, &block) ⇒ Object

Forcibly creates a table. If the table already exists it is dropped.



64
65
66
67
 
# File 'lib/sequel_core/database/schema.rb', line 64

def create_table!(name, options={}, &block)
  drop_table(name) rescue nil
  create_table(name, options, &block)
end

#create_view(name, source) ⇒ Object

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'))



83
84
85
86
 
# File 'lib/sequel_core/database/schema.rb', line 83

def create_view(name, source)
  source = source.sql if source.is_a?(Dataset)
  execute_ddl("CREATE VIEW #{quote_identifier(name)} AS #{source}")
end

#dataset ⇒ Object

Returns a blank dataset



266
267
268
 
# File 'lib/sequel_core/database.rb', line 266

def dataset
  ds = Sequel::Dataset.new(self)
end

#disconnect ⇒ Object

Disconnects all available connections from the connection pool. If any connections are currently in use, they will not be disconnected.



272
273
274
 
# File 'lib/sequel_core/database.rb', line 272

def disconnect
  pool.disconnect
end

#drop_column(table, *args) ⇒ Object

Removes a column from the specified table:

DB.drop_column :items, :category

See alter_table.



93
94
95
 
# File 'lib/sequel_core/database/schema.rb', line 93

def drop_column(table, *args)
  alter_table(table) {drop_column(*args)}
end

#drop_index(table, columns) ⇒ Object

Removes an index for the given table and column/s:

DB.drop_index :posts, :title
DB.drop_index :posts, [:author, :title]

See alter_table.



103
104
105
 
# File 'lib/sequel_core/database/schema.rb', line 103

def drop_index(table, columns)
  alter_table(table) {drop_index(columns)}
end

#drop_table(*names) ⇒ Object

Drops one or more tables corresponding to the given table names:

DB.drop_table(:posts, :comments)



110
111
112
113
114
115
 
# File 'lib/sequel_core/database/schema.rb', line 110

def drop_table(*names)
  names.each do |n|
    remove_cached_schema(n)
    execute_ddl(drop_table_sql(n))
  end
end

#drop_view(*names) ⇒ Object

Drops a view:

DB.drop_view(:cheap_items)



120
121
122
123
124
125
 
# File 'lib/sequel_core/database/schema.rb', line 120

def drop_view(*names)
  names.each do |n|
    remove_cached_schema(n)
    execute_ddl("DROP VIEW #{quote_identifier(n)}")
  end
end

#execute(sql, opts = {}) ⇒ Object

Executes the given SQL. This method should be overridden in descendants.

Raises:

  • (NotImplementedError) 


277
278
279
 
# File 'lib/sequel_core/database.rb', line 277

def execute(sql, opts={})
  raise NotImplementedError, "#execute should be overridden by adapters"
end

#execute_ddl(sql, opts = {}, &block) ⇒ Object

Method that should be used when submitting any DDL (Data Definition Language) SQL. By default, calls execute_dui.



283
284
285
 
# File 'lib/sequel_core/database.rb', line 283

def execute_ddl(sql, opts={}, &block)
  execute_dui(sql, opts, &block)
end

#execute_dui(sql, opts = {}, &block) ⇒ Object

Method that should be used when issuing a DELETE, UPDATE, or INSERT statement. By default, calls execute.



289
290
291
 
# File 'lib/sequel_core/database.rb', line 289

def execute_dui(sql, opts={}, &block)
  execute(sql, opts, &block)
end

#execute_insert(sql, opts = {}, &block) ⇒ Object

Method that should be used when issuing a INSERT statement. By default, calls execute_dui.



295
296
297
 
# File 'lib/sequel_core/database.rb', line 295

def execute_insert(sql, opts={}, &block)
  execute_dui(sql, opts, &block)
end

#fetch(sql, *args, &block) ⇒ Object Also known as: >>

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



312
313
314
315
316
317
 
# File 'lib/sequel_core/database.rb', line 312

def fetch(sql, *args, &block)
  ds = dataset
  ds.opts[:sql] = Sequel::SQL::PlaceholderLiteralString.new(sql, args)
  ds.each(&block) if block
  ds
end

#from(*args, &block) ⇒ Object

Returns a new dataset with the from method invoked. If a block is given, it is used as a filter on the dataset.



322
323
324
325
 
# File 'lib/sequel_core/database.rb', line 322

def from(*args, &block)
  ds = dataset.from(*args)
  block ? ds.filter(&block) : ds
end

#get(expr) ⇒ Object

Returns a single value from the database, e.g.:

# SELECT 1
DB.get(1) #=> 1 

# SELECT version()
DB.get(:version.sql_function) #=> ...



334
335
336
 
# File 'lib/sequel_core/database.rb', line 334

def get(expr)
  dataset.get(expr)
end

#identifier_input_method ⇒ Object

The method to call on identifiers going into the database



339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/sequel_core/database.rb', line 339

def identifier_input_method
  case @identifier_input_method
  when nil
    @identifier_input_method = @opts.include?(:identifier_input_method) ? @opts[:identifier_input_method] : (@@identifier_input_method.nil? ? identifier_input_method_default : @@identifier_input_method)
    @identifier_input_method == "" ? nil : @identifier_input_method
  when ""
    nil
  else
    @identifier_input_method
  end
end

#identifier_input_method=(v) ⇒ Object

Set the method to call on identifiers going into the database



352
353
354
355
 
# File 'lib/sequel_core/database.rb', line 352

def identifier_input_method=(v)
  reset_schema_utility_dataset
  @identifier_input_method = v || ""
end

#identifier_output_method ⇒ Object

The method to call on identifiers coming from the database



358
359
360
361
362
363
364
365
366
367
368
 
# File 'lib/sequel_core/database.rb', line 358

def identifier_output_method
  case @identifier_output_method
  when nil
    @identifier_output_method = @opts.include?(:identifier_output_method) ? @opts[:identifier_output_method] : (@@identifier_output_method.nil? ? identifier_output_method_default : @@identifier_output_method)
    @identifier_output_method == "" ? nil : @identifier_output_method
  when ""
    nil
  else
    @identifier_output_method
  end
end

#identifier_output_method=(v) ⇒ Object

Set the method to call on identifiers coming from the database



371
372
373
374
 
# File 'lib/sequel_core/database.rb', line 371

def identifier_output_method=(v)
  reset_schema_utility_dataset
  @identifier_output_method = v || ""
end

#inspect ⇒ Object

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).



379
380
381
 
# File 'lib/sequel_core/database.rb', line 379

def inspect
  "#<#{self.class}: #{(uri rescue opts).inspect}>" 
end

#log_info(message, args = nil) ⇒ Object

Log a message at level info to all loggers. All SQL logging goes through this method.



385
386
387
388
 
# File 'lib/sequel_core/database.rb', line 385

def log_info(message, args=nil)
  message = "#{message}; #{args.inspect}" if args
  @loggers.each{|logger| logger.info(message)}
end

#logger ⇒ Object

Return the first logger or nil if no loggers are being used. Should only be used for backwards compatibility.



392
393
394
 
# File 'lib/sequel_core/database.rb', line 392

def logger
  @loggers.first
end

#logger=(logger) ⇒ Object

Replace the array of loggers with the given logger(s).



397
398
399
 
# File 'lib/sequel_core/database.rb', line 397

def logger=(logger)
  @loggers = Array(logger)
end

#multi_threaded? ⇒ Boolean

Returns true unless the database is using a single-threaded connection pool.

Returns:

  • (Boolean) 


402
403
404
 
# File 'lib/sequel_core/database.rb', line 402

def multi_threaded?
  !@single_threaded
end

#query(&block) ⇒ Object

Returns a dataset modified by the given query block. See Dataset#query.



407
408
409
 
# File 'lib/sequel_core/database.rb', line 407

def query(&block)
  dataset.query(&block)
end

#quote_identifiers=(v) ⇒ Object

Whether to quote identifiers (columns and tables) for this database



412
413
414
415
 
# File 'lib/sequel_core/database.rb', line 412

def quote_identifiers=(v)
  reset_schema_utility_dataset
  @quote_identifiers = v
end

#quote_identifiers? ⇒ Boolean

Returns true if the database quotes identifiers.

Returns:

  • (Boolean) 


418
419
420
421
 
# File 'lib/sequel_core/database.rb', line 418

def quote_identifiers?
  return @quote_identifiers unless @quote_identifiers.nil?
  @quote_identifiers = @opts.include?(:quote_identifiers) ? @opts[:quote_identifiers] : (@@quote_identifiers.nil? ? quote_identifiers_default : @@quote_identifiers)
end

#rename_column(table, *args) ⇒ Object

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.



142
143
144
 
# File 'lib/sequel_core/database/schema.rb', line 142

def rename_column(table, *args)
  alter_table(table) {rename_column(*args)}
end

#rename_table(*args) ⇒ Object

Renames a table:

DB.tables #=> [:items]
DB.rename_table :items, :old_items
DB.tables #=> [:old_items]



132
133
134
 
# File 'lib/sequel_core/database/schema.rb', line 132

def rename_table(*args)
  execute_ddl(rename_table_sql(*args))
end

#select(*args) ⇒ Object

Returns a new dataset with the select method invoked.



424
425
426
 
# File 'lib/sequel_core/database.rb', line 424

def select(*args)
  dataset.select(*args)
end

#serial_primary_key_options ⇒ Object

Default serial primary key options.



429
430
431
 
# File 'lib/sequel_core/database.rb', line 429

def serial_primary_key_options
  {:primary_key => true, :type => Integer, :auto_increment => true}
end

#set_column_default(table, *args) ⇒ Object

Sets the default value for the given column in the given table:

DB.set_column_default :items, :category, 'perl!'

See alter_table.



151
152
153
 
# File 'lib/sequel_core/database/schema.rb', line 151

def set_column_default(table, *args)
  alter_table(table) {set_column_default(*args)}
end

#set_column_type(table, *args) ⇒ Object

Set the data type for the given column in the given table:

DB.set_column_type :items, :price, :float

See alter_table.



160
161
162
 
# File 'lib/sequel_core/database/schema.rb', line 160

def set_column_type(table, *args)
  alter_table(table) {set_column_type(*args)}
end

#single_threaded? ⇒ Boolean

Returns true if the database is using a single-threaded connection pool.

Returns:

  • (Boolean) 


434
435
436
 
# File 'lib/sequel_core/database.rb', line 434

def single_threaded?
  @single_threaded
end

#synchronize(server = nil, &block) ⇒ Object

Acquires a database connection, yielding it to the passed block.



439
440
441
 
# File 'lib/sequel_core/database.rb', line 439

def synchronize(server=nil, &block)
  @pool.hold(server || :default, &block)
end

#table_exists?(name) ⇒ Boolean

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.

Returns:

  • (Boolean) 


446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'lib/sequel_core/database.rb', line 446

def table_exists?(name)
  if @schemas && @schemas[name]
    true
  else
    begin 
      from(name).first
      true
    rescue
      false
    end
  end
end

#test_connection(server = nil) ⇒ Object

Attempts to acquire a database connection. Returns true if successful. Will probably raise an error if unsuccessful.



461
462
463
464
 
# File 'lib/sequel_core/database.rb', line 461

def test_connection(server=nil)
  synchronize(server){|conn|}
  true
end

#transaction(server = nil) ⇒ Object

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.



470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
 
# File 'lib/sequel_core/database.rb', line 470

def transaction(server=nil)
  synchronize(server) do |conn|
    return yield(conn) if @transactions.include?(Thread.current)
    log_info(begin_transaction_sql)
    conn.execute(begin_transaction_sql)
    begin
      @transactions << Thread.current
      yield(conn)
    rescue Exception => e
      log_info(rollback_transaction_sql)
      conn.execute(rollback_transaction_sql)
      transaction_error(e)
    ensure
      unless e
        log_info(commit_transaction_sql)
        conn.execute(commit_transaction_sql)
      end
      @transactions.delete(Thread.current)
    end
  end
end

#typecast_value(column_type, value) ⇒ Object

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.



496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
 
# File 'lib/sequel_core/database.rb', line 496

def typecast_value(column_type, value)
  return nil if value.nil?
  begin
    case column_type
    when :integer
      Integer(value)
    when :string
      value.to_s
    when :float
      Float(value)
    when :decimal
      case value
      when BigDecimal
        value
      when String, Float
        value.to_d
      when Integer
        value.to_s.to_d
      else
        raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
      end
    when :boolean
      case value
      when false, 0, "0", /\Af(alse)?\z/i
        false
      else
        value.blank? ? nil : true
      end
    when :date
      case value
      when Date
        value
      when DateTime, Time
        Date.new(value.year, value.month, value.day)
      when String
        value.to_date
      else
        raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
      end
    when :time
      case value
      when Time
        value
      when String
        value.to_time
      else
        raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
      end
    when :datetime
      raise(Sequel::Error::InvalidValue, "invalid value for Datetime: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
      if Sequel.datetime_class === value
        # Already the correct class, no need to convert
        value
      else
        # First convert it to standard ISO 8601 time, then
        # parse that string using the time class.
        (Time === value ? value.iso8601 : value.to_s).to_sequel_time
      end
    when :blob
      ::Sequel::SQL::Blob.new(value)
    else
      value
    end
  rescue ArgumentError => exp
    e = Sequel::Error::InvalidValue.new("#{exp.class} #{exp.message}")
    e.set_backtrace(exp.backtrace)
    raise e
  end
end

#upcase_identifiers=(v) ⇒ Object

Set whether to upcase identifiers going into the database.



567
568
569
 
# File 'lib/sequel_core/database.rb', line 567

def upcase_identifiers=(v)
  self.identifier_input_method = v ? :upcase : nil
end

#upcase_identifiers? ⇒ Boolean

Returns true if the database upcases identifiers.

Returns:

  • (Boolean) 


572
573
574
 
# File 'lib/sequel_core/database.rb', line 572

def upcase_identifiers?
  identifier_input_method == :upcase
end

#uri ⇒ Object

Returns the URI identifying the database. This method can raise an error if the database used options instead of a connection string.



579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
 
# File 'lib/sequel_core/database.rb', line 579

def uri
  uri = URI::Generic.new(
    self.class.adapter_scheme.to_s,
    nil,
    @opts[:host],
    @opts[:port],
    nil,
    "/#{@opts[:database]}",
    nil,
    nil,
    nil
  )
  uri.user = @opts[:user]
  uri.password = @opts[:password] if uri.user
  uri.to_s
end

#url ⇒ Object

Explicit alias of uri for easier subclassing.



597
598
599
 
# File 'lib/sequel_core/database.rb', line 597

def url
  uri
end