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/io)
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
248 def create_or_replace_view(name, source, options = OPTS)
249   if supports_create_or_replace_view?
250     options = options.merge(:replace=>true)
251   else
252     swallow_database_error{drop_view(name)}
253   end
254 
255   create_view(name, source, options)
256   nil
257 end

    # File lib/sequel/database/schema_methods.rb
196 def create_table(name, options=OPTS, &block)
197   remove_cached_schema(name)
198   if sql = options[:as]
199     raise(Error, "can't provide both :as option and block to create_table") if block
200     create_table_as(name, sql, options)
201   else
202     generator = options[:generator] || create_table_generator(&block)
203     create_table_from_generator(name, generator, options)
204     create_table_indexes_from_generator(name, generator, options)
205   end
206   nil
207 end

    # File lib/sequel/database/schema_methods.rb
215 def create_table!(name, options=OPTS, &block)
216   drop_table?(name)
217   create_table(name, options, &block)
218 end

    # File lib/sequel/database/schema_methods.rb
225 def create_table?(name, options=OPTS, &block)
226   options = options.dup
227   generator = options[:generator] ||= create_table_generator(&block)
228   if generator.indexes.empty? && supports_create_table_if_not_exists?
229     create_table(name, options.merge!(:if_not_exists=>true))
230   elsif !table_exists?(name)
231     create_table(name, options)
232   end
233 end

    # File lib/sequel/database/schema_methods.rb
237 def create_table_generator(&block)
238   create_table_generator_class.new(self, &block)
239 end

    # File lib/sequel/database/schema_methods.rb
302 def create_view(name, source, options = OPTS)
303   execute_ddl(create_view_sql(name, source, options))
304   remove_cached_schema(name)
305   nil
306 end

    # File lib/sequel/database/schema_methods.rb
313 def drop_column(table, *args)
314   alter_table(table) {drop_column(*args)}
315 end

    # File lib/sequel/database/schema_methods.rb
323 def drop_index(table, columns, options=OPTS)
324   alter_table(table){drop_index(columns, options)}
325 end

    # File lib/sequel/database/schema_methods.rb
332 def drop_join_table(hash, options=OPTS)
333   drop_table(join_table_name(hash, options), options)
334 end

    # File lib/sequel/database/schema_methods.rb
341 def drop_table(*names)
342   options = names.last.is_a?(Hash) ? names.pop : OPTS 
343   names.each do |n|
344     execute_ddl(drop_table_sql(n, options))
345     remove_cached_schema(n)
346   end
347   nil
348 end

    # File lib/sequel/database/schema_methods.rb
356 def drop_table?(*names)
357   options = names.last.is_a?(Hash) ? names.pop : OPTS
358   if supports_drop_table_if_exists?
359     options = options.merge(:if_exists=>true)
360     names.each do |name|
361       drop_table(name, options)
362     end
363   else
364     names.each do |name|
365       drop_table(name, options) if table_exists?(name)
366     end
367   end
368   nil
369 end

    # File lib/sequel/database/schema_methods.rb
384 def drop_view(*names)
385   options = names.last.is_a?(Hash) ? names.pop : OPTS
386   names.each do |n|
387     execute_ddl(drop_view_sql(n, options))
388     remove_cached_schema(n)
389   end
390   nil
391 end

    # File lib/sequel/database/schema_methods.rb
410 def rename_column(table, *args)
411   alter_table(table) {rename_column(*args)}
412 end

    # File lib/sequel/database/schema_methods.rb
398 def rename_table(name, new_name)
399   execute_ddl(rename_table_sql(name, new_name))
400   remove_cached_schema(name)
401   nil
402 end

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

    # File lib/sequel/database/schema_methods.rb
428 def set_column_type(table, *args)
429   alter_table(table) {set_column_type(*args)}
430 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
49 def fetch(sql, *args, &block)
50   ds = @default_dataset.with_sql(sql, *args)
51   ds.each(&block) if block
52   ds
53 end

   # File lib/sequel/database/dataset.rb
60 def from(*args, &block)
61   if block
62     @default_dataset.from(*args, &block)
63   elsif args.length == 1 && (table = args[0]).is_a?(Symbol)
64     @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){@default_dataset.from(table)}
65   else
66     @default_dataset.from(*args)
67   end
68 end

   # File lib/sequel/database/dataset.rb
75 def select(*args, &block)
76   @default_dataset.select(*args, &block)
77 end

    # File lib/sequel/database/connecting.rb
161 def adapter_scheme
162   self.class.adapter_scheme
163 end

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

    # File lib/sequel/database/connecting.rb
192 def database_type
193   adapter_scheme
194 end

    # File lib/sequel/database/connecting.rb
206 def disconnect(opts = OPTS)
207   pool.disconnect(opts)
208 end

    # File lib/sequel/database/connecting.rb
213 def disconnect_connection(conn)
214   conn.close
215 end

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

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

    # File lib/sequel/database/connecting.rb
240 def servers
241   pool.servers
242 end

    # File lib/sequel/database/connecting.rb
269 def single_threaded?
270   @single_threaded
271 end

    # File lib/sequel/database/connecting.rb
275 def synchronize(server=nil)
276   @pool.hold(server || :default){|conn| yield conn}
277 end

    # File lib/sequel/database/connecting.rb
301 def test_connection(server=nil)
302   synchronize(server){|conn|}
303   true
304 end

    # File lib/sequel/database/connecting.rb
310 def valid_connection?(conn)
311   sql = valid_connection_sql
312   begin
313     log_connection_execute(conn, sql)
314   rescue Sequel::DatabaseError, *database_error_classes
315     false
316   else
317     true
318   end
319 end

   # File lib/sequel/database/dataset_defaults.rb
18 def dataset_class=(c)
19   unless @dataset_modules.empty?
20     c = Class.new(c)
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 = Dataset::DatasetModule.new(&block) if block
65   if @dataset_modules.empty?
66    @dataset_modules = [mod]
67    @dataset_class = Class.new(@dataset_class)
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
222 def cast_type_literal(type)
223   type_literal(:type=>type)
224 end

    # File lib/sequel/database/misc.rb
231 def extension(*exts)
232   Sequel.extension(*exts)
233   exts.each do |ext|
234     if pr = Sequel.synchronize{EXTENSIONS[ext]}
235       if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
236         pr.call(self)
237       end
238     else
239       raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
240     end
241   end
242   self
243 end

    # File lib/sequel/database/misc.rb
196 def freeze
197   valid_connection_sql
198   metadata_dataset
199   @opts.freeze
200   @loggers.freeze
201   @pool.freeze
202   @dataset_class.freeze
203   @dataset_modules.freeze
204   @schema_type_classes.freeze
205   @loaded_extensions.freeze
206   metadata_dataset
207   super
208 end

    # File lib/sequel/database/misc.rb
248 def from_application_timestamp(v)
249   Sequel.convert_output_timestamp(v, timezone)
250 end

    # File lib/sequel/database/misc.rb
254 def inspect
255   a = []
256   a << uri.inspect if uri
257   if (oo = opts[:orig_opts]) && !oo.empty?
258     a << oo.inspect
259   end
260   "#<#{self.class}: #{a.join(' ')}>"
261 end

    # File lib/sequel/database/misc.rb
268 def literal(v)
269   schema_utility_dataset.literal(v)
270 end

    # File lib/sequel/database/misc.rb
274 def literal_symbol(sym)
275   Sequel.synchronize{@symbol_literal_cache[sym]}
276 end

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

    # File lib/sequel/database/misc.rb
284 def prepared_statement(name)
285   Sequel.synchronize{prepared_statements[name]}
286 end

    # File lib/sequel/database/misc.rb
291 def quote_identifier(v)
292   schema_utility_dataset.quote_identifier(v)
293 end

    # File lib/sequel/database/misc.rb
296 def schema_type_class(type)
297   @schema_type_classes[type]
298 end

    # File lib/sequel/database/misc.rb
301 def serial_primary_key_options
302   {:primary_key => true, :type => Integer, :auto_increment => true}
303 end

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

    # File lib/sequel/database/misc.rb
312 def sharded?
313   @sharded
314 end

    # File lib/sequel/database/misc.rb
317 def timezone
318   @timezone || Sequel.database_timezone
319 end

    # File lib/sequel/database/misc.rb
324 def to_application_timestamp(v)
325   Sequel.convert_timestamp(v, timezone)
326 end

    # File lib/sequel/database/misc.rb
333 def typecast_value(column_type, value)
334   return nil if value.nil?
335   meth = "typecast_value_#{column_type}"
336   begin
337     # Allow calling private methods as per-type typecasting methods are private
338     respond_to?(meth, true) ? send(meth, value) : value
339   rescue ArgumentError, TypeError => e
340     raise Sequel.convert_exception_class(e, InvalidValue)
341   end
342 end

    # File lib/sequel/database/misc.rb
346 def uri
347   opts[:uri]
348 end

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