sequel 4.10.0 → 4.11.0

data/doc/virtual_rows.rdoc

@@ -95,8 +95,8 @@ local variable access.  This is mostly useful in instance_evaled procs:
 
 == VirtualRow Methods
 
-VirtualRow is a class that returns SQL::Identifiers, SQL::QualifiedIdentifiers,
-SQL::Functions, or SQL::WindowFunctions depending on how it is called.
+VirtualRow is a class that returns SQL::Identifiers, SQL::QualifiedIdentifiers, or
+SQL::Functions depending on how it is called.
 
 == SQL::Identifiers - Regular columns
 
@@ -165,10 +165,9 @@ distinct method on the returned Function:
   ds.select{count(col1, col2).distinct}
   # SELECT count(DISTINCT col1, col2)
   
-== SQL::WindowFunctions - SQL window function calls
+== SQL::Functions with windows - SQL window function calls
 
-SQL::WindowFunctions can be thought of as calls to SQL window functions.  Not
-all databases support them, but they are very helpful for certain types of
+Not all databases support window functions, but they are very helpful for certain types of
 queries.  To use them, you should just call the over method on the Function
 object returned, with the options for the window:
 

data/lib/sequel/adapters/ibmdb.rb

@@ -43,8 +43,13 @@ module Sequel
       end
 
       # Create the underlying IBM_DB connection.
-      def initialize(connection_string)
-        @conn = IBM_DB.connect(connection_string, '', '')
+      def initialize(connection_param)
+        @conn = if connection_param.class == String
+          IBM_DB.connect(connection_param, '', '')
+        else  # connect using catalog 
+          IBM_DB.connect(*connection_param)
+        end
+
         self.autocommit = true
         @prepared_statements = {}
       end
@@ -193,19 +198,22 @@ module Sequel
       # Create a new connection object for the given server.
       def connect(server)
         opts = server_opts(server)
-        
-        # use uncataloged connection so that host and port can be supported
-        connection_string = ( \
-            'Driver={IBM DB2 ODBC DRIVER};' \
-            "Database=#{opts[:database]};" \
-            "Hostname=#{opts[:host]};" \
-            "Port=#{opts[:port] || 50000};" \
-            'Protocol=TCPIP;' \
-            "Uid=#{opts[:user]};" \
-            "Pwd=#{opts[:password]};" \
-        )
 
-        Connection.new(connection_string)
+        connection_params = if opts[:host].nil? && opts[:port].nil? && opts[:database]
+          # use a cataloged connection
+          opts.values_at(:database, :user, :password)
+        else
+          # use uncataloged connection so that host and port can be supported
+          'Driver={IBM DB2 ODBC DRIVER};' \
+          "Database=#{opts[:database]};" \
+          "Hostname=#{opts[:host]};" \
+          "Port=#{opts[:port] || 50000};" \
+          'Protocol=TCPIP;' \
+          "Uid=#{opts[:user]};" \
+          "Pwd=#{opts[:password]};" \
+        end 
+
+        Connection.new(connection_params)
       end
 
       # Execute the given SQL on the database.
@@ -432,9 +440,9 @@ module Sequel
           stmt.num_fields.times do |i|
             k = stmt.field_name i
             key = output_identifier(k)
-            type = stmt.field_type(k).downcase.to_sym
+            type = stmt.field_type(i).downcase.to_sym
             # decide if it is a smallint from precision
-            type = :boolean  if type == :int && convert && stmt.field_precision(k) < 8
+            type = :boolean  if type == :int && convert && stmt.field_precision(i) < 8
             type = :blob if type == :clob && Sequel::DB2.use_clob_as_blob
             columns << [key, cps[type]]
           end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -160,6 +160,11 @@ module Sequel
           end
         end
         
+        # H2 does not support derived column lists
+        def supports_derived_column_lists?
+          false
+        end
+
         # H2 requires SQL standard datetimes
         def requires_sql_standard_datetimes?
           true

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -122,6 +122,11 @@ module Sequel
         def uses_clob_for_text?
           true
         end
+
+        # HSQLDB supports views with check option.
+        def view_with_check_option_support
+          :local
+        end
       end
       
       # Dataset class for HSQLDB datasets accessed via JDBC.

data/lib/sequel/adapters/mock.rb

@@ -34,6 +34,7 @@ module Sequel
       # mock adapters for specific database types.
       SHARED_ADAPTERS = {
         'access'=>'Access',
+        'cubrid'=>'Cubrid',
         'db2'=>'DB2',
         'firebird'=>'Firebird',
         'informix'=>'Informix',
@@ -41,6 +42,7 @@ module Sequel
         'mysql'=>'MySQL',
         'oracle'=>'Oracle',
         'postgres'=>'Postgres',
+        'sqlanywhere'=>'SqlAnywhere',
         'sqlite'=>'SQLite'
       }
 
@@ -49,7 +51,7 @@ module Sequel
       SHARED_ADAPTER_SETUP = {
         'postgres' => lambda do |db|
           db.instance_eval do
-            @server_version = 90103
+            @server_version = 90400
             initialize_postgres_adapter
           end
           db.extend(Module.new do
@@ -67,9 +69,19 @@ module Sequel
             @primary_key_sequences = {}
           end
         end,
+        'mysql' => lambda do |db|
+          db.instance_eval do
+            @server_version = 50617
+          end
+        end,
         'mssql' => lambda do |db|
           db.instance_eval do
-            @server_version = 10000000
+            @server_version = 11000000
+          end
+        end,
+        'sqlite' => lambda do |db|
+          db.instance_eval do
+            @sqlite_version = 30804
           end
         end
       }

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

@@ -112,6 +112,7 @@ module Sequel
       TIME_FUNCTION = 'Time()'.freeze
       CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}
 
+      EMULATED_FUNCTION_MAP = {:char_length=>:len}
       EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}
       COMMA = Dataset::COMMA
       DATEPART_OPEN = "datepart(".freeze
@@ -189,15 +190,6 @@ module Sequel
         clone(:from=>@opts[:from] + [table])
       end
 
-      def emulated_function_sql_append(sql, f)
-        case f.f
-        when :char_length
-          literal_append(sql, SQL::Function.new(:len, f.args.first))
-        else
-          super
-        end
-      end
-      
       # Access uses [] to escape metacharacters, instead of backslashes.
       def escape_like(string)
         string.gsub(/[\\*#?\[]/){|m| "[#{m}]"}
@@ -208,6 +200,11 @@ module Sequel
         clone(:into => table)
       end
 
+      # Access does not support derived column lists.
+      def supports_derived_column_lists?
+        false
+      end
+
       # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false

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

@@ -162,6 +162,11 @@ module Sequel
       def uses_clob_for_text?
         true
       end
+
+      # CUBRID supports views with check option, but not local.
+      def view_with_check_option_support
+        true
+      end
     end
     
     module DatasetMethods

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

@@ -222,6 +222,11 @@ module Sequel
       def uses_clob_for_text?
         true
       end
+
+      # DB2 supports views with check option.
+      def view_with_check_option_support
+        :local
+      end
     end
 
     module DatasetMethods

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

@@ -146,6 +146,11 @@ module Sequel
       def type_literal_generic_string(column)
         column[:text] ? :"BLOB SUB_TYPE TEXT" : super
       end
+
+      # Firebird supports views with check option, but not local.
+      def view_with_check_option_support
+        true
+      end
     end
 
     module DatasetMethods

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

@@ -301,7 +301,7 @@ module Sequel
       def begin_transaction_sql
         SQL_BEGIN
       end
-      
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = MSSQL_DEFAULT_RE.match(default)
@@ -487,6 +487,11 @@ module Sequel
       def type_literal_generic_file(column)
         :'varbinary(max)'
       end
+      
+      # MSSQL supports views with check option, but not local.
+      def view_with_check_option_support
+        true
+      end
     end
   
     module DatasetMethods
@@ -609,21 +614,6 @@ module Sequel
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}
       end
    
-      # There is no function on Microsoft SQL Server that does character length
-      # and respects trailing spaces (datalength respects trailing spaces, but
-      # counts bytes instead of characters).  Use a hack to work around the
-      # trailing spaces issue.
-      def emulated_function_sql_append(sql, f)
-        case f.f
-        when :char_length
-          literal_append(sql, SQL::Function.new(:len, Sequel.join([f.args.first, 'x'])) - 1)
-        when :trim
-          literal_append(sql, SQL::Function.new(:ltrim, SQL::Function.new(:rtrim, f.args.first)))
-        else
-          super
-        end
-      end
-      
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = OPTS)
         terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
@@ -825,6 +815,23 @@ module Sequel
       end
       alias update_from_sql delete_from2_sql
 
+      # There is no function on Microsoft SQL Server that does character length
+      # and respects trailing spaces (datalength respects trailing spaces, but
+      # counts bytes instead of characters).  Use a hack to work around the
+      # trailing spaces issue.
+      def emulate_function?(name)
+        name == :char_length || name == :trim
+      end
+
+      def emulate_function_sql_append(sql, f)
+        case f.name
+        when :char_length
+          literal_append(sql, SQL::Function.new(:len, Sequel.join([f.args.first, 'x'])) - 1)
+        when :trim
+          literal_append(sql, SQL::Function.new(:ltrim, SQL::Function.new(:rtrim, f.args.first)))
+        end
+      end
+      
       # Microsoft SQL Server 2012 has native support for offsets, but only for ordered datasets.
       def emulate_offset_with_row_number?
         super && !(is_2012_or_later? && @opts[:order])

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

@@ -129,12 +129,12 @@ module Sequel
         true
       end
       
-      # MySQL supports prepared transactions (two-phase commit) using XA
+      # MySQL 5+ supports prepared transactions (two-phase commit) using XA
       def supports_prepared_transactions?
         server_version >= 50000
       end
 
-      # MySQL supports savepoints
+      # MySQL 5+ supports savepoints
       def supports_savepoints?
         server_version >= 50000
       end
@@ -540,6 +540,11 @@ module Sequel
       def type_literal_generic_trueclass(column)
         :'tinyint(1)'
       end
+
+      # MySQL 5.0.2+ supports views with check option.
+      def view_with_check_option_support
+        :local if server_version >= 50002
+      end
     end
   
     # Dataset methods shared by datasets that use MySQL databases.
@@ -755,6 +760,11 @@ module Sequel
         sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
       end
 
+      # MySQL does not support derived column lists
+      def supports_derived_column_lists?
+        false
+      end
+
       # MySQL can emulate DISTINCT ON with its non-standard GROUP BY implementation,
       # though the rows returned cannot be made deterministic through ordering.
       def supports_distinct_on?

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

@@ -244,6 +244,11 @@ module Sequel
       def uses_clob_for_text?
         true
       end
+
+      # Oracle supports views with check option, but not local.
+      def view_with_check_option_support
+        true
+      end
     end
 
     module DatasetMethods
@@ -295,20 +300,6 @@ module Sequel
         end
       end
 
-      # Oracle treats empty strings like NULL values, and doesn't support
-      # char_length, so make char_length use length with a nonempty string.
-      # Unfortunately, as Oracle treats the empty string as NULL, there is
-      # no way to get trim to return an empty string instead of nil if
-      # the string only contains spaces.
-      def emulated_function_sql_append(sql, f)
-        case f.f
-        when :char_length
-          literal_append(sql, Sequel::SQL::Function.new(:length, Sequel.join([f.args.first, 'x'])) - 1)
-        else
-          super
-        end
-      end
-      
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, opts=OPTS)
         raise(Sequel::Error, "EXCEPT ALL not supported") if opts[:all]
@@ -373,6 +364,11 @@ module Sequel
         type == :select
       end
 
+      # Oracle does not support derived column lists
+      def supports_derived_column_lists?
+        false
+      end
+
       # Oracle supports GROUP BY CUBE
       def supports_group_cube?
         true
@@ -427,7 +423,8 @@ module Sequel
 
       # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require
       # the use of AS anywhere, so this disables it in all cases.
-      def as_sql_append(sql, aliaz)
+      def as_sql_append(sql, aliaz, column_aliases=nil)
+        raise Error, "oracle does not support derived column lists" if column_aliases
         sql << SPACE
         quote_identifier_append(sql, aliaz)
       end
@@ -441,6 +438,25 @@ module Sequel
         DUAL
       end
 
+      # There is no function on Microsoft SQL Server that does character length
+      # and respects trailing spaces (datalength respects trailing spaces, but
+      # counts bytes instead of characters).  Use a hack to work around the
+      # trailing spaces issue.
+      def emulate_function?(name)
+        name == :char_length
+      end
+
+      # Oracle treats empty strings like NULL values, and doesn't support
+      # char_length, so make char_length use length with a nonempty string.
+      # Unfortunately, as Oracle treats the empty string as NULL, there is
+      # no way to get trim to return an empty string instead of nil if
+      # the string only contains spaces.
+      def emulate_function_sql_append(sql, f)
+        if f.name == :char_length
+          literal_append(sql, Sequel::SQL::Function.new(:length, Sequel.join([f.args.first, 'x'])) - 1)
+        end
+      end
+      
       # If this dataset is associated with a sequence, return the most recently
       # inserted sequence value.
       def execute_insert(sql, opts=OPTS)

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

@@ -402,8 +402,10 @@ module Sequel
       # 
       #   DB.refresh_view(:items_view)
       #   # REFRESH MATERIALIZED VIEW items_view
+      #   DB.refresh_view(:items_view, :concurrently=>true)
+      #   # REFRESH MATERIALIZED VIEW CONCURRENTLY items_view
       def refresh_view(name, opts=OPTS)
-        run "REFRESH MATERIALIZED VIEW #{quote_schema_table(name)}"
+        run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}"
       end
       
       # Reset the database's conversion procs, requires a server query if there
@@ -588,6 +590,15 @@ module Sequel
         end
       end
       
+      # Set the READ ONLY transaction setting per savepoint, as PostgreSQL supports that.
+      def begin_savepoint(conn, opts)
+        super
+
+        unless (read_only = opts[:read_only]).nil?
+          log_connection_execute(conn, "SET TRANSACTION READ #{read_only ? 'ONLY' : 'WRITE'}")
+        end
+      end
+
       # Handle PostgreSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = POSTGRES_DEFAULT_RE.match(default)
@@ -1094,6 +1105,11 @@ module Sequel
           :text
         end
       end
+
+      # PostgreSQL 9.4+ supports views with check option.
+      def view_with_check_option_support
+        :local if server_version >= 90400
+      end
     end
 
     # Instance methods for datasets that connect to a PostgreSQL database.
@@ -1227,17 +1243,25 @@ module Sequel
       #           contains all of the words in terms.  This ignores search operators in terms.
       # :phrase :: Similar to :plain, but also adding an ILIKE filter to ensure that
       #            returned rows also include the exact phrase used.
+      # :rank :: Set to true to order by the rank, so that closer matches are returned first.
       def full_text_search(cols, terms, opts = OPTS)
-        lang = opts[:language] || 'simple'
+        lang = Sequel.cast(opts[:language] || 'simple', :regconfig)
         terms = terms.join(' | ') if terms.is_a?(Array)
-        to_tsquery = (opts[:phrase] || opts[:plain]) ? 'plainto_tsquery' : 'to_tsquery'
+        columns = full_text_string_join(cols)
+        query_func = (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
+        vector = Sequel.function(:to_tsvector, lang, columns)
+        query = Sequel.function(query_func, lang, terms)
 
-        ds = where(Sequel.lit(["(to_tsvector(", "::regconfig, ", ") @@ #{to_tsquery}(", "::regconfig, ", "))"], lang, full_text_string_join(cols), lang, terms))
+        ds = where(Sequel.lit(["(", " @@ ", ")"], vector, query))
 
         if opts[:phrase]
           ds = ds.grep(cols, "%#{escape_like(terms)}%", :case_insensitive=>true)
         end
 
+        if opts[:rank]
+          ds = ds.order{ts_rank_cd(vector, query)}
+        end
+
         ds
       end