Class: Sequel::Database

39
40
41

# File 'lib/sequel/database/connecting.rb', line 39

def self.adapter_scheme
  @scheme
end

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

# File 'lib/sequel/database/connecting.rb', line 44

def self.connect(conn_string, opts = {})
  case conn_string
  when String
    if match = /\A(jdbc|do):/o.match(conn_string)
      c = adapter_class(match[1].to_sym)
      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 = c.send(:uri_to_options, uri)
      uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
      uri_options.to_a.each{|k,v| uri_options[k] = URI.unescape(v) if v.is_a?(String)}
      opts = uri_options.merge(opts)
      opts[:adapter] = scheme
    end
  when Hash
    opts = conn_string.merge(opts)
    c = adapter_class(opts[:adapter_class] || opts[:adapter] || opts['adapter'])
  else
    raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
  end
  # process opts a bit
  opts = opts.inject({}) do |m, (k,v)|
    k = :user if k.to_s == 'username'
    m[k.to_sym] = v
    m
  end
  begin
    db = c.new(opts)
    db.test_connection if opts[:test] && db.send(:typecast_value_boolean, opts[:test])
    result = yield(db) if block_given?
  ensure
    if block_given?
      db.disconnect if db
      ::Sequel::DATABASES.delete(db)
    end
  end
  block_given? ? result : db
end

21
22
23

# File 'lib/sequel/database/dataset_defaults.rb', line 21

def self.identifier_input_method
  @@identifier_input_method
end

27
28
29

# File 'lib/sequel/database/dataset_defaults.rb', line 27

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

32
33
34

# File 'lib/sequel/database/dataset_defaults.rb', line 32

def self.identifier_output_method
  @@identifier_output_method
end

38
39
40

# File 'lib/sequel/database/dataset_defaults.rb', line 38

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

44
45
46

# File 'lib/sequel/database/dataset_defaults.rb', line 44

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

104
105
106
107

# File 'lib/sequel/database/connecting.rb', line 104

def self.set_adapter_scheme(scheme) # :nodoc:
  @scheme = scheme
  ADAPTER_MAP[scheme.to_sym] = self
end

88
89
90

# File 'lib/sequel/database/connecting.rb', line 88

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

10
11
12
13
14
15
16

# File 'lib/sequel/database/misc.rb', line 10

def self.uri_to_options(uri)
  { :user => uri.user,
    :password => uri.password,
    :host => uri.host,
    :port => uri.port,
    :database => (m = /\/(.*)/.match(uri.path)) && (m[1]) }
end

19
20
21

# File 'lib/sequel/database/dataset.rb', line 19

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

120
121
122

# File 'lib/sequel/database/connecting.rb', line 120

def adapter_scheme
  self.class.adapter_scheme
end

33
34
35

# File 'lib/sequel/database/schema_methods.rb', line 33

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

46
47
48
49
50
51
52
53

# File 'lib/sequel/database/schema_methods.rb', line 46

def add_index(table, columns, options={})
  e = options[:ignore_errors]
  begin
    alter_table(table){add_index(columns, options)}
  rescue DatabaseError
    raise unless e
  end
end

133
134
135
136

# File 'lib/sequel/database/connecting.rb', line 133

def add_servers(servers)
  @opts[:servers] = @opts[:servers] ? @opts[:servers].merge(servers) : servers
  @pool.add_servers(servers.keys)
end

74
75
76
77
78
79
80
81
82
83
84

# File 'lib/sequel/database/misc.rb', line 74

def after_commit(opts={}, &block)
  raise Error, "must provide block to after_commit" unless block
  synchronize(opts[:server]) do |conn|
    if h = @transactions[conn]
      raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
      (h[:after_commit] ||= []) << block
    else
      yield
    end
  end
end

91
92
93
94
95
96
97
98
99

# File 'lib/sequel/database/misc.rb', line 91

def after_rollback(opts={}, &block)
  raise Error, "must provide block to after_rollback" unless block
  synchronize(opts[:server]) do |conn|
    if h = @transactions[conn]
      raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
      (h[:after_rollback] ||= []) << block
    end
  end
end

72
73
74
75
76
77

# File 'lib/sequel/database/schema_methods.rb', line 72

def alter_table(name, generator=nil, &block)
  generator ||= Schema::AlterTableGenerator.new(self, &block)
  remove_cached_schema(name)
  apply_alter_table(name, generator.operations)
  nil
end

53
54
55

# File 'lib/sequel/database/query.rb', line 53

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

105
106
107

# File 'lib/sequel/database/misc.rb', line 105

def cast_type_literal(type)
  type_literal(:type=>type)
end

402
403
404
405
406
407
408
409

# File 'lib/sequel/database/query.rb', line 402

def commit_or_rollback_transaction(exception, conn, opts)
  if exception
    false
  else
    commit_transaction(conn, opts)
    true
  end
end

139
140
141

# File 'lib/sequel/database/connecting.rb', line 139

def connect(server)
  raise NotImplemented, "#connect should be overridden by adapters"
end

130
131
132
133
134
135

# File 'lib/sequel/database/schema_methods.rb', line 130

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

93
94
95
96
97
98
99
100

# File 'lib/sequel/database/schema_methods.rb', line 93

def create_table(name, options={}, &block)
  remove_cached_schema(name)
  options = {:generator=>options} if options.is_a?(Schema::Generator)
  generator = options[:generator] || Schema::Generator.new(self, &block)
  create_table_from_generator(name, generator, options)
  create_table_indexes_from_generator(name, generator, options)
  nil
end

108
109
110
111

# File 'lib/sequel/database/schema_methods.rb', line 108

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

118
119
120
121
122
123
124

# File 'lib/sequel/database/schema_methods.rb', line 118

def create_table?(name, options={}, &block)
  if supports_create_table_if_not_exists?
    create_table(name, options.merge(:if_not_exists=>true), &block)
  elsif !table_exists?(name)
    create_table(name, options, &block)
  end
end

141
142
143
144

# File 'lib/sequel/database/schema_methods.rb', line 141

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

152
153
154

# File 'lib/sequel/database/connecting.rb', line 152

def database_type
  adapter_scheme
end

27
28
29

# File 'lib/sequel/database/dataset.rb', line 27

def dataset(opts=nil)
  @dataset_class.new(self, opts)
end

166
167
168

# File 'lib/sequel/database/connecting.rb', line 166

def disconnect(opts = {})
  pool.disconnect(opts)
end

151
152
153

# File 'lib/sequel/database/schema_methods.rb', line 151

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

161
162
163

# File 'lib/sequel/database/schema_methods.rb', line 161

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

170
171
172
173
174
175
176
177

# File 'lib/sequel/database/schema_methods.rb', line 170

def drop_table(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names.each do |n|
    execute_ddl(drop_table_sql(n, options))
    remove_cached_schema(n)
  end
  nil
end

185
186
187
188
189
190
191
192
193
194
195
196
197

# File 'lib/sequel/database/schema_methods.rb', line 185

def drop_table?(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  if supports_drop_table_if_exists?
    options = options.merge(:if_exists=>true)
    names.each do |name|
      drop_table(name, options)
    end
  else
    names.each do |name|
      drop_table(name, options) if table_exists?(name)
    end
  end
end

204
205
206
207
208
209
210
211

# File 'lib/sequel/database/schema_methods.rb', line 204

def drop_view(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names.each do |n|
    execute_ddl(drop_view_sql(n, options))
    remove_cached_schema(n)
  end
  nil
end

13
14
15
16
17
18
19
20
21
22
23
24
25
26

# File 'lib/sequel/extensions/schema_dumper.rb', line 13

def dump_indexes_migration(options={})
  ts = tables(options)
  <<END_MIG
Sequel.migration do
  up do
#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
  end
  
  down do
#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_indexes(t, :drop_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
  end
end
END_MIG
end

37
38
39
40
41
42
43
44
45
46
47
48
49
50

# File 'lib/sequel/extensions/schema_dumper.rb', line 37

def dump_schema_migration(options={})
  ts = tables(options)
  <<END_MIG
Sequel.migration do
  up do
#{ts.sort_by{|t| t.to_s}.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}
  end
  
  down do
drop_table(#{ts.sort_by{|t| t.to_s}.inspect[1...-1]})
  end
end
END_MIG
end

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# File 'lib/sequel/extensions/schema_dumper.rb', line 54

def dump_table_schema(table, options={})
  table = table.value.to_s if table.is_a?(SQL::Identifier)
  raise(Error, "must provide table as a Symbol, String, or Sequel::SQL::Identifier") unless [String, Symbol].any?{|c| table.is_a?(c)}
  s = schema(table).dup
  pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
  options = options.merge(:single_pk=>true) if pks.length == 1
  m = method(:column_schema_to_generator_opts)
  im = method(:index_to_generator_opts)
  begin
    indexes = indexes(table).sort_by{|k,v| k.to_s} if options[:indexes] != false
  rescue Sequel::NotImplemented
    nil
  end
  gen = Schema::Generator.new(self) do
    s.each{|name, info| send(*m.call(name, info, options))}
    primary_key(pks) if !@primary_key && pks.length > 0
    indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))} if indexes
  end
  commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
  "create_table(#{table.inspect}#{', :ignore_index_errors=>true' if !options[:same_db] && options[:indexes] != false && indexes && !indexes.empty?}) do\n#{commands.gsub(/^/o, '  ')}\nend"
end

175
176
177

# File 'lib/sequel/database/connecting.rb', line 175

def each_server(&block)
  servers.each{|s| self.class.connect(server_opts(s), &block)}
end

59
60
61

# File 'lib/sequel/database/query.rb', line 59

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

66
67
68

# File 'lib/sequel/database/query.rb', line 66

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

73
74
75

# File 'lib/sequel/database/query.rb', line 73

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

80
81
82

# File 'lib/sequel/database/query.rb', line 80

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

89
90
91
92
93
94
95
96
97
98
99
100

# File 'lib/sequel/database/dataset_defaults.rb', line 89

def extend_datasets(mod=nil, &block)
  raise(Error, "must provide either mod or block, not both") if mod && block
  reset_schema_utility_dataset
  mod = Module.new(&block) if block
  if @dataset_modules.empty?
   @dataset_modules = [mod]
   @dataset_class = Class.new(@dataset_class)
  else
   @dataset_modules << mod
  end
  @dataset_class.send(:include, mod)
end

44
45
46
47
48

# File 'lib/sequel/database/dataset.rb', line 44

def fetch(sql, *args, &block)
  ds = dataset.with_sql(sql, *args)
  ds.each(&block) if block
  ds
end

55
56
57
58

# File 'lib/sequel/database/dataset.rb', line 55

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

112
113
114

# File 'lib/sequel/database/misc.rb', line 112

def from_application_timestamp(v)
  Sequel.convert_output_timestamp(v, timezone)
end

89
90
91

# File 'lib/sequel/database/query.rb', line 89

def get(*args, &block)
  dataset.get(*args, &block)
end

103
104
105
106
107
108
109
110
111
112
113

# File 'lib/sequel/database/dataset_defaults.rb', line 103

def identifier_input_method
  case @identifier_input_method
  when nil
    @identifier_input_method = @opts.fetch(: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

120
121
122
123

# File 'lib/sequel/database/dataset_defaults.rb', line 120

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

126
127
128
129
130
131
132
133
134
135
136

# File 'lib/sequel/database/dataset_defaults.rb', line 126

def identifier_output_method
  case @identifier_output_method
  when nil
    @identifier_output_method = @opts.fetch(: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

143
144
145
146

# File 'lib/sequel/database/dataset_defaults.rb', line 143

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

119
120
121

# File 'lib/sequel/database/misc.rb', line 119

def in_transaction?(opts={})
  synchronize(opts[:server]){|conn| !!@transactions[conn]}
end

102
103
104

# File 'lib/sequel/database/query.rb', line 102

def indexes(table, opts={})
  raise NotImplemented, "#indexes should be overridden by adapters"
end

126
127
128

# File 'lib/sequel/database/misc.rb', line 126

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

135
136
137

# File 'lib/sequel/database/misc.rb', line 135

def literal(v)
  schema_utility_dataset.literal(v)
end

21
22
23

# File 'lib/sequel/database/logging.rb', line 21

def log_info(message, args=nil)
  log_each(:info, args ? "#{message}; #{args.inspect}" : message)
end

27
28
29
30
31
32
33
34
35
36
37
38
39

# File 'lib/sequel/database/logging.rb', line 27

def log_yield(sql, args=nil)
  return yield if @loggers.empty?
  sql = "#{sql}; #{args.inspect}" if args
  start = Time.now
  begin
    yield
  rescue => e
    log_each(:error, "#{e.class}: #{e.message.strip}: #{sql}")
    raise
  ensure
    log_duration(Time.now - start, sql) unless e
  end
end

44
45
46

# File 'lib/sequel/database/logging.rb', line 44

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

8
9
10

# File 'lib/sequel/extensions/query.rb', line 8

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

153
154
155
156

# File 'lib/sequel/database/dataset_defaults.rb', line 153

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

159
160
161
162

# File 'lib/sequel/database/dataset_defaults.rb', line 159

def quote_identifiers?
  return @quote_identifiers unless @quote_identifiers.nil?
  @quote_identifiers = @opts.fetch(:quote_identifiers, (@@quote_identifiers.nil? ? quote_identifiers_default : @@quote_identifiers))
end

189
190
191
192
193
194
195
196
197

# File 'lib/sequel/database/connecting.rb', line 189

def remove_servers(*servers)
  if @opts[:servers] && !@opts[:servers].empty?
    servs = @opts[:servers].dup
    servers.flatten!
    servers.each{|s| servs.delete(s)}
    @opts[:servers] = servs
    @pool.remove_servers(servers)
  end
end

230
231
232

# File 'lib/sequel/database/schema_methods.rb', line 230

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

218
219
220
221
222

# File 'lib/sequel/database/schema_methods.rb', line 218

def rename_table(name, new_name)
  execute_ddl(rename_table_sql(name, new_name))
  remove_cached_schema(name)
  nil
end

111
112
113
114

# File 'lib/sequel/database/query.rb', line 111

def run(sql, opts={})
  execute_ddl(sql, opts)
  nil
end

156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

# File 'lib/sequel/database/query.rb', line 156

def schema(table, opts={})
  raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)

  opts = opts.dup
  if table.is_a?(Dataset)
    o = table.opts
    from = o[:from]
    raise(Error, "can only parse the schema for a dataset with a single from table") unless from && from.length == 1 && !o.include?(:join) && !o.include?(:sql)
    tab = table.first_source_table
    sch, table_name = schema_and_table(tab)
    quoted_name = table.literal(tab)
    opts[:dataset] = table
  else
    sch, table_name = schema_and_table(table)
    quoted_name = quote_schema_table(table)
  end
  opts[:schema] = sch if sch && !opts.include?(:schema)

  @schemas.delete(quoted_name) if opts[:reload]
  return @schemas[quoted_name] if @schemas[quoted_name]

  cols = schema_parse_table(table_name, opts)
  raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
  cols.each{|_,c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
  @schemas[quoted_name] = cols
end

65
66
67

# File 'lib/sequel/database/dataset.rb', line 65

def select(*args, &block)
  dataset.select(*args, &block)
end

141
142
143

# File 'lib/sequel/database/misc.rb', line 141

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

203
204
205

# File 'lib/sequel/database/connecting.rb', line 203

def servers
  pool.servers
end

239
240
241

# File 'lib/sequel/database/schema_methods.rb', line 239

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

248
249
250

# File 'lib/sequel/database/schema_methods.rb', line 248

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

208
209
210

# File 'lib/sequel/database/connecting.rb', line 208

def single_threaded?
  @single_threaded
end

147
148
149

# File 'lib/sequel/database/misc.rb', line 147

def supports_create_table_if_not_exists?
  false
end

153
154
155

# File 'lib/sequel/database/misc.rb', line 153

def supports_drop_table_if_exists?
  supports_create_table_if_not_exists?
end

159
160
161

# File 'lib/sequel/database/misc.rb', line 159

def supports_prepared_transactions?
  false
end

164
165
166

# File 'lib/sequel/database/misc.rb', line 164

def supports_savepoints?
  false
end

170
171
172

# File 'lib/sequel/database/misc.rb', line 170

def supports_savepoints_in_prepared_transactions?
  supports_prepared_transactions? && supports_savepoints?
end

175
176
177

# File 'lib/sequel/database/misc.rb', line 175

def supports_transaction_isolation_levels?
  false
end

224
225
226

# File 'lib/sequel/database/connecting.rb', line 224

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

191
192
193
194
195
196
197
198

# File 'lib/sequel/database/query.rb', line 191

def table_exists?(name)
  sch, table_name = schema_and_table(name)
  name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
  _table_exists?(from(name))
  true
rescue DatabaseError
  false
end

203
204
205

# File 'lib/sequel/database/query.rb', line 203

def tables(opts={})
  raise NotImplemented, "#tables should be overridden by adapters"
end

232
233
234
235

# File 'lib/sequel/database/connecting.rb', line 232

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

187
188
189

# File 'lib/sequel/database/misc.rb', line 187

def to_application_timestamp(v)
  Sequel.convert_timestamp(v, timezone)
end

228
229
230
231
232
233

# File 'lib/sequel/database/query.rb', line 228

def transaction(opts={}, &block)
  synchronize(opts[:server]) do |conn|
    return yield(conn) if already_in_transaction?(conn, opts)
    _transaction(conn, opts, &block)
  end
end

196
197
198
199
200
201
202
203
204

# File 'lib/sequel/database/misc.rb', line 196

def typecast_value(column_type, value)
  return nil if value.nil?
  meth = "typecast_value_#{column_type}"
  begin
    respond_to?(meth, true) ? send(meth, value) : value
  rescue ArgumentError, TypeError => e
    raise Sequel.convert_exception_class(e, InvalidValue)
  end
end

334
335
336

# File 'lib/sequel/database/misc.rb', line 334

def typecast_value_integer(value)
  Integer(value.is_a?(String) ? value.sub(LEADING_ZERO_RE, LEADING_ZERO_REP) : value)
end

214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

# File 'lib/sequel/database/misc.rb', line 214

def uri
  uri = URI::Generic.new(
    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

232
233
234

# File 'lib/sequel/database/misc.rb', line 232

def url
  uri
end