sequel 3.21.0 → 3.28.0

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
@@ -11,10 +13,16 @@ module Sequel
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       
+      # Whether to use N'' to quote strings, which allows unicode characters inside the
+      # strings.  True by default for compatibility, can be set to false for a possible
+      # performance increase.  This sets the default for all datasets created from this
+      # Database object.
+      attr_accessor :mssql_unicode_strings
+
       # The types to check for 0 scale to transform :decimal types
       # to :integer.
       DECIMAL_TYPE_RE = /number|numeric|decimal/io
-      
+
       # Microsoft SQL Server uses the :mssql type.
       def database_type
         :mssql
@@ -47,11 +55,13 @@ module Sequel
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:information_schema__tables___t).
-          select(:table_name).
-          filter(:table_type=>'BASE TABLE', :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
-          map{|x| m.call(x[:table_name])}
+        information_schema_tables('BASE TABLE', opts)
+      end
+
+      # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
+      # information on views.
+      def views(opts={})
+        information_schema_tables('VIEW', opts)
       end
 
       private
@@ -117,6 +127,15 @@ module Sequel
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
+      # Backbone of the tables and views support.
+      def information_schema_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:information_schema__tables___t).
+          select(:table_name).
+          filter(:table_type=>type, :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
+          map{|x| m.call(x[:table_name])}
+      end
+
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
       def metadata_dataset
         ds = super
@@ -139,6 +158,16 @@ module Sequel
         SQL_ROLLBACK
       end
       
+      # The closest MSSQL equivalent of a boolean datatype is the bit type.
+      def schema_column_type(db_type)
+        case db_type
+        when /\A(bit)\z/io
+          :boolean
+        else
+          super
+        end
+      end
+
       # MSSQL uses the INFORMATION_SCHEMA to hold column information.  This method does
       # not support the parsing of primary key information.
       def schema_parse_table(table_name, opts)
@@ -163,6 +192,11 @@ module Sequel
           [m.call(row.delete(:column)), row]
         end
       end
+
+      # Set the mssql_unicode_strings settings from the given options.
+      def set_mssql_unicode_strings
+        @mssql_unicode_strings = typecast_value_boolean(@opts.fetch(:mssql_unicode_strings, true))
+      end
       
       # MSSQL has both datetime and timestamp classes, most people are going
       # to want datetime
@@ -199,6 +233,8 @@ module Sequel
     end
   
     module DatasetMethods
+      include EmulateOffsetWithRowNumber
+
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
@@ -210,6 +246,16 @@ 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
+
+      # Copy the mssql_unicode_strings option from the +db+ object.
+      def initialize(db, opts={})
+        super
+        @mssql_unicode_strings = db.mssql_unicode_strings
+      end
 
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.
       def complex_expression_sql(op, args)
@@ -224,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
@@ -257,8 +310,8 @@ module Sequel
 
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
       def insert_select(*values)
-        return unless supports_output_clause?
-        naked.clone(default_server_opts(:sql=>output(nil, [:inserted.*]).insert_sql(*values))).single_record unless opts[:disable_insert_output]
+        return unless supports_insert_select?
+        naked.clone(default_server_opts(:sql=>output(nil, [SQL::ColumnAll.new(:inserted)]).insert_sql(*values))).single_record
       end
 
       # Specify a table for a SELECT ... INTO query.
@@ -266,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 ")))]
@@ -319,34 +364,16 @@ 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])
       end
 
+      # MSSQL supports insert_select via the OUTPUT clause.
+      def supports_insert_select?
+        supports_output_clause? && !opts[:disable_insert_output]
+      end
+
       # MSSQL 2005+ supports INTERSECT and EXCEPT
       def supports_intersect_except?
         is_2005_or_later?
@@ -381,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
@@ -389,6 +421,7 @@ module Sequel
       end
 
       private
+
       def is_2005_or_later?
         server_version >= 9000000
       end
@@ -434,6 +467,16 @@ module Sequel
         INSERT_CLAUSE_METHODS
       end
 
+      # Use OUTPUT INSERTED.* to return all columns of the inserted row,
+      # for use with the prepared statement code.
+      def insert_output_sql(sql)
+        if @opts.has_key?(:returning)
+          sql << " OUTPUT INSERTED.*"
+        else
+          output_sql(sql)
+        end
+      end
+
       # MSSQL uses a literal hexidecimal number for blob strings
       def literal_blob(v)
         blob = '0x'
@@ -441,9 +484,10 @@ module Sequel
         blob
       end
       
-      # Use unicode string syntax for all strings. Don't double backslashes.
+      # Optionally use unicode string syntax for all strings. Don't double
+      # backslashes.
       def literal_string(v)
-        "N'#{v.gsub(/'/, "''")}'"
+        "#{'N' if mssql_unicode_strings}'#{v.gsub(/'/, "''")}'"
       end
       
       # Use 0 for false on MSSQL
@@ -456,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
@@ -508,7 +547,6 @@ module Sequel
       end
       alias delete_output_sql output_sql
       alias update_output_sql output_sql
-      alias insert_output_sql output_sql
 
       # MSSQL supports the OUTPUT clause for UPDATE statements.
       # It also allows prepending a WITH clause.

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
@@ -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
@@ -312,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 :'||'
@@ -451,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/mysql_prepared_statements.rb

@@ -0,0 +1,143 @@
+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(ds)
+            ps = ds.to_prepared_statement(:select)
+            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
+          
+          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

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

@@ -26,10 +26,6 @@ module Sequel
         ds.map{|r| ds.send(:output_identifier, r[:tname])}
       end
 
-      def table_exists?(name)
-        from(:tab).filter(:tname =>dataset.send(:input_identifier, name), :tabtype => 'TABLE').count > 0
-      end
-
       def views(opts={}) 
         ds = from(:tab).server(opts[:server]).select(:tname).filter(:tabtype => 'VIEW') 
         ds.map{|r| ds.send(:output_identifier, r[:tname])}