sam-dm-core 0.9.6 → 0.9.7

data/lib/dm-core/query.rb

@@ -99,9 +99,12 @@ module DataMapper
       bind_values
     end
 
-    # TODO: spec this
-    def inheritance_property_index(repository)
-      fields.index(model.inheritance_property(repository.name))
+    def inheritance_property
+      fields.detect { |property| property.type == DataMapper::Types::Discriminator }
+    end
+
+    def inheritance_property_index
+      fields.index(inheritance_property)
     end
 
     # TODO: spec this
@@ -190,7 +193,7 @@ module DataMapper
       @includes = normalize_includes(@includes)
 
       # treat all non-options as conditions
-      (options.keys - OPTIONS - OPTIONS.map { |option| option.to_s }).each do |k|
+      (options.keys - OPTIONS).each do |k|
         append_condition(k, options[k])
       end
 
@@ -218,53 +221,50 @@ module DataMapper
 
     # validate the options
     def assert_valid_options(options)
-      # validate the reload option and unique option
-      ([ :reload, :unique ] & options.keys).each do |attribute|
-        if options[attribute] != true && options[attribute] != false
-          raise ArgumentError, "+options[:#{attribute}]+ must be true or false, but was #{options[attribute].inspect}", caller(2)
-        end
-      end
-
-      # validate the offset and limit options
-      ([ :offset, :limit ] & options.keys).each do |attribute|
-        value = options[attribute]
-        assert_kind_of "options[:#{attribute}]", value, Integer
-      end
-
-      if options.has_key?(:offset) && options[:offset] < 0
-        raise ArgumentError, "+options[:offset]+ must be greater than or equal to 0, but was #{options[:offset].inspect}", caller(2)
-      end
-
-      if options.has_key?(:limit)  && options[:limit] < 1
-        raise ArgumentError, "+options[:limit]+ must be greater than or equal to 1, but was #{options[:limit].inspect}", caller(2)
-      end
+      # [DB] This might look more ugly now, but it's 2x as fast as the old code
+      # [DB] This is one of the heavy spots for Query.new I found during profiling.
+      options.each_pair do |attribute, value|
+
+        # validate the reload option and unique option
+        if [:reload, :unique].include? attribute
+          if value != true && value != false
+            raise ArgumentError, "+options[:#{attribute}]+ must be true or false, but was #{value.inspect}", caller(2)
+          end
 
-      # validate the order, fields, links, includes and conditions options
-      ([ :order, :fields, :links, :includes ] & options.keys).each do |attribute|
-        value = options[attribute]
-        assert_kind_of "options[:#{attribute}]", value, Array
+        # validate the offset and limit options
+        elsif [:offset, :limit].include? attribute
+          assert_kind_of "options[:#{attribute}]", value, Integer
+          if attribute == :offset && value < 0
+            raise ArgumentError, "+options[:offset]+ must be greater than or equal to 0, but was #{value.inspect}", caller(2)
+          elsif attribute == :limit && value < 1
+            raise ArgumentError, "+options[:limit]+ must be greater than or equal to 1, but was #{options[:limit].inspect}", caller(2)
+          end
 
-        if value.empty?
-          if attribute == :fields
-            if options[:unique] == false
-              raise ArgumentError, '+options[:fields]+ cannot be empty if +options[:unique] is false', caller(2)
-            end
-          elsif attribute == :order
-            if options[:fields] && options[:fields].any? { |p| !p.kind_of?(Operator) }
-              raise ArgumentError, '+options[:order]+ cannot be empty if +options[:fields] contains a non-operator', caller(2)
+        # validate the :order, :fields, :links and :includes options
+        elsif [ :order, :fields, :links, :includes ].include? attribute
+          assert_kind_of "options[:#{attribute}]", value, Array
+
+          if value.empty?
+            if attribute == :fields
+              if options[:unique] == false
+                raise ArgumentError, '+options[:fields]+ cannot be empty if +options[:unique] is false', caller(2)
+              end
+            elsif attribute == :order
+              if options[:fields] && options[:fields].any? { |p| !p.kind_of?(Operator) }
+                raise ArgumentError, '+options[:order]+ cannot be empty if +options[:fields] contains a non-operator', caller(2)
+              end
+            else
+              raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
             end
-          else
-            raise ArgumentError, "+options[:#{attribute}]+ cannot be empty", caller(2)
           end
-        end
-      end
 
-      if options.has_key?(:conditions)
-        value = options[:conditions]
-        assert_kind_of 'options[:conditions]', value, Hash, Array
+        # validates the :conditions option
+        elsif :conditions == attribute
+          assert_kind_of 'options[:conditions]', value, Hash, Array
 
-        if value.empty?
-          raise ArgumentError, '+options[:conditions]+ cannot be empty', caller(2)
+          if value.empty?
+            raise ArgumentError, '+options[:conditions]+ cannot be empty', caller(2)
+          end
         end
       end
     end
@@ -464,10 +464,11 @@ module DataMapper
 
       # build an index of conditions by the property and operator to
       # avoid nested looping
-      conditions_index = Hash.new { |h,k| h[k] = {} }
+      conditions_index = {}
       @conditions.each do |condition|
         operator, property = *condition
         next if :raw == operator
+        conditions_index[property] ||= {}
         conditions_index[property][operator] = condition
       end
 
@@ -477,6 +478,7 @@ module DataMapper
         other_operator, other_property, other_bind_value = *other_condition
 
         unless :raw == other_operator
+          conditions_index[other_property] ||= {}
           if condition = conditions_index[other_property][other_operator]
             operator, property, bind_value = *condition
 
@@ -571,7 +573,7 @@ module DataMapper
     class Path
       include Assertions
 
-   %w[ id type ].each { |m| undef_method m }
+      instance_methods.each { |m| undef_method m if %w[ id type ].include?(m.to_s) }
 
       attr_reader :relationships, :model, :property, :operator
 

data/lib/dm-core/repository.rb

@@ -33,11 +33,11 @@ module DataMapper
     end
 
     def identity_map(model)
-      @identity_maps[model]
+      @identity_maps[model] ||= IdentityMap.new
     end
 
     # TODO: spec this
-    def scope(&block)
+    def scope
       Repository.context << self
 
       begin
@@ -97,7 +97,7 @@ module DataMapper
       assert_kind_of 'name', name, Symbol
 
       @name          = name
-      @identity_maps = Hash.new { |h,model| h[model] = IdentityMap.new }
+      @identity_maps = {}
     end
 
     # TODO: move to dm-more/dm-migrations

data/lib/dm-core/resource.rb

@@ -198,7 +198,7 @@ module DataMapper
       attrs = []
 
       properties.each do |property|
-        value = if property.lazy? && !attribute_loaded?(property.name) && !new_record?
+        value = if !attribute_loaded?(property.name) && !new_record?
           '<not loaded>'
         else
           send(property.getter).inspect
@@ -277,9 +277,7 @@ module DataMapper
       associations_saved = false
       child_associations.each { |a| associations_saved |= a.save }
 
-      saved = if dirty? || (new_record? && key_properties.any? { |p| p.serial? })
-        new_record? ? create : update
-      end
+      saved = new_record? ? create : update
 
       if saved
         original_values.clear
@@ -493,13 +491,13 @@ module DataMapper
     # --
     # @api public
     def attributes=(values_hash)
-      values_hash.each_pair do |k,v|
-        setter = "#{k.to_s.sub(/\?\z/, '')}="
+      values_hash.each do |name, value|
+        name = name.to_s.sub(/\?\z/, '')
 
-        if respond_to?(setter)
-          send(setter, v)
+        if self.class.public_method_defined?(setter = "#{name}=")
+          send(setter, value)
         else
-          raise NameError, "#{setter} is not a public property"
+          raise ArgumentError, "The property '#{name}' is not a public property."
         end
       end
     end
@@ -546,6 +544,8 @@ module DataMapper
 
     # Needs to be a protected method so that it is hookable
     def create
+      # Can't create a resource that is not dirty and doesn't have serial keys
+      return false if new_record? && !dirty? && !model.key.any? { |p| p.serial? }
       # set defaults for new resource
       properties.each do |property|
         next if attribute_loaded?(property.name)
@@ -588,7 +588,7 @@ module DataMapper
         raise IncompleteResourceError, "#{model.name} must have a key."
       end
 
-      class << self; @_valid_model = true; end
+      self.class.instance_variable_set("@_valid_model", true)
     end
 
     # TODO document
@@ -627,8 +627,8 @@ module DataMapper
       # @api public
       #
       # TODO: move to dm-more/dm-transactions
-      def transaction(&block)
-        model.transaction(&block)
+      def transaction
+        model.transaction { |*block_args| yield(*block_args) }
       end
     end # module Transaction
 

data/lib/dm-core/scope.rb

@@ -5,8 +5,8 @@ module DataMapper
     # @api private
     def default_scope(repository_name = nil)
       repository_name = self.default_repository_name if repository_name == :default || repository_name.nil?
-      @default_scope ||= Hash.new{|h,k| h[k] = {}}
-      @default_scope[repository_name]
+      @default_scope ||= {}
+      @default_scope[repository_name] ||= {}
     end
 
     # @api private
@@ -17,13 +17,13 @@ module DataMapper
     protected
 
     # @api semipublic
-    def with_scope(query, &block)
+    def with_scope(query)
       # merge the current scope with the passed in query
-      with_exclusive_scope(self.query ? self.query.merge(query) : query, &block)
+      with_exclusive_scope(self.query ? self.query.merge(query) : query) {|*block_args| yield(*block_args) }
     end
 
     # @api semipublic
-    def with_exclusive_scope(query, &block)
+    def with_exclusive_scope(query)
       query = DataMapper::Query.new(repository, self, query) if query.kind_of?(Hash)
 
       scope_stack << query
@@ -44,8 +44,8 @@ module DataMapper
 
     # @api private
     def scope_stack
-      scope_stack_for = Thread.current[:dm_scope_stack] ||= Hash.new { |h,model| h[model] = [] }
-      scope_stack_for[self]
+      scope_stack_for = Thread.current[:dm_scope_stack] ||= {}
+      scope_stack_for[self] ||= []
     end
 
     # @api private

data/lib/dm-core/support/kernel.rb

@@ -1,7 +1,11 @@
 module Kernel
   # Delegates to DataMapper::repository.
   # Will not overwrite if a method of the same name is pre-defined.
-  def repository(*args, &block)
-    DataMapper.repository(*args, &block)
+  def repository(*args)
+    if block_given?
+      DataMapper.repository(*args) { |*block_args| yield(*block_args) }
+    else
+      DataMapper.repository(*args)
+    end
   end
 end # module Kernel

data/lib/dm-core/transaction.rb

@@ -13,12 +13,12 @@ module DataMapper
     # In fact, it just calls #link with the given arguments at the end of the
     # constructor.
     #
-    def initialize(*things, &block)
+    def initialize(*things)
       @transaction_primitives = {}
       @state = :none
       @adapters = {}
       link(*things)
-      commit(&block) if block_given?
+      commit { |*block_args| yield(*block_args) } if block_given?
     end
 
     #
@@ -39,7 +39,7 @@ module DataMapper
     #   within this transaction. The transaction will begin and commit around
     #   the block, and rollback if an exception is raised.
     #
-    def link(*things, &block)
+    def link(*things)
       raise "Illegal state for link: #{@state}" unless @state == :none
       things.each do |thing|
         if thing.is_a?(Array)
@@ -56,7 +56,7 @@ module DataMapper
           raise "Unknown argument to #{self}#link: #{thing.inspect}"
         end
       end
-      return commit(&block) if block_given?
+      return commit { |*block_args| yield(*block_args) } if block_given?
       return self
     end
 
@@ -83,12 +83,12 @@ module DataMapper
     #   If no block is given, it will simply commit any changes made since the
     #   Transaction did #begin.
     #
-    def commit(&block)
+    def commit
       if block_given?
         raise "Illegal state for commit with block: #{@state}" unless @state == :none
         begin
           self.begin
-          rval = within(&block)
+          rval = within { |*block_args| yield(*block_args) }
           self.commit if @state == :begin
           return rval
         rescue Exception => e
@@ -128,7 +128,7 @@ module DataMapper
     #   adapter it is associated with, and it will ensures that it will pop the
     #   Transaction away again after the block is finished.
     #
-    def within(&block)
+    def within
       raise "No block provided" unless block_given?
       raise "Illegal state for within: #{@state}" unless @state == :begin
       @adapters.each do |adapter, state|

data/lib/dm-core/version.rb

@@ -1,3 +1,3 @@
 module DataMapper
-  VERSION = '0.9.6' unless defined?(DataMapper::VERSION)
+  VERSION = '0.9.7' unless defined?(DataMapper::VERSION)
 end

data/script/performance.rb

@@ -1,19 +1,18 @@
 #!/usr/bin/env ruby
 
 require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core', 'version')
 
-require 'rubygems'
 require 'ftools'
+require 'rubygems'
 
-# sudo gem install rbench
-# OR git clone git://github.com/somebee/rbench.git , rake install
-gem 'rbench', '>=0.2.2'
+gem 'rbench', '~>0.2.3'
 require 'rbench'
 
-gem 'faker', '>=0.3.1'
+gem 'faker', '~>0.3.1'
 require 'faker'
 
-gem 'activerecord', '>=2.1.0'
+gem 'activerecord', '~>2.2.2'
 require 'active_record'
 
 socket_file = Pathname.glob(%w[
@@ -38,11 +37,11 @@ configuration_options[:socket] = socket_file unless socket_file.nil?
 log_dir = DataMapper.root / 'log'
 log_dir.mkdir unless log_dir.directory?
 
-DataMapper::Logger.new(log_dir / 'dm.log', :debug)
+DataMapper::Logger.new(log_dir / 'dm.log', :off)
 adapter = DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{socket_file}")
 
 if configuration_options[:adapter]
-  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','perf.sql')
+  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','performance.sql')
   mysql_bin = %w[mysql mysql5].select{|bin| `which #{bin}`.length > 0 }
   mysqldump_bin = %w[mysqldump mysqldump5].select{|bin| `which #{bin}`.length > 0 }
 end
@@ -54,6 +53,15 @@ ActiveRecord::Base.establish_connection(configuration_options)
 
 class ARExhibit < ActiveRecord::Base #:nodoc:
   set_table_name 'exhibits'
+
+  belongs_to :user, :class_name => 'ARUser', :foreign_key => 'user_id'
+end
+
+class ARUser < ActiveRecord::Base #:nodoc:
+  set_table_name 'users'
+
+  has_many :exhibits, :foreign_key => 'user_id'
+
 end
 
 ARExhibit.find_by_sql('SELECT 1')
@@ -64,17 +72,39 @@ class Exhibit
   property :id,         Serial
   property :name,       String
   property :zoo_id,     Integer
+  property :user_id,    Integer
   property :notes,      Text, :lazy => true
   property :created_on, Date
+
+  belongs_to :user
 #  property :updated_at, DateTime
 end
 
+class User
+  include DataMapper::Resource
+
+  property :id,    Serial
+  property :name,  String
+  property :email, String
+  property :about, Text, :lazy => true
+  property :created_on, Date
+
+end
+
 touch_attributes = lambda do |exhibits|
   [*exhibits].each do |exhibit|
     exhibit.id
     exhibit.name
     exhibit.created_on
-#    exhibit.updated_at
+  end
+end
+
+touch_relationships = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.user
   end
 end
 
@@ -87,27 +117,49 @@ if sqlfile && File.exists?(sqlfile)
   `#{mysql_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} < #{sqlfile}`
 else
 
+  puts "Generating data for benchmarking..."
+
+  User.auto_migrate!
   Exhibit.auto_migrate!
 
+  users = []
   exhibits = []
+
   # pre-compute the insert statements and fake data compilation,
   # so the benchmarks below show the actual runtime for the execute
   # method, minus the setup steps
-  10_000.times do
+
+  # Using the same paragraph for all exhibits because it is very slow
+  # to generate unique paragraphs for all exhibits.
+  paragraph = Faker::Lorem.paragraphs.join($/)
+
+  10_000.times do |i|
+    users << [
+      'INSERT INTO `users` (`name`,`email`,`created_on`) VALUES (?, ?, ?)',
+      Faker::Name.name,
+      Faker::Internet.email,
+      Date.today
+    ]
+
     exhibits << [
-      'INSERT INTO `exhibits` (`name`, `zoo_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?)',
+      'INSERT INTO `exhibits` (`name`, `zoo_id`, `user_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?, ?)',
       Faker::Company.name,
       rand(10).ceil,
-      Faker::Lorem.paragraphs.join($/),
+      i,
+      paragraph,#Faker::Lorem.paragraphs.join($/),
       Date.today
     ]
   end
+
+  puts "Inserting 10,000 users..."
+  10_000.times { |i| adapter.execute(*users.at(i)) }
+  puts "Inserting 10,000 exhibits..."
   10_000.times { |i| adapter.execute(*exhibits.at(i)) }
 
   if sqlfile
     answer = nil
     until answer && answer[/^$|y|yes|n|no/]
-      print("Would you like to dump data into tmp/perf.sql (for faster setup)? [Yn]");
+      print("Would you like to dump data into tmp/performance.sql (for faster setup)? [Yn]");
       STDOUT.flush
       answer = gets
     end
@@ -115,7 +167,7 @@ else
     if answer[/^$|y|yes/]
       File.makedirs(File.dirname(sqlfile))
       #adapter.execute("SELECT * INTO OUTFILE '#{sqlfile}' FROM exhibits;")
-      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits > #{sqlfile}`
+      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits users > #{sqlfile}`
       puts "File saved\n"
     end
   end
@@ -127,48 +179,63 @@ TIMES = ENV['x'] ? ENV['x'].to_i : 10_000
 puts "You can specify how many times you want to run the benchmarks with rake:perf x=(number)"
 puts "Some tasks will be run 10 and 1000 times less than (number)"
 puts "Benchmarks will now run #{TIMES} times"
+# Inform about slow benchmark
+# answer = nil
+# until answer && answer[/^$|y|yes|n|no/]
+#   print("A slow benchmark exposing problems with SEL is newly added. It takes approx. 20s\n");
+#   print("you have scheduled it to run #{TIMES / 100} times.\nWould you still include the particular benchmark? [Yn]")
+#   STDOUT.flush
+#   answer = gets
+# end
+# run_rel_bench = answer[/^$|y|yes/] ? true : false
+
 
 RBench.run(TIMES) do
 
   column :times
-  column :dm, :title => "DM 0.9.4"
   column :ar, :title => "AR 2.1"
-  column :diff, :compare => [:dm,:ar]
+  column :dm, :title => "DM #{DataMapper::VERSION}"
+  column :diff, :compare => [:ar,:dm]
 
   report "Model.new (instantiation)" do
-    dm { Exhibit.new }
     ar { ARExhibit.new }
+    dm { Exhibit.new }
   end
 
   report "Model.new (setting attributes)" do
     attrs = {:name => 'sam', :zoo_id => 1}
-    dm { Exhibit.new(attrs) }
     ar { ARExhibit.new(attrs) }
+    dm { Exhibit.new(attrs) }
   end
 
   report "Model.get specific (not cached)" do
-    dm { touch_attributes[Exhibit.get(1)] }
     ActiveRecord::Base.uncached { ar { touch_attributes[ARExhibit.find(1)] } }
+    dm { touch_attributes[Exhibit.get(1)] }
   end
 
   report "Model.get specific (cached)" do
-    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)]    } }
     ActiveRecord::Base.cache    { ar { touch_attributes[ARExhibit.find(1)] } }
+    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)] } }
   end
 
   report "Model.first" do
-    dm { touch_attributes[Exhibit.first]   }
     ar { touch_attributes[ARExhibit.first] }
+    dm { touch_attributes[Exhibit.first] }
   end
 
-  report "Model.all limit(100)", TIMES / 10 do
-    dm { touch_attributes[Exhibit.all(:limit => 100)] }
+  report "Model.all limit(100)", (TIMES / 10.0).ceil do
     ar { touch_attributes[ARExhibit.find(:all, :limit => 100)] }
+    dm { touch_attributes[Exhibit.all(:limit => 100)] }
   end
 
-  report "Model.all limit(10,000)", TIMES / 1000 do
-    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
+  report "Model.all limit(100) with relationship", (TIMES / 10.0).ceil do
+    ar { touch_relationships[ARExhibit.all(:limit => 100, :include => [:user])] }
+    dm { touch_relationships[Exhibit.all(:limit => 100)] }
+  end
+
+  report "Model.all limit(10,000)", (TIMES / 1000.0).ceil do
     ar { touch_attributes[ARExhibit.find(:all, :limit => 10_000)] }
+    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
   end
 
   create_exhibit = {
@@ -179,25 +246,37 @@ RBench.run(TIMES) do
   }
 
   report "Model.create" do
-    dm { Exhibit.create(create_exhibit)   }
     ar { ARExhibit.create(create_exhibit) }
+    dm { Exhibit.create(create_exhibit) }
+  end
+
+  report "Resource#attributes" do
+    attrs_first  = {:name => 'sam', :zoo_id => 1}
+    attrs_second = {:name => 'tom', :zoo_id => 1}
+    ar { e = ARExhibit.new(attrs_first); e.attributes = attrs_second }
+    dm { e = Exhibit.new(attrs_first); e.attributes = attrs_second }
   end
 
   report "Resource#update" do
-    dm { e = Exhibit.get(1); e.name = 'bob'; e.save   }
-    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save  }
+    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save }
+    dm { e = Exhibit.get(1); e.name = 'bob'; e.save }
   end
 
   report "Resource#destroy" do
-    dm { Exhibit.first.destroy }
     ar { ARExhibit.first.destroy }
+    dm { Exhibit.first.destroy }
   end
 
-  summary "Total"
+  report "Model.transaction" do
+    ar { ARExhibit.transaction { ARExhibit.new } }
+    dm { Exhibit.transaction { Exhibit.new } }
+  end
 
+  summary "Total"
 end
 
 connection = adapter.send(:create_connection)
 command = connection.create_command("DROP TABLE exhibits")
+command = connection.create_command("DROP TABLE users")
 command.execute_non_query rescue nil
 connection.close