dm-mongo-adapter 0.2.0.pre1

data/lib/mongo_adapter/types/object_id.rb

@@ -0,0 +1,72 @@
+module DataMapper
+  module Mongo
+    module Types
+      # Each object (document) stored in Mongo DB has an _id field as its
+      # first attribute.  This is an object id.  It must be unique for each
+      # member of a collection (this is enforced if the collection has an _id
+      # index, which is the case by default).
+      #
+      # The database will assign an _id if an object being inserted into a
+      # collection does not have one.
+      #
+      # The _id may be of any type as long as it is a unique value.
+      #
+      # @see http://www.mongodb.org/display/DOCS/Object+IDs
+      #
+      # @api public
+      class ObjectID < DataMapper::Type
+        primitive ::Object
+        key true
+        field "_id"
+        required false
+
+        # Returns the ObjectID as a string; suitable for use in a Resource
+        #
+        # @return [String]
+        #
+        # @api public
+        def self.load(value, property)
+          typecast(value, property)
+        end
+
+        # Returns the ObjectID as a Mongo::ObjectID; suitable to be passed to
+        # the Mongo library
+        #
+        # @return [Mongo::ObjectID] The dumped ID.
+        #
+        # @api public
+        def self.dump(value, property)
+          case value
+          when NilClass
+            nil
+          when String
+            ::Mongo::ObjectID.from_string(value)
+          when ::Mongo::ObjectID
+            value
+          else
+            raise ArgumentError.new('+value+ must be nil, String or ObjectID')
+          end
+        end
+
+        # Returns the ObjectID as a string
+        #
+        # @return [String]
+        #
+        # @api semipublic
+        def self.typecast(value, property)
+          case value
+          when NilClass
+            nil
+          when String
+            value
+          when ::Mongo::ObjectID
+            value.to_s
+          else
+            raise ArgumentError.new('+value+ must be nil, String or ObjectID')
+          end
+        end
+
+      end # ObjectID
+    end # Types
+  end # Mongo
+end # DataMapper

data/lib/mongo_adapter/types/objects.rb

@@ -0,0 +1,31 @@
+module DataMapper
+  module Mongo
+    module Types
+      class EmbeddedArray < DataMapper::Type
+        primitive Object
+      end
+
+      class EmbeddedHash < DataMapper::Type
+        primitive Object
+
+        # @api public
+        def self.load(value, property)
+          typecast(value, property)
+        end
+
+        # @api semipublic
+        def self.typecast(value, property)
+          case value
+          when NilClass
+            nil
+          when Hash
+            value.to_mash.symbolize_keys
+          when Array
+            value.empty? ? Mash.new : [value].to_mash.symbolize_keys
+          end
+        end
+      end #EmbeddedHash
+
+    end # Types
+  end # Mongo
+end # DataMapper

data/script/performance.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'rubygems'
+
+gem 'addressable',  '~>2.0'
+gem 'faker',        '~>0.3.1'
+gem 'rbench',       '~>0.2.3'
+
+require 'addressable/uri'
+require 'faker'
+require 'rbench'
+require 'dm-core'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'mongo_adapter'))
+
+TIMES = ENV.key?('x') ? ENV['x'].to_i : 10_000
+
+configuration = { :hostname => 'localhost', :database => 'dm_core_test', :username => 'root', :password => '' }
+
+DataMapper.setup(:default, configuration.merge(:adapter => "mongo").except(:username, :password))
+DataMapper.setup(:mysql, configuration.merge(:adapter => "mysql"))
+
+class User
+  include DataMapper::Resource
+
+  def self.default_repository_name; :mysql; end
+
+  property :id,         Serial
+  property :name,       String
+  property :email,      String
+  property :about,      Text,   :lazy => false
+  property :created_on, Time
+end
+
+class Exhibit
+  include DataMapper::Resource
+
+  def self.default_repository_name; :mysql; end
+
+  property :id,         Serial
+  property :name,       String
+  property :user_id,    Integer
+  property :notes,      Text,    :lazy => false
+  property :created_on, Time
+end
+
+User.has User.n, :exhibits
+Exhibit.belongs_to :user
+
+module Mongo
+  class User
+    include DataMapper::Mongo::Resource
+
+    def self.default_storage_name; 'user'; end
+
+    property :id,         DataMapper::Mongo::Types::ObjectID
+    property :name,       String
+    property :email,      String
+    property :about,      Text,   :lazy => false
+    property :created_on, Time
+  end
+
+  class Exhibit
+    include DataMapper::Mongo::Resource
+
+    def self.default_storage_name; 'exhibit'; end
+
+    property :id,         DataMapper::Mongo::Types::ObjectID
+    property :name,       String
+    property :user_id,    Integer
+    property :notes,      Text,    :lazy => false
+    property :created_on, Time
+
+    belongs_to :user
+  end
+
+  User.has User.n, :exhibits
+  Exhibit.belongs_to :user
+end
+
+def touch_attributes(*exhibits)
+  exhibits.flatten.each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+  end
+end
+
+def touch_relationships(*exhibits)
+  exhibits.flatten.each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.user
+  end
+end
+
+root = File.dirname(__FILE__)
+
+dump_dir = root / 'dumps'
+
+dump_dir_mysql = dump_dir / 'mysql'
+dump_dir_mongo = dump_dir / 'mongo'
+
+FileUtils.mkdir_p(dump_dir_mysql) unless File.exist?(dump_dir_mysql)
+FileUtils.mkdir_p(dump_dir_mongo) unless File.exist?(dump_dir_mongo)
+
+dump_sql = dump_dir / 'mysql' / 'dump.sql'
+dump_mongo_users = dump_dir_mongo / configuration[:database] / 'users.bson'
+dump_mongo_exhibits = dump_dir_mongo / configuration[:database] / 'exhibits.bson'
+
+mongo_user_ids    = []
+mongo_exhibit_ids = []
+
+mysql_user_ids    = []
+mysql_exhibit_ids = []
+
+puts 'Clearing databases...'
+
+User.auto_migrate!
+Exhibit.auto_migrate!
+
+Mongo::User.auto_migrate!
+Mongo::Exhibit.auto_migrate!
+
+# pre-compute the insert statements and fake data compilation,
+# so the benchmmysqlks below show the actual runtime for the execute
+# method, minus the setup steps
+
+# Using the same paragraphs for all exhibits because it is very slow
+# to generate unique paragraphs for all exhibits.
+notes = Faker::Lorem.paragraphs.join($/)
+today = Time.now
+
+puts 'Generating data for benchmarking...'
+
+c = configuration
+
+if File.exist?(dump_sql) && File.exist?(dump_mongo_users) && File.exist?(dump_mongo_exhibits)
+  puts "Found db dumps, importing..."
+  
+  `mysql -u #{c[:username]} #{"-p#{ c[:password]}" unless c[:password].blank?} --database #{c[:database]} < #{dump_sql}`
+  `mongorestore -d #{c[:database]} -c users --dir #{dump_mongo_users}`
+  `mongorestore -d #{c[:database]} -c exhibits --dir #{dump_mongo_exhibits}`
+
+  mysql_user_ids    = User.all.map(&:id)
+  mysql_exhibit_ids = Exhibit.all.map(&:id)
+
+  mongo_user_ids   = Mongo::User.all.map(&:id)
+  mongo_exhibit_ids = Mongo::Exhibit.all.map(&:id)
+else
+  FileUtils.rm(dump_sql) if File.exist?(dump_sql)
+  FileUtils.rm_r(dump_mongo_users) if File.exist?(dump_mongo_users)
+  FileUtils.rm_r(dump_mongo_exhibits) if File.exist?(dump_mongo_exhibits)
+
+  puts 'Inserting 10,000 users and exhibits...'
+  10_000.times do
+    user_properties = {
+      :created_on => today,
+      :name       => Faker::Name.name,
+      :email      => Faker::Internet.email }
+
+    exhibit_properties = {
+      :created_on => today,
+      :name       => Faker::Company.name,
+      :notes      => notes
+    }
+
+    mongo_user    = Mongo::User.create(user_properties)
+    mongo_exhibit = Mongo::Exhibit.create(exhibit_properties.merge(:user_id => mongo_user.id))
+
+    mongo_user_ids    << mongo_user.id.to_s
+    mongo_exhibit_ids << mongo_exhibit.id.to_s
+
+    mysql_user = User.new(user_properties)
+    mysql_user.save!
+    mysql_exhibit = Exhibit.new(exhibit_properties.merge(:user_id => mysql_user.id))
+    mysql_exhibit.save!
+
+    mysql_user_ids    << mysql_user.id
+    mysql_exhibit_ids << mysql_exhibit.id
+  end
+
+  # mysql dump
+  `mysqldump -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits users > #{dump_sql}`
+  # mongo dump
+  `mongodump -d #{c[:database]} -c users -o #{dump_dir_mongo}`
+  `mongodump -d #{c[:database]} -c exhibits -o #{dump_dir_mongo}`
+end
+
+RBench.run(TIMES) do
+  column :times
+  column :mysql, :title => 'MySQL Adapter'
+  column :mongo, :title => "Mongo Adapter"
+  column :diff, :compare => [:mysql, :mongo]
+
+  report 'Model#id', (TIMES * 100).ceil do
+    mysql_obj = Exhibit.get(mysql_exhibit_ids.first)
+    mongo_obj = Mongo::Exhibit.get(mongo_exhibit_ids.first)
+
+    mysql { mysql_obj.id }
+    mongo { mongo_obj.id }
+  end
+
+  report 'Model.get specific (not cached)' do
+    mysql { touch_attributes(Exhibit.get(mysql_exhibit_ids.first)) }
+    mongo { touch_attributes(Mongo::Exhibit.get(mongo_exhibit_ids.first)) }
+  end
+
+  report 'Model.get specific (cached)' do
+    Exhibit.repository(:mysql) { mysql { touch_attributes(Exhibit.get(mysql_exhibit_ids.first)) } }
+    Mongo::Exhibit.repository(:default) { mongo { touch_attributes(Mongo::Exhibit.get(mongo_exhibit_ids.first)) } }
+  end
+
+  report 'Model.first' do
+    mysql { touch_attributes(Exhibit.first) }
+    mongo { touch_attributes(Mongo::Exhibit.first) }
+  end
+
+  report 'Model.all limit(100)', (TIMES / 100).ceil do
+    mysql { touch_attributes(Exhibit.all(:limit => 100)) }
+    mongo { touch_attributes(Mongo::Exhibit.all(:limit => 100)) }
+  end
+
+  report 'Model.all limit(10,000)', (TIMES / 1000).ceil do
+    mysql { touch_attributes(Exhibit.all(:limit => 10_000)) }
+    mongo { touch_attributes(Mongo::Exhibit.all(:limit => 10_000)) }
+  end
+
+  exhibit = {
+    :name       => Faker::Company.name,
+    :notes      => Faker::Lorem.paragraphs.join($/),
+    :created_on => today
+  }
+
+  report 'Model.create' do
+    mysql { Exhibit.create(exhibit) }
+    mongo { Mongo::Exhibit.create(exhibit) }
+  end
+
+  report 'Resource#attributes=' do
+    attrs_first  = { :name => 'sam', :notes => 'foo bar' }
+    attrs_second = { :name => 'tom', :notes => 'foo bar' }
+    mysql { exhibit = Exhibit.new(attrs_first); exhibit.attributes = attrs_second }
+    mongo { exhibit = Mongo::Exhibit.new(attrs_first);   exhibit.attributes = attrs_second }
+  end
+
+  report 'Resource#update' do
+    mysql { Exhibit.get(mysql_user_ids.first).update(:name => 'bob') }
+    mongo { Mongo::Exhibit.get(mongo_exhibit_ids.first).update(:name => 'bob') }
+  end
+
+  report 'Resource#destroy' do
+    mysql { Exhibit.first.destroy }
+    mongo { Mongo::Exhibit.first.destroy }
+  end
+
+  summary 'Total'
+end

data/spec/legacy/README

@@ -0,0 +1,6 @@
+This directory contains the old specs, written for 0.1.0. They are retained
+here while the specs are separated into spec/{public,semipublic}.
+
+Examples marked as @done indicate those for which there are equivalents in
+spec/{public,semipublic}. Once all specs are moved (or rewritten, as
+appropriate), the legacy specs will be removed.

data/spec/legacy/adapter_shared_spec.rb

@@ -0,0 +1,299 @@
+share_examples_for 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  before :all do
+    # create all tables and constraints before each spec
+    if @repository.respond_to?(:auto_migrate!)
+      Heffalump.auto_migrate!
+    end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.create(:color => 'peach')
+        }.should_not raise_error
+      end
+
+      it 'should set the identity field for the resource' do
+        heffalump = Heffalump.new(:color => 'peach')
+        heffalump.id.should be_nil
+        heffalump.save
+        heffalump.id.should_not be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+    describe '#read' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.all()
+        }.should_not raise_error
+      end
+
+      it 'should return stuff' do
+        Heffalump.all.should be_include(@heffalump)
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+    describe '#update' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.color = 'violet'
+          @heffalump.save
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.color = 'violet'
+        @heffalump.save
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.color = 'violet'
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.num_spots = 3
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = Heffalump.create(:color => 'forest green')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.destroy
+        }.should_not raise_error
+      end
+
+      it 'should delete the requested resource' do
+        id = @heffalump.id
+        @heffalump.destroy
+        Heffalump.get(id).should be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red = Heffalump.create(:color => 'red')
+        @two = Heffalump.create(:num_spots => 2)
+        @five = Heffalump.create(:num_spots => 5)
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'should be able to search for objects included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..5).should be_include(@five)
+          end
+
+          it 'should be able to search for objects included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...6).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'should be able to search for objects with not equal value' do
+            Heffalump.all(:color.not => 'red').should_not be_include(@red)
+          end
+
+          it 'should include objects that are not like the value' do
+            Heffalump.all(:color.not => 'black').should be_include(@red)
+          end
+
+          it 'should be able to search for objects with not nil value' do
+            Heffalump.all(:color.not => nil).should be_include(@red)
+          end
+
+          it 'should not include objects with a nil value' do
+            Heffalump.all(:color.not => nil).should_not be_include(@two)
+          end
+
+          it 'should be able to search for object with a nil value using required properties' do
+            Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects not in an empty list (match all)' do
+            Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+            Heffalump.all(:conditions => DataMapper::Query::Conditions::Operation.new(
+                                           :or,
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                                           DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5]))).should == [ @five ]
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color.like => '%ed').should be_include(@red)
+          end
+
+          it 'should not search for objects that do not match the value' do
+            Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+          end
+        end
+
+        describe 'regexp' do
+          before do
+            if (defined?(DataMapper::Adapters::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /ed/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /blak/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /blak/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+          end
+
+        end
+
+        describe 'gt' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'should be able to limit the objects' do
+          Heffalump.all(:limit => 2).length.should == 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end