sequel 3.27.0 → 3.28.0

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

@@ -0,0 +1,214 @@
+module Sequel
+  module Firebird
+    module DatabaseMethods
+      AUTO_INCREMENT = ''.freeze
+      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+
+      def clear_primary_key(*tables)
+        tables.each{|t| @primary_keys.delete(dataset.send(:input_identifier, t))}
+      end
+
+      def create_trigger(*args)
+        self << create_trigger_sql(*args)
+      end
+
+      def database_type
+        :firebird
+      end
+
+      def drop_sequence(name)
+        self << drop_sequence_sql(name)
+      end
+
+      def drop_table(*names)
+        clear_primary_key(*names)
+        super
+      end
+
+      # Return primary key for the given table.
+      def primary_key(table)
+        t = dataset.send(:input_identifier, table)
+        @primary_keys.fetch(t) do
+          pk = fetch("SELECT RDB$FIELD_NAME FROM RDB$INDEX_SEGMENTS NATURAL JOIN RDB$RELATION_CONSTRAINTS WHERE RDB$CONSTRAINT_TYPE = 'PRIMARY KEY' AND RDB$RELATION_NAME = ?", t).single_value
+          @primary_keys[t] = dataset.send(:output_identifier, pk.rstrip) if pk
+        end
+      end
+
+      def restart_sequence(*args)
+        self << restart_sequence_sql(*args)
+      end
+
+      def sequences(opts={})
+        ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
+        block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
+      end
+
+      def tables(opts={})
+        tables_or_views(0, opts)
+      end
+
+      def views(opts={})
+        tables_or_views(1, opts)
+      end
+
+      private
+
+      # Use Firebird specific syntax for add column
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :drop_column
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
+        when :rename_column
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+        else
+          super(table, op)
+        end
+      end
+
+      def auto_increment_sql()
+        AUTO_INCREMENT
+      end
+      
+      def create_sequence_sql(name, opts={})
+        "CREATE SEQUENCE #{quote_identifier(name)}"
+      end
+
+      # Firebird gets an override because of the mess of creating a
+      # sequence and trigger for auto-incrementing primary keys.
+      def create_table_from_generator(name, generator, options)
+        drop_statement, create_statements = create_table_sql_list(name, generator, options)
+        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        create_statements.each{|sql| execute_ddl(sql)}
+      end
+
+      def create_table_sql_list(name, generator, options={})
+        statements = [create_table_sql(name, generator, options)]
+        drop_seq_statement = nil
+        generator.columns.each do |c|
+          if c[:auto_increment]
+            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
+            unless c[:create_sequence] == false
+              drop_seq_statement = drop_sequence_sql(c[:sequence_name])
+              statements << create_sequence_sql(c[:sequence_name])
+              statements << restart_sequence_sql(c[:sequence_name], {:restart_position => c[:sequence_start_position]}) if c[:sequence_start_position]
+            end
+            unless c[:create_trigger] == false
+              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
+              c[:quoted_name] = quote_identifier(c[:name])
+              trigger_definition = <<-END
+              begin
+                if ((new.#{c[:quoted_name]} is null) or (new.#{c[:quoted_name]} = 0)) then
+                begin
+                  new.#{c[:quoted_name]} = next value for #{c[:sequence_name]};
+                end
+              end
+              END
+              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
+            end
+          end
+        end
+        [drop_seq_statement, statements]
+      end
+
+      def create_trigger_sql(table, name, definition, opts={})
+        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
+        whence = opts[:after] ? 'AFTER' : 'BEFORE'
+        inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
+        position = opts.fetch(:position, 0)
+        sql = <<-end_sql
+          CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
+          #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
+          as #{definition}
+        end_sql
+        sql
+      end
+      
+      def drop_sequence_sql(name)
+        "DROP SEQUENCE #{quote_identifier(name)}"
+      end
+
+      def restart_sequence_sql(name, opts={})
+        seq_name = quote_identifier(name)
+        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
+      end
+
+      def tables_or_views(type, opts)
+        ds = self[:"rdb$relations"].server(opts[:server]).filter(:"rdb$relation_type" => type, Sequel::SQL::Function.new(:COALESCE, :"rdb$system_flag", 0) => 0).select(:"rdb$relation_name")
+        ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"].rstrip)}
+      end
+
+      def type_literal_generic_string(column)
+        column[:text] ? :"BLOB SUB_TYPE TEXT" : super
+      end
+    end
+
+    module DatasetMethods
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
+      NULL = LiteralString.new('NULL').freeze
+      COMMA_SEPARATOR = ', '.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct limit columns from join where group having compounds order')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values returning')
+      
+      # Insert given values into the database.
+      def insert(*values)
+        if @opts[:sql] || @opts[:returning]
+          super
+        elsif supports_insert_select?
+          returning(insert_pk).insert(*values){|r| return r.values.first}
+        end
+      end
+
+      # Insert a record returning the record inserted
+      def insert_select(*values)
+        returning.insert(*values){|r| return r}
+      end
+
+      def requires_sql_standard_datetimes?
+        true
+      end
+
+      def supports_insert_select?
+        true
+      end
+
+      # Firebird does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
+      private
+
+      def insert_clause_methods
+        INSERT_CLAUSE_METHODS
+      end
+
+      def insert_pk(*values)
+        pk = db.primary_key(opts[:from].first)
+        pk ? Sequel::SQL::Identifier.new(pk) : NULL
+      end
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
+
+      # The order of clauses in the SELECT SQL statement
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+      
+      def select_limit_sql(sql)
+        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
+        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+
 module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output
   module MSSQL
@@ -231,6 +233,8 @@ module Sequel
     end
   
     module DatasetMethods
+      include EmulateOffsetWithRowNumber
+
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
@@ -242,6 +246,7 @@ module Sequel
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
+      EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       attr_accessor :mssql_unicode_strings
@@ -252,29 +257,6 @@ module Sequel
         @mssql_unicode_strings = db.mssql_unicode_strings
       end
 
-      # Ugly hack.  While MSSQL supports TRUE and FALSE values, you can't
-      # actually specify them directly in SQL.  Unfortunately, you also cannot
-      # use an integer value when a boolean is required.  Also unforunately, you
-      # cannot use an expression that yields a boolean type in cases where in an
-      # integer type is needed, such as inserting into a bit field (the closest thing
-      # MSSQL has to a boolean).
-      #
-      # In filters, SQL::BooleanConstants are used more, while in other places
-      # the ruby true/false values are used more, so use expressions that return booleans
-      # for SQL::BooleanConstants, and 1/0 for other places.
-      # The correct fix for this would require separate literalization paths for
-      # filters compared to other values, but that's more work than I want to do right now.
-      def boolean_constant_sql(constant)
-        case constant
-        when true
-          '(1 = 1)'
-        when false
-          '(1 = 0)'
-        else
-          super
-        end
-      end
-
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.
       def complex_expression_sql(op, args)
         case op
@@ -288,6 +270,13 @@ module Sequel
           "(#{literal(args[0])} * POWER(2, #{literal(args[1])}))"
         when :>>
           "(#{literal(args[0])} / POWER(2, #{literal(args[1])}))"
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          expr = literal(args.at(1))
+          s = "datepart(#{format}, #{expr})"
+          s = "CAST((#{s} + datepart(ns, #{expr})/1000000000.0) AS double precision)" if part == :second
+          s
         else
           super(op, args)
         end
@@ -330,14 +319,6 @@ module Sequel
         clone(:into => table)
       end
 
-      # SQL Server does not support CTEs on subqueries, so move any CTEs
-      # on joined datasets to the top level. The user is responsible for
-      # resolving any name clashes this may cause.
-      def join_table(type, table, expr=nil, table_alias={}, &block)
-        return super unless Dataset === table && table.opts[:with]
-        clone(:with => (opts[:with] || []) + table.opts[:with]).join_table(type, table.clone(:with => nil), expr, table_alias, &block)
-      end
-
       # MSSQL uses a UNION ALL statement to insert multiple values at once.
       def multi_insert_sql(columns, values)
         [insert_sql(columns, LiteralString.new(values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")))]
@@ -383,29 +364,6 @@ module Sequel
         "[#{name}]"
       end
       
-      # MSSQL Requires the use of the ROW_NUMBER window function to emulate
-      # an offset.  This implementation requires MSSQL 2005 or greater (offset
-      # can't be emulated well in MSSQL 2000).
-      # 
-      # The implementation is ugly, cloning the current dataset and modifying
-      # the clone to add a ROW_NUMBER window function (and some other things),
-      # then using the modified clone in a subselect which is selected from.
-      #
-      # If offset is used, an order must be provided, because the use of ROW_NUMBER
-      # requires an order.
-      def select_sql
-        return super unless o = @opts[:offset]
-        raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
-        dsa1 = dataset_alias(1)
-        rn = row_number_column
-        subselect_sql(unlimited.
-          unordered.
-          select_append{ROW_NUMBER(:over, :order=>order){}.as(rn)}.
-          from_self(:alias=>dsa1).
-          limit(@opts[:limit]).
-          where(SQL::Identifier.new(rn) > o))
-      end
-
       # The version of the database server.
       def server_version
         db.server_version(@opts[:server])
@@ -450,6 +408,11 @@ module Sequel
       def supports_window_functions?
         true
       end
+
+      # MSSQL cannot use WHERE 1.
+      def supports_where_true?
+        false
+      end
       
       protected
       # MSSQL does not allow ordering in sub-clauses unless 'top' (limit) is specified
@@ -458,6 +421,7 @@ module Sequel
       end
 
       private
+
       def is_2005_or_later?
         server_version >= 9000000
       end
@@ -490,22 +454,6 @@ module Sequel
       alias insert_with_sql delete_with_sql
       alias update_with_sql delete_with_sql
       
-      # Special case when true or false is provided directly to filter.
-      def filter_expr(expr)
-        if block_given?
-          super
-        else
-          case expr
-          when true
-            Sequel::TRUE
-          when false
-            Sequel::FALSE
-          else
-            super
-          end
-        end
-      end
-      
       # MSSQL raises an error if you try to provide more than 3 decimal places
       # for a fractional timestamp.  This probably doesn't work for smalldatetime
       # fields.
@@ -552,11 +500,6 @@ module Sequel
         BOOL_TRUE
       end
       
-      # The alias to use for the row_number column when emulating OFFSET
-      def row_number_column
-        :x_sequel_row_number_x
-      end
-
       # MSSQL adds the limit before the columns
       def select_clause_methods
         SELECT_CLAUSE_METHODS

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

@@ -342,6 +342,13 @@ module Sequel
       # string concatenation.
       def complex_expression_sql(op, args)
         case op
+        when :IN, :"NOT IN"
+          ds = args.at(1)
+          if ds.is_a?(Sequel::Dataset) && ds.opts[:limit]
+            super(op, [args.at(0), ds.from_self])
+          else
+            super
+          end
         when :~, :'!~', :'~*', :'!~*', :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
           "(#{literal(args.at(0))} #{'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)}#{[:~, :'!~', :'~*', :'!~*'].include?(op) ? 'REGEXP' : 'LIKE'} #{'BINARY ' if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)}#{literal(args.at(1))})"
         when :'||'
@@ -481,6 +488,12 @@ module Sequel
         true
       end
 
+      # MySQL's DISTINCT ON emulation using GROUP BY does not respect the
+      # queries ORDER BY clause.
+      def supports_ordered_distinct_on?
+        false
+      end
+    
       # MySQL does support fractional timestamps in literal timestamps, but it
       # ignores them.  Also, using them seems to cause problems on 1.9.  Since
       # they are ignored anyway, not using them is probably best.

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

@@ -358,6 +358,11 @@ module Sequel
         @supports_prepared_transactions = self['SHOW max_prepared_transactions'].get.to_i > 0
       end
 
+      # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
+      def supports_create_table_if_not_exists?
+        server_version >= 90100
+      end
+
       # PostgreSQL supports savepoints
       def supports_savepoints?
         true
@@ -625,11 +630,14 @@ module Sequel
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from using where')
+      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values returning_select')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values')
+      INSERT_CLAUSE_METHODS_82 = Dataset.clause_methods(:insert, %w'into columns values returning')
+      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with into columns values returning')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
@@ -643,17 +651,23 @@ module Sequel
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set from where')
+      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with table set from where returning')
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
+        def run(&block)
+          if @prepared_type == :insert && supports_insert_select?
+            fetch_rows(prepared_sql){|r| return r.values.first}
+          else
+            super
+          end
+        end
+
         def prepared_sql
           return @prepared_sql if @prepared_sql
+          @opts[:returning] = insert_pk if @prepared_type == :insert && supports_insert_select?
           super
-          if @prepared_type == :insert and !@opts[:disable_insert_returning] and server_version >= 80200
-            @prepared_sql = insert_returning_pk_sql(*@prepared_modify_values)
-            meta_def(:insert_returning_pk_sql){|*args| prepared_sql}
-          end
           @prepared_sql
         end
       end
@@ -707,25 +721,20 @@ module Sequel
       end
       
       # Insert given values into the database.
-      def insert(*values)
-        if @opts[:sql]
-          execute_insert(insert_sql(*values))
-        elsif @opts[:disable_insert_returning] || server_version < 80200
-          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
+      def insert(*values, &block)
+        if @opts[:sql] || @opts[:returning]
+          super
+        elsif supports_insert_select?
+          returning(insert_pk).insert(*values){|r| return r.values.first}
         else
-          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
+          execute_insert(insert_sql(*values), :table=>opts[:from].first, :values=>values.size == 1 ? values.first : values)
         end
       end
 
-      # Use the RETURNING clause to return the columns listed in returning.
-      def insert_returning_sql(returning, *values)
-        "#{insert_sql(*values)} RETURNING #{column_list(Array(returning))}"
-      end
-
       # Insert a record returning the record inserted
       def insert_select(*values)
         return unless supports_insert_select?
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
+        returning.insert(*values){|r| return r}
       end
 
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
@@ -750,21 +759,30 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # PostgreSQL supports using the WITH clause in subqueries if it
+      # supports using WITH at all (i.e. on PostgreSQL 8.4+).
+      def supports_cte_in_subqueries?
+        supports_cte?
+      end
+
       # DISTINCT ON is a PostgreSQL extension
       def supports_distinct_on?
         true
       end
       
-      # PostgreSQL support insert_select using the RETURNING clause.
-      def supports_insert_select?
-        server_version >= 80200 && !opts[:disable_insert_returning]
-      end
-
       # PostgreSQL supports modifying joined datasets
       def supports_modifying_joins?
         true
       end
 
+      def supports_returning?(type)
+        if type == :insert
+          server_version >= 80200 && !opts[:disable_insert_returning]
+        else
+          server_version >= 90100
+        end
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -784,7 +802,7 @@ module Sequel
       
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
-        DELETE_CLAUSE_METHODS
+        server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
       end 
 
       # Only include the primary table in the main delete clause
@@ -799,23 +817,21 @@ module Sequel
 
       # PostgreSQL allows a RETURNING clause.
       def insert_clause_methods
-        INSERT_CLAUSE_METHODS
+        if server_version >= 90100
+          INSERT_CLAUSE_METHODS_91
+        elsif server_version >= 80200
+          INSERT_CLAUSE_METHODS_82
+        else
+          INSERT_CLAUSE_METHODS
+        end
       end
 
-      # Use the RETURNING clause to return the primary key of the inserted record, if it exists
-      def insert_returning_pk_sql(*values)
+      # Return the primary key to use for RETURNING in an INSERT statement
+      def insert_pk
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
+        pk ? Sequel::SQL::Identifier.new(pk) : NULL
       end
 
-      # Add a RETURNING clause if it is set and the database supports it and
-      # this dataset hasn't disabled it.
-      def insert_returning_select_sql(sql)
-        if supports_insert_select? && opts.has_key?(:returning)
-          sql << " RETURNING #{column_list(Array(opts[:returning]))}"
-        end
-      end
-      
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.
       def join_from_sql(type, sql)
@@ -882,7 +898,7 @@ module Sequel
 
       # PostgreSQL splits the main table from the joined tables
       def update_clause_methods
-        UPDATE_CLAUSE_METHODS
+        server_version >= 90100 ? UPDATE_CLAUSE_METHODS_91 : UPDATE_CLAUSE_METHODS
       end
 
       # Use FROM to specify additional tables in an update query