dm-core 0.10.1 → 0.10.2

data/lib/dm-core/adapters/mysql_adapter.rb

@@ -10,25 +10,24 @@ module DataMapper
 
         private
 
-        # TODO: document
         # @api private
         def supports_default_values? #:nodoc:
           false
         end
 
-        # TODO: document
         # @api private
-        def regexp_operator(operand)
-          'REGEXP'
+        def supports_subquery?(query, source_key, target_key, qualify)
+          # TODO: renable once query does not include target_model for deletes and updates
+          # query.limit.nil?
+
+          false
         end
 
-        # TODO: document
         # @api private
-        def not_regexp_operator(operand)
-          'NOT REGEXP'
+        def regexp_operator(operand)
+          'REGEXP'
         end
 
-        # TODO: document
         # @api private
         def quote_name(name)
           "`#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('`', '``')}`"

data/lib/dm-core/adapters/oracle_adapter.rb

@@ -24,10 +24,12 @@ module DataMapper
         def insert_statement(model, properties, serial)
           statement = "INSERT INTO #{quote_name(model.storage_name(name))} "
 
+          no_properties   = properties.empty?
           custom_sequence = serial && serial.options[:sequence]
+          serial_field    = serial && quote_name(serial.field)
 
-          if supports_default_values? && properties.empty? && !custom_sequence
-            statement << "(#{quote_name(serial.field)}) " if serial
+          if supports_default_values? && no_properties && !custom_sequence
+            statement << "(#{serial_field}) " if serial
             statement << default_values_clause
           else
             # do not use custom sequence if identity field was assigned a value
@@ -36,14 +38,14 @@ module DataMapper
             end
             statement << "("
             if custom_sequence
-              statement << "#{quote_name(serial.field)}"
-              statement << ", " unless properties.empty?
+              statement << "#{serial_field}"
+              statement << ", " unless no_properties
             end
-            statement << "#{properties.map { |p| quote_name(p.field) }.join(', ')}) "
+            statement << "#{properties.map { |property| quote_name(property.field) }.join(', ')}) "
             statement << "VALUES ("
             if custom_sequence
               statement << "#{quote_name(custom_sequence)}.NEXTVAL"
-              statement << ", " unless properties.empty?
+              statement << ", " unless no_properties
             end
             statement << "#{(['?'] * properties.size).join(', ')})"
           end
@@ -60,7 +62,6 @@ module DataMapper
           'VALUES (DEFAULT)'
         end
 
-        # TODO: document
         # @api private
         def supports_returning?
           true
@@ -78,6 +79,7 @@ module DataMapper
         #
         # @api private
         def select_statement(query)
+          name       = self.name
           model      = query.model
           fields     = query.fields
           conditions = query.conditions
@@ -96,14 +98,16 @@ module DataMapper
           qualify = query.links.any?
 
           if query.unique?
-            group_by = fields.select { |p| p.kind_of?(Property) }
+            group_by = fields.select { |property| property.kind_of?(Property) }
           end
 
           # create subquery to find all valid keys and then use these keys to retrive all other columns
           use_subquery = qualify
+          no_group_by  = group_by.blank?
+          no_order     = order.blank?
 
           # when we can include ROWNUM condition in main WHERE clause
-          use_simple_rownum_limit = limit && (offset||0 == 0) && group_by.blank? && order.blank?
+          use_simple_rownum_limit = limit && (offset||0 == 0) && no_group_by && no_order
 
           unless (limit && limit > 1) || offset > 0 || qualify
             # TODO: move this method to Query, so that it walks the conditions
@@ -114,25 +118,31 @@ module DataMapper
 
             # if a unique property is used, and there is no OR operator, then an ORDER
             # and LIMIT are unecessary because it should only return a single row
-            if conditions.kind_of?(Query::Conditions::AndOperation) &&
-               conditions.any? { |operand| operand.kind_of?(Query::Conditions::EqualToComparison) && operand.subject.respond_to?(:unique?) && operand.subject.unique? } &&
-               !conditions.any? { |operand| operand.kind_of?(Query::Conditions::OrOperation) }
+            if conditions.respond_to?(:slug) && conditions.slug == :and &&
+               conditions.any? { |operand| operand.respond_to?(:slug) && operand.slug == :eql && operand.subject.respond_to?(:unique?) && operand.subject.unique? } &&
+               !conditions.any? { |operand| operand.respond_to?(:slug) && operand.slug == :or }
               order = nil
+              no_order = true
               limit = nil
             end
           end
 
           conditions_statement, bind_values = conditions_statement(conditions, qualify)
 
+          model_key_column = columns_statement(model.key(name), qualify)
+          from_statement   = " FROM #{quote_name(model.storage_name(name))}"
+
           statement = "SELECT #{columns_statement(fields, qualify)}"
           if use_subquery
-            statement << " FROM #{quote_name(model.storage_name(name))}"
-            statement << " WHERE (#{columns_statement(model.key, qualify)}) IN"
-            statement << " (SELECT DISTINCT #{columns_statement(model.key, qualify)}"
+            statement << from_statement
+            statement << " WHERE (#{model_key_column}) IN"
+            statement << " (SELECT DISTINCT #{model_key_column}"
+            # do not need to do group by for uniqueness as just one row per primary key will be returned
+            no_group_by = true
           end
-          statement << " FROM #{quote_name(model.storage_name(name))}"
-          statement << join_statement(query, qualify)                      if qualify
-          statement << " WHERE (#{conditions_statement})"                  unless conditions_statement.blank?
+          statement << from_statement
+          statement << join_statement(query, qualify)     if qualify
+          statement << " WHERE (#{conditions_statement})" unless conditions_statement.blank?
           if use_subquery
             statement << ")"
           end
@@ -140,8 +150,8 @@ module DataMapper
             statement << " AND rownum <= ?"
             bind_values << limit
           end
-          statement << " GROUP BY #{columns_statement(group_by, qualify)}" unless group_by.blank?
-          statement << " ORDER BY #{order_statement(order, qualify)}"      unless order.blank?
+          statement << " GROUP BY #{columns_statement(group_by, qualify)}" unless no_group_by
+          statement << " ORDER BY #{order_statement(order, qualify)}"      unless no_order
 
           add_limit_offset!(statement, limit, offset, bind_values) unless use_simple_rownum_limit
 
@@ -152,19 +162,20 @@ module DataMapper
         # Functionality is mimiced through the use of nested selects.
         # See http://asktom.oracle.com/pls/ask/f?p=4950:8:::::F4950_P8_DISPLAYID:127412348064
         def add_limit_offset!(statement, limit, offset, bind_values)
-          if limit && offset > 0
+          positive_offset = offset > 0
+
+          if limit && positive_offset
             statement.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{statement}) raw_sql_ where rownum <= ?) where raw_rnum_ > ?"
             bind_values << offset + limit << offset
           elsif limit
             statement.replace "select raw_sql_.* from (#{statement}) raw_sql_ where rownum <= ?"
             bind_values << limit
-          elsif offset > 0
+          elsif positive_offset
             statement.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{statement}) raw_sql_) where raw_rnum_ > ?"
             bind_values << offset
           end
         end
 
-        # TODO: document
         # @api private
         # Oracle does not allow " in table or column names therefore substitute them with underscore
         def quote_name(name)
@@ -181,25 +192,15 @@ module DataMapper
         # NOTE: just first 32767 bytes will be compared!
         # @api private
         def equality_operator(property, operand)
-          if property.type == Types::Text
-            operand.nil? ? 'IS' : 'DBMS_LOB.SUBSTR(%s) = ?'
-          else
-            operand.nil? ? 'IS' : '='
-          end
-        end
-
-        # CLOB value should be compared using DBMS_LOB.SUBSTR function
-        # NOTE: just first 32767 bytes will be compared!
-        # @api private
-        def inequality_operator(property, operand)
-          if property.type == Types::Text
-            operand.nil? ? 'IS NOT' : 'DBMS_LOB.SUBSTR(%s) <> ?'
+          if operand.nil?
+            'IS'
+          elsif property.type == Types::Text
+            'DBMS_LOB.SUBSTR(%s) = ?'
           else
-            operand.nil? ? 'IS NOT' : '<>'
+            '='
           end
         end
 
-        # TODO: document
         # @api private
         def include_operator(property, operand)
           operator = case operand
@@ -213,32 +214,11 @@ module DataMapper
           end
         end
 
-        # TODO: document
-        # @api private
-        def exclude_operator(property, operand)
-          operator = case operand
-            when Array then 'NOT IN'
-            when Range then 'NOT BETWEEN'
-          end
-          if property.type == Types::Text
-            "DBMS_LOB.SUBSTR(%s) #{operator} ?"
-          else
-            operator
-          end
-        end
-
-        # TODO: document
         # @api private
         def regexp_operator(operand)
           'REGEXP_LIKE(%s, ?)'
         end
 
-        # TODO: document
-        # @api private
-        def not_regexp_operator(operand)
-          'NOT REGEXP_LIKE(%s, ?)'
-        end
-
       end #module SQL
 
       include SQL

data/lib/dm-core/adapters/postgres_adapter.rb

@@ -8,7 +8,6 @@ module DataMapper
       module SQL #:nodoc:
         private
 
-        # TODO: document
         # @api private
         def supports_returning?
           true

data/lib/dm-core/adapters/sqlite3_adapter.rb

@@ -5,6 +5,11 @@ require 'do_sqlite3'
 module DataMapper
   module Adapters
     class Sqlite3Adapter < DataObjectsAdapter
+      # @api private
+      def supports_subquery?(query, source_key, target_key, qualify)
+        # SQLite3 cannot match a subquery against more than one column
+        source_key.size == 1 && target_key.size == 1
+      end
     end # class Sqlite3Adapter
 
     const_added(:Sqlite3Adapter)

data/lib/dm-core/adapters/sqlserver_adapter.rb

@@ -0,0 +1,114 @@
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
+require 'do_sqlserver'
+
+DataObjects::Sqlserver = DataObjects::SqlServer
+
+module DataMapper
+  module Adapters
+    class SqlserverAdapter < DataObjectsAdapter
+      module SQL #:nodoc:
+        private
+
+        # Constructs INSERT statement for given query,
+        #
+        # @return [String] INSERT statement as a string
+        #
+        # @api private
+        def insert_statement(model, properties, serial)
+          statement = ""
+          # Check if there is a serial property being set directly
+          require_identity_insert = !properties.empty? && properties.any? { |property| property.serial? }
+          set_identity_insert(model, statement, true) if require_identity_insert
+          statement << super
+          set_identity_insert(model, statement, false) if require_identity_insert
+          statement
+        end
+
+        def set_identity_insert(model, statement, enable = true)
+          statement << " SET IDENTITY_INSERT #{quote_name(model.storage_name(name))} #{enable ? 'ON' : 'OFF'} "
+        end
+
+        def select_statement(query)
+          name     = self.name
+          qualify  = query.links.any?
+          fields   = query.fields
+          offset   = query.offset
+          limit    = query.limit
+          order_by = query.order
+          group_by = if qualify || query.unique?
+            fields.select { |property| property.kind_of?(Property) }
+          end
+
+          conditions_statement, bind_values = conditions_statement(query.conditions, qualify)
+
+          use_limit_offset_subquery = limit && offset > 0
+
+          columns_statement = columns_statement(fields, qualify)
+          from_statement    = " FROM #{quote_name(query.model.storage_name(name))}"
+          where_statement   = " WHERE #{conditions_statement}" unless conditions_statement.blank?
+          join_statement    = join_statement(query, qualify)
+          order_statement   = order_statement(order_by, qualify)
+          no_group_by       = group_by ? group_by.empty? : true
+          no_order_by       = order_by ? order_by.empty? : true
+
+          if use_limit_offset_subquery
+            # If using qualifiers, we must qualify elements outside the subquery
+            # with 'RowResults' -- this is a different scope to the subquery.
+            # Otherwise, we hit upon "multi-part identifier cannot be bound"
+            # error from SQL Server.
+            statement = "SELECT #{columns_statement(fields, qualify, 'RowResults')}"
+            statement << " FROM ( SELECT Row_Number() OVER (ORDER BY #{order_statement}) AS RowID,"
+            statement << " #{columns_statement}"
+            statement << from_statement
+            statement << join_statement                                      if qualify
+            statement << where_statement                                     if where_statement
+            statement << ") AS RowResults"
+            statement << " WHERE RowId > #{offset} AND RowId <= #{offset + limit}"
+            statement << " GROUP BY #{columns_statement(group_by, qualify, 'RowResults')}" unless no_group_by
+            statement << " ORDER BY #{order_statement(order_by, qualify, 'RowResults')}"   unless no_order_by
+          else
+            statement = "SELECT #{columns_statement}"
+            statement << from_statement
+            statement << join_statement                                      if qualify
+            statement << where_statement                                     if where_statement
+            statement << " GROUP BY #{columns_statement(group_by, qualify)}" unless no_group_by
+            statement << " ORDER BY #{order_statement}"   unless no_order_by
+          end
+
+          add_limit_offset!(statement, limit, offset, bind_values) unless use_limit_offset_subquery
+
+          return statement, bind_values
+        end
+
+        # SQL Server does not support LIMIT and OFFSET
+        # Functionality therefore must be mimicked through the use of nested selects.
+        # See also:
+        # - http://stackoverflow.com/questions/2840/paging-sql-server-2005-results
+        # - http://stackoverflow.com/questions/216673/emulate-mysql-limit-clause-in-microsoft-sql-server-2000
+        #
+        def add_limit_offset!(statement, limit, offset, bind_values)
+          # Limit and offset is handled by subqueries (see #select_statement).
+          if limit
+            # If there is just a limit on rows to return, but no offset, then we
+            # can use TOP clause.
+            statement.sub!(/^\s*SELECT(\s+DISTINCT)?/i) { "SELECT#{$1} TOP #{limit}" }
+            # bind_values << limit
+          end
+        end
+
+        # @api private
+        # TODO: Not actually supported out of the box. Is theoretically possible
+        # via CLR integration, custom functions.
+        def regexp_operator(operand)
+          'REGEXP'
+        end
+
+      end #module SQL
+
+      include SQL
+    end # class SqlserverAdapter
+
+    const_added(:SqlserverAdapter)
+  end # module Adapters
+end # module DataMapper

data/lib/dm-core/adapters/yaml_adapter.rb

@@ -4,7 +4,6 @@ require 'yaml'
 module DataMapper
   module Adapters
     class YamlAdapter < AbstractAdapter
-      # TODO: document
       # @api semipublic
       def create(resources)
         update_records(resources.first.model) do |records|
@@ -15,13 +14,11 @@ module DataMapper
         end
       end
 
-      # TODO: document
       # @api semipublic
       def read(query)
         query.filter_records(records_for(query.model).dup)
       end
 
-      # TODO: document
       # @api semipublic
       def update(attributes, collection)
         attributes = attributes_as_fields(attributes)
@@ -32,7 +29,6 @@ module DataMapper
         end
       end
 
-      # TODO: document
       # @api semipublic
       def delete(collection)
         update_records(collection.model) do |records|
@@ -44,7 +40,6 @@ module DataMapper
 
       private
 
-      # TODO: document
       # @api semipublic
       def initialize(name, options = {})
         super

data/lib/dm-core/associations/many_to_many.rb

@@ -26,7 +26,6 @@ module DataMapper
           end
         end
 
-        # TODO: document
         # @api semipublic
         alias target_key child_key
 
@@ -52,17 +51,20 @@ module DataMapper
         def through
           return @through if defined?(@through)
 
-          if options[:through].kind_of?(Associations::Relationship)
-            return @through = options[:through]
+          @through = options[:through]
+
+          if @through.kind_of?(Associations::Relationship)
+            return @through
           end
 
+          model           = source_model
           repository_name = source_repository_name
-          relationships   = source_model.relationships(repository_name)
+          relationships   = model.relationships(repository_name)
           name            = through_relationship_name
 
           @through = relationships[name] ||
             DataMapper.repository(repository_name) do
-              source_model.has(min..max, name, through_model, one_to_many_options)
+              model.has(min..max, name, through_model, one_to_many_options)
             end
 
           @through.child_key
@@ -70,22 +72,25 @@ module DataMapper
           @through
         end
 
-        # TODO: document
         # @api semipublic
         def via
           return @via if defined?(@via)
 
-          if options[:via].kind_of?(Associations::Relationship)
-            return @via = options[:via]
+          @via = options[:via]
+
+          if @via.kind_of?(Associations::Relationship)
+            return @via
           end
 
+          name            = self.name
+          through         = self.through
           repository_name = through.relative_target_repository_name
           through_model   = through.target_model
           relationships   = through_model.relationships(repository_name)
           singular_name   = name.to_s.singularize.to_sym
 
-          @via = relationships[options[:via]] ||
-            relationships[name]               ||
+          @via = relationships[@via] ||
+            relationships[name]      ||
             relationships[singular_name]
 
           @via ||= if anonymous_through_model?
@@ -101,7 +106,6 @@ module DataMapper
           @via
         end
 
-        # TODO: document
         # @api semipublic
         def links
           return @links if defined?(@links)
@@ -120,13 +124,11 @@ module DataMapper
           @links.freeze
         end
 
-        # TODO: document
         # @api private
         def source_scope(source)
           { through.inverse => source }
         end
 
-        # TODO: document
         # @api private
         def query
           # TODO: consider making this a query_for method, so that ManyToMany::Relationship#query only
@@ -152,7 +154,6 @@ module DataMapper
 
         private
 
-        # TODO: document
         # @api private
         def through_model
           namespace, name = through_model_namespace_name
@@ -173,7 +174,6 @@ module DataMapper
           end
         end
 
-        # TODO: document
         # @api private
         def through_model_namespace_name
           target_parts = target_model.base_model.name.split('::')
@@ -192,7 +192,6 @@ module DataMapper
           return namespace, name
         end
 
-        # TODO: document
         # @api private
         def through_relationship_name
           if anonymous_through_model?
@@ -218,7 +217,39 @@ module DataMapper
           options[:through] == Resource
         end
 
-        # TODO: document
+        # @api private
+        def nearest_relationship
+          return @nearest_relationship if defined?(@nearest_relationship)
+
+          nearest_relationship = self
+
+          while nearest_relationship.respond_to?(:through)
+            nearest_relationship = nearest_relationship.through
+          end
+
+          @nearest_relationship = nearest_relationship
+        end
+
+        # @api private
+        def valid_target?(target)
+          relationship = via
+          source_key   = relationship.source_key
+          target_key   = relationship.target_key
+
+          target.kind_of?(target_model) &&
+          source_key.valid?(target_key.get(target))
+        end
+
+        # @api private
+        def valid_source?(source)
+          relationship = nearest_relationship
+          source_key   = relationship.source_key
+          target_key   = relationship.target_key
+
+          source.kind_of?(source_model) &&
+          target_key.valid?(source_key.get(source))
+        end
+
         # @api semipublic
         chainable do
           def many_to_one_options
@@ -226,7 +257,6 @@ module DataMapper
           end
         end
 
-        # TODO: document
         # @api semipublic
         chainable do
           def one_to_many_options
@@ -241,13 +271,11 @@ module DataMapper
           self.class
         end
 
-        # TODO: document
         # @api private
         def invert
           inverse_class.new(inverse_name, parent_model, child_model, inverted_options)
         end
 
-        # TODO: document
         # @api private
         def inverted_options
           links   = self.links.dup
@@ -264,6 +292,8 @@ module DataMapper
             )
           end
 
+          options = self.options
+
           options.only(*OPTIONS - [ :min, :max ]).update(
             :through    => through,
             :child_key  => options[:parent_key],
@@ -312,7 +342,7 @@ module DataMapper
           # the intermediaries are removed
           lazy_load
 
-          unless intermediaries.destroy
+          unless intermediaries.all(via => self).destroy
             return false
           end
 
@@ -332,45 +362,71 @@ module DataMapper
         def destroy!
           assert_source_saved 'The source must be saved before mass-deleting the collection'
 
-          # make sure the records are loaded so they can be found when
-          # the intermediaries are removed
-          lazy_load
+          model      = self.model
+          key        = model.key(repository_name)
+          conditions = Query.target_conditions(self, key, key)
 
-          unless intermediaries.destroy!
+          unless intermediaries.all(via => self).destroy!
             return false
           end
 
-          super
+          unless model.all(:repository => repository, :conditions => conditions).destroy!
+            return false
+          end
+
+          each { |resource| resource.reset }
+          clear
+
+          true
         end
 
-        # Return the intermediaries between the source and the targets
+        # Return the intermediaries linking the source to the targets
         #
         # @return [Collection]
         #   the intermediary collection
         #
         # @api public
         def intermediaries
-          return @intermediaries if @intermediaries
+          through = self.through
+          source  = self.source
 
-          intermediaries = if through.loaded?(source)
+          @intermediaries ||= if through.loaded?(source)
             through.get!(source)
           else
-            through.set!(source, through.collection_for(source))
+            reset_intermediaries
           end
+        end
 
-          scoped = intermediaries.all(via => self)
+        protected
 
-          @intermediaries = scoped.query == intermediaries.query ? intermediaries : scoped
+        # Map the resources in the collection to the intermediaries
+        #
+        # @return [Hash]
+        #   the map of resources to their intermediaries
+        #
+        # @api private
+        def intermediary_for
+          @intermediary_for ||= {}
+        end
+
+        # @api private
+        def through
+          relationship.through
+        end
+
+        # @api private
+        def via
+          relationship.via
         end
 
         private
 
-        # TODO: document
         # @api private
         def _create(safe, attributes)
+          via = self.via
           if via.respond_to?(:resource_for)
             resource = super
-            if create_intermediary(safe, via => resource)
+            if create_intermediary(safe, resource)
               resource
             end
           else
@@ -380,21 +436,23 @@ module DataMapper
           end
         end
 
-        # TODO: document
         # @api private
         def _save(safe)
+          via = self.via
+
           if @removed.any?
             # delete only intermediaries linked to the removed targets
-            removed_intermediaries = intermediaries.all(via => @removed).each do |resource|
-              intermediaries.delete(resource)
-            end
+            return false unless intermediaries.all(via => @removed).send(safe ? :destroy : :destroy!)
 
-            return false unless removed_intermediaries.send(safe ? :destroy : :destroy!)
+            # reset the intermediaries so that it reflects the current state of the datastore
+            reset_intermediaries
           end
 
+          loaded_entries = self.loaded_entries
+
           if via.respond_to?(:resource_for)
             super
-            loaded_entries.all? { |resource| create_intermediary(safe, via => resource) }
+            loaded_entries.all? { |resource| create_intermediary(safe, resource) }
           else
             if intermediary = create_intermediary(safe)
               inverse = via.inverse
@@ -405,32 +463,36 @@ module DataMapper
           end
         end
 
-        # TODO: document
         # @api private
-        def create_intermediary(safe, attributes = {})
-          collection = intermediaries
+        def create_intermediary(safe, resource = nil)
+          intermediary_for = self.intermediary_for
 
-          return unless collection.send(safe ? :save : :save!)
+          intermediary_resource = intermediary_for[resource]
+          return intermediary_resource if intermediary_resource
 
-          intermediary = collection.first(attributes) ||
-                         collection.send(safe ? :create : :create!, attributes)
+          intermediaries = self.intermediaries
+          method         = safe ? :save : :save!
 
-          return intermediary if intermediary.saved?
-        end
+          return unless intermediaries.send(method)
 
-        # TODO: document
-        # @api private
-        def through
-          relationship.through
+          attributes = {}
+          attributes[via] = resource if resource
+
+          intermediary = intermediaries.first_or_new(attributes)
+          return unless intermediary.__send__(method)
+
+          # map the resource, even if it is nil, to the intermediary
+          intermediary_for[resource] = intermediary
         end
 
-        # TODO: document
         # @api private
-        def via
-          relationship.via
+        def reset_intermediaries
+          through = self.through
+          source  = self.source
+
+          through.set!(source, through.collection_for(source))
         end
 
-        # TODO: document
         # @api private
         def inverse_set(*)
           # do nothing