sequel 3.48.0 → 4.0.0

data/lib/sequel/adapters/shared/mssql.rb

@@ -46,7 +46,7 @@ module Sequel
 
       # Return foreign key information using the system views, including
       # :name, :on_delete, and :on_update entries in the hashes.
-      def foreign_key_list(table, opts={})
+      def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
         schema, table = schema_and_table(table)
@@ -86,7 +86,7 @@ module Sequel
       end
 
       # Use the system tables to get index information
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
@@ -136,13 +136,13 @@ module Sequel
 
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
-      def tables(opts={})
+      def tables(opts=OPTS)
         information_schema_tables('BASE TABLE', opts)
       end
 
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on views.
-      def views(opts={})
+      def views(opts=OPTS)
         information_schema_tables('VIEW', opts)
       end
       
@@ -220,7 +220,7 @@ module Sequel
 
       # Commit the active transaction on the connection, does not commit/release
       # savepoints.
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         log_connection_execute(conn, commit_transaction_sql) unless _trans(conn)[:savepoint_level] > 1
       end
 
@@ -288,7 +288,7 @@ module Sequel
         m = output_identifier_meth
         metadata_dataset.from(:information_schema__tables___t).
           select(:table_name).
-          filter(:table_type=>type, :table_schema=>(opts[:schema]||_default_schema||'dbo').to_s).
+          filter(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
           map{|x| m.call(x[:table_name])}
       end
 
@@ -350,7 +350,7 @@ module Sequel
               :table_schema => :table_schema, :table_name => :table_name).
          select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
          filter(:c__table_name=>tn)
-        if schema = opts[:schema] || _default_schema
+        if schema = opts[:schema]
           ds.filter!(:c__table_schema=>schema)
         end
         ds.map do |row|
@@ -524,7 +524,7 @@ module Sequel
       end
       
       # MSSQL uses the CONTAINS keyword for full text search
-      def full_text_search(cols, terms, opts = {})
+      def full_text_search(cols, terms, opts = OPTS)
         terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
         filter("CONTAINS (?, ?)", cols, terms)
       end
@@ -660,7 +660,7 @@ module Sequel
       # dataset.  If OUTPUT is already set, use existing returning values.  If OUTPUT
       # is only set to return a single columns, return an array of just that column.
       # Otherwise, return an array of hashes.
-      def _import(columns, values, opts={})
+      def _import(columns, values, opts=OPTS)
         if opts[:return] == :primary_key && !@opts[:output]
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]

data/lib/sequel/adapters/shared/mysql.rb

@@ -61,7 +61,7 @@ module Sequel
       # Use the Information Schema's KEY_COLUMN_USAGE table to get
       # basic information on foreign key columns, but include the
       # constraint name.
-      def foreign_key_list(table, opts={})
+      def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
         ds = metadata_dataset.
@@ -93,7 +93,7 @@ module Sequel
       #
       # By default partial indexes are not included, you can use the
       # option :partial to override this.
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         indexes = {}
         remove_indexes = []
         m = output_identifier_meth
@@ -153,7 +153,7 @@ module Sequel
       #
       # Options:
       # * :server - Set the server to use
-      def tables(opts={})
+      def tables(opts=OPTS)
         full_tables('BASE TABLE', opts)
       end
       
@@ -170,7 +170,7 @@ module Sequel
       #
       # Options:
       # * :server - Set the server to use
-      def views(opts={})
+      def views(opts=OPTS)
         full_tables('VIEW', opts)
       end
       
@@ -290,7 +290,7 @@ module Sequel
 
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
-      def begin_transaction(conn, opts={})
+      def begin_transaction(conn, opts=OPTS)
         if (s = opts[:prepare]) && (th = _trans(conn))[:savepoint_level] == 0
           log_connection_execute(conn, "XA START #{literal(s)}")
           th[:savepoint_level] += 1
@@ -313,7 +313,7 @@ module Sequel
       
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
@@ -323,7 +323,7 @@ module Sequel
       end
 
       # Use MySQL specific syntax for engine type and character encoding
-      def create_table_sql(name, generator, options = {})
+      def create_table_sql(name, generator, options = OPTS)
         engine = options.fetch(:engine, Sequel::MySQL.default_engine)
         charset = options.fetch(:charset, Sequel::MySQL.default_charset)
         collate = options.fetch(:collate, Sequel::MySQL.default_collate)
@@ -418,7 +418,7 @@ module Sequel
       end
 
       # Rollback the currently open XA transaction
-      def rollback_transaction(conn, opts={})
+      def rollback_transaction(conn, opts=OPTS)
         if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
@@ -563,6 +563,8 @@ module Sequel
       EXPLAIN_EXTENDED = 'EXPLAIN EXTENDED '.freeze
       BACKSLASH_RE = /\\/.freeze
       QUAD_BACKSLASH = "\\\\\\\\".freeze
+      BLOB_START = "0x".freeze
+      HSTAR = "H*".freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -620,7 +622,7 @@ module Sequel
       
       # Return the results of an EXPLAIN query as a string. Options:
       # :extended :: Use EXPLAIN EXPTENDED instead of EXPLAIN if true.
-      def explain(opts={})
+      def explain(opts=OPTS)
         # Load the PrettyTable class, needed for explain output
         Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
 
@@ -635,12 +637,12 @@ module Sequel
       end
 
       # Adds full text filter
-      def full_text_search(cols, terms, opts = {})
+      def full_text_search(cols, terms, opts = OPTS)
         filter(full_text_sql(cols, terms, opts))
       end
       
       # MySQL specific full text search syntax.
-      def full_text_sql(cols, terms, opts = {})
+      def full_text_sql(cols, terms, opts = OPTS)
         terms = terms.join(' ') if terms.is_a?(Array)
         SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
@@ -652,10 +654,10 @@ module Sequel
       
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
-      def join_table(type, table, expr=nil, table_alias={}, &block)
+      def join_table(type, table, expr=nil, opts=OPTS, &block)
         type = :inner if (type == :cross) && !expr.nil?
         raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
-        super(type, table, expr, table_alias, &block)
+        super(type, table, expr, opts, &block)
       end
       
       # Transforms :natural_inner to NATURAL LEFT JOIN and straight to
@@ -893,11 +895,25 @@ module Sequel
       alias delete_limit_sql limit_sql
       alias update_limit_sql limit_sql
 
+      # MySQL uses a preceding X for hex escaping strings
+      def literal_blob_append(sql, v)
+        sql << BLOB_START << v.unpack(HSTAR).first
+      end
+
       # Use 0 for false on MySQL
       def literal_false
         BOOL_FALSE
       end
 
+      # Raise error for infinitate and NaN values
+      def literal_float(v)
+        if v.infinite? || v.nan?
+          raise InvalidValue, "Infinite floats and NaN values are not valid on MySQL"
+        else
+          super
+        end
+      end
+
       # SQL fragment for String.  Doubles \ and ' by default.
       def literal_string_append(sql, v)
         sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS

data/lib/sequel/adapters/shared/mysql_prepared_statements.rb

@@ -18,14 +18,14 @@ module Sequel
         MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
        
         # Support stored procedures on MySQL
-        def call_sproc(name, opts={}, &block)
+        def call_sproc(name, opts=OPTS, &block)
           args = opts[:args] || [] 
           execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
         end
         
         # Executes the given SQL using an available connection, yielding the
         # connection if the block is given.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           if opts[:sproc]
             call_sproc(sql, opts, &block)
           elsif sql.is_a?(Symbol)
@@ -114,17 +114,17 @@ module Sequel
           
           # Execute the prepared statement with the bind arguments instead of
           # the given SQL.
-          def execute(sql, opts={}, &block)
+          def execute(sql, opts=OPTS, &block)
             super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
           end
           
           # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts={}, &block)
+          def execute_dui(sql, opts=OPTS, &block)
             super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
           end
           
           # Same as execute, explicit due to intricacies of alias and super.
-          def execute_insert(sql, opts={}, &block)
+          def execute_insert(sql, opts=OPTS, &block)
             super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
           end
         end
@@ -136,12 +136,12 @@ module Sequel
           private
           
           # Execute the database stored procedure with the stored arguments.
-          def execute(sql, opts={}, &block)
+          def execute(sql, opts=OPTS, &block)
             super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
           end
           
           # Same as execute, explicit due to intricacies of alias and super.
-          def execute_dui(sql, opts={}, &block)
+          def execute_dui(sql, opts=OPTS, &block)
             super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
           end
         end

data/lib/sequel/adapters/shared/oracle.rb

@@ -10,7 +10,7 @@ module Sequel
 
       attr_accessor :autosequence
 
-      def create_sequence(name, opts={})
+      def create_sequence(name, opts=OPTS)
         self << create_sequence_sql(name, opts)
       end
 
@@ -36,12 +36,12 @@ module Sequel
         false
       end
 
-      def tables(opts={})
+      def tables(opts=OPTS)
         m = output_identifier_meth
         metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE').map{|r| m.call(r[:tname])}
       end
 
-      def views(opts={}) 
+      def views(opts=OPTS) 
         m = output_identifier_meth
         metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
       end 
@@ -96,7 +96,7 @@ module Sequel
         AUTOINCREMENT
       end
 
-      def create_sequence_sql(name, opts={})
+      def create_sequence_sql(name, opts=OPTS)
         "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
       end
 
@@ -106,7 +106,7 @@ module Sequel
         create_statements.each{|sql| execute_ddl(sql)}
       end
 
-      def create_table_sql_list(name, generator, options={})
+      def create_table_sql_list(name, generator, options=OPTS)
         statements = [create_table_sql(name, generator, options)]
         drop_seq_statement = nil
         generator.columns.each do |c|
@@ -132,7 +132,7 @@ module Sequel
         [drop_seq_statement, statements]
       end
 
-      def create_trigger_sql(table, name, definition, opts={})
+      def create_trigger_sql(table, name, definition, opts=OPTS)
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
         sql = <<-end_sql
           CREATE#{' OR REPLACE' if opts[:replace]} TRIGGER #{quote_identifier(name)}
@@ -247,17 +247,27 @@ module Sequel
         when :&
           sql << complex_expression_arg_pairs(args){|a, b| "CAST(BITAND(#{literal(a)}, #{literal(b)}) AS INTEGER)"}
         when :|
-          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} - #{complex_expression_sql(:&, [a, b])} + #{literal(b)})"}
+          sql << complex_expression_arg_pairs(args) do |a, b|
+            s1 = ''
+            complex_expression_sql_append(s1, :&, [a, b])
+            "(#{literal(a)} - #{s1} + #{literal(b)})"
+          end
         when :^
-          sql << complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
+          sql << complex_expression_arg_pairs(args) do |*x|
+            s1 = ''
+            s2 = ''
+            complex_expression_sql_append(s1, :|, x)
+            complex_expression_sql_append(s2, :&, x)
+            "(#{s1} - #{s2})"
+          end
         when :'B~'
           sql << BITCOMP_OPEN
           literal_append(sql, args.at(0))
           sql << BITCOMP_CLOSE
         when :<<
-          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * power(2, #{literal b}))"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * power(2, #{literal(b)}))"}
         when :>>
-          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / power(2, #{literal b}))"}
+          sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / power(2, #{literal(b)}))"}
         when :%
           sql << complex_expression_arg_pairs(args){|a, b| "MOD(#{literal(a)}, #{literal(b)})"}
         else
@@ -291,8 +301,7 @@ module Sequel
       end
       
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
-      def except(dataset, opts={})
-        opts = {:all=>opts} unless opts.is_a?(Hash)
+      def except(dataset, opts=OPTS)
         raise(Sequel::Error, "EXCEPT ALL not supported") if opts[:all]
         compound_clone(:minus, dataset, opts)
       end
@@ -391,7 +400,7 @@ module Sequel
 
       # If this dataset is associated with a sequence, return the most recently
       # inserted sequence value.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         f = @opts[:from]
         super(sql, {:table=>(f.first if f), :sequence=>@opts[:sequence]}.merge(opts))
       end

data/lib/sequel/adapters/shared/postgres.rb

@@ -63,7 +63,7 @@ module Sequel
       # :using :: Override the index_method for the exclusion constraint (defaults to gist).
       # :where :: Create a partial exclusion constraint, which only affects
       #           a subset of table rows, value should be a filter expression.
-      def exclude(elements, opts={})
+      def exclude(elements, opts=OPTS)
         constraints << {:type => :exclude, :elements => elements}.merge(opts)
       end
     end
@@ -71,7 +71,7 @@ module Sequel
     class AlterTableGenerator < Sequel::Schema::AlterTableGenerator
       # Adds an exclusion constraint to an existing table, see
       # CreateTableGenerator#exclude.
-      def add_exclusion_constraint(elements, opts={})
+      def add_exclusion_constraint(elements, opts=OPTS)
         @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge(opts)
       end
 
@@ -89,10 +89,8 @@ module Sequel
     module DatabaseMethods
       extend Sequel::Database::ResetIdentifierMangling
 
-      EXCLUDE_SCHEMAS = /pg_*|information_schema/i
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
-      SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
       FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'.freeze=>:no_action, 'r'.freeze=>:restrict, 'c'.freeze=>:cascade, 'n'.freeze=>:set_null, 'd'.freeze=>:set_default}.freeze
       POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
       UNLOGGED = 'UNLOGGED '.freeze
@@ -179,7 +177,7 @@ module Sequel
       #   * :set : Configuration variables to set while the function is being run, can be a hash or an array of two pairs.  search_path is
       #     often used here if :security_definer is used.
       #   * :strict : Makes the function return NULL when any argument is NULL.
-      def create_function(name, definition, opts={})
+      def create_function(name, definition, opts=OPTS)
         self << create_function_sql(name, definition, opts)
       end
 
@@ -187,17 +185,20 @@ module Sequel
       # * name : Name of the procedural language (e.g. plpgsql)
       # * opts : options hash:
       #   * :handler : The name of a previously registered function used as a call handler for this language.
-      #   * :replace: Replace the installed language if it already exists (on PostgreSQL 9.0+).
+      #   * :replace : Replace the installed language if it already exists (on PostgreSQL 9.0+).
       #   * :trusted : Marks the language being created as trusted, allowing unprivileged users to create functions using this language.
       #   * :validator : The name of previously registered function used as a validator of functions defined in this language.
-      def create_language(name, opts={})
+      def create_language(name, opts=OPTS)
         self << create_language_sql(name, opts)
       end
 
       # Create a schema in the database. Arguments:
       # * name : Name of the schema (e.g. admin)
-      def create_schema(name)
-        self << create_schema_sql(name)
+      # * opts : options hash:
+      #   * :if_not_exists : Don't raise an error if the schema already exists (PostgreSQL 9.3+)
+      #   * :owner : The owner to set for the schema (defaults to current user if not specified)
+      def create_schema(name, opts=OPTS)
+        self << create_schema_sql(name, opts)
       end
 
       # Create a trigger in the database.  Arguments:
@@ -210,7 +211,7 @@ module Sequel
       #   * :each_row : Calls the trigger for each row instead of for each statement.
       #   * :events : Can be :insert, :update, :delete, or an array of any of those. Calls the trigger whenever that type of statement is used.  By default,
       #     the trigger is called for insert, update, or delete.
-      def create_trigger(table, name, function, opts={})
+      def create_trigger(table, name, function, opts=OPTS)
         self << create_trigger_sql(table, name, function, opts)
       end
 
@@ -224,7 +225,7 @@ module Sequel
       #
       # :language :: The procedural language the code is written in.  The PostgreSQL
       #              default is plpgsql.  Can be specified as a string or a symbol.
-      def do(code, opts={})
+      def do(code, opts=OPTS)
         language = opts[:language]
         run "DO #{"LANGUAGE #{literal(language.to_s)} " if language}#{literal(code)}"
       end
@@ -235,7 +236,7 @@ module Sequel
       #   * :args : The arguments for the function.  See create_function_sql.
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      def drop_function(name, opts={})
+      def drop_function(name, opts=OPTS)
         self << drop_function_sql(name, opts)
       end
 
@@ -244,7 +245,7 @@ module Sequel
       # * opts : options hash:
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      def drop_language(name, opts={})
+      def drop_language(name, opts=OPTS)
         self << drop_language_sql(name, opts)
       end
 
@@ -253,7 +254,7 @@ module Sequel
       # * opts : options hash:
       #   * :cascade : Drop all objects in this schema.
       #   * :if_exists : Don't raise an error if the schema doesn't exist.
-      def drop_schema(name, opts={})
+      def drop_schema(name, opts=OPTS)
         self << drop_schema_sql(name, opts)
       end
 
@@ -263,13 +264,13 @@ module Sequel
       # * opts : options hash:
       #   * :cascade : Drop other objects depending on this function.
       #   * :if_exists : Don't raise an error if the function doesn't exist.
-      def drop_trigger(table, name, opts={})
+      def drop_trigger(table, name, opts=OPTS)
         self << drop_trigger_sql(table, name, opts)
       end
 
       # Return full foreign key information using the pg system tables, including
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
-      def foreign_key_list(table, opts={})
+      def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
         range = 0...32
@@ -323,7 +324,7 @@ module Sequel
       end
 
       # Use the pg_* system tables to determine indexes on a table
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         m = output_identifier_meth
         range = 0...32
         attnums = server_version >= 80100 ? SQL::Function.new(:ANY, :ind__indkey) : range.map{|x| SQL::Subscript.new(:ind__indkey, [x])}
@@ -358,7 +359,7 @@ module Sequel
       #             in PostgreSQL 9.0+.
       # :server :: The server to which to send the NOTIFY statement, if the sharding support
       #            is being used.
-      def notify(channel, opts={})
+      def notify(channel, opts=OPTS)
         sql = "NOTIFY "
         dataset.send(:identifier_append, sql, channel)
         if payload = opts[:payload]
@@ -369,7 +370,7 @@ module Sequel
       end
 
       # Return primary key for the given table.
-      def primary_key(table, opts={})
+      def primary_key(table, opts=OPTS)
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}
         sql = "#{SELECT_PK_SQL} AND pg_class.oid = #{literal(regclass_oid(table, opts))}"
@@ -378,7 +379,7 @@ module Sequel
       end
 
       # Return the sequence providing the default for the primary key for the given table.
-      def primary_key_sequence(table, opts={})
+      def primary_key_sequence(table, opts=OPTS)
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_key_sequences[quoted_table] if @primary_key_sequences.has_key?(quoted_table)}
         sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND t.oid = #{literal(regclass_oid(table, opts))}"
@@ -393,6 +394,14 @@ module Sequel
           end
         end
       end
+
+      # Refresh the materialized view with the given name.
+      # 
+      #   DB.refresh_view(:items_view)
+      #   # REFRESH MATERIALIZED VIEW items_view
+      def refresh_view(name, opts=OPTS)
+        run "REFRESH MATERIALIZED VIEW #{quote_schema_table(name)}"
+      end
       
       # Reset the database's conversion procs, requires a server query if there
       # any named types.
@@ -492,7 +501,7 @@ module Sequel
       #             using the schema the table is located in as the qualifier.
       # :schema :: The schema to search
       # :server :: The server to use
-      def tables(opts={}, &block)
+      def tables(opts=OPTS, &block)
         pg_class_relname('r', opts, &block)
       end
 
@@ -510,7 +519,7 @@ module Sequel
       #             using the schema the view is located in as the qualifier.
       # :schema :: The schema to search
       # :server :: The server to use
-      def views(opts={})
+      def views(opts=OPTS)
         pg_class_relname('v', opts)
       end
 
@@ -578,7 +587,7 @@ module Sequel
 
       # If the :prepare option is given and we aren't in a savepoint,
       # prepare the transaction for a two-phase commit.
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "PREPARE TRANSACTION #{literal(s)}")
         else
@@ -602,7 +611,7 @@ module Sequel
         if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
           cmm = cmm.to_s.upcase.strip
           unless VALID_CLIENT_MIN_MESSAGES.include?(cmm)
-            Sequel::Deprecation.deprecate("Using an unsupported client_min_messages setting will raise an Error in Sequel 4.")
+            raise Error, "Unsupported client_min_messages setting: #{cmm}"
           end
           sqls << "SET client_min_messages = '#{cmm.to_s.upcase}'"
         end
@@ -718,7 +727,7 @@ module Sequel
       end
 
       # SQL statement to create database function.
-      def create_function_sql(name, definition, opts={})
+      def create_function_sql(name, definition, opts=OPTS)
         args = opts[:args]
         if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
           returns = opts[:returns] || 'void'
@@ -739,13 +748,13 @@ module Sequel
       end
 
       # SQL for creating a procedural language.
-      def create_language_sql(name, opts={})
+      def create_language_sql(name, opts=OPTS)
         "CREATE#{' OR REPLACE' if opts[:replace] && server_version >= 90000}#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
       end
 
       # SQL for creating a schema.
-      def create_schema_sql(name)
-        "CREATE SCHEMA #{quote_identifier(name)}"
+      def create_schema_sql(name, opts=OPTS)
+        "CREATE SCHEMA #{'IF NOT EXISTS ' if opts[:if_not_exists]}#{quote_identifier(name)}#{" AUTHORIZATION #{literal(opts[:owner])}" if opts[:owner]}"
       end
 
       # DDL statement for creating a table with the given name, columns, and options
@@ -765,7 +774,7 @@ module Sequel
       end
     
       # SQL for creating a database trigger.
-      def create_trigger_sql(table, name, function, opts={})
+      def create_trigger_sql(table, name, function, opts=OPTS)
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
         whence = opts[:after] ? 'AFTER' : 'BEFORE'
         "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
@@ -773,7 +782,7 @@ module Sequel
 
       # DDL fragment for initial part of CREATE VIEW statement
       def create_view_prefix_sql(name, options)
-        "CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}"
+        create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}#{'RECURSIVE ' if options[:recursive]}#{'MATERIALIZED ' if options[:materialized]}VIEW #{quote_schema_table(name)}", options[:columns] || options[:recursive])
       end
 
       # The errors that the main adapters can raise, depends on the adapter being used
@@ -782,7 +791,7 @@ module Sequel
       end
 
       # SQL for dropping a function from the database.
-      def drop_function_sql(name, opts={})
+      def drop_function_sql(name, opts=OPTS)
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
       end
       
@@ -792,28 +801,34 @@ module Sequel
       end
 
       # SQL for dropping a procedural language from the database.
-      def drop_language_sql(name, opts={})
+      def drop_language_sql(name, opts=OPTS)
         "DROP LANGUAGE#{' IF EXISTS' if opts[:if_exists]} #{name}#{' CASCADE' if opts[:cascade]}"
       end
 
       # SQL for dropping a schema from the database.
-      def drop_schema_sql(name, opts={})
+      def drop_schema_sql(name, opts=OPTS)
         "DROP SCHEMA#{' IF EXISTS' if opts[:if_exists]} #{quote_identifier(name)}#{' CASCADE' if opts[:cascade]}"
       end
 
       # SQL for dropping a trigger from the database.
-      def drop_trigger_sql(table, name, opts={})
+      def drop_trigger_sql(table, name, opts=OPTS)
         "DROP TRIGGER#{' IF EXISTS' if opts[:if_exists]} #{name} ON #{quote_schema_table(table)}#{' CASCADE' if opts[:cascade]}"
       end
 
+      # SQL for dropping a view from the database.
+      def drop_view_sql(name, opts=OPTS)
+        "DROP #{'MATERIALIZED ' if opts[:materialized]}VIEW#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(name)}#{' CASCADE' if opts[:cascade]}"
+      end
+
       # If opts includes a :schema option, or a default schema is used, restrict the dataset to
       # that schema.  Otherwise, just exclude the default PostgreSQL schemas except for public.
       def filter_schema(ds, opts)
-        if schema = opts[:schema] || _default_schema
-          ds.filter(:pg_namespace__nspname=>schema.to_s)
+        expr = if schema = opts[:schema]
+          schema.to_s
         else
-          ds.exclude(:pg_namespace__nspname=>EXCLUDE_SCHEMAS)
+          Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
+        ds.where(:pg_namespace__nspname=>expr)
       end
 
       # Return a hash with oid keys and callable values, used for converting types.
@@ -850,7 +865,7 @@ module Sequel
         case index_type
         when :full_text
           expr = "(to_tsvector(#{literal(index[:language] || 'simple')}::regconfig, #{literal(dataset.send(:full_text_string_join, cols))}))"
-          index_type = :gin
+          index_type = index[:index_type] || :gin
         when :spatial
           index_type = :gist
         end
@@ -867,7 +882,7 @@ module Sequel
 
       # Backbone of the tables and views support.
       def pg_class_relname(type, opts)
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
         if block_given?
@@ -887,7 +902,7 @@ module Sequel
 
       # Return an expression the oid for the table expr.  Used by the metadata parsing
       # code to disambiguate unqualified tables.
-      def regclass_oid(expr, opts={})
+      def regclass_oid(expr, opts=OPTS)
         if expr.is_a?(String) && !expr.is_a?(LiteralString)
           expr = Sequel.identifier(expr)
         end
@@ -1133,7 +1148,7 @@ module Sequel
       end
 
       # Return the results of an EXPLAIN query as a string
-      def explain(opts={})
+      def explain(opts=OPTS)
         with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
       end
 
@@ -1144,7 +1159,7 @@ module Sequel
 
       # PostgreSQL specific full text search syntax, using tsearch2 (included
       # in 8.3 by default, and available for earlier versions as an add-on).
-      def full_text_search(cols, terms, opts = {})
+      def full_text_search(cols, terms, opts = OPTS)
         lang = opts[:language] || 'simple'
         terms = terms.join(' | ') if terms.is_a?(Array)
         filter("to_tsvector(?::regconfig, ?) @@ to_tsquery(?::regconfig, ?)", lang, full_text_string_join(cols), lang, terms)
@@ -1178,7 +1193,7 @@ module Sequel
       # a new transaction, locks the table, and yields.  If a block is not given
       # just locks the tables.  Note that PostgreSQL will probably raise an error
       # if you lock the table outside of an existing transaction.  Returns nil.
-      def lock(mode, opts={})
+      def lock(mode, opts=OPTS)
         if block_given? # perform locking inside a transaction and yield to block
           @db.transaction(opts){lock(mode, opts); yield}
         else
@@ -1186,7 +1201,7 @@ module Sequel
           source_list_append(sql, @opts[:from])
           mode = mode.to_s.upcase.strip
           unless LOCK_MODES.include?(mode)
-            Sequel::Deprecation.deprecate("Calling Dataset#lock with an unsupported lock mode will raise an Error in Sequel 4.")
+            raise Error, "Unsupported lock mode: #{mode}"
           end
           sql << " IN #{mode} MODE"
           @db.execute(sql, opts)
@@ -1252,7 +1267,7 @@ module Sequel
       #   # => nil
       #   DB[:table].truncate(:cascade => true, :only=>true, :restart=>true) # TRUNCATE TABLE ONLY "table" RESTART IDENTITY CASCADE
       #   # => nil
-      def truncate(opts = {})
+      def truncate(opts = OPTS)
         if opts.empty?
           super()
         else
@@ -1271,7 +1286,7 @@ module Sequel
       # dataset.  If RETURNING is already set, use existing returning values.  If RETURNING
       # is only set to return a single columns, return an array of just that column.
       # Otherwise, return an array of hashes.
-      def _import(columns, values, opts={})
+      def _import(columns, values, opts=OPTS)
         if @opts[:returning]
           statements = multi_insert_sql(columns, values)
           @db.transaction(opts.merge(:server=>@opts[:server])) do