sequel 3.1.0 → 3.2.0

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

@@ -1,10 +1,4 @@
-Sequel.require %w'unsupported savepoint_transactions', 'adapters/utils'
-
 module Sequel
-  class Database
-    # Keep default column_references_sql for add_foreign_key support
-    alias default_column_references_sql column_references_sql
-  end
   module MySQL
     class << self
       # Set the default options used for CREATE TABLE
@@ -14,8 +8,6 @@ module Sequel
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
-      include Sequel::Database::SavepointTransactions
-    
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
       PRIMARY = 'PRIMARY'.freeze
@@ -68,6 +60,11 @@ module Sequel
         metadata_dataset.with_sql('SHOW TABLES').server(opts[:server]).map{|r| m.call(r.values.first)}
       end
       
+      # MySQL supports savepoints
+      def supports_savepoints?
+        true
+      end
+
       # Changes the database in use by issuing a USE statement.  I would be
       # very careful if I used this.
       def use(db_name)
@@ -87,7 +84,7 @@ module Sequel
           if related = op.delete(:table)
             sql = super(table, op)
             op[:table] = related
-            [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{default_column_references_sql(op)}"]
+            [sql, "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"]
           else
             super(table, op)
           end
@@ -98,8 +95,8 @@ module Sequel
           name = o == :rename_column ? op[:new_name] : op[:name]
           type = o == :set_column_type ? op[:type] : old_opts[:db_type]
           null = o == :set_column_null ? op[:null] : old_opts[:allow_null]
-          default = o == :set_column_default ? op[:default] : (old_opts[:default].lit if old_opts[:default])
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(:name=>name, :type=>type, :null=>null, :default=>default)}"
+          default = o == :set_column_default ? op[:default] : old_opts[:ruby_default]
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(:name=>name, :type=>type, :null=>null, :default=>default))}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
@@ -119,9 +116,9 @@ module Sequel
         super
       end
       
-      # Handle MySQL specific syntax for column references
-      def column_references_sql(column)
-        "#{", FOREIGN KEY (#{quote_identifier(column[:name])})" unless column[:type] == :check}#{super(column)}"
+      # MySQL doesn't handle references as column constraints, it must use a separate table constraint
+      def column_references_column_constraint_sql(column)
+        "#{", FOREIGN KEY (#{quote_identifier(column[:name])})" unless column[:type] == :check}#{column_references_sql(column)}"
       end
       
       # Use MySQL specific syntax for engine type and character encoding
@@ -199,12 +196,11 @@ module Sequel
   
     # Dataset methods shared by datasets that use MySQL databases.
     module DatasetMethods
-      include Dataset::UnsupportedIntersectExcept
-
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
       COMMA_SEPARATOR = ', '.freeze
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -231,12 +227,6 @@ module Sequel
         sql
       end
 
-      # MySQL doesn't support DISTINCT ON
-      def distinct(*columns)
-        raise(Error, "DISTINCT ON not supported by MySQL") unless columns.empty?
-        super
-      end
-
       # Adds full text filter
       def full_text_search(cols, terms, opts = {})
         filter(full_text_sql(cols, terms, opts))
@@ -313,15 +303,11 @@ module Sequel
       def on_duplicate_key_update(*args)
         clone(:on_duplicate_key_update => args)
       end
-      
+
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
-        if update_cols = opts[:on_duplicate_key_update]
-          update_cols = columns if update_cols.empty?
-          update_string = update_cols.map{|c| "#{quote_identifier(c)}=VALUES(#{quote_identifier(c)})"}.join(COMMA_SEPARATOR)
-        end
         values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{" ON DUPLICATE KEY UPDATE #{update_string}" if update_string}"]
+        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{insert_sql_suffix}"]
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
@@ -365,6 +351,16 @@ module Sequel
         end
       end
       
+      #  does not support DISTINCT ON
+      def supports_distinct_on?
+        false
+      end
+
+      # MySQL does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
       def update_sql(values)
         sql = super
@@ -380,6 +376,11 @@ module Sequel
         "INSERT #{'IGNORE ' if opts[:insert_ignore]}INTO "
       end
 
+      # MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
+      def insert_sql_suffix
+        on_duplicate_key_update_sql if opts[:on_duplicate_key_update]
+      end
+
       # MySQL doesn't use the SQL standard DEFAULT VALUES.
       def insert_default_values_sql
         "#{insert_sql_base}#{source_list(@opts[:from])} () VALUES ()"
@@ -404,6 +405,30 @@ module Sequel
       def literal_true
         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
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
     end
   end
 end

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

@@ -1,5 +1,3 @@
-Sequel.require %w'date_format unsupported', 'adapters/utils'
-
 module Sequel
   module Oracle
     module DatabaseMethods
@@ -96,16 +94,7 @@ module Sequel
     end
     
     module DatasetMethods
-      include Dataset::UnsupportedIntersectExceptAll
-      include Dataset::SQLStandardDateFormat
-
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
-
-      # Oracle doesn't support DISTINCT ON
-      def distinct(*columns)
-        raise(Error, "DISTINCT ON not supported by Oracle") unless columns.empty?
-        super
-      end
+      SELECT_CLAUSE_ORDER = %w'with distinct columns from join where group having compounds order limit'.freeze
 
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, all = false)
@@ -117,6 +106,26 @@ module Sequel
         db[:dual].where(exists).get(1) == nil
       end
 
+      # Oracle requires SQL standard datetimes
+      def requires_sql_standard_datetimes?
+        true
+      end
+
+      # Oracle does not support DISTINCT ON
+      def supports_distinct_on?
+        false
+      end
+
+      # Oracle does not support INTERSECT ALL or EXCEPT ALL
+      def supports_intersect_except_all?
+        false
+      end
+      
+      # Oracle supports window functions
+      def supports_window_functions?
+        true
+      end
+
       private
 
       # Oracle doesn't support the use of AS when aliasing a dataset.  It doesn't require

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

@@ -1,5 +1,3 @@
-Sequel.require 'adapters/utils/savepoint_transactions'
-
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
   # for Sequel.  There are a few module level accessors that are added via
@@ -165,13 +163,8 @@ module Sequel
     
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
-      include Sequel::Database::SavepointTransactions
-      
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
-      SQL_BEGIN = 'BEGIN'.freeze
-      SQL_COMMIT = 'COMMIT'.freeze
-      SQL_ROLLBACK = 'ROLLBACK'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
 
       # Creates the function in the database.  Arguments:
@@ -277,16 +270,20 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         schema, table = schema_and_table(table)
+        range = 0...32
+        attnums = server_version >= 80100 ? SQL::Function.new(:ANY, :ind__indkey) : range.map{|x| SQL::Subscript.new(:ind__indkey, [x])}
         ds = metadata_dataset.
           from(:pg_class___tab).
           join(:pg_index___ind, :indrelid=>:oid, im.call(table)=>:relname).
           join(:pg_class___indc, :oid=>:indexrelid).
-          join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>SQL::Function.new(:ANY, :ind__indkey)).
-          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true, :indisready=>true, :indcheckxmin=>false).
-          order(:indc__relname, (0...32).map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
+          join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
+          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil).
+          order(:indc__relname, range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
           select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
         
-        ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema) if schema
+        ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema.to_s) if schema
+        ds.filter!(:indisvalid=>true) if server_version >= 80200
+        ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
         
         indexes = {}
         ds.each do |r|
@@ -346,12 +343,17 @@ module Sequel
           (conn.server_version rescue nil) if conn.respond_to?(:server_version)
         end
         unless @server_version
-          m = /PostgreSQL (\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
+          m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
           @server_version = (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
         end
         @server_version
       end
       
+      # PostgreSQL supports savepoints
+      def supports_savepoints?
+        true
+      end
+
       # Whether the given table exists in the database
       #
       # Options:
@@ -451,7 +453,11 @@ module Sequel
       def index_definition_sql(table_name, index)
         cols = index[:columns]
         index_name = index[:name] || default_index_name(table_name, cols)
-        expr = literal(Array(cols))
+        expr = if o = index[:opclass] 
+          "(#{Array(cols).map{|c| "#{literal(c)} #{o}"}.join(', ')})"
+        else
+          literal(Array(cols))
+        end
         unique = "UNIQUE " if index[:unique]
         index_type = index[:type]
         filter = index[:where] || index[:filter]
@@ -582,9 +588,11 @@ module Sequel
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
       SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit lock'.freeze
+      SELECT_CLAUSE_ORDER_84 = %w'with distinct columns from join where group having window compounds order limit lock'.freeze
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
+      SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
       
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
@@ -611,12 +619,8 @@ module Sequel
       end
 
       # Return the results of an ANALYZE query as a string
-      def analyze(opts = nil)
-        analysis = []
-        fetch_rows(EXPLAIN_ANALYZE + select_sql(opts)) do |r|
-          analysis << r[QUERY_PLAN]
-        end
-        analysis.join("\r\n")
+      def analyze
+        explain(:analyze=>true)
       end
       
       # Disable the use of INSERT RETURNING, even if the server supports it
@@ -625,12 +629,8 @@ module Sequel
       end
 
       # Return the results of an EXPLAIN query as a string
-      def explain(opts = nil)
-        analysis = []
-        fetch_rows(EXPLAIN + select_sql(opts)) do |r|
-          analysis << r[QUERY_PLAN]
-        end
-        analysis.join("\r\n")
+      def explain(opts={})
+        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join("\r\n")
       end
       
       # Return a cloned dataset with a :share lock type.
@@ -693,6 +693,16 @@ module Sequel
         ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
       end
       
+      # PostgreSQL 8.4+ supports window functions
+      def supports_window_functions?
+        server_version >= 80400
+      end
+
+      # Return a clone of the dataset with an addition named window that can be referenced in window functions.
+      def window(name, opts)
+        clone(:window=>(@opts[:windows]||[]) + [[name, SQL::Window.new(opts)]])
+      end
+      
       private
       
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
@@ -733,7 +743,12 @@ module Sequel
 
       # The order of clauses in the SELECT SQL statement
       def select_clause_order
-        SELECT_CLAUSE_ORDER
+        server_version >= 80400 ? SELECT_CLAUSE_ORDER_84 : SELECT_CLAUSE_ORDER
+      end
+
+      # SQL fragment for named window specifications
+      def select_window_sql(sql)
+        sql << " WINDOW #{@opts[:window].map{|name, window| "#{literal(name)} AS #{literal(window)}"}.join(', ')}" if @opts[:window]
       end
 
       # Support lock mode, allowing FOR SHARE and FOR UPDATE queries.
@@ -746,6 +761,11 @@ module Sequel
         end
       end
       
+      # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
+      def select_with_sql_base
+        opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
+      end
+      
       # The version of the database server
       def server_version
         db.server_version(@opts[:server])

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

@@ -1,5 +1,3 @@
-Sequel.require %w'date_format unsupported', 'adapters/utils'
-
 module Sequel
   module Progress
     module DatabaseMethods
@@ -17,11 +15,18 @@ module Sequel
     end
   
     module DatasetMethods
-      include Dataset::UnsupportedIntersectExcept
-      include Dataset::SQLStandardDateFormat
-
       SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having compounds'.freeze
 
+      # Progress requires SQL standard datetimes
+      def requires_sql_standard_datetimes?
+        true
+      end
+
+      # Progress does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
       private
 
       def select_clause_order

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

@@ -1,10 +1,6 @@
-Sequel.require %w'savepoint_transactions unsupported', 'adapters/utils'
-
 module Sequel
   module SQLite
     module DatabaseMethods
-      include Sequel::Database::SavepointTransactions
-
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
@@ -67,6 +63,11 @@ module Sequel
         execute_ddl("PRAGMA #{name} = #{value}")
       end
       
+      # SQLite supports savepoints
+      def supports_savepoints?
+        true
+      end
+
       # A symbol signifying the value of the synchronous PRAGMA.
       def synchronous
         SYNCHRONOUS[pragma_get(:synchronous).to_i]
@@ -233,9 +234,8 @@ module Sequel
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
-      include Dataset::UnsupportedIntersectExceptAll
-      include Dataset::UnsupportedIsTrue
-
+      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+    
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
       # ILIKE.
@@ -277,19 +277,35 @@ module Sequel
         "`#{c}`"
       end
       
-      private
+      # SQLite does not support INTERSECT ALL or EXCEPT ALL
+      def supports_intersect_except_all?
+        false
+      end
 
-      def literal_blob(v)
-        blob = ''
-        v.each_byte{|x| blob << sprintf('%02x', x)}
-        "X'#{blob}'"
+      # SQLite does not support IS TRUE
+      def supports_is_true?
+        false
       end
+
+      private
       
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql(expression, aliaz)
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
+      
+      # SQLite uses a preceding X for hex escaping strings
+      def literal_blob(v)
+        blob = ''
+        v.each_byte{|x| blob << sprintf('%02x', x)}
+        "X'#{blob}'"
+      end
+      
+      # SQLite does not support the SQL WITH clause
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
     end
   end
 end