class Sequel::Database

   # File lib/sequel/database/query.rb
25 def <<(sql)
26   run(sql)
27   self
28 end

   # File lib/sequel/database/query.rb
35 def call(ps_name, hash=OPTS, &block)
36   prepared_statement(ps_name).call(hash, &block)
37 end

   # File lib/sequel/database/query.rb
42 def execute_ddl(sql, opts=OPTS, &block)
43   execute_dui(sql, opts, &block)
44 end

   # File lib/sequel/database/query.rb
49 def execute_dui(sql, opts=OPTS, &block)
50   execute(sql, opts, &block)
51 end

   # File lib/sequel/database/query.rb
56 def execute_insert(sql, opts=OPTS, &block)
57   execute_dui(sql, opts, &block)
58 end

   # File lib/sequel/database/query.rb
65 def get(*args, &block)
66   @default_dataset.get(*args, &block)
67 end

   # File lib/sequel/database/query.rb
74 def run(sql, opts=OPTS)
75   sql = literal(sql) if sql.is_a?(SQL::PlaceholderLiteralString)
76   execute_ddl(sql, opts)
77   nil
78 end

    # File lib/sequel/database/query.rb
121 def schema(table, opts=OPTS)
122   raise(Error, 'schema parsing is not implemented on this database') unless supports_schema_parsing?
123 
124   opts = opts.dup
125   tab = if table.is_a?(Dataset)
126     o = table.opts
127     from = o[:from]
128     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)
129     table.first_source_table
130   else
131     table
132   end
133 
134   qualifiers = split_qualifiers(tab)
135   table_name = qualifiers.pop
136   sch = qualifiers.pop
137   information_schema_schema = case qualifiers.length
138   when 1
139     Sequel.identifier(*qualifiers)
140   when 2
141     Sequel.qualify(*qualifiers)
142   end
143 
144   if table.is_a?(Dataset)
145     quoted_name = table.literal(tab)
146     opts[:dataset] = table
147   else
148     quoted_name = schema_utility_dataset.literal(table)
149   end
150 
151   opts[:schema] = sch if sch && !opts.include?(:schema)
152   opts[:information_schema_schema] = information_schema_schema if information_schema_schema && !opts.include?(:information_schema_schema)
153 
154   Sequel.synchronize{@schemas.delete(quoted_name)} if opts[:reload]
155   if v = Sequel.synchronize{@schemas[quoted_name]}
156     return v
157   end
158 
159   cols = schema_parse_table(table_name, opts)
160   raise(Error, "schema parsing returned no columns, table #{table_name.inspect} probably doesn't exist") if cols.nil? || cols.empty?
161 
162   primary_keys = 0
163   auto_increment_set = false
164   cols.each do |_,c|
165     auto_increment_set = true if c.has_key?(:auto_increment)
166     primary_keys += 1 if c[:primary_key]
167   end
168 
169   cols.each do |_,c|
170     c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type]) unless c.has_key?(:ruby_default)
171     if c[:primary_key] && !auto_increment_set
172       # If adapter didn't set it, assume that integer primary keys are auto incrementing
173       c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/i)
174     end
175     if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
176       c[:max_length] = max_length
177     end
178     if !c[:max_value] && !c[:min_value]
179       min_max = case c[:type]
180       when :integer
181         column_schema_integer_min_max_values(c)
182       when :decimal
183         column_schema_decimal_min_max_values(c)
184       end
185       c[:min_value], c[:max_value] = min_max if min_max
186     end
187   end
188   schema_post_process(cols)
189 
190   Sequel.synchronize{@schemas[quoted_name] = cols} if cache_schema
191   cols
192 end

    # File lib/sequel/database/query.rb
202 def table_exists?(name)
203   sch, table_name = schema_and_table(name)
204   name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
205   ds = from(name)
206   transaction(:savepoint=>:only){_table_exists?(ds)}
207   true
208 rescue DatabaseError
209   false
210 end

   # File lib/sequel/database/schema_methods.rb
25 def add_column(table, *args)
26   alter_table(table) {add_column(*args)}
27 end

   # File lib/sequel/database/schema_methods.rb
40 def add_index(table, columns, options=OPTS)
41   e = options[:ignore_errors]
42   begin
43     alter_table(table){add_index(columns, options)}
44   rescue DatabaseError
45     raise unless e
46   end
47   nil
48 end

   # File lib/sequel/database/schema_methods.rb
67 def alter_table(name, &block)
68   generator = alter_table_generator(&block)
69   remove_cached_schema(name)
70   apply_alter_table_generator(name, generator)
71   nil
72 end

   # File lib/sequel/database/schema_methods.rb
76 def alter_table_generator(&block)
77   alter_table_generator_class.new(self, &block)
78 end

    # File lib/sequel/database/schema_methods.rb
119 def create_join_table(hash, options=OPTS)
120   keys = hash.keys.sort
121   create_table(join_table_name(hash, options), options) do
122     keys.each do |key|
123       v = hash[key]
124       unless v.is_a?(Hash)
125         v = {:table=>v}
126       end
127       v[:null] = false unless v.has_key?(:null)
128       foreign_key(key, v)
129     end
130     primary_key(keys) unless options[:no_primary_key]
131     index(keys.reverse, options[:index_options] || OPTS) unless options[:no_index]
132   end
133   nil
134 end

    # File lib/sequel/database/schema_methods.rb
137 def create_join_table!(hash, options=OPTS)
138   drop_table?(join_table_name(hash, options))
139   create_join_table(hash, options)
140 end

    # File lib/sequel/database/schema_methods.rb
143 def create_join_table?(hash, options=OPTS)
144   if supports_create_table_if_not_exists? && options[:no_index]
145     create_join_table(hash, options.merge(:if_not_exists=>true))
146   elsif !table_exists?(join_table_name(hash, options))
147     create_join_table(hash, options)
148   end
149 end

    # File lib/sequel/database/schema_methods.rb
256 def create_or_replace_view(name, source, options = OPTS)
257   if supports_create_or_replace_view? && !options[:materialized]
258     options = options.merge(:replace=>true)
259   else
260     swallow_database_error{drop_view(name, options)}
261   end
262 
263   create_view(name, source, options)
264   nil
265 end

    # File lib/sequel/database/schema_methods.rb
204 def create_table(name, options=OPTS, &block)
205   remove_cached_schema(name)
206   if sql = options[:as]
207     raise(Error, "can't provide both :as option and block to create_table") if block
208     create_table_as(name, sql, options)
209   else
210     generator = options[:generator] || create_table_generator(&block)
211     create_table_from_generator(name, generator, options)
212     create_table_indexes_from_generator(name, generator, options)
213   end
214   nil
215 end

    # File lib/sequel/database/schema_methods.rb
223 def create_table!(name, options=OPTS, &block)
224   drop_table?(name)
225   create_table(name, options, &block)
226 end

    # File lib/sequel/database/schema_methods.rb
233 def create_table?(name, options=OPTS, &block)
234   options = options.dup
235   generator = options[:generator] ||= create_table_generator(&block)
236   if generator.indexes.empty? && supports_create_table_if_not_exists?
237     create_table(name, options.merge!(:if_not_exists=>true))
238   elsif !table_exists?(name)
239     create_table(name, options)
240   end
241 end

    # File lib/sequel/database/schema_methods.rb
245 def create_table_generator(&block)
246   create_table_generator_class.new(self, &block)
247 end

    # File lib/sequel/database/schema_methods.rb
310 def create_view(name, source, options = OPTS)
311   execute_ddl(create_view_sql(name, source, options))
312   remove_cached_schema(name)
313   nil
314 end

    # File lib/sequel/database/schema_methods.rb
321 def drop_column(table, *args)
322   alter_table(table) {drop_column(*args)}
323 end

    # File lib/sequel/database/schema_methods.rb
331 def drop_index(table, columns, options=OPTS)
332   alter_table(table){drop_index(columns, options)}
333 end

    # File lib/sequel/database/schema_methods.rb
340 def drop_join_table(hash, options=OPTS)
341   drop_table(join_table_name(hash, options), options)
342 end

    # File lib/sequel/database/schema_methods.rb
349 def drop_table(*names)
350   options = names.last.is_a?(Hash) ? names.pop : OPTS 
351   names.each do |n|
352     execute_ddl(drop_table_sql(n, options))
353     remove_cached_schema(n)
354   end
355   nil
356 end

    # File lib/sequel/database/schema_methods.rb
364 def drop_table?(*names)
365   options = names.last.is_a?(Hash) ? names.pop : OPTS
366   if supports_drop_table_if_exists?
367     options = options.merge(:if_exists=>true)
368     names.each do |name|
369       drop_table(name, options)
370     end
371   else
372     names.each do |name|
373       drop_table(name, options) if table_exists?(name)
374     end
375   end
376   nil
377 end

    # File lib/sequel/database/schema_methods.rb
392 def drop_view(*names)
393   options = names.last.is_a?(Hash) ? names.pop : OPTS
394   names.each do |n|
395     execute_ddl(drop_view_sql(n, options))
396     remove_cached_schema(n)
397   end
398   nil
399 end

    # File lib/sequel/database/schema_methods.rb
418 def rename_column(table, *args)
419   alter_table(table) {rename_column(*args)}
420 end

    # File lib/sequel/database/schema_methods.rb
406 def rename_table(name, new_name)
407   execute_ddl(rename_table_sql(name, new_name))
408   remove_cached_schema(name)
409   nil
410 end

    # File lib/sequel/database/schema_methods.rb
427 def set_column_default(table, *args)
428   alter_table(table) {set_column_default(*args)}
429 end

    # File lib/sequel/database/schema_methods.rb
436 def set_column_type(table, *args)
437   alter_table(table) {set_column_type(*args)}
438 end

   # File lib/sequel/database/dataset.rb
21 def [](*args)
22   args.first.is_a?(String) ? fetch(*args) : from(*args)
23 end

   # File lib/sequel/database/dataset.rb
29 def dataset
30   @dataset_class.new(self)
31 end

   # File lib/sequel/database/dataset.rb
59 def fetch(sql, *args, &block)
60   ds = @default_dataset.with_sql(sql, *args)
61   ds.each(&block) if block
62   ds
63 end

   # File lib/sequel/database/dataset.rb
70 def from(*args, &block)
71   if block
72     @default_dataset.from(*args, &block)
73   elsif args.length == 1 && (table = args[0]).is_a?(Symbol)
74     @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){@default_dataset.from(table)}
75   else
76     @default_dataset.from(*args)
77   end
78 end

   # File lib/sequel/database/dataset.rb
85 def select(*args, &block)
86   @default_dataset.select(*args, &block)
87 end

    # File lib/sequel/database/connecting.rb
158 def adapter_scheme
159   self.class.adapter_scheme
160 end

    # File lib/sequel/database/connecting.rb
170 def add_servers(servers)
171   unless sharded?
172     raise Error, "cannot call Database#add_servers on a Database instance that does not use a sharded connection pool"
173   end
174 
175   h = @opts[:servers]
176   Sequel.synchronize{h.merge!(servers)}
177   @pool.add_servers(servers.keys)
178 end

    # File lib/sequel/database/connecting.rb
189 def database_type
190   adapter_scheme
191 end

    # File lib/sequel/database/connecting.rb
203 def disconnect(opts = OPTS)
204   pool.disconnect(opts)
205 end

    # File lib/sequel/database/connecting.rb
210 def disconnect_connection(conn)
211   conn.close
212 end

    # File lib/sequel/database/connecting.rb
244 def new_connection(server)
245   conn = connect(server)
246   opts = server_opts(server)
247 
248   if ac = opts[:after_connect]
249     if ac.arity == 2
250       ac.call(conn, server)
251     else
252       ac.call(conn)
253     end
254   end
255 
256   if cs = opts[:connect_sqls]
257     cs.each do |sql|
258       log_connection_execute(conn, sql)
259     end
260   end
261 
262   conn
263 end

    # File lib/sequel/database/connecting.rb
223 def remove_servers(*servers)
224   unless sharded?
225     raise Error, "cannot call Database#remove_servers on a Database instance that does not use a sharded connection pool"
226   end
227 
228   h = @opts[:servers]
229   servers.flatten.each{|s| Sequel.synchronize{h.delete(s)}}
230   @pool.remove_servers(servers)
231 end

    # File lib/sequel/database/connecting.rb
237 def servers
238   pool.servers
239 end

    # File lib/sequel/database/connecting.rb
266 def single_threaded?
267   @single_threaded
268 end

    # File lib/sequel/database/connecting.rb
282 def synchronize(server=nil, &block)
283   @pool.hold(server || :default, &block)
284 end

    # File lib/sequel/database/connecting.rb
290 def test_connection(server=nil)
291   synchronize(server){|conn|}
292   true
293 end

    # File lib/sequel/database/connecting.rb
299 def valid_connection?(conn)
300   sql = valid_connection_sql
301   begin
302     log_connection_execute(conn, sql)
303   rescue Sequel::DatabaseError, *database_error_classes
304     false
305   else
306     true
307   end
308 end

   # File lib/sequel/database/dataset_defaults.rb
18 def dataset_class=(c)
19   unless @dataset_modules.empty?
20     c = Sequel.set_temp_name(Class.new(c)){"Sequel::Dataset::_Subclass"}
21     @dataset_modules.each{|m| c.send(:include, m)}
22   end
23   @dataset_class = c
24   reset_default_dataset
25 end

   # File lib/sequel/database/dataset_defaults.rb
62 def extend_datasets(mod=nil, &block)
63   raise(Error, "must provide either mod or block, not both") if mod && block
64   mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"} if block
65   if @dataset_modules.empty?
66    @dataset_modules = [mod]
67    @dataset_class = Sequel.set_temp_name(Class.new(@dataset_class)){"Sequel::Dataset::_Subclass"}
68   else
69    @dataset_modules << mod
70   end
71   @dataset_class.send(:include, mod)
72   reset_default_dataset
73 end

   # File lib/sequel/database/logging.rb
37 def log_connection_yield(sql, conn, args=nil)
38   return yield if skip_logging?
39   sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
40   timer = Sequel.start_timer
41 
42   begin
43     yield
44   rescue => e
45     log_exception(e, sql)
46     raise
47   ensure
48     log_duration(Sequel.elapsed_seconds_since(timer), sql) unless e
49   end
50 end

   # File lib/sequel/database/logging.rb
26 def log_exception(exception, message)
27   log_each(:error, "#{exception.class}: #{exception.message.strip if exception.message}: #{message}")
28 end

   # File lib/sequel/database/logging.rb
31 def log_info(message, args=nil)
32   log_each(:info, args ? "#{message}; #{args.inspect}" : message)
33 end

   # File lib/sequel/database/logging.rb
55 def logger=(logger)
56   @loggers = Array(logger)
57 end

    # File lib/sequel/database/misc.rb
243 def cast_type_literal(type)
244   type_literal(:type=>type)
245 end

    # File lib/sequel/database/misc.rb
252 def extension(*exts)
253   exts.each do |ext|
254     unless pr = Sequel.synchronize{EXTENSIONS[ext]}
255       Sequel.extension(ext)
256       pr = Sequel.synchronize{EXTENSIONS[ext]}
257     end
258 
259     if pr
260       if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
261         pr.call(self)
262       end
263     else
264       raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
265     end
266   end
267   self
268 end

    # File lib/sequel/database/misc.rb
217 def freeze
218   valid_connection_sql
219   metadata_dataset
220   @opts.freeze
221   @loggers.freeze
222   @pool.freeze
223   @dataset_class.freeze
224   @dataset_modules.freeze
225   @schema_type_classes.freeze
226   @loaded_extensions.freeze
227   metadata_dataset
228   super
229 end

    # File lib/sequel/database/misc.rb
273 def from_application_timestamp(v)
274   Sequel.convert_output_timestamp(v, timezone)
275 end

    # File lib/sequel/database/misc.rb
279 def inspect
280   s = String.new
281   s << "#<#{self.class}"
282   s << " database_type=#{database_type}" if database_type && database_type != adapter_scheme
283 
284   keys = [:host, :database, :user]
285   opts = self.opts
286   if !keys.any?{|k| opts[k]} && opts[:uri]
287     opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
288   end
289 
290   keys.each do |key|
291     val = opts[key]
292     if val && val != ''
293       s << " #{key}=#{val}"
294     end
295   end
296 
297   s << ">"
298 end

    # File lib/sequel/database/misc.rb
305 def literal(v)
306   schema_utility_dataset.literal(v)
307 end

    # File lib/sequel/database/misc.rb
311 def literal_symbol(sym)
312   Sequel.synchronize{@symbol_literal_cache[sym]}
313 end

    # File lib/sequel/database/misc.rb
316 def literal_symbol_set(sym, lit)
317   Sequel.synchronize{@symbol_literal_cache[sym] = lit}
318 end

    # File lib/sequel/database/misc.rb
321 def prepared_statement(name)
322   Sequel.synchronize{prepared_statements[name]}
323 end

    # File lib/sequel/database/misc.rb
328 def quote_identifier(v)
329   schema_utility_dataset.quote_identifier(v)
330 end

    # File lib/sequel/database/misc.rb
333 def schema_type_class(type)
334   @schema_type_classes[type]
335 end

    # File lib/sequel/database/misc.rb
338 def serial_primary_key_options
339   {:primary_key => true, :type => Integer, :auto_increment => true}
340 end

    # File lib/sequel/database/misc.rb
343 def set_prepared_statement(name, ps)
344   Sequel.synchronize{prepared_statements[name] = ps}
345 end

    # File lib/sequel/database/misc.rb
349 def sharded?
350   @sharded
351 end

    # File lib/sequel/database/misc.rb
354 def timezone
355   @timezone || Sequel.database_timezone
356 end

    # File lib/sequel/database/misc.rb
361 def to_application_timestamp(v)
362   Sequel.convert_timestamp(v, timezone)
363 end

    # File lib/sequel/database/misc.rb
370 def typecast_value(column_type, value)
371   return nil if value.nil?
372   meth = "typecast_value_#{column_type}"
373   begin
374     # Allow calling private methods as per-type typecasting methods are private
375     respond_to?(meth, true) ? send(meth, value) : value
376   rescue ArgumentError, TypeError => e
377     raise Sequel.convert_exception_class(e, InvalidValue)
378   end
379 end

    # File lib/sequel/database/misc.rb
383 def uri
384   opts[:uri]
385 end

    # File lib/sequel/database/misc.rb
388 def url
389   uri
390 end

   # File lib/sequel/database/transactions.rb
31 def after_commit(opts=OPTS, &block)
32   raise Error, "must provide block to after_commit" unless block
33   synchronize(opts[:server]) do |conn|
34     if h = _trans(conn)
35       raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
36       if opts[:savepoint] && in_savepoint?(conn)
37         add_savepoint_hook(conn, :after_commit, block)
38       else
39         add_transaction_hook(conn, :after_commit, block)
40       end
41     else
42       yield
43     end
44   end
45 end

   # File lib/sequel/database/transactions.rb
55 def after_rollback(opts=OPTS, &block)
56   raise Error, "must provide block to after_rollback" unless block
57   synchronize(opts[:server]) do |conn|
58     if h = _trans(conn)
59       raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
60       if opts[:savepoint] && in_savepoint?(conn)
61         add_savepoint_hook(conn, :after_rollback, block)
62       else
63         add_transaction_hook(conn, :after_rollback, block)
64       end
65     end
66   end
67 end

    # File lib/sequel/database/transactions.rb
113 def in_transaction?(opts=OPTS)
114   synchronize(opts[:server]){|conn| !!_trans(conn)}
115 end

    # File lib/sequel/database/transactions.rb
123 def rollback_checker(opts=OPTS)
124   synchronize(opts[:server]) do |conn|
125     raise Error, "not in a transaction" unless t = _trans(conn)
126     t[:rollback_checker] ||= proc{Sequel.synchronize{t[:rolled_back]}}
127   end
128 end

    # File lib/sequel/database/transactions.rb
 83 def rollback_on_exit(opts=OPTS)
 84   synchronize(opts[:server]) do |conn|
 85     raise Error, "Cannot call Sequel:: Database#rollback_on_exit unless inside a transaction" unless h = _trans(conn)
 86     rollback = !opts[:cancel]
 87 
 88     if supports_savepoints?
 89       savepoints = h[:savepoints]
 90 
 91       if level = opts[:savepoint]
 92         level = 1 if level == true
 93         raise Error, "invalid :savepoint option to Database#rollback_on_exit: #{level.inspect}" unless level.is_a?(Integer)
 94         raise Error, "cannot pass nonpositive integer (#{level.inspect}) as :savepoint option to Database#rollback_on_exit" if level < 1
 95         level.times do |i|
 96           break unless savepoint = savepoints[-1 - i]
 97           savepoint[:rollback_on_exit] = rollback
 98         end
 99       else
100         savepoints[0][:rollback_on_exit] = rollback
101       end
102     else
103       h[:rollback_on_exit] = rollback
104     end
105   end
106 
107   nil
108 end

    # File lib/sequel/database/transactions.rb
179 def transaction(opts=OPTS, &block)
180   opts = Hash[opts]
181   if retry_on = opts[:retry_on]
182     tot_retries = opts.fetch(:num_retries, 5)
183     num_retries = 0
184     begin
185       opts[:retry_on] = nil
186       opts[:retrying] = true
187       transaction(opts, &block)
188     rescue *retry_on => e
189       num_retries += 1
190       if tot_retries.nil? || num_retries <= tot_retries
191         opts[:before_retry].call(num_retries, e) if opts[:before_retry]
192         retry
193       end
194       raise
195     end
196   else
197     synchronize(opts[:server]) do |conn|
198       if opts[:skip_transaction]
199         return yield(conn)
200       end
201 
202       if opts[:savepoint] == :only
203         if supports_savepoints?
204           if _trans(conn)
205             opts[:savepoint] = true
206           else
207             return yield(conn)
208           end
209         else
210           opts[:savepoint] = false
211         end
212       end
213 
214       if opts[:savepoint] && !supports_savepoints?
215         raise Sequel::InvalidOperation, "savepoints not supported on #{database_type}"
216       end
217 
218       if already_in_transaction?(conn, opts)
219         if opts[:rollback] == :always && !opts.has_key?(:savepoint)
220           if supports_savepoints? 
221             opts[:savepoint] = true
222           else
223             raise Sequel::Error, "cannot set :rollback=>:always transaction option if already inside a transaction"
224           end
225         end
226 
227         if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last[:auto_savepoint]
228           opts[:savepoint] = true
229         end
230 
231         unless opts[:savepoint]
232           if opts[:retrying]
233             raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
234           end
235           return yield(conn)
236         end
237       end
238 
239       _transaction(conn, opts, &block)
240     end
241   end
242 end

   # File lib/sequel/database/features.rb
13 def global_index_namespace?
14   true
15 end

   # File lib/sequel/database/features.rb
19 def supports_create_table_if_not_exists?
20   false
21 end

   # File lib/sequel/database/features.rb
25 def supports_deferrable_constraints?
26   false
27 end

   # File lib/sequel/database/features.rb
31 def supports_deferrable_foreign_key_constraints?
32   supports_deferrable_constraints?
33 end

   # File lib/sequel/database/features.rb
37 def supports_drop_table_if_exists?
38   supports_create_table_if_not_exists?
39 end

   # File lib/sequel/database/features.rb
43 def supports_foreign_key_parsing?
44   respond_to?(:foreign_key_list)
45 end

   # File lib/sequel/database/features.rb
48 def supports_index_parsing?
49   respond_to?(:indexes)
50 end

   # File lib/sequel/database/features.rb
54 def supports_partial_indexes?
55   false
56 end

   # File lib/sequel/database/features.rb
60 def supports_prepared_transactions?
61   false
62 end

   # File lib/sequel/database/features.rb
65 def supports_savepoints?
66   false
67 end

   # File lib/sequel/database/features.rb
71 def supports_savepoints_in_prepared_transactions?
72   supports_prepared_transactions? && supports_savepoints?
73 end

   # File lib/sequel/database/features.rb
76 def supports_schema_parsing?
77   respond_to?(:schema_parse_table, true)
78 end

   # File lib/sequel/database/features.rb
81 def supports_table_listing?
82   respond_to?(:tables)
83 end

   # File lib/sequel/database/features.rb
91 def supports_transaction_isolation_levels?
92   false
93 end

   # File lib/sequel/database/features.rb
96 def supports_transactional_ddl?
97   false
98 end

   # File lib/sequel/database/features.rb
86 def supports_view_listing?
87   respond_to?(:views)
88 end

    # File lib/sequel/database/features.rb
101 def supports_views_with_check_option?
102   !!view_with_check_option_support
103 end

    # File lib/sequel/database/features.rb
106 def supports_views_with_local_check_option?
107   view_with_check_option_support == :local
108 end