sequel 4.9.0 → 4.10.0

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

@@ -10,7 +10,7 @@ module Sequel
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
+      Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where group order having compounds')
 
       # Progress requires SQL standard datetimes
       def requires_sql_standard_datetimes?
@@ -24,10 +24,6 @@ module Sequel
 
       private
 
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
-
       # Progress uses TOP for limit, but it is only supported in Progress 10.
       # The Progress adapter targets Progress 9, so it silently ignores the option.
       def select_limit_sql(sql)

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

@@ -240,8 +240,6 @@ module Sequel
     module DatasetMethods
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with insert into columns values')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns into from join where group having order compounds lock')
       WILDCARD = LiteralString.new('%').freeze
       TOP = " TOP ".freeze
       START_AT = " START AT ".freeze
@@ -261,6 +259,10 @@ module Sequel
       HSTAR = "H*".freeze
       CROSS_APPLY = 'CROSS APPLY'.freeze
       OUTER_APPLY = 'OUTER APPLY'.freeze
+      ONLY_OFFSET = " TOP 2147483647".freeze
+
+      Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
+      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having order compounds lock')
 
       # Whether to convert smallint to boolean arguments for this dataset.
       # Defaults to the SqlAnywhere module setting.
@@ -271,6 +273,10 @@ module Sequel
       # Override the default SqlAnywhere.convert_smallint_to_bool setting for this dataset.
       attr_writer :convert_smallint_to_bool
 
+      def supports_cte?(type=:select)
+        type == :select || type == :insert
+      end
+
       def supports_multiple_column_in?
         false
       end
@@ -401,14 +407,9 @@ module Sequel
         end
       end
 
-      # Sybase supports the OUTPUT clause for INSERT statements.
-      # It also allows prepending a WITH clause.
-      def insert_clause_methods
-        INSERT_CLAUSE_METHODS
-      end
-
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # Sybase supports multiple rows in INSERT.
+      def multi_insert_sql_strategy
+        :values
       end
 
       def select_into_sql(sql)
@@ -425,14 +426,21 @@ module Sequel
       # Sybase uses TOP N for limit.  For Sybase TOP (N) is used
       # to allow the limit to be a bound variable.
       def select_limit_sql(sql)
-        if l = @opts[:limit]
-          sql << TOP
-          literal_append(sql, l)
-        end
-        if o = @opts[:offset]
-          sql << START_AT + "("
-          literal_append(sql, o)
-          sql << " + 1)"
+        l = @opts[:limit]
+        o = @opts[:offset]
+        if l || o
+          if l
+            sql << TOP
+            literal_append(sql, l)
+          else
+            sql << ONLY_OFFSET
+          end
+
+          if o 
+            sql << START_AT + "("
+            literal_append(sql, o)
+            sql << " + 1)"
+          end
         end
       end
 

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

@@ -132,7 +132,7 @@ module Sequel
       def sqlite_version
         return @sqlite_version if defined?(@sqlite_version)
         @sqlite_version = begin
-          v = get{sqlite_version{}}
+          v = fetch('SELECT sqlite_version()').single_value
           [10000, 100, 1].zip(v.split('.')).inject(0){|a, m| a + m[0] * Integer(m[1])}
         rescue
           0
@@ -497,7 +497,6 @@ module Sequel
     module DatasetMethods
       include Dataset::Replace
 
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
       EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
@@ -517,6 +516,11 @@ module Sequel
       HSTAR = "H*".freeze
       DATE_OPEN = "date(".freeze
       DATETIME_OPEN = "datetime(".freeze
+      ONLY_OFFSET = " LIMIT -1 OFFSET ".freeze
+
+      Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
+      Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert into columns values'], ["else", %w'insert into columns values']])
+      Dataset.def_sql_method(self, :update, [['if db.sqlite_version >= 30803', %w'with update table set where'], ["else", %w'update table set where']])
 
       def cast_sql_append(sql, expr, type)
         if type == Time or type == DateTime
@@ -604,6 +608,11 @@ module Sequel
         end
       end
       
+      # SQLite 3.8.3+ supports common table expressions.
+      def supports_cte?(type=:select)
+        db.sqlite_version >= 30803
+      end
+
       # SQLite does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
@@ -677,11 +686,12 @@ module Sequel
         @db.integer_booleans ? '1' : "'t'"
       end
 
-      # SQLite does not support the SQL WITH clause
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # SQLite only supporting multiple rows in the VALUES clause
+      # starting in 3.7.11.  On older versions, fallback to using a UNION.
+      def multi_insert_sql_strategy
+        db.sqlite_version >= 30711 ? :values : :union
       end
-      
+
       # SQLite does not support FOR UPDATE, but silently ignore it
       # instead of raising an error for compatibility with other
       # databases.
@@ -689,6 +699,11 @@ module Sequel
         super unless @opts[:lock] == :update
       end
 
+      def select_only_offset_sql(sql)
+        sql << ONLY_OFFSET
+        literal_append(sql, @opts[:offset])
+      end
+  
       # SQLite supports quoted function names.
       def supports_quoted_function_names?
         true

data/lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb

@@ -18,6 +18,7 @@ module Sequel
     # reversed in the subselect.  Note that the order needs to be unambiguous
     # to work correctly, and you must select all columns that you are ordering on.
     def select_sql
+      return super if @opts[:sql]
       return super unless o = @opts[:offset]
 
       order = @opts[:order] || default_offset_order
@@ -26,7 +27,7 @@ module Sequel
       end
 
       ds = unlimited
-      row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>'').count
+      row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>'', :placeholder_literal_null=>true).count
       dsa1 = dataset_alias(1)
 
       if o.is_a?(Symbol) && @opts[:bind_vars] && (match = Sequel::Dataset::PreparedStatementMethods::PLACEHOLDER_RE.match(o.to_s))
@@ -57,6 +58,12 @@ module Sequel
       sql
     end
 
+    # This does not support offsets in correlated subqueries, as it requires a query to get
+    # a count that will be invalid if a correlated subquery is used.
+    def supports_offsets_in_correlated_subqueries?
+      false
+    end
+
     private
 
     # The default order to use for datasets with offsets, if no order is defined.

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -20,7 +20,7 @@ module Sequel
         end
       end
 
-      columns = clone(:append_sql=>'').columns
+      columns = clone(:append_sql=>'', :placeholder_literal_null=>true).columns
       dsa1 = dataset_alias(1)
       rn = row_number_column
       sql = @opts[:append_sql] || ''
@@ -35,6 +35,12 @@ module Sequel
       sql
     end
 
+    # This does not support offsets in correlated subqueries, as it requires a query to get
+    # the columns that will be invalid if a correlated subquery is used.
+    def supports_offsets_in_correlated_subqueries?
+      false
+    end
+
     private
 
     # The default order to use for datasets with offsets, if no order is defined.
@@ -50,7 +56,7 @@ module Sequel
 
     # Whether to use ROW_NUMBER to emulate offsets
     def emulate_offset_with_row_number?
-      @opts[:offset]
+      @opts[:offset] && !@opts[:sql]
     end
   end
 end

data/lib/sequel/adapters/utils/split_alter_table.rb

@@ -24,6 +24,9 @@ module Sequel::Database::SplitAlterTable
         modified_columns << op[:name] unless modified_columns.include?(op[:name])
         modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
       end
+      if split_alter_table_op?(op)
+        op_groups << []
+      end
       op_groups.last << op
     end
 
@@ -33,4 +36,9 @@ module Sequel::Database::SplitAlterTable
       remove_cached_schema(name)
     end
   end
+
+  # Whether the given alter table op should start a new group.
+  def split_alter_table_op?(op)
+    false
+  end
 end

data/lib/sequel/core.rb

@@ -219,6 +219,7 @@ module Sequel
   COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
   COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
   COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
+  SPLIT_SYMBOL_CACHE = {}
 
   # Splits the symbol into three parts.  Each part will
   # either be a string or nil.
@@ -226,16 +227,20 @@ module Sequel
   # For columns, these parts are the table, column, and alias.
   # For tables, these parts are the schema, table, and alias.
   def self.split_symbol(sym)
-    case s = sym.to_s
-    when COLUMN_REF_RE1
-      [$1, $2, $3]
-    when COLUMN_REF_RE2
-      [nil, $1, $2]
-    when COLUMN_REF_RE3
-      [$1, $2, nil]
-    else
-      [nil, s, nil]
+    unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
+      v = case s = sym.to_s
+      when COLUMN_REF_RE1
+        [$1.freeze, $2.freeze, $3.freeze].freeze
+      when COLUMN_REF_RE2
+        [nil, $1.freeze, $2.freeze].freeze
+      when COLUMN_REF_RE3
+        [$1.freeze, $2.freeze, nil].freeze
+      else
+        [nil, s.freeze, nil].freeze
+      end
+      Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym] = v}
     end
+    v
   end
 
   # Converts the given +string+ into a +Date+ object.

data/lib/sequel/database/dataset_defaults.rb

@@ -137,6 +137,7 @@ module Sequel
     # create datasets.  Usually done after changes to the identifier
     # mangling methods.
     def reset_default_dataset
+      Sequel.synchronize{@symbol_literal_cache.clear}
       @default_dataset = dataset
     end
 

data/lib/sequel/database/misc.rb

@@ -131,6 +131,7 @@ module Sequel
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
+      @symbol_literal_cache = {}
       @schema_type_classes = SCHEMA_TYPE_CLASSES.dup
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(self, @opts)
@@ -235,6 +236,17 @@ module Sequel
       schema_utility_dataset.literal(v)
     end
 
+    # Return the literalized version of the symbol if cached, or
+    # nil if it is not cached.
+    def literal_symbol(sym)
+      Sequel.synchronize{@symbol_literal_cache[sym]}
+    end
+
+    # Set the cached value of the literal symbol.
+    def literal_symbol_set(sym, lit)
+      Sequel.synchronize{@symbol_literal_cache[sym] = lit}
+    end
+
     # Synchronize access to the prepared statements cache.
     def prepared_statement(name)
       Sequel.synchronize{prepared_statements[name]}

data/lib/sequel/database/query.rb

@@ -279,7 +279,10 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
-      Sequel.synchronize{@schemas.delete(quote_schema_table(table))} if @schemas
+      if @schemas
+        k = quote_schema_table(table)
+        Sequel.synchronize{@schemas.delete(k)}
+      end
     end
     
     # Match the database's column type to a ruby type via a

data/lib/sequel/database/schema_methods.rb

@@ -332,12 +332,13 @@ module Sequel
     #   DB.drop_view(:cheap_items)
     #   DB.drop_view(:cheap_items, :pricey_items)
     #   DB.drop_view(:cheap_items, :pricey_items, :cascade=>true)
+    #   DB.drop_view(:cheap_items, :pricey_items, :if_exists=>true)
     #
     # Options:
     # :cascade :: Also drop objects depending on this view.
+    # :if_exists :: Do not raise an error if the view does not exist.
     #
     # PostgreSQL specific options:
-    # :if_exists :: Do not raise an error if the view does not exist.
     # :materialized :: Drop a materialized view.
     def drop_view(*names)
       options = names.last.is_a?(Hash) ? names.pop : {}
@@ -721,7 +722,7 @@ module Sequel
     
     # SQL DDL statement to drop a view with the given name.
     def drop_view_sql(name, options)
-      "DROP VIEW #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
+      "DROP VIEW#{' IF EXISTS' if options[:if_exists]} #{quote_schema_table(name)}#{' CASCADE' if options[:cascade]}"
     end
 
     # Proxy the filter_expr call to the dataset, used for creating constraints.

data/lib/sequel/database/transactions.rb

@@ -36,6 +36,8 @@ module Sequel
     #
     # The following general options are respected:
     #
+    # :auto_savepoint :: Automatically use a savepoint for Database#transaction calls
+    #                    inside this transaction block.
     # :isolation :: The transaction isolation level to use for this transaction,
     #               should be :uncommitted, :committed, :repeatable, or :serializable,
     #               used if given and the database/adapter supports customizable
@@ -59,7 +61,8 @@ module Sequel
     # :savepoint :: Whether to create a new savepoint for this transaction,
     #               only respected if the database/adapter supports savepoints.  By
     #               default Sequel will reuse an existing transaction, so if you want to
-    #               use a savepoint you must use this option.
+    #               use a savepoint you must use this option.  If the surrounding transaction
+    #               uses :auto_savepoint, you can set this to false to not use a savepoint.
     #
     # PostgreSQL specific options:
     #
@@ -88,9 +91,14 @@ module Sequel
             if opts[:retrying]
               raise Sequel::Error, "cannot set :retry_on options if you are already inside a transaction"
             end
-            return yield(conn)
+            if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
+              _transaction(conn, opts.merge(:savepoint=>true), &block)
+            else
+              return yield(conn)
+            end
+          else
+            _transaction(conn, opts, &block)
           end
-          _transaction(conn, opts, &block)
         end
       end
     end
@@ -151,18 +159,24 @@ module Sequel
 
     # Add the current thread to the list of active transactions
     def add_transaction(conn, opts)
+      hash = {}
+
       if supports_savepoints?
-        unless _trans(conn)
+        if _trans(conn)
+          hash = nil
+          _trans(conn)[:savepoints].push(opts[:auto_savepoint])
+        else
+          hash[:savepoints] = [opts[:auto_savepoint]]
           if (prep = opts[:prepare]) && supports_prepared_transactions?
-            Sequel.synchronize{@transactions[conn] = {:savepoint_level=>0, :prepare=>prep}}
-          else
-            Sequel.synchronize{@transactions[conn] = {:savepoint_level=>0}}
+            hash[:prepare] = prep
           end
         end
       elsif (prep = opts[:prepare]) && supports_prepared_transactions?
-        Sequel.synchronize{@transactions[conn] = {:prepare => prep}}
-      else
-        Sequel.synchronize{@transactions[conn] = {}}
+        hash[:prepare] = prep
+      end
+
+      if hash
+        Sequel.synchronize{@transactions[conn] = hash}
       end
     end    
 
@@ -199,13 +213,12 @@ module Sequel
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts=OPTS)
       if supports_savepoints?
-        th = _trans(conn)
-        if (depth = th[:savepoint_level]) > 0
-          log_connection_execute(conn, begin_savepoint_sql(depth))
+        depth = savepoint_level(conn)
+        if depth > 1
+          log_connection_execute(conn, begin_savepoint_sql(depth-1))
         else
           begin_new_transaction(conn, opts)
         end
-        th[:savepoint_level] += 1
       else
         begin_new_transaction(conn, opts)
       end
@@ -243,7 +256,7 @@ module Sequel
     # Commit the active transaction on the connection
     def commit_transaction(conn, opts=OPTS)
       if supports_savepoints?
-        depth = _trans(conn)[:savepoint_level]
+        depth = savepoint_level(conn)
         log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
       else
         log_connection_execute(conn, commit_transaction_sql)
@@ -263,7 +276,7 @@ module Sequel
 
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
-      if !supports_savepoints? || ((_trans(conn)[:savepoint_level] -= 1) <= 0)
+      if transaction_finished?(conn)
         begin
           if committed
             after_transaction_commit(conn)
@@ -284,7 +297,7 @@ module Sequel
     # Rollback the active transaction on the connection
     def rollback_transaction(conn, opts=OPTS)
       if supports_savepoints?
-        depth = _trans(conn)[:savepoint_level]
+        depth = savepoint_level(conn)
         log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
       else
         log_connection_execute(conn, rollback_transaction_sql)
@@ -308,6 +321,11 @@ module Sequel
       "SET TRANSACTION ISOLATION LEVEL #{TRANSACTION_ISOLATION_LEVELS[level]}"
     end
 
+    # Current savepoint level.
+    def savepoint_level(conn)
+      _trans(conn)[:savepoints].length
+    end
+
     # Raise a database error unless the exception is an Rollback.
     def transaction_error(e, opts=OPTS)
       if e.is_a?(Rollback)
@@ -316,5 +334,17 @@ module Sequel
         raise_error(e, opts.merge(:classes=>database_error_classes))
       end
     end
+
+    # Finish a subtransaction.  If savepoints are supported, pops the current
+    # tansaction off the savepoint stack.
+    def transaction_finished?(conn)
+      if supports_savepoints?
+        stack = _trans(conn)[:savepoints]
+        stack.pop
+        stack.empty?
+      else
+        true
+      end
+    end
   end
 end