sequel 3.1.0 → 3.2.0

data/lib/sequel/extensions/schema_dumper.rb

@@ -6,10 +6,6 @@
 
 module Sequel
   class Database
-    POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
-    MYSQL_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
-    STRING_DEFAULT_RE = /\A'(.*)'\z/
-    
     # Dump indexes for all tables as a migration.  This complements
     # the :indexes=>false option to dump_schema_migration. Options:
     # * :same_db - Create a dump for the same database type, so
@@ -72,65 +68,12 @@ END_MIG
     end
 
     private
-    
-    # Convert the given default, which should be a database specific string, into
-    # a ruby object.
-    def column_schema_to_ruby_default(default, type, options)
-      return if default.nil?
-      orig_default = default
-      if database_type == :postgres and m = POSTGRES_DEFAULT_RE.match(default)
-        default = m[1] || m[2]
-      end
-      if [:string, :blob, :date, :datetime, :time].include?(type)
-        if database_type == :mysql
-          if [:date, :datetime, :time].include?(type) && MYSQL_TIMESTAMP_RE.match(default)
-            return column_schema_to_ruby_default_fallback(default, options)
-          end
-          orig_default = default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'" 
-        end
-        if m = STRING_DEFAULT_RE.match(default)
-          default = m[1].gsub("''", "'")
-        else
-          return column_schema_to_ruby_default_fallback(default, options)
-        end
-      end
-      res = begin
-        case type
-        when :boolean
-          case default 
-          when /[f0]/i
-            false
-          when /[t1]/i
-            true
-          end
-        when :string
-          default
-        when :blob
-          Sequel::SQL::Blob.new(default)
-        when :integer
-          Integer(default)
-        when :float
-          Float(default)
-        when :date
-          Sequel.string_to_date(default)
-        when :datetime
-          DateTime.parse(default)
-        when :time
-          Sequel.string_to_time(default)
-        when :decimal
-          BigDecimal.new(default)
-        end
-      rescue
-        nil
-      end
-      res.nil? ? column_schema_to_ruby_default_fallback(orig_default, options) : res
-    end
         
-    # If the database default can't be converted, return the string with the inspect
+    # If a database default exists and can't be converted, return the string with the inspect
     # method modified so that .lit is always appended after it, only if the
     # :same_db option is used.
     def column_schema_to_ruby_default_fallback(default, options)
-      if options[:same_db]
+      if options[:same_db] && default.is_a?(String)
         default = default.to_s
         def default.inspect
           "#{super}.lit"
@@ -148,8 +91,12 @@ END_MIG
         col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
-        default = column_schema_to_ruby_default(schema[:default], schema[:type], options) if schema[:default]
-        col_opts[:default] = default unless default.nil?
+        col_opts[:default] = if schema[:ruby_default].nil?
+          column_schema_to_ruby_default_fallback(schema[:default], options)
+        else
+          schema[:ruby_default]
+        end
+        col_opts.delete(:default) if col_opts[:default].nil?
         col_opts[:null] = false if schema[:allow_null] == false
         [:column, name, type, col_opts]
       end

data/lib/sequel/model.rb

@@ -40,13 +40,13 @@ module Sequel
     # Class methods added to model that call the method of the same name on the dataset
     DATASET_METHODS = %w'<< all avg count delete distinct eager eager_graph
        each each_page empty? except exclude filter first from from_self
-       full_outer_join get graph group group_and_count group_by having import
+       full_outer_join get graph grep group group_and_count group_by having import
        inner_join insert insert_multiple intersect interval join join_table
        last left_outer_join limit map multi_insert naked order order_by
-       order_more paginate print query range reverse_order right_outer_join
+       order_more paginate print qualify query range reverse_order right_outer_join
        select select_all select_more server set set_graph_aliases 
        single_value to_csv to_hash union unfiltered unordered 
-       update where with_sql'.map{|x| x.to_sym}
+       update where with with_sql'.map{|x| x.to_sym}
   
     # Class instance variables to set to nil when a subclass is created, for -w compliance
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]

data/lib/sequel/model/associations.rb

@@ -1104,6 +1104,14 @@ module Sequel
           ds.eager_graph_associations(ds, model, table_name, [], *associations)
         end
         
+        # Do not attempt to split the result set into associations,
+        # just return results as simple objects.  This is useful if you
+        # want to use eager_graph as a shortcut to have all of the joins
+        # and aliasing set up, but want to do something else with the dataset.
+        def ungraphed
+          super.clone(:eager_graph=>nil)
+        end
+      
         protected
       
         # Call graph on the association with the correct arguments,
@@ -1240,7 +1248,7 @@ module Sequel
           end
           table_alias
         end
-      
+
         private
       
         # Make sure the association is valid for this model, and return the related AssociationReflection.

data/lib/sequel/model/base.rb

@@ -563,6 +563,13 @@ module Sequel
       def associations
         @associations ||= {}
       end
+
+      # The autoincrementing primary key for this model object. Should be
+      # overridden if you have a composite primary key with one part of it
+      # being autoincrementing.
+      def autoincrementing_primary_key
+        primary_key
+      end
   
       # The columns that have been updated.  This isn't completely accurate,
       # see Model#[]=.
@@ -794,7 +801,7 @@ module Sequel
             iid = ds.insert(@values)
             # if we have a regular primary key and it's not set in @values,
             # we assume it's the last inserted id
-            if (pk = primary_key) && !(Array === pk) && !@values[pk]
+            if (pk = autoincrementing_primary_key) && pk.is_a?(Symbol) && !@values[pk]
               @values[pk] = iid
             end
             @this = nil if pk

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -55,7 +55,7 @@ module Sequel
         # Set the sti_key column to the name of the model.
         def before_create
           return false if super == false
-          send("#{model.sti_key}=", model.name.to_s)
+          send("#{model.sti_key}=", model.name.to_s) unless send(model.sti_key)
         end
       end
     end

data/lib/sequel/sql.rb

@@ -1,8 +1,12 @@
 module Sequel
+  class LiteralString < ::String
+  end
+
   # The SQL module holds classes whose instances represent SQL fragments.
   # It also holds modules that are included in core ruby classes that
   # make Sequel a friendly DSL.
   module SQL
+
     ### Parent Classes ###
 
     # Classes/Modules aren't an alphabetical order due to the fact that
@@ -693,6 +697,9 @@ module Sequel
       include StringConcatenationMethods
       include InequalityMethods
       include NoBooleanInputMethods
+
+      # Map of [regexp, case_insenstive] to ComplexExpression operator
+      LIKE_MAP = {[true, true]=>:'~*', [true, false]=>:~, [false, true]=>:ILIKE, [false, false]=>:LIKE}
       
       # Creates a SQL pattern match exprssion. left (l) is the SQL string we
       # are matching against, and ces are the patterns we are matching.
@@ -709,13 +716,27 @@ module Sequel
       # if a case insensitive regular expression is used (//i), that particular
       # pattern which will always be case insensitive.
       def self.like(l, *ces)
-        case_insensitive = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive]
+        l, lre, lci = like_element(l)
+        lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
         ces.collect! do |ce|
-          op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce]
-          BooleanExpression.new(op, l, expr)
+          r, rre, rci = like_element(ce)
+          BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
         end
         ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)
       end
+      
+      # An array of three parts:
+      # * The object to use
+      # * Whether it is a regular expression
+      # * Whether it is case insensitive
+      def self.like_element(re) # :nodoc:
+        if re.is_a?(Regexp)
+          [re.source, true, re.casefold?]
+        else
+          [re, false, false]
+        end
+      end
+      private_class_method :like_element
     end
 
     # Represents an SQL array.  Added so it is possible to deal with a
@@ -769,38 +790,124 @@ module Sequel
     # the methods defined by Sequel, or if you are running on ruby 1.9.
     #
     # An instance of this class is yielded to the block supplied to filter, order, and select.
-    # If Sequel.virtual_row_instance_eval is true and the block doesn't take an argument,
-    # the block is instance_evaled in the context of a new instance of this class.
+    # If the block doesn't take an argument, the block is instance_evaled in the context of
+    # a new instance of this class.
+    #
+    # VirtualRow uses method_missing to return Identifiers, QualifiedIdentifiers, Functions, or WindowFunctions, 
+    # depending on how it is called.  If a block is not given, creates one of the following objects:
+    # * Function - returned if any arguments are supplied, using the method name
+    #   as the function name, and the arguments as the function arguments.
+    # * QualifiedIdentifier - returned if the method name contains __, with the
+    #   table being the part before __, and the column being the part after.
+    # * Identifier - returned otherwise, using the method name.
+    # If a block is given, it returns either a Function or WindowFunction, depending on the first
+    # argument to the method.  Note that the block is currently not called by the code, though
+    # this may change in a future version.  If the first argument is:
+    # * no arguments given - uses a Function with no arguments.
+    # * :* - uses a Function with a literal wildcard argument (*), mostly useful for COUNT.
+    # * :distinct - uses a Function that prepends DISTINCT to the rest of the arguments, mostly
+    #   useful for aggregate functions.
+    # * :over - uses a WindowFunction.  If a second argument is provided, it should be a hash
+    #   of options which are passed to Window (e.g. :window, :partition, :order, :frame).  The
+    #   arguments to the function itself should be specified as :*=>true for a wildcard, or via
+    #   the :args option.
     #
     # Examples:
     #
     #   ds = DB[:t]
+    #   # Argument yielded to block
     #   ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
-    #   ds.filter{|r| r.table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
-    #   ds.filter{|r| r.is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
+    #   # Block without argument (instance_eval)
+    #   ds.filter{name < 2} # SELECT * FROM t WHERE (name < 2)
+    #   # Qualified identifiers
+    #   ds.filter{table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
+    #   # Functions
+    #   ds.filter{is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
+    #   ds.select{version{}} # SELECT version() FROM t
+    #   ds.select{count(:*){}} # SELECT count(*) FROM t
+    #   ds.select{count(:distinct, col1){}} # SELECT count(DISTINCT col1) FROM t
+    #   # Window Functions
+    #   ds.select{rank(:over){}} # SELECT rank() OVER () FROM t
+    #   ds.select{count(:over, :*=>true){}} # SELECT count(*) OVER () FROM t
+    #   ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}} # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM t
     class VirtualRow
-      # Can return Identifiers, QualifiedIdentifiers, or Functions:
-      #
-      # * Function - returned if any arguments are supplied, using the method name
-      #   as the function name, and the arguments as the function arguments.
-      # * QualifiedIdentifier - returned if the method name contains __, with the
-      #   table being the part before __, and the column being the part after.
-      # * Identifier - returned otherwise, using the method name.
-      def method_missing(m, *args)
-        if args.empty?
-          table, column = m.to_s.split('__', 2)
+      WILDCARD = LiteralString.new('*').freeze
+      QUESTION_MARK = LiteralString.new('?').freeze
+      COMMA_SEPARATOR = LiteralString.new(', ').freeze
+      DOUBLE_UNDERSCORE = '__'.freeze
+
+      # Return Identifiers, QualifiedIdentifiers, Functions, or WindowFunctions, depending
+      # on arguments and whether a block is provided.  Does not currently call the block.
+      # See the class level documentation.
+      def method_missing(m, *args, &block)
+        if block
+          if args.empty?
+            Function.new(m)
+          else
+            case arg = args.shift
+            when :*
+              Function.new(m, WILDCARD)
+            when :distinct
+              Function.new(m, PlaceholderLiteralString.new("DISTINCT #{args.map{QUESTION_MARK}.join(COMMA_SEPARATOR)}", args))
+            when :over
+              opts = args.shift || {}
+              fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args])
+              WindowFunction.new(Function.new(m, *fun_args), Window.new(opts))
+            else
+              raise Error, 'unsupported VirtualRow method argument used with block'
+            end
+          end
+        elsif args.empty?
+          table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2)
           column ? QualifiedIdentifier.new(table, column) : Identifier.new(m)
         else
           Function.new(m, *args)
         end
       end
     end
+
+    # A window is part of a window function specifying the window over which the function operates.
+    # It is separated from the WindowFunction class because it also can be used separately on
+    # some databases.
+    class Window < Expression
+      # The options for this window.  Options currently used are:
+      # * :frame - if specified, should be :all or :rows.  :all always operates over all rows in the
+      #   partition, while :rows excludes the current row's later peers.  The default is to include
+      #   all previous rows in the partition up to the current row's last peer.
+      # * :order - order on the column(s) given
+      # * :partition - partition/group on the column(s) given
+      # * :window - base results on a previously specified named window
+      attr_reader :opts
+
+      # Set the options to the options given
+      def initialize(opts={})
+        @opts = opts
+      end
+
+      to_s_method :window_sql, '@opts'
+    end
+
+    # A WindowFunction is a grouping of a function with a window over which it operates.
+    class WindowFunction < Expression
+      # The function to use, should be an SQL::Function.
+      attr_reader :function
+
+      # The window to use, should be an SQL::Window.
+      attr_reader :window
+
+      # Set the function and window.
+      def initialize(function, window)
+        @function, @window = function, window
+      end
+
+      to_s_method :window_function_sql, '@function, @window'
+    end
   end
 
   # LiteralString is used to represent literal SQL expressions. A 
   # LiteralString is copied verbatim into an SQL statement. Instances of
   # LiteralString can be created by calling String#lit.
-  class LiteralString < ::String
+  class LiteralString
     include SQL::OrderMethods
     include SQL::ComplexExpressionMethods
     include SQL::BooleanMethods

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 1
+  MINOR = 2
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/ado_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 unless defined?(ADO_DB)
   ADO_DB = Sequel.ado(:host => 'MY_SQL_SERVER', :database => 'MyDB', :user => 'my_usr', :password => 'my_pwd')
 end
+INTEGRATION_DB = ADO_DB unless defined?(INTEGRATION_DB)
 
 context "An ADO dataset" do
   before(:each) do

data/spec/adapters/firebird_spec.rb

@@ -4,6 +4,7 @@ unless defined?(FIREBIRD_DB)
   FIREBIRD_URL = 'firebird://sysdba:masterkey@localhost/reality_spec' unless defined? FIREBIRD_URL
   FIREBIRD_DB = Sequel.connect(ENV['SEQUEL_FB_SPEC_DB']||FIREBIRD_URL)
 end
+INTEGRATION_DB = FIREBIRD_DB unless defined?(INTEGRATION_DB)
 
 def FIREBIRD_DB.sqls
   (@sqls ||= [])

data/spec/adapters/informix_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 unless defined?(INFORMIX_DB)
   INFORMIX_DB = Sequel.connect('informix://localhost/mydb')
 end
+INTEGRATION_DB = INFORMIX_DB unless defined?(INTEGRATION_DB)
 
 if INFORMIX_DB.table_exists?(:test)
   INFORMIX_DB.drop_table :test

data/spec/adapters/mysql_spec.rb

@@ -10,6 +10,7 @@ end
 unless defined?(MYSQL_SOCKET_FILE)
   MYSQL_SOCKET_FILE = '/tmp/mysql.sock'
 end
+INTEGRATION_DB = MYSQL_DB unless defined?(INTEGRATION_DB)
 
 MYSQL_URI = URI.parse(MYSQL_DB.uri)
 
@@ -78,10 +79,10 @@ context "A MySQL database" do
   end
 
   specify "should correctly parse the schema" do
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}]]
     
     Sequel.convert_tinyint_to_bool = false
-    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :ruby_default=>nil, :db_type=>"tinyint(4)"}]]
   end
   
   specify "should accept and return tinyints as bools or integers when configured to do so" do
@@ -425,11 +426,11 @@ context "A MySQL database" do
   end
   
   specify "should have rename_column support keep existing options" do
-    @db.create_table(:items){Integer :id, :null=>false, :default=>5}
+    @db.create_table(:items){String :id, :null=>false, :default=>'blah'}
     @db.alter_table(:items){rename_column :id, :nid}
-    @db.sqls.should == ["CREATE TABLE items (id integer NOT NULL DEFAULT 5)", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id nid int(11) NOT NULL DEFAULT 5"]
+    @db.sqls.should == ["CREATE TABLE items (id varchar(255) NOT NULL DEFAULT 'blah')", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id nid varchar(255) NOT NULL DEFAULT 'blah'"]
     @db[:items].insert
-    @db[:items].all.should == [{:nid=>5}]
+    @db[:items].all.should == [{:nid=>'blah'}]
     proc{@db[:items].insert(:nid=>nil)}.should raise_error(Sequel::DatabaseError)
   end
   
@@ -635,6 +636,21 @@ context "MySQL::Dataset#insert and related methods" do
     ]
   end
 
+  specify "#on_duplicate_key_update should work with regular inserts" do
+    MYSQL_DB.add_index :items, :name, :unique=>true
+    MYSQL_DB.sqls.clear
+    @d.insert(:name => 'abc', :value => 1)
+    @d.on_duplicate_key_update(:name, :value => 6).insert(:name => 'abc', :value => 1)
+    @d.on_duplicate_key_update(:name, :value => 6).insert(:name => 'def', :value => 2)
+
+    MYSQL_DB.sqls.length.should == 3
+    MYSQL_DB.sqls[0].should =~ /\AINSERT INTO items \((name|value), (name|value)\) VALUES \(('abc'|1), (1|'abc')\)\z/
+    MYSQL_DB.sqls[1].should =~ /\AINSERT INTO items \((name|value), (name|value)\) VALUES \(('abc'|1), (1|'abc')\) ON DUPLICATE KEY UPDATE name=VALUES\(name\), value=6\z/
+    MYSQL_DB.sqls[2].should =~ /\AINSERT INTO items \((name|value), (name|value)\) VALUES \(('def'|2), (2|'def')\) ON DUPLICATE KEY UPDATE name=VALUES\(name\), value=6\z/
+
+    @d.all.should == [{:name => 'abc', :value => 6}, {:name => 'def', :value => 2}]
+  end
+
   specify "#multi_insert should insert multiple records in a single statement" do
     @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
     
@@ -727,11 +743,10 @@ context "MySQL::Dataset#insert and related methods" do
   end
   
   specify "#on_duplicate_key_update should add the ON DUPLICATE KEY UPDATE and ALL columns when no args given" do
-    @d.on_duplicate_key_update.import([:name,:value], 
-      [['abc', 1], ['def',2]]
-    )
+    @d.on_duplicate_key_update.import([:name,:value], [['abc', 1], ['def',2]])
     
     MYSQL_DB.sqls.should == [
+      "SELECT * FROM items LIMIT 1",
       SQL_BEGIN,
       "INSERT INTO items (name, value) VALUES ('abc', 1), ('def', 2) ON DUPLICATE KEY UPDATE name=VALUES(name), value=VALUES(value)",
       SQL_COMMIT