viking-sequel 3.10.0

data/lib/sequel/plugins/association_proxies.rb

@@ -0,0 +1,41 @@
+module Sequel
+  module Plugins
+    # Sequel by default does not use proxies for associations.  The association
+    # method for *_to_many associations returns an array, and the association_dataset
+    # method returns a dataset.  This plugin makes the association method return a proxy
+    # that will load the association and call a method on the association array if sent
+    # an array method, and otherwise send the method to the association's dataset.
+    module AssociationProxies
+      # A proxy for the association.  Calling an array method will load the
+      # associated objects and call the method on the associated object array.
+      # Calling any other method will call that method on the association's dataset.
+      class AssociationProxy < BasicObject
+        # Empty array used to check if an array responds to the given method.
+        ARRAY = []
+
+        # Set the association reflection to use, and whether the association should be
+        # reloaded if an array method is called.
+        def initialize(instance, reflection, reload=nil)
+          @instance = instance
+          @reflection = reflection
+          @reload = reload
+        end
+
+        # Call the method given on the array of associated objects if the method
+        # is an array method, otherwise call the method on the association's dataset.
+        def method_missing(meth, *args, &block)
+          (ARRAY.respond_to?(meth) ? @instance.send(:load_associated_objects, @reflection, @reload) : @instance.send(@reflection.dataset_method)).
+            send(meth, *args, &block)
+        end
+      end
+
+      module ClassMethods
+        # Changes the association method to return a proxy instead of the associated objects
+        # directly.
+        def def_association_method(opts)
+          opts.returns_array? ? association_module_def(opts.association_method){|*r| AssociationProxy.new(self, opts, r[0])} : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/boolean_readers.rb

@@ -0,0 +1,53 @@
+module Sequel
+  module Plugins
+    # The BooleaReaders plugin allows for the creation of attribute? methods
+    # for boolean columns, which provide a nicer API.  By default, the accessors
+    # are created for all columns of type :boolean.  However, you can provide a
+    # block to the plugin to change the criteria used to determine if a
+    # column is boolean:
+    #
+    #   Sequel::Model.plugin(:boolean_readers){|c| db_schema[c][:db_type] =~ /\Atinyint/}
+    #
+    # This may be useful if you are using MySQL and have some tinyint columns
+    # that represent booleans and others that represent integers.  You can turn
+    # the convert_tinyint_to_bool setting off and use the attribute methods for
+    # the integer value and the attribute? methods for the boolean value.
+    module BooleanReaders
+      # Default proc for determining if given column is a boolean, which
+      # just checks that the :type is boolean.
+      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| s = db_schema[c] and s[:type] == :boolean}
+
+      # Add the boolean_attribute? class method to the model, and create
+      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      def self.configure(model, &block)
+        model.meta_def(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+        model.instance_eval{send(:create_boolean_readers) if @dataset}
+      end
+
+      module ClassMethods
+        # Create boolean readers for the class using the columns from the new dataset.
+        def set_dataset(*args)
+          super
+          create_boolean_readers
+          self
+        end
+
+        private
+
+        # Add a attribute? method for the column to a module included in the class.
+        def create_boolean_reader(column)
+          overridable_methods_module.module_eval do
+            define_method("#{column}?"){model.db.typecast_value(:boolean, send(column))}
+          end
+        end
+
+        # Add attribute? methods for all of the boolean attributes for this model.
+        def create_boolean_readers
+          im = instance_methods.collect{|x| x.to_s}
+          cs = columns rescue return
+          cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/caching.rb

@@ -0,0 +1,141 @@
+module Sequel
+  module Plugins
+    # Sequel's built-in caching plugin supports caching to any object that
+    # implements the Ruby-Memcache API (or memcached API with the :ignore_exceptions
+    # option).  You can add caching for any model or for all models via:
+    #
+    #   Model.plugin :caching, store   # Cache all models
+    #   MyModel.plugin :caching, store # Just cache MyModel
+    #
+    # The cache store should implement the Ruby-Memcache API:
+    #
+    #    cache_store.set(key, obj, time) # Associate the obj with the given key
+    #                                    # in the cache for the time (specified
+    #                                    # in seconds).
+    #    cache_store.get(key) => obj     # Returns object set with same key.
+    #    cache_store.get(key2) => nil    # nil returned if there isn't an object
+    #                                    # currently in the cache with that key.
+    #    cache_store.delete(key)         # Remove key from cache
+    #
+    # If the :ignore_exceptions option is true, exceptions raised by cache_store.get
+    # are ignored and nil is returned instead.  The memcached API is to
+    # raise an exception for a missing record, so if you use memcached, you will
+    # want to use this option.
+    #
+    # Note that only Model.[] method calls with a primary key argument are cached
+    # using this plugin.
+    module Caching
+      # Set the cache_store and cache_ttl attributes for the given model.
+      # If the :ttl option is not given, 3600 seconds is the default.
+      def self.configure(model, store, opts={})
+        model.instance_eval do
+          @cache_store = store
+          @cache_ttl = opts[:ttl] || 3600
+          @cache_ignore_exceptions = opts[:ignore_exceptions]
+        end
+      end
+
+      module ClassMethods
+        # If true, ignores exceptions when gettings cached records (the memcached API).
+        attr_reader :cache_ignore_exceptions
+        
+        # The cache store object for the model, which should implement the
+        # Ruby-Memcache (or memcached) API
+        attr_reader :cache_store
+        
+        # The time to live for the cache store, in seconds.
+        attr_reader :cache_ttl
+
+        # Set the time to live for the cache store, in seconds (default is 3600, # so 1 hour).
+        def set_cache_ttl(ttl)
+          @cache_ttl = ttl
+        end
+        
+        # Copy the necessary class instance variables to the subclass.
+        def inherited(subclass)
+          super
+          store = @cache_store
+          ttl = @cache_ttl
+          cache_ignore_exceptions = @cache_ignore_exceptions
+          subclass.instance_eval do
+            @cache_store = store
+            @cache_ttl = ttl
+            @cache_ignore_exceptions = cache_ignore_exceptions
+          end
+        end
+
+        private
+    
+        # Delete the entry with the matching key from the cache
+        def cache_delete(ck)
+          @cache_store.delete(ck)
+          nil
+        end
+        
+        def cache_get(ck)
+          if @cache_ignore_exceptions
+            @cache_store.get(ck) rescue nil
+          else
+            @cache_store.get(ck)
+          end
+        end
+    
+        # Return a key string for the pk
+        def cache_key(pk)
+          "#{self}:#{Array(pk).join(',')}"
+        end
+        
+        # Set the object in the cache_store with the given key for cache_ttl seconds.
+        def cache_set(ck, obj)
+          @cache_store.set(ck, obj, @cache_ttl)
+        end
+        
+        # Check the cache before a database lookup unless a hash is supplied.
+        def primary_key_lookup(pk)
+          ck = cache_key(pk)
+          unless obj = cache_get(ck)
+            if obj = super(pk)
+              cache_set(ck, obj)
+            end
+          end 
+          obj
+        end
+      end
+
+      module InstanceMethods
+        # Remove the object from the cache when updating
+        def before_update
+          return false if super == false
+          cache_delete
+        end
+
+        # Return a key unique to the underlying record for caching, based on the
+        # primary key value(s) for the object.  If the model does not have a primary
+        # key, raise an Error.
+        def cache_key
+          raise(Error, "No primary key is associated with this model") unless key = primary_key
+          pk = case key
+          when Array
+            key.collect{|k| @values[k]}
+          else
+            @values[key] || (raise Error, 'no primary key for this record')
+          end
+          model.send(:cache_key, pk)
+        end
+    
+        # Remove the object from the cache when deleting
+        def delete
+          cache_delete
+          super
+        end
+
+        private
+    
+        # Delete this object from the cache
+        def cache_delete
+          model.send(:cache_delete, cache_key)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -0,0 +1,214 @@
+module Sequel
+  module Plugins
+    # The class_table_inheritance plugin allows you to model inheritance in the
+    # database using a table per model class in the hierarchy, with only columns
+    # unique to that model class (or subclass hierarchy) being stored in the related
+    # table.  For example, with this hierarchy:
+    #
+    #                        Employee
+    #                       /        \ 
+    #                    Staff     Manager
+    #                                 |
+    #                             Executive
+    #
+    # the following database schema may be used (table - columns):
+    #
+    # * employees - id, name, kind
+    # * staff - id, manager_id
+    # * managers - id, num_staff
+    # * executives - id, num_managers
+    #
+    # The class_table_inheritance plugin assumes that the main table
+    # (e.g. employees) has a primary key field (usually autoincrementing),
+    # and all other tables have a foreign key of the same name that points
+    # to the same key in their superclass's table.  For example:
+    #
+    # * employees.id  - primary key, autoincrementing
+    # * staff.id - foreign key referencing employees(id)
+    # * managers.id - foreign key referencing employees(id)
+    # * executives.id - foreign key referencing managers(id)
+    #
+    # When using the class_table_inheritance plugin, subclasses use joined 
+    # datasets:
+    #
+    #   Employee.dataset.sql  # SELECT * FROM employees
+    #   Manager.dataset.sql   # SELECT * FROM employees
+    #                         # INNER JOIN managers USING (id)
+    #   Executive.dataset.sql # SELECT * FROM employees 
+    #                         # INNER JOIN managers USING (id)
+    #                         # INNER JOIN executives USING (id)
+    #
+    # This allows Executive.all to return instances with all attributes
+    # loaded.  The plugin overrides the deleting, inserting, and updating
+    # in the model to work with multiple tables, by handling each table
+    # individually.
+    #
+    # This plugin allows the use of a :key option when loading to mark
+    # a column holding a class name.  This allows methods on the
+    # superclass to return instances of specific subclasses.
+    # This plugin also requires the lazy_attributes plugin and uses it to
+    # return subclass specific attributes that would not be loaded
+    # when calling superclass methods (since those wouldn't join
+    # to the subclass tables).  For example:
+    #
+    #   a = Employee.all # [<#Staff>, <#Manager>, <#Executive>]
+    #   a.first.values # {:id=>1, name=>'S', :kind=>'Staff'}
+    #   a.first.manager_id # Loads the manager_id attribute from the database
+    module ClassTableInheritance
+      # The class_table_inheritance plugin requires the lazy_attributes plugin
+      # to handle lazily-loaded attributes for subclass instances returned
+      # by superclass methods.
+      def self.apply(model, opts={}, &block)
+        model.plugin :lazy_attributes
+      end
+      
+      # Initialize the per-model data structures and set the dataset's row_proc
+      # to check for the :key option column for the type of class when loading objects.
+      # Options:
+      # * :key - The column symbol holding the name of the model class this
+      #   is an instance of.  Necessary if you want to call model methods
+      #   using the superclass, but have them return subclass instances.
+      # * :table_map - Hash with class name symbol keys and table name symbol
+      #   values.  Necessary if the implicit table name for the model class
+      #   does not match the database table name
+      # Example:
+      #   class Employee < Sequel::Model
+      #     plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
+      #   end
+      def self.configure(model, opts={}, &block)
+        model.instance_eval do
+          m = method(:constantize)
+          @cti_base_model = self
+          @cti_key = key = opts[:key] 
+          @cti_tables = [table_name]
+          @cti_columns = {table_name=>columns}
+          @cti_table_map = opts[:table_map] || {}
+          dataset.row_proc = lambda{|r| (m.call(r[key]) rescue model).load(r)}
+        end
+      end
+
+      module ClassMethods
+        # The parent/root/base model for this class table inheritance hierarchy.
+        # This is the only model in the hierarchy that load the
+        # class_table_inheritance plugin.
+        attr_reader :cti_base_model
+        
+        # Hash with table name symbol keys and arrays of column symbol values,
+        # giving the columns to update in each backing database table.
+        attr_reader :cti_columns
+        
+        # The column containing the class name as a string.  Used to
+        # return instances of subclasses when calling the superclass's
+        # load method.
+        attr_reader :cti_key
+        
+        # An array of table symbols that back this model.  The first is
+        # cti_base_model table symbol, and the last is the current model
+        # table symbol.
+        attr_reader :cti_tables
+        
+        # A hash with class name symbol keys and table name symbol values.
+        # Specified with the :table_map option to the plugin, and used if
+        # the implicit naming is incorrect.
+        attr_reader :cti_table_map
+        
+        # Add the appropriate data structures to the subclass.  Does not
+        # allow anonymous subclasses to be created, since they would not
+        # be mappable to a table.
+        def inherited(subclass)
+          cc = cti_columns
+          ck = cti_key
+          ct = cti_tables.dup
+          ctm = cti_table_map.dup
+          cbm = cti_base_model
+          pk = primary_key
+          ds = dataset
+          subclass.instance_eval do
+            raise(Error, "cannot create anonymous subclass for model class using class_table_inheritance") if !(n = name) || n.empty?
+            table = ctm[n.to_sym] || implicit_table_name
+            columns = db.from(table).columns
+            @cti_key = ck 
+            @cti_tables = ct + [table]
+            @cti_columns = cc.merge(table=>columns)
+            @cti_table_map = ctm
+            @cti_base_model = cbm
+            # Need to set dataset and columns before calling super so that
+            # the main column accessor module is included in the class before any
+            # plugin accessor modules (such as the lazy attributes accessor module).
+            set_dataset(ds.join(table, [pk]))
+            set_columns(self.columns)
+          end
+          super
+          subclass.instance_eval do
+            m = method(:constantize)
+            dataset.row_proc = lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+            (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
+            cti_tables.reverse.each do |table|
+              db.schema(table).each{|k,v| db_schema[k] = v}
+            end
+          end
+        end
+        
+        # The primary key in the parent/base/root model, which should have a
+        # foreign key with the same name referencing it in each model subclass.
+        def primary_key
+          return super if self == cti_base_model
+          cti_base_model.primary_key
+        end
+        
+        # The table name for the current model class's main table (not used
+        # by any superclasses).
+        def table_name
+          self == cti_base_model ? super : cti_tables.last
+        end
+      end
+
+      module InstanceMethods
+        # Set the cti_key column to the name of the model.
+        def before_create
+          return false if super == false
+          send("#{model.cti_key}=", model.name.to_s) if model.cti_key
+        end
+        
+        # Delete the row from all backing tables, starting from the
+        # most recent table and going through all superclasses.
+        def delete
+          m = model
+          m.cti_tables.reverse.each do |table|
+            m.db.from(table).filter(m.primary_key=>pk).delete
+          end
+          self
+        end
+        
+        private
+        
+        # Insert rows into all backing tables, using the columns
+        # in each table.  
+        def _insert
+          return super if model == model.cti_base_model
+          iid = nil
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            h[m.primary_key] = iid if iid
+            m.cti_columns[table].each{|c| h[c] = @values[c] if @values.include?(c)}
+            nid = m.db.from(table).insert(h)
+            iid ||= nid
+          end
+          @values[primary_key] = iid
+        end
+        
+        # Update rows in all backing tables, using the columns in each table.
+        def _update(columns)
+          pkh = pk_hash
+          m = model
+          m.cti_tables.each do |table|
+            h = {}
+            m.cti_columns[table].each{|c| h[c] = columns[c] if columns.include?(c)}
+            m.db.from(table).filter(pkh).update(h) unless h.empty?
+          end
+        end
+      end
+    end
+  end
+end