sequel 3.21.0 → 3.31.0

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

@@ -83,13 +83,9 @@ module Sequel
         @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
       end
       
-      # Return an array of symbols specifying table names in the current database.
-      #
-      # Options:
-      # * :server - Set the server to use
-      def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.with_sql('SHOW TABLES').server(opts[:server]).map{|r| m.call(r.values.first)}
+      # MySQL supports CREATE TABLE IF NOT EXISTS syntax.
+      def supports_create_table_if_not_exists?
+        true
       end
       
       # MySQL supports prepared transactions (two-phase commit) using XA
@@ -107,6 +103,14 @@ module Sequel
         true
       end
 
+      # Return an array of symbols specifying table names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def tables(opts={})
+        full_tables('BASE TABLE', opts)
+      end
+      
       # Changes the database in use by issuing a USE statement.  I would be
       # very careful if I used this.
       def use(db_name)
@@ -116,6 +120,14 @@ module Sequel
         self
       end
       
+      # Return an array of symbols specifying view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def views(opts={})
+        full_tables('VIEW', opts)
+      end
+      
       private
       
       # Use MySQL specific syntax for rename column, set column type, and
@@ -142,6 +154,18 @@ module Sequel
           "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
+        when :drop_constraint
+          type = case op[:type]
+          when :primary_key
+            return "ALTER TABLE #{quote_schema_table(table)} DROP PRIMARY KEY"
+          when :foreign_key
+            'FOREIGN KEY'
+          when :unique
+            'INDEX'
+          else
+            raise(Error, "must specify constraint type via :type=>(:foreign_key|:primary_key|:unique) when dropping constraints on MySQL")
+          end
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{type} #{quote_identifier(op[:name])}"
         else
           super(table, op)
         end
@@ -161,9 +185,9 @@ module Sequel
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
       def begin_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && (th = @transactions[conn])[:savepoint_level] == 0
           log_connection_execute(conn, "XA START #{literal(s)}")
-          conn
+          th[:savepoint_level] += 1
         else
           super
         end
@@ -184,7 +208,7 @@ module Sequel
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
       def commit_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
         else
@@ -205,6 +229,12 @@ module Sequel
         "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 
+      # Backbone of the tables and views support using SHOW FULL TABLES.
+      def full_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.with_sql('SHOW FULL TABLES').server(opts[:server]).map{|r| m.call(r.values.first) if r.delete(:Table_type) == type}.compact
+      end
+
       # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil
@@ -232,7 +262,7 @@ module Sequel
       
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts={})
-        if s = opts[:prepare]
+        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
           log_connection_execute(conn, "XA ROLLBACK #{literal(s)}")
@@ -248,8 +278,8 @@ module Sequel
 
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
-        im = input_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
+        im = input_identifier_meth(opts[:dataset])
         metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
           row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
           row[:allow_null] = row.delete(:Null) == 'YES'
@@ -303,27 +333,71 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       FOR_SHARE = ' LOCK IN SHARE MODE'.freeze
       SQL_CALC_FOUND_ROWS = ' SQL_CALC_FOUND_ROWS'.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from where order limit')
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'ignore into columns values on_duplicate_key_update')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct calc_found_rows columns from join where group having compounds order limit lock')
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set where order limit')
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from where order limit')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert ignore into columns values on_duplicate_key_update')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set where order limit')
+      SPACE = Dataset::SPACE
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      NOT_SPACE = Dataset::NOT_SPACE
+      FROM = Dataset::FROM
+      INSERT = Dataset::INSERT
+      COMMA = Dataset::COMMA
+      LIMIT = Dataset::LIMIT
+      GROUP_BY = Dataset::GROUP_BY
+      REGEXP = 'REGEXP'.freeze
+      LIKE = 'LIKE'.freeze
+      BINARY = 'BINARY '.freeze
+      CONCAT = "CONCAT".freeze
+      CAST_BITCOMP_OPEN = "CAST(~".freeze
+      CAST_BITCOMP_CLOSE = " AS SIGNED INTEGER)".freeze
+      STRAIGHT_JOIN = 'STRAIGHT_JOIN'.freeze
+      NATURAL_LEFT_JOIN = 'NATURAL LEFT JOIN'.freeze
+      BACKTICK = '`'.freeze
+      EMPTY_COLUMNS = " ()".freeze
+      EMPTY_VALUES = " VALUES ()".freeze
+      IGNORE = " IGNORE".freeze
+      REPLACE = 'REPLACE'.freeze
+      ON_DUPLICATE_KEY_UPDATE = " ON DUPLICATE KEY UPDATE ".freeze
+      EQ_VALUES = '=VALUES('.freeze
+      EQ = '='.freeze
+      WITH_ROLLUP = ' WITH ROLLUP'.freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
-      def complex_expression_sql(op, args)
+      def complex_expression_sql_append(sql, op, args)
         case op
+        when :IN, :"NOT IN"
+          ds = args.at(1)
+          if ds.is_a?(Sequel::Dataset) && ds.opts[:limit]
+            super(sql, 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))})"
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << SPACE
+          sql << 'NOT ' if [:'NOT LIKE', :'NOT ILIKE', :'!~', :'!~*'].include?(op)
+          sql << ([:~, :'!~', :'~*', :'!~*'].include?(op) ? REGEXP : LIKE)
+          sql << SPACE
+          sql << BINARY if [:~, :'!~', :LIKE, :'NOT LIKE'].include?(op)
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
         when :'||'
           if args.length > 1
-            "CONCAT(#{args.collect{|a| literal(a)}.join(', ')})"
+            sql << CONCAT
+            array_sql_append(sql, args)
           else
-            literal(args.at(0))
+            literal_append(sql, args.at(0))
           end
         when :'B~'
-          "CAST(~#{literal(args.at(0))} AS SIGNED INTEGER)"
+          sql << CAST_BITCOMP_OPEN
+          literal_append(sql, args.at(0))
+          sql << CAST_BITCOMP_CLOSE
         else
-          super(op, args)
+          super
         end
       end
       
@@ -351,8 +425,9 @@ module Sequel
       end
       
       # MySQL specific full text search syntax.
-      def full_text_sql(cols, term, opts = {})
-        "MATCH #{literal(Array(cols))} AGAINST (#{literal(Array(term).join(' '))}#{" IN BOOLEAN MODE" if opts[:boolean]})"
+      def full_text_sql(cols, terms, opts = {})
+        terms = terms.join(' ') if terms.is_a?(Array)
+        SQL::PlaceholderLiteralString.new("MATCH ? AGAINST (?#{" IN BOOLEAN MODE" if opts[:boolean]})", [Array(cols), terms], true)
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
@@ -372,9 +447,12 @@ module Sequel
       # STRAIGHT_JOIN.
       def join_type_sql(join_type)
         case join_type
-        when :straight then 'STRAIGHT_JOIN'
-        when :natural_inner then 'NATURAL LEFT JOIN'
-        else super
+        when :straight
+          STRAIGHT_JOIN
+        when :natural_inner
+          NATURAL_LEFT_JOIN
+        else
+          super
         end
       end
       
@@ -415,7 +493,9 @@ module Sequel
 
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
-        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
+        sql = LiteralString.new('VALUES ')
+        expression_list_append(sql, values.map{|r| Array(r)})
+        [insert_sql(columns, sql)]
       end
       
       # MySQL uses the number of rows actually modified in the update,
@@ -425,8 +505,8 @@ module Sequel
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
-      def quoted_identifier(c)
-        "`#{c}`"
+      def quoted_identifier_append(sql, c)
+        sql << BACKTICK << c.to_s << BACKTICK
       end
       
       # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
@@ -441,6 +521,11 @@ module Sequel
         true
       end
 
+      # MySQL supports GROUP BY WITH ROLLUP (but not CUBE)
+      def supports_group_rollup?
+        true
+      end
+
       # MySQL does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
@@ -451,6 +536,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.
@@ -458,13 +549,6 @@ module Sequel
         false
       end
       
-      protected
-      
-      # If this is an replace instead of an insert, use replace instead
-      def _insert_sql
-        @opts[:replace] ? clause_sql(:replace) : super
-      end
-
       private
 
       # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
@@ -476,7 +560,10 @@ module Sequel
       # from, but include the others for the purposes of selecting rows.
       def delete_from_sql(sql)
         if joined_dataset?
-          sql << " #{source_list(@opts[:from][0..0])} FROM #{source_list(@opts[:from])}"
+          sql << SPACE
+          source_list_append(sql, @opts[:from][0..0])
+          sql << FROM
+          source_list_append(sql, @opts[:from])
           select_join_sql(sql)
         else
           super
@@ -493,7 +580,7 @@ module Sequel
       def insert_columns_sql(sql)
         values = opts[:values]
         if values.is_a?(Array) && values.empty?
-          sql << " ()"
+          sql << EMPTY_COLUMNS
         else
           super
         end
@@ -501,19 +588,57 @@ module Sequel
 
       # MySQL supports INSERT IGNORE INTO
       def insert_ignore_sql(sql)
-        sql << " IGNORE" if opts[:insert_ignore]
+        sql << IGNORE if opts[:insert_ignore]
+      end
+
+      # If this is an replace instead of an insert, use replace instead
+      def insert_insert_sql(sql)
+        sql << (@opts[:replace] ? REPLACE : INSERT)
       end
 
       # MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
       def insert_on_duplicate_key_update_sql(sql)
-        sql << on_duplicate_key_update_sql if opts[:on_duplicate_key_update]
+        if update_cols = opts[:on_duplicate_key_update]
+          update_vals = nil
+
+          if update_cols.empty?
+            update_cols = columns
+          elsif update_cols.last.is_a?(Hash)
+            update_vals = update_cols.last
+            update_cols = update_cols[0..-2]
+          end
+
+          sql << ON_DUPLICATE_KEY_UPDATE
+          c = false
+          co = COMMA
+          values = EQ_VALUES
+          endp = PAREN_CLOSE
+          update_cols.each do |col|
+            sql << co if c
+            quote_identifier_append(sql, col)
+            sql << values
+            quote_identifier_append(sql, col)
+            sql << endp
+            c ||= true
+          end
+          if update_vals
+            eq = EQ
+            update_vals.map do |col,v| 
+              sql << co if c
+              quote_identifier_append(sql, col)
+              sql << eq
+              literal_append(sql, v)
+              c ||= true
+            end
+          end
+        end
       end
 
       # MySQL doesn't use the standard DEFAULT VALUES for empty values.
       def insert_values_sql(sql)
         values = opts[:values]
         if values.is_a?(Array) && values.empty?
-          sql << " VALUES ()"
+          sql << EMPTY_VALUES
         else
           super
         end
@@ -521,7 +646,10 @@ module Sequel
 
       # MySQL allows a LIMIT in DELETE and UPDATE statements.
       def limit_sql(sql)
-        sql << " LIMIT #{@opts[:limit]}" if @opts[:limit]
+        if l = @opts[:limit]
+          sql << LIMIT
+          literal_append(sql, @opts[:limit])
+        end
       end
       alias delete_limit_sql limit_sql
       alias update_limit_sql limit_sql
@@ -536,30 +664,20 @@ module Sequel
         BOOL_TRUE
       end
       
-      # MySQL specific syntax for ON DUPLICATE KEY UPDATE
-      def on_duplicate_key_update_sql
-        if update_cols = opts[:on_duplicate_key_update]
-          update_vals = nil
-
-          if update_cols.empty?
-            update_cols = columns
-          elsif update_cols.last.is_a?(Hash)
-            update_vals = update_cols.last
-            update_cols = update_cols[0..-2]
-          end
-
-          updating = update_cols.map{|c| "#{quote_identifier(c)}=VALUES(#{quote_identifier(c)})" }
-          updating += update_vals.map{|c,v| "#{quote_identifier(c)}=#{literal(v)}" } if update_vals
-
-          " ON DUPLICATE KEY UPDATE #{updating.join(COMMA_SEPARATOR)}"
-        end
-      end
-
       # MySQL does not support the SQL WITH clause for SELECT statements
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end
       
+      # MySQL supports ROLLUP via nonstandard SQL syntax
+      def select_group_sql(sql)
+        if group = @opts[:group]
+          sql << GROUP_BY
+          expression_list_append(sql, group)
+          sql << WITH_ROLLUP if @opts[:group_options] == :rollup
+        end
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super

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

@@ -0,0 +1,149 @@
+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_statements[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?
+            _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
+        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.prepared_statements[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