sequel 3.30.0 → 3.31.0

data/lib/sequel/dataset/sql.rb

@@ -20,7 +20,7 @@ module Sequel
     #   DB.select(1).where(DB[:items].exists)
     #   # SELECT 1 WHERE (EXISTS (SELECT * FROM items))
     def exists
-      LiteralString.new("EXISTS (#{select_sql})")
+      SQL::PlaceholderLiteralString.new("EXISTS ?", [self], true)
     end
     
     # Returns an INSERT SQL query string.  See +insert+.
@@ -1196,7 +1196,12 @@ module Sequel
     def select_group_sql(sql)
       if group = @opts[:group]
         sql << GROUP_BY
+        if go = @opts[:group_options]
+          sql << go.to_s.upcase
+          sql << PAREN_OPEN
+        end
         expression_list_append(sql, group)
+        sql << PAREN_CLOSE if go
       end
     end
 

data/lib/sequel/model/associations.rb

@@ -761,6 +761,10 @@ module Sequel
         # :key :: foreign key in current model's table that references
         #         associated model's primary key, as a symbol.  Defaults to :"#{name}_id".  Can use an
         #         array of symbols for a composite key association.
+        # :key_column :: Similar to, and usually identical to, :key, but :key refers to the model method
+        #                to call, where :key_column refers to the underlying column.  Should only be
+        #                used if the association has the same name as the foreign key column, in conjunction
+        #                with defining a model alias method for the key column.
         # :primary_key :: column in the associated table that :key option references, as a symbol.
         #                 Defaults to the primary key of the associated table. Can use an
         #                 array of symbols for a composite key association.
@@ -1121,8 +1125,13 @@ module Sequel
           name = opts[:name]
           model = self
           opts[:key] = opts.default_key unless opts.include?(:key)
-          key = opts[:key]
-          cks = opts[:keys] = Array(opts[:key])
+          key_column = key = opts[:key]
+          cks = opts[:graph_keys] = opts[:keys] = Array(key)
+          if opts[:key_column]
+            key_column = opts[:key_column]
+            opts[:eager_loader_key] ||= key_column
+            opts[:graph_keys] = Array(key_column)
+          end
           opts[:qualified_key] = opts.qualify_cur(key)
           if opts[:primary_key]
             cpks = Array(opts[:primary_key])
@@ -1136,7 +1145,7 @@ module Sequel
             klass.filter(Array(opts.qualified_primary_key).zip(cks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][key]
+            h = eo[:key_hash][key_column]
             keys = h.keys
             # Default the cached association to nil, so any object that doesn't have it
             # populated will have cached the negative lookup.
@@ -1158,9 +1167,10 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           conditions = opts[:graph_conditions]
           graph_block = opts[:graph_block]
+          graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
           end
       
           def_association_dataset_methods(opts)

data/lib/sequel/model/base.rb

@@ -234,6 +234,16 @@ module Sequel
         @db_schema ||= get_db_schema
       end
   
+      # Create a column alias, where the column methods have one name, but the underlying storage uses a
+      # different name.
+      def def_column_alias(meth, column)
+        clear_setter_methods_cache
+        overridable_methods_module.module_eval do
+          define_method(meth){self[column]}
+          define_method("#{meth}="){|v| self[column] = v}
+        end
+      end
+  
       # If a block is given, define a method on the dataset (if the model currently has an dataset)  with the given argument name using
       # the given block.  Also define a class method on the model that calls the
       # dataset method.  Stores the method name and block so that it can be reapplied if the model's

data/lib/sequel/plugins/serialization.rb

@@ -11,8 +11,17 @@ module Sequel
     # set the @deserialized_values entry.  This plugin adds a before_save hook
     # that serializes all @deserialized_values to @values.
     #
-    # You can use either marshal, yaml, or json as the serialization format.
-    # If you use yaml or json, you should require them by yourself.
+    # You can specify the serialization format as a pair of serializer/deserializer
+    # callable objects.  You can also specify the serialization format as a single
+    # symbol, if such a symbol has a registered serializer/deserializer pair in the
+    # plugin.  By default, the plugin registers the :marshal, :yaml, and :json
+    # serialization formats.  To register your own serialization formats, use
+    # Sequel::Plugins::Serialization.register_format.
+    # If you use yaml or json format, you need to require the libraries, Sequel
+    # does not do the requiring for you.
+    #
+    # You can specify the columns to serialize when loading the plugin, or later
+    # using the serialize_attributes class method.
     #
     # Because of how this plugin works, it must be used inside each model class
     # that needs serialization, after any set_dataset method calls in that class.
@@ -22,56 +31,96 @@ module Sequel
     # == Example
     #
     #   require 'sequel'
+    #   # Require json, as the plugin doesn't require it for you.
     #   require 'json'
+    #
+    #   # Register custom serializer/deserializer pair
+    #   Sequel::Plugins::Serialization.register_format(:reverse,
+    #     lambda{|v| v.reverse},
+    #     lambda{|v| v.reverse})
+    #
     #   class User < Sequel::Model
+    #     # Built-in format support when loading the plugin
     #     plugin :serialization, :json, :permissions
-    #     # or
+    #
+    #     # Built-in format support after loading the plugin using serialize_attributes
     #     plugin :serialization
-    #     serialize_attributes :marshal, :permissions, :attributes
+    #     serialize_attributes :marshal, :permissions
+    #
+    #     # Use custom registered serialization format just like built-in format
+    #     serialize_attributes :reverse, :password
+    #
+    #     # Use a custom serializer/deserializer pair without registering
+    #     serialize_attributes [lambda{|v| v.reverse}, lambda{|v| v.reverse}], :password
     #   end
     #   user = User.create
     #   user.permissions = { :global => 'read-only' }
     #   user.save
     module Serialization
+      # The default serializers supported by the serialization module.
+      # Use register_format to add serializers to this hash.
+      REGISTERED_FORMATS = {}
+
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.apply(model, *args)
-        model.instance_eval{@serialization_map = {}}
+        model.instance_eval do
+          @deserialization_map = {}
+          @serialization_map = {}
+        end
       end
       
+      # Automatically call serialize_attributes with the format and columns unless
+      # no columns were provided.
       def self.configure(model, format=nil, *columns)
         model.serialize_attributes(format, *columns) unless columns.empty?
       end
 
+      # Register a serializer/deserializer pair with a format symbol, to allow
+      # models to pick this format by name.  Both serializer and deserializer
+      # should be callable objects.
+      def self.register_format(format, serializer, deserializer)
+        REGISTERED_FORMATS[format] = [serializer, deserializer]
+      end
+      register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')}, lambda{|v| Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)})
+      register_format(:yaml, lambda{|v| v.to_yaml}, lambda{|v| YAML.load(v)})
+      register_format(:json, lambda{|v| v.to_json}, lambda{|v| JSON.parse(v)})
+
       module ClassMethods
-        # A map of the serialized columns for this model.  Keys are column
-        # symbols, values are serialization formats (:marshal, :yaml, or :json).
+        # A hash with column name symbols and callable values, with the value
+        # called to deserialize the column.
+        attr_reader :deserialization_map
+
+        # A hash with column name symbols and callable values, with the value
+        # called to serialize the column.
         attr_reader :serialization_map
 
         # Module to store the serialized column accessor methods, so they can
         # call be overridden and call super to get the serialization behavior
         attr_accessor :serialization_module
 
-        # Copy the serialization format and columns to serialize into the subclass.
+        # Copy the serialization_map and deserialization map into the subclass.
         def inherited(subclass)
           super
           sm = serialization_map.dup
-          subclass.instance_eval{@serialization_map = sm}
-        end
-        
-        # The first value in the serialization map.  This is only for
-        # backwards compatibility, use serialization_map in new code.
-        def serialization_format
-          serialization_map.values.first
+          dsm = deserialization_map.dup
+          subclass.instance_eval do
+            @deserialization_map = dsm
+            @serialization_map = sm
+          end
         end
         
         # Create instance level reader that deserializes column values on request,
-        # and instance level writer that stores new deserialized value in deserialized
-        # columns
+        # and instance level writer that stores new deserialized values.
         def serialize_attributes(format, *columns)
-          raise(Error, "Unsupported serialization format (#{format}), should be :marshal, :yaml, or :json") unless [:marshal, :yaml, :json].include?(format)
+          if format.is_a?(Symbol)
+            unless format = REGISTERED_FORMATS[format]
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map{|k| k.inspect}.join})")
+            end
+          end
+          serializer, deserializer = format
           raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
-          define_serialized_attribute_accessor(format, *columns)
+          define_serialized_attribute_accessor(serializer, deserializer, *columns)
         end
         
         # The columns that will be serialized.  This is only for
@@ -83,12 +132,13 @@ module Sequel
         private
 
         # Add serializated attribute acessor methods to the serialization_module
-        def define_serialized_attribute_accessor(format, *columns)
+        def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
           include(self.serialization_module ||= Module.new) unless serialization_module
           serialization_module.class_eval do
             columns.each do |column|
-              m.serialization_map[column] = format
+              m.serialization_map[column] = serializer
+              m.deserialization_map[column] = deserializer
               define_method(column) do 
                 if deserialized_values.has_key?(column)
                   deserialized_values[column]
@@ -127,6 +177,7 @@ module Sequel
           super
         end
 
+        # Initialization the deserialized values for objects retrieved from the database.
         def set_values(*)
           @deserialized_values ||= {}
           super
@@ -134,33 +185,21 @@ module Sequel
 
         private
 
-        # Deserialize the column from either marshal or yaml format
+        # Deserialize the column value.  Called when the model column accessor is called to
+        # return a deserialized value.
         def deserialize_value(column, v)
-          return v if v.nil?
-          case model.serialization_map[column] 
-          when :marshal
-            Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)
-          when :yaml
-            YAML.load v if v
-          when :json
-            JSON.parse v if v
-          else
-            raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
+          unless v.nil?
+            raise Sequel::Error, "no entry in deserialization_map for #{column.inspect}" unless callable = model.deserialization_map[column]
+            callable.call(v)
           end
         end
 
-        # Serialize the column to either marshal or yaml format
+        # Serialize the column value.  Called before saving to ensure the serialized value
+        # is saved in the database.
         def serialize_value(column, v)
-          return v if v.nil?
-          case model.serialization_map[column] 
-          when :marshal
-            [Marshal.dump(v)].pack('m')
-          when :yaml
-            v.to_yaml
-          when :json
-            v.to_json
-          else
-            raise Error, "Bad serialization format (#{model.serialization_map[column].inspect}) for column #{column.inspect}"
+          unless v.nil?
+            raise Sequel::Error, "no entry in serialization_map for #{column.inspect}" unless callable = model.serialization_map[column]
+            callable.call(v)
           end
         end
       end

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 30
+  MINOR = 31
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -60,6 +60,35 @@ describe "A MSSQL database" do
   end
 end
 
+# This spec is currently disabled as the SQL Server 2008 R2 Express doesn't support
+# full text searching.  Even if full text searching is supported,
+# you may need to create a full text catalog on the database first via:
+#   CREATE FULLTEXT CATALOG ftscd AS DEFAULT
+describe "MSSQL full_text_search" do
+  before do
+    @db = MSSQL_DB
+    @db.drop_table(:posts) rescue nil
+  end
+  after do
+    @db.drop_table(:posts) rescue nil
+  end
+  
+  specify "should support fulltext indexes and full_text_search" do
+    log do
+    @db.create_table(:posts){Integer :id, :null=>false; String :title; String :body; index :id, :name=>:fts_id_idx, :unique=>true; full_text_index :title, :key_index=>:fts_id_idx; full_text_index [:title, :body], :key_index=>:fts_id_idx}
+    @db[:posts].insert(:title=>'ruby rails', :body=>'y')
+    @db[:posts].insert(:title=>'sequel', :body=>'ruby')
+    @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
+
+    @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'y'}]
+    @db[:posts].full_text_search([:title, :body], ['sequel', 'ruby']).all.should == [{:title=>'sequel', :body=>'ruby'}]
+
+    @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+    @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+    end
+  end
+end if false
+
 describe "MSSQL Dataset#join_table" do
   specify "should emulate the USING clause with ON" do
     MSSQL_DB[:items].join(:categories, [:id]).sql.should ==
@@ -219,6 +248,23 @@ describe "MSSQL dataset" do
   end
 end
 
+describe "MSSQL::Dataset#import" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table!(:test){primary_key :x; Integer :y}
+    @db.sqls.clear
+    @ds = @db[:test]
+  end
+  after do
+    @db.drop_table(:test) rescue nil
+  end
+  
+  specify "#import should work correctly with an arbitrary output value" do
+    @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).should == [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
+    @ds.all.should == [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
+  end
+end
+
 describe "MSSQL joined datasets" do
   before do
     @db = MSSQL_DB

data/spec/adapters/mysql_spec.rb

@@ -645,6 +645,9 @@ describe "A MySQL database" do
       "SELECT * FROM `posts` WHERE (MATCH (`title`) AGAINST ('rails'))",
       "SELECT * FROM `posts` WHERE (MATCH (`title`, `body`) AGAINST ('sequel ruby'))",
       "SELECT * FROM `posts` WHERE (MATCH (`title`) AGAINST ('+ruby -rails' IN BOOLEAN MODE))"]
+
+    @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
+    @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'y'}]
   end
 
   specify "should support spatial indexes" do

data/spec/adapters/postgres_spec.rb

@@ -380,6 +380,9 @@ describe "A PostgreSQL database" do
       %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", ''))) @@ to_tsquery('simple', 'rails'))},
       %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple', 'yowsa | rails'))},
       %{SELECT * FROM "posts" WHERE (to_tsvector('french', (COALESCE("title", ''))) @@ to_tsquery('french', 'scooby'))}]
+
+    @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
+    @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
   end
 
   specify "should support spatial indexes" do
@@ -431,7 +434,7 @@ end
 describe "Postgres::Dataset#import" do
   before do
     @db = POSTGRES_DB
-    @db.create_table!(:test){Integer :x; Integer :y}
+    @db.create_table!(:test){primary_key :x; Integer :y}
     @db.sqls.clear
     @ds = @db[:test]
   end
@@ -441,28 +444,45 @@ describe "Postgres::Dataset#import" do
   
   specify "#import should return separate insert statements if server_version < 80200" do
     @ds.meta_def(:server_version){80199}
-    
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    
-    @db.sqls.should == [
-      'BEGIN',
-      'INSERT INTO "test" ("x", "y") VALUES (1, 2)',
-      'INSERT INTO "test" ("x", "y") VALUES (3, 4)',
-      'COMMIT'
-    ]
+    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2)', 'INSERT INTO "test" ("x", "y") VALUES (3, 4)', 'COMMIT']
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
   
   specify "#import should a single insert statement if server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
-    
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    
-    @db.sqls.should == [
-      'BEGIN',
-      'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)',
-      'COMMIT'
-    ]
+    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys for server_version < 80200" do
+    @ds.meta_def(:server_version){80199}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys for server_version >= 80200" do
+    @ds.meta_def(:server_version){80200}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys with :slice option for server_version < 80200" do
+    @ds.meta_def(:server_version){80199}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys with :slice option for server_version >= 80200" do
+    @ds.meta_def(:server_version){80200}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly with an arbitrary returning value" do
+    @ds.meta_def(:server_version){80200}
+    @ds.returning(:y, :x).import([:x, :y], [[1, 2], [3, 4]]).should == [{:y=>2, :x=>1}, {:y=>4, :x=>3}]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 end
@@ -500,21 +520,26 @@ describe "Postgres::Dataset#insert" do
     @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}, {:xid=>3, :value=>13}]
   end
   
-  specify "should call execute_insert if server_version < 80200" do
+  specify "should insert correctly if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
-    @ds.should_receive(:execute_insert).once.with('INSERT INTO "test5" ("value") VALUES (10)', :table=>:test5, :values=>{:value=>10})
-    @ds.insert(:value=>10)
+    @ds.insert(:value=>10).should == 1
+    @ds.all.should == [{:xid=>1, :value=>10}]
   end
 
-  specify "should call execute_insert if disabling insert returning" do
-    @ds.disable_insert_returning!
-    @ds.should_receive(:execute_insert).once.with('INSERT INTO "test5" ("value") VALUES (10)', :table=>:test5, :values=>{:value=>10})
-    @ds.insert(:value=>10)
+  specify "should insert correctly if disabling insert returning" do
+    @ds.disable_insert_returning.insert(:value=>10).should == 1
+    @ds.all.should == [{:xid=>1, :value=>10}]
+  end
+
+  specify "should insert correctly if using a column array and a value array and server_version < 80200" do
+    @ds.meta_def(:server_version){80100}
+    @ds.insert([:value], [10]).should == 1
+    @ds.all.should == [{:xid=>1, :value=>10}]
   end
 
   specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
-    @ds.insert(:value=>10)
+    @ds.insert(:value=>10).should == 1
     @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"'
   end
 
@@ -605,6 +630,18 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.drop_table(:domains)
   end
   
+  specify "#schema should raise an exception if columns from tables in two separate schema are returned" do
+    POSTGRES_DB.create_table!(:public__domains){integer :d}
+    POSTGRES_DB.create_table(:schema_test__domains){integer :i}
+    begin
+      proc{POSTGRES_DB.schema(:domains)}.should raise_error(Sequel::Error)
+      POSTGRES_DB.schema(:public__domains).map{|x| x.first}.should == [:d]
+      POSTGRES_DB.schema(:schema_test__domains).map{|x| x.first}.should == [:i]
+    ensure
+      POSTGRES_DB.drop_table(:public__domains)
+    end
+  end
+  
   specify "#table_exists? should see if the table is in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true