sequel 3.21.0 → 3.39.0

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

@@ -0,0 +1,155 @@
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  module MySQL
+    # This module is used by the mysql and mysql2 adapters to support
+    # prepared statements and stored procedures.
+    module PreparedStatements
+      module DatabaseMethods
+        # Support stored procedures on MySQL
+        def call_sproc(name, 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)
+          if opts[:sproc]
+            call_sproc(sql, opts, &block)
+          elsif sql.is_a?(Symbol)
+            execute_prepared_statement(sql, opts, &block)
+          else
+            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+          end
+        end
+        
+        private
+
+        def add_prepared_statements_cache(conn)
+          class << conn
+            attr_accessor :prepared_statements
+          end
+          conn.prepared_statements = {}
+        end
+
+        # Executes a prepared statement on an available connection.  If the
+        # prepared statement already exists for the connection and has the same
+        # SQL, reuse it, otherwise, prepare the new statement.  Because of the
+        # usual MySQL stupidity, we are forced to name arguments via separate
+        # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
+        # arguments.
+        def execute_prepared_statement(ps_name, opts, &block)
+          args = opts[:arguments]
+          ps = prepared_statement(ps_name)
+          sql = ps.prepared_sql
+          synchronize(opts[:server]) do |conn|
+            unless conn.prepared_statements[ps_name] == sql
+              conn.prepared_statements[ps_name] = sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+        
+      end
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        # Methods to add to MySQL prepared statement calls without using a
+        # real database prepared statement and bound variables.
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql_append(sql, ds)
+            ps = ds.to_prepared_statement(:select).clone(:append_sql => sql)
+            ps.extend(CallableStatementMethods)
+            ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
+            ps.prepared_args = prepared_args
+            ps.prepared_sql
+          end
+        end
+        
+        # Methods for MySQL prepared statements using the native driver.
+        module PreparedStatementMethods
+          include Sequel::Dataset::UnnumberedArgumentMapper
+          
+          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+          def call(*)
+            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+            super
+          end
+          
+          private
+          
+          # Execute the prepared statement with the bind arguments instead of
+          # the given SQL.
+          def execute(sql, 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)
+            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)
+            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+        end
+        
+        # Methods for MySQL stored procedures using the native driver.
+        module StoredProcedureMethods
+          include Sequel::Dataset::StoredProcedureMethods
+          
+          private
+          
+          # Execute the database stored procedure with the stored arguments.
+          def execute(sql, 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)
+            super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+          end
+        end
+        
+        # MySQL is different in that it supports prepared statements but not bound
+        # variables outside of prepared statements.  The default implementation
+        # breaks the use of subselects in prepared statements, so extend the
+        # temporary prepared statement that this creates with a module that
+        # fixes it.
+        def call(type, bind_arguments={}, *values, &block)
+          ps = to_prepared_statement(type, values)
+          ps.extend(CallableStatementMethods)
+          ps.call(bind_arguments, &block)
+        end
+        
+        # Store the given type of prepared statement in the associated database
+        # with the given name.
+        def prepare(type, name=nil, *values)
+          ps = to_prepared_statement(type, values)
+          ps.extend(PreparedStatementMethods)
+          if name
+            ps.prepared_statement_name = name
+            db.set_prepared_statement(name, ps)
+          end
+          ps
+        end
+        
+        private
+
+        # Extend the dataset with the MySQL stored procedure methods.
+        def prepare_extend_sproc(ds)
+          ds.extend(StoredProcedureMethods)
+        end
+        
+      end
+    end
+  end
+end

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

@@ -1,9 +1,13 @@
+Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+
 module Sequel
   module Oracle
     module DatabaseMethods
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
       AUTOINCREMENT = ''.freeze
 
+      attr_accessor :autosequence
+
       def create_sequence(name, opts={})
         self << create_sequence_sql(name, opts)
       end
@@ -12,6 +16,10 @@ module Sequel
         self << create_trigger_sql(*args)
       end
 
+      def current_user
+        @current_user ||= metadata_dataset.get{sys_context('USERENV', 'CURRENT_USER')}
+      end
+
       def drop_sequence(name)
         self << drop_sequence_sql(name)
       end
@@ -21,33 +29,59 @@ module Sequel
         :oracle
       end
 
-      def tables(opts={})
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'TABLE')
-        ds.map{|r| ds.send(:output_identifier, r[:tname])}
+      # Oracle namespaces indexes per table.
+      def global_index_namespace?
+        false
       end
 
-      def table_exists?(name)
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
+      def tables(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={}) 
-        ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW') 
-        ds.map{|r| ds.send(:output_identifier, r[:tname])} 
+        m = output_identifier_meth
+        metadata_dataset.from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW').map{|r| m.call(r[:tname])}
       end 
  
       def view_exists?(name) 
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'VIEW').count > 0 
+        m = input_identifier_meth
+        metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
       end 
 
       private
 
-      def auto_increment_sql
-        AUTOINCREMENT
+      # Handle Oracle specific ALTER TABLE SQL
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          if op[:primary_key]
+            sqls = []
+            sqls << alter_table_sql(table, op.merge(:primary_key=>nil))
+            if op[:auto_increment]
+              seq_name = default_sequence_name(table, op[:name])
+              sqls << drop_sequence_sql(seq_name)
+              sqls << create_sequence_sql(seq_name, op)
+              sqls << "UPDATE #{quote_schema_table(table)} SET #{quote_identifier(op[:name])} = #{seq_name}.nextval"
+            end
+            sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"
+            sqls
+          else
+             "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+          end
+        when :set_column_null
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{op[:null] ? 'NULL' : 'NOT NULL'}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} #{type_literal(op)}"
+        when :set_column_default
+          "ALTER TABLE #{quote_schema_table(table)} MODIFY #{quote_identifier(op[:name])} DEFAULT #{literal(op[:default])}"
+        else
+          super(table, op)
+        end
       end
 
-      # SQL fragment for showing a table is temporary
-      def temporary_table_sql
-        TEMPORARY
+      def auto_increment_sql
+        AUTOINCREMENT
       end
 
       def create_sequence_sql(name, opts={})
@@ -65,7 +99,7 @@ module Sequel
         drop_seq_statement = nil
         generator.columns.each do |c|
           if c[:auto_increment]
-            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
+            c[:sequence_name] ||= default_sequence_name(name, c[:name])
             unless c[:create_sequence] == false
               drop_seq_statement = drop_sequence_sql(c[:sequence_name])
               statements << create_sequence_sql(c[:sequence_name], c)
@@ -97,14 +131,137 @@ module Sequel
         sql
       end
 
+      def default_sequence_name(table, column)
+        "seq_#{table}_#{column}"
+      end
+
       def drop_sequence_sql(name)
         "DROP SEQUENCE #{quote_identifier(name)}"
       end
+
+      def remove_cached_schema(table)
+        @primary_key_sequences.delete(table)
+        super
+      end
+      
+      def sequence_for_table(table)
+        return nil unless autosequence
+        @primary_key_sequences.fetch(table) do |key|
+          pk = schema(table).select{|k, v| v[:primary_key]}
+          @primary_key_sequences[table] = if pk.length == 1
+            seq = "seq_#{table}_#{pk.first.first}"
+            seq.to_sym unless from(:user_sequences).filter(:sequence_name=>input_identifier_meth.call(seq)).empty?
+          end
+        end
+      end
+
+      # Oracle's integer/:number type handles larger values than
+      # most other databases's bigint types, so it should be
+      # safe to use for Bignum.
+      def type_literal_generic_bignum(column)
+        :integer
+      end
+
+      # Oracle doesn't have a time type, so use timestamp for all
+      # time columns.
+      def type_literal_generic_time(column)
+        :timestamp
+      end
+
+      # Oracle doesn't have a boolean type or even a reasonable
+      # facsimile.  Using a char(1) seems to be the recommended way.
+      def type_literal_generic_trueclass(column)
+        :'char(1)'
+      end
+
+      # SQL fragment for showing a table is temporary
+      def temporary_table_sql
+        TEMPORARY
+      end
     end
 
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order limit lock')
+      include EmulateOffsetWithRowNumber
+
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having compounds order lock')
+      ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
+      SPACE = Dataset::SPACE
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
+      FROM = Dataset::FROM
+      BITCOMP_OPEN = "((0 - ".freeze
+      BITCOMP_CLOSE = ") - 1)".freeze
+      ILIKE_0 = "(UPPER(".freeze
+      ILIKE_1 = ") ".freeze
+      ILIKE_2 = ' UPPER('.freeze
+      ILIKE_3 = "))".freeze
+      LIKE = 'LIKE'.freeze
+      NOT_LIKE = 'NOT LIKE'.freeze
+      TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+      TIMESTAMP_OFFSET_FORMAT = "%+03i:%02i".freeze
+      BOOL_FALSE = "'N'".freeze
+      BOOL_TRUE = "'Y'".freeze
+      HSTAR = "H*".freeze
+      DUAL = ['DUAL'.freeze].freeze
+
+      # Oracle needs to emulate bitwise operators and ILIKE/NOT ILIKE operators.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        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)})"}
+        when :^
+          sql << complex_expression_arg_pairs(args){|*x| "(#{complex_expression_sql(:|, x)} - #{complex_expression_sql(:&, x)})"}
+        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}))"}
+        when :>>
+          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)})"}
+        when :ILIKE, :'NOT ILIKE'
+          sql << ILIKE_0
+          literal_append(sql, args.at(0))
+          sql << ILIKE_1
+          sql << (op == :ILIKE ? LIKE : NOT_LIKE)
+          sql<< ILIKE_2
+          literal_append(sql, args.at(1))
+          sql << ILIKE_3
+        else
+          super
+        end
+      end
 
+      # Oracle doesn't support CURRENT_TIME, as it doesn't have
+      # a type for storing just time values without a date, so
+      # use CURRENT_TIMESTAMP in its place.
+      def constant_sql_append(sql, c)
+        if c == :CURRENT_TIME
+          super(sql, :CURRENT_TIMESTAMP)
+        else
+          super
+        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 = {:all=>opts} unless opts.is_a?(Hash)
@@ -112,19 +269,10 @@ module Sequel
         compound_clone(:minus, dataset, opts)
       end
 
+      # Use a custom expression with EXISTS to determine whether a dataset
+      # is empty.
       def empty?
-        db[:dual].where(exists).get(1) == nil
-      end
-
-      # If this dataset is associated with a sequence, return the most recently
-      # inserted sequence value.
-      def insert(*args)
-        r = super
-        if s = opts[:sequence]
-          with_sql("SELECT #{literal(s)}.currval FROM dual").single_value.to_i
-        else
-          r
-        end
+        db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
       end
 
       # Oracle requires SQL standard datetimes
@@ -139,16 +287,61 @@ module Sequel
         clone(:sequence=>s)
       end
 
+      # Handle LIMIT by using a unlimited subselect filtered with ROWNUM.
+      def select_sql
+        if (limit = @opts[:limit]) && !@opts[:sql]
+          ds = clone(:limit=>nil)
+          # Lock doesn't work in subselects, so don't use a subselect when locking.
+          # Don't use a subselect if custom SQL is used, as it breaks somethings.
+          ds = ds.from_self unless @opts[:lock]
+          sql = @opts[:append_sql] || ''
+          subselect_sql_append(sql, ds.where(SQL::ComplexExpression.new(:<=, ROW_NUMBER_EXPRESSION, limit)))
+          sql
+        else
+          super
+        end
+      end
+
+      # Oracle requires recursive CTEs to have column aliases.
+      def recursive_cte_requires_column_aliases?
+        true
+      end
+
+      # Oracle supports GROUP BY CUBE
+      def supports_group_cube?
+        true
+      end
+
+      # Oracle supports GROUP BY ROLLUP
+      def supports_group_rollup?
+        true
+      end
+
       # Oracle does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false
       end
+
+      # Oracle does not support IS TRUE.
+      def supports_is_true?
+        false
+      end
+      
+      # Oracle does not support SELECT *, column
+      def supports_select_all_and_column?
+        false
+      end
       
       # Oracle supports timezones in literal timestamps.
       def supports_timestamp_timezones?
         true
       end
       
+      # Oracle does not support WHERE 'Y' for WHERE TRUE.
+      def supports_where_true?
+        false
+      end
+
       # Oracle supports window functions
       def supports_window_functions?
         true
@@ -158,25 +351,54 @@ 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(expression, aliaz)
-        "#{expression} #{quote_identifier(aliaz)}"
+      def as_sql_append(sql, aliaz)
+        sql << SPACE
+        quote_identifier_append(sql, aliaz)
       end
 
       # The strftime format to use when literalizing the time.
       def default_timestamp_format
-        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+        TIMESTAMP_FORMAT
+      end
+
+      # If this dataset is associated with a sequence, return the most recently
+      # inserted sequence value.
+      def execute_insert(sql, opts={})
+        f = @opts[:from]
+        super(sql, {:table=>(f.first if f), :sequence=>@opts[:sequence]}.merge(opts))
       end
 
       # Use a colon for the timestamp offset, since Oracle appears to require it.
       def format_timestamp_offset(hour, minute)
-        sprintf("%+03i:%02i", hour, minute)
+        sprintf(TIMESTAMP_OFFSET_FORMAT, hour, minute)
+      end
+
+      # Oracle doesn't support empty values when inserting.
+      def insert_supports_empty_values?
+        false
+      end
+
+      # Use string in hex format for blob data.
+      def literal_blob_append(sql, v)
+        sql << APOS << v.unpack(HSTAR).first << APOS
+      end
+
+      # Oracle uses 'N' for false values.
+      def literal_false
+        BOOL_FALSE
       end
 
       # Oracle uses the SQL standard of only doubling ' inside strings.
-      def literal_string(v)
-        "'#{v.gsub("'", "''")}'"
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+      end
+
+      # Oracle uses 'Y' for true values.
+      def literal_true
+        BOOL_TRUE
       end
 
+      # Use the Oracle-specific SQL clauses (no limit, since it is emulated).
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
@@ -186,18 +408,8 @@ module Sequel
       # so add the dummy DUAL table if the dataset doesn't select
       # from a table.
       def select_from_sql(sql)
-        sql << " FROM #{source_list(@opts[:from] || ['DUAL'])}"
-      end
-
-      # Oracle requires a subselect to do limit and offset
-      def select_limit_sql(sql)
-        if limit = @opts[:limit]
-          if (offset = @opts[:offset]) && (offset > 0)
-            sql.replace("SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}")
-          else
-            sql.replace("SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}")
-          end
-        end
+        sql << FROM
+        source_list_append(sql, @opts[:from] || DUAL)
       end
     end
   end