datastax_rails 1.0.5

data/lib/datastax_rails/reflection.rb

@@ -0,0 +1,472 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+# This is shamelessly ripped from Active Record 3.1
+module DatastaxRails
+  # = DatastaxRails Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Reflection enables interrogation of DatastaxRails classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an DatastaxRails object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    module ClassMethods
+      def create_reflection(macro, name, options, datastax_rails)
+        klass = options[:through] ? ThroughReflection : AssociationReflection
+        reflection = klass.new(macro, name, options, datastax_rails)
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.grep(AssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      attr_reader :datastax_rails
+      
+      # Returns a hash of all the denormalizations for this relationship (if any)
+      attr_reader :denorms
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(macro, name, options, datastax_rails)
+        @macro           = macro
+        @name            = name
+        @options         = options
+        @datastax_rails  = datastax_rails
+        @plural_name     = name.to_s.pluralize
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +datastax_rails+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+          name == other_aggregation.name &&
+          other_aggregation.options &&
+          datastax_rails == other_aggregation.datastax_rails
+      end
+
+      # XXX: Do we need to sanitize our query?
+      def sanitized_conditions #:nodoc:
+        @sanitized_conditions ||= options[:conditions]
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # DatastaxRails class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < DatastaxRails::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= datastax_rails.send(:compute_type, class_name)
+      end
+      
+      def initialize(macro, name, options, datastax_rails)
+        super
+        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options, &block)
+        klass.new(*options, &block)
+      end
+
+      def column_family
+        @column_family ||= klass.column_family
+      end
+
+      def quoted_column_family
+        column_family
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= options[:as] && "#{options[:as]}_type"
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      # klass option is necessary to support loading polymorphic associations
+      # def association_primary_key(klass = nil)
+        # options[:primary_key] || primary_key(klass || self.klass)
+      # end
+# 
+      # def datastax_rails_primary_key
+        # @datastax_rails_primary_key ||= options[:primary_key] || primary_key(solandra_object)
+      # end
+
+      def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      def through_reflection
+        nil
+      end
+
+      def source_reflection
+        nil
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
+
+      # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
+      # in the #chain. The inside arrays are simply conditions (and each condition may itself be
+      # a hash, array, arel predicate, etc...)
+      def conditions
+        [[options[:conditions]].compact]
+      end
+
+      alias :source_macro :macro
+
+      def has_inverse?
+        @options[:inverse_of]
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>:validate => false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      def association_class
+        case macro
+        when :belongs_to
+          Associations::BelongsToAssociation
+        when :has_and_belongs_to_many
+          Associations::HasAndBelongsToManyAssociation
+        when :has_many
+          if options[:through]
+            Associations::HasManyThroughAssociation
+          else
+            Associations::HasManyAssociation
+          end
+        when :has_one
+          if options[:through]
+            Associations::HasOneThroughAssociation
+          else
+            Associations::HasOneAssociation
+          end
+        end
+      end
+
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+
+        def derive_foreign_key
+          if belongs_to?
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            datastax_rails.name.foreign_key
+          end
+        end
+
+        # def primary_key(klass)
+          # klass.key || raise(UnknownPrimaryKey.new(klass))
+        # end
+    end
+    
+    # Holds all the meta-data about a :through association as it was specified
+    # in the DatastaxRails class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+      delegate :foreign_key, :foreign_type, :association_foreign_key,
+               :datastax_rails_primary_key, :type, :to => :source_reflection
+
+      # Gets the source of the through reflection.  It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      def source_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      # Returns the AssociationReflection object specified in the <tt>:through</tt> option
+      # of a HasManyThrough or HasOneThrough association.
+      #
+      #   class Post < DatastaxRails::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   taggings_reflection = tags_reflection.through_reflection
+      #
+      def through_reflection
+        @through_reflection ||= datastax_rails.reflect_on_association(options[:through])
+      end
+
+      # Returns an array of reflections which are involved in this association. Each item in the
+      # array corresponds to a table which will be part of the query for this association.
+      #
+      # The chain is built by recursively calling #chain on the source reflection and the through
+      # reflection. The base case for the recursion is a normal association, which just returns
+      # [self] as its #chain.
+      def chain
+        @chain ||= begin
+          chain = source_reflection.chain + through_reflection.chain
+          chain[0] = self # Use self so we don't lose the information from :source_type
+          chain
+        end
+      end
+
+      # Consider the following example:
+      #
+      #   class Person
+      #     has_many :articles
+      #     has_many :comment_tags, :through => :articles
+      #   end
+      #
+      #   class Article
+      #     has_many :comments
+      #     has_many :comment_tags, :through => :comments, :source => :tags
+      #   end
+      #
+      #   class Comment
+      #     has_many :tags
+      #   end
+      #
+      # There may be conditions on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # but only Comment.tags will be represented in the #chain. So this method creates an array
+      # of conditions corresponding to the chain. Each item in the #conditions array corresponds
+      # to an item in the #chain, and is itself an array of conditions from an arbitrary number
+      # of relevant reflections, plus any :source_type or polymorphic :as constraints.
+      def conditions
+        @conditions ||= begin
+          conditions = source_reflection.conditions.map { |c| c.dup }
+
+          # Add to it the conditions from this reflection if necessary.
+          conditions.first << options[:conditions] if options[:conditions]
+
+          through_conditions = through_reflection.conditions
+
+          if options[:source_type]
+            through_conditions.first << { foreign_type => options[:source_type] }
+          end
+
+          # Recursively fill out the rest of the array from the through reflection
+          conditions += through_conditions
+
+          # And return
+          conditions
+        end
+      end
+
+      # The macro used by the source association
+      def source_macro
+        source_reflection.source_macro
+      end
+
+      # A through association is nested iff there would be more than one join table
+      def nested?
+        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+      end
+
+      # We want to use the klass from this reflection, rather than just delegate straight to
+      # the source_reflection, because the source_reflection may be polymorphic. We still
+      # need to respect the source_reflection's :primary_key option, though.
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        source_reflection = self.source_reflection
+        while source_reflection.source_reflection
+          source_reflection = source_reflection.source_reflection
+        end
+
+        source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      # Gets an array of possible <tt>:through</tt> source reflection names:
+      #
+      #   [:singularized, :pluralized]
+      #
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      def source_options
+        source_reflection.options
+      end
+
+      def through_options
+        through_reflection.options
+      end
+
+      def check_validity!
+        if through_reflection.nil?
+          raise HasManyThroughAssociationNotFoundError.new(datastax_rails.name, self)
+        end
+
+        if through_reflection.options[:polymorphic]
+          raise HasManyThroughAssociationPolymorphicThroughError.new(datastax_rails.name, self)
+        end
+
+        if source_reflection.nil?
+          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+        end
+
+        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+          raise HasManyThroughAssociationPointlessSourceTypeError.new(datastax_rails.name, self, source_reflection)
+        end
+
+        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+          raise HasManyThroughAssociationPolymorphicSourceError.new(datastax_rails.name, self, source_reflection)
+        end
+
+        if macro == :has_one && through_reflection.collection?
+          raise HasOneThroughCantAssociateThroughCollection.new(datastax_rails.name, self, through_reflection)
+        end
+
+        check_validity_of_inverse!
+      end
+
+      private
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          options[:source_type] || source_reflection.class_name
+        end
+    end
+  end
+end

data/lib/datastax_rails/relation/finder_methods.rb

@@ -0,0 +1,184 @@
+module DatastaxRails
+  module FinderMethods
+    # Find operates with four different retrieval approaches:
+    #
+    # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    #   If no record can be found for all of the listed ids, then RecordNotFound will be raised.
+    # * Find first - This will return the first record matched by the options used. These options can either be specific
+    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+    #   <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
+    # * Find last - This will return the last record matched by the options used. These options can either be specific
+    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+    #   <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
+    # * Find all - This will return all the records matched by the options used.
+    #   If no records are found, an empty array is returned. Use
+    #   <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
+    #
+    # All approaches accept an options hash as their last parameter.
+    #
+    # ==== Options
+    #
+    # * <tt>:conditions</tt> - See conditions in the intro.
+    # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
+    # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
+    # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
+    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5,
+    #   it would skip rows 0 through 4.
+    #
+    # ==== Examples
+    #
+    # # find by id
+    #   Person.find(1) # returns the object for ID = 1
+    #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1]) # returns an array for the object with ID = 1
+    #   Person.where(:administrator => 1).order(:created_on => :desc).find(1)
+    #
+    # Note that the returned order is undefined unless you give a specific +:order+ clause.
+    # Further note that order is handled in memory and so does suffer a performance penalty.
+    #
+    # ==== Examples
+    #
+    #   # find first
+    #   Person.first # returns the first object fetched by SELECT * FROM people
+    #   Person.where(:user_name => user_name).first
+    #   Person.order(:created_on => :desc).offset(5).first
+    #
+    #   # find last
+    #   Person.last # returns the last object in the column family
+    #   Person.where(:user_name => user_name).last
+    #   Person.order(:created_at => :desc).offset(5).last
+    #
+    #   # find all
+    #   Person.all # returns an array of objects for all the rows in the column family
+    #   Person.where(["category IN (?)", categories]).limit(50).all
+    #   Person.where(:friends => ["Bob", "Steve", "Fred"]).all
+    #   Person.offset(10).limit(10).all
+    #   Person.group("category").all
+    def find(*args)
+      return to_a.find { |*block_args| yield(*block_args) } if block_given?
+
+      options = args.extract_options!
+
+      if options.present?
+        apply_finder_options(options).find(*args)
+      else
+        case args.first
+        when :first, :last, :all
+          send(args.first)
+        else
+          self.use_solr_value = false
+          find_with_ids(*args)
+        end
+      end
+    end
+    
+    # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:first)</tt>.
+    def first(*args)
+      if args.any?
+        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+          limit(*args).to_a
+        else
+          apply_finder_options(args.first).first
+        end
+      else
+        find_first
+      end
+    end
+    
+    # Same as +first+ but raises <tt>DatastaxRails::RecordNotFound</tt> if no record
+    # is found. Note that <tt>first!</tt> accepts no arguments.
+    def first!
+      first or raise RecordNotFound
+    end
+    
+    # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:last)</tt>.
+    def last(*args)
+      if args.any?
+        if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+          if order_values.empty? && reorder_value.nil?
+            order(:id => :desc).limit(*args).reverse
+          else
+            to_a.last(*args)
+          end
+        else
+          apply_finder_options(args.first).last
+        end
+      else
+        find_last
+      end
+    end
+
+    # Same as +last+ but raises <tt>DatastaxRails::RecordNotFound</tt> if no record
+    # is found. Note that <tt>last!</tt> accepts no arguments.
+    def last!
+      last or raise RecordNotFound
+    end
+    
+    private
+      def find_with_ids(*ids)
+        return to_a.find { |*block_args| yield(*block_args) } if block_given?
+  
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+  
+        ids = ids.flatten.compact.uniq
+  
+        case ids.size
+        when 0
+          raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids)
+        end
+      end
+      
+      def find_one(id)
+        with_cassandra.where(:key => id).first || raise(RecordNotFound, "Couldn't find #{@klass.name} with #{primary_key}=#{id}")
+      end
+  
+      def find_some(ids)
+        result = with_cassandra.where(:key => ids).all
+  
+        expected_size =
+          if @limit_value && ids.size > @limit_value
+            @limit_value
+          else
+            ids.size
+          end
+  
+        # 11 ids with limit 3, offset 9 should give 2 results.
+        if @offset_value && (ids.size - @offset_value < expected_size)
+          expected_size = ids.size - @offset_value
+        end
+  
+        if result.size == expected_size
+          result
+        else
+          error = "Couldn't find all #{@klass.name.pluralize} with IDs "
+          error << "(#{ids.join(", ")}) (found #{result.size} results, but was looking for #{expected_size})"
+          raise RecordNotFound, error
+        end
+      end
+    
+      def find_first
+        if loaded?
+          @results.first
+        else
+          @first ||= limit(1).to_a[0]
+        end
+      end
+      
+      def find_last
+        if loaded?
+          @results.last
+        else
+          @last ||= reverse_order.limit(1).to_a[0]
+        end
+      end
+  end
+end