datamapper-dm-core 0.9.11 → 0.10.0

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

@@ -1,87 +1,108 @@
 module DataMapper
   module Adapters
+    # This is probably the simplest functional adapter possible. It simply
+    # stores and queries from a hash containing the model classes as keys,
+    # and an array of hashes. It is not persistent whatsoever; when the Ruby
+    # process finishes, everything that was stored it lost. However, it doesn't
+    # require any other external libraries, such as data_objects, so it is ideal
+    # for writing specs against. It also serves as an excellent example for
+    # budding adapter developers, so it is critical that it remains well documented
+    # and up to date.
     class InMemoryAdapter < AbstractAdapter
-      def initialize(name, uri_or_options)
-        @records = Hash.new { |hash,model| hash[model] = Array.new }
-      end
-
+      # Used by DataMapper to put records into a data-store: "INSERT" in SQL-speak.
+      # It takes an array of the resources (model instances) to be saved. Resources
+      # each have a key that can be used to quickly look them up later without
+      # searching, if the adapter supports it.
+      #
+      # @param [Enumerable(Resource)] resources
+      #   The set of resources (model instances)
+      #
+      # @api semipublic
       def create(resources)
-        resources.each do |resource|
-          @records[resource.model] << resource
-        end.size # just return the number of records
-      end
+        records = records_for(resources.first.model)
 
-      def update(attributes, query)
-        read_many(query).each do |resource|
-          attributes.each do |property,value|
-            property.set!(resource, value)
-          end
-        end.size
+        resources.each do |resource|
+          initialize_serial(resource, records.size.succ)
+          records << resource.attributes(:field)
+        end
       end
 
-      def read_one(query)
-        read(query, query.model, false)
+      # Looks up one record or a collection of records from the data-store:
+      # "SELECT" in SQL.
+      #
+      # @param [Query] query
+      #   The query to be used to seach for the resources
+      #
+      # @return [Array]
+      #   An Array of Hashes containing the key-value pairs for
+      #   each record
+      #
+      # @api semipublic
+      def read(query)
+        query.filter_records(records_for(query.model).dup)
       end
 
-      def read_many(query)
-        Collection.new(query) do |set|
-          read(query, set, true)
-        end
+      # Used by DataMapper to update the attributes on existing records in a
+      # data-store: "UPDATE" in SQL-speak. It takes a hash of the attributes
+      # to update with, as well as a collection object that specifies which resources
+      # should be updated.
+      #
+      # @param [Hash] attributes
+      #   A set of key-value pairs of the attributes to update the resources with.
+      # @param [DataMapper::Collection] resources
+      #   The collection of resources to update.
+      #
+      # @api semipublic
+      def update(attributes, collection)
+        attributes = attributes_as_fields(attributes)
+        read(collection.query).each { |resource| resource.update(attributes) }.size
       end
 
-      def delete(query)
-        records = @records[query.model]
-
-        read_many(query).each do |resource|
-          records.delete(resource)
-        end.size
+      # Destroys all the records matching the given query. "DELETE" in SQL.
+      #
+      # @param [DataMapper::Collection] resources
+      #   The collection of resources to delete.
+      #
+      # @return [Integer]
+      #   The number of records that were deleted.
+      #
+      # @api semipublic
+      def delete(collection)
+        records = records_for(collection.model)
+        records_to_delete = collection.query.filter_records(records.dup)
+        records.replace(records - records_to_delete)
+        records_to_delete.size
       end
 
       private
 
-      def read(query, set, many = true)
-        model      = query.model
-        conditions = query.conditions
-
-        match_with = many ? :select : :detect
-
-        # Iterate over the records for this model, and return
-        # the ones that match the conditions
-        result = @records[model].send(match_with) do |resource|
-          conditions.all? do |tuple|
-            operator, property, bind_value = *tuple
-
-            value = property.get!(resource)
-
-            case operator
-              when :eql, :in then equality_comparison(bind_value, value)
-              when :not      then !equality_comparison(bind_value, value)
-              when :like     then Regexp.new(bind_value) =~ value
-              when :gt       then !value.nil? && value >  bind_value
-              when :gte      then !value.nil? && value >= bind_value
-              when :lt       then !value.nil? && value <  bind_value
-              when :lte      then !value.nil? && value <= bind_value
-              else raise "Invalid query operator: #{operator.inspect}"
-            end
-          end
-        end
-
-        return result unless many
-
-        # TODO Sort
-
-        # TODO Limit
-
-        set.replace(result)
+      # Make a new instance of the adapter. The @records ivar is the 'data-store'
+      # for this adapter. It is not shared amongst multiple incarnations of this
+      # adapter, eg DataMapper.setup(:default, :adapter => :in_memory);
+      # DataMapper.setup(:alternate, :adapter => :in_memory) do not share the
+      # data-store between them.
+      #
+      # @param [String, Symbol] name
+      #   The name of the Repository using this adapter.
+      # @param [String, Hash] uri_or_options
+      #   The connection uri string, or a hash of options to set up
+      #   the adapter
+      #
+      # @api semipublic
+      def initialize(name, options = {})
+        super
+        @records = {}
       end
 
-      def equality_comparison(bind_value, value)
-        case bind_value
-          when Array, Range then bind_value.include?(value)
-          when NilClass     then value.nil?
-          else                   bind_value == value
-        end
+      # All the records we're storing. This method will look them up by model name
+      #
+      # @api private
+      def records_for(model)
+        @records[model.storage_name(name)] ||= []
       end
-    end
-  end
-end
+
+    end # class InMemoryAdapter
+
+    const_added(:InMemoryAdapter)
+  end # module Adapters
+end # module DataMapper

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

@@ -1,136 +1,43 @@
-gem 'do_mysql', '~>0.9.12'
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
 require 'do_mysql'
 
 module DataMapper
   module Adapters
-    # Options:
-    # host, user, password, database (path), socket(uri query string), port
     class MysqlAdapter < DataObjectsAdapter
-      module SQL
+      module SQL #:nodoc:
+        IDENTIFIER_MAX_LENGTH = 64
+
         private
 
-        def supports_default_values?
+        # TODO: document
+        # @api private
+        def supports_default_values? #:nodoc:
           false
         end
 
-        def quote_table_name(table_name)
-          "`#{table_name.gsub('`', '``')}`"
+        # TODO: document
+        # @api private
+        def regexp_operator(operand)
+          'REGEXP'
         end
 
-        def quote_column_name(column_name)
-          "`#{column_name.gsub('`', '``')}`"
+        # TODO: document
+        # @api private
+        def not_regexp_operator(operand)
+          'NOT REGEXP'
         end
 
-        def quote_column_value(column_value)
-          case column_value
-            when TrueClass  then quote_column_value(1)
-            when FalseClass then quote_column_value(0)
-            else
-              super
-          end
+        # TODO: document
+        # @api private
+        def quote_name(name)
+          "`#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('`', '``')}`"
         end
       end #module SQL
 
       include SQL
-
-      # TODO: move to dm-more/dm-migrations
-      module Migration
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def storage_exists?(storage_name)
-          statement = <<-EOS.compress_lines
-            SELECT COUNT(*)
-            FROM `information_schema`.`tables`
-            WHERE `table_type` = 'BASE TABLE'
-            AND `table_schema` = ?
-            AND `table_name` = ?
-          EOS
-
-          query(statement, db_name, storage_name).first > 0
-        end
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def field_exists?(storage_name, field_name)
-          statement = <<-EOS.compress_lines
-            SELECT COUNT(*)
-            FROM `information_schema`.`columns`
-            WHERE `table_schema` = ?
-            AND `table_name` = ?
-            AND `column_name` = ?
-          EOS
-
-          query(statement, db_name, storage_name, field_name).first > 0
-        end
-
-        private
-
-        # TODO: move to dm-more/dm-migrations (if possible)
-        def db_name
-          @uri.path.split('/').last
-        end
-
-        module SQL
-          private
-
-          # TODO: move to dm-more/dm-migrations
-          def supports_serial?
-            true
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def create_table_statement(repository, model)
-            "#{super} ENGINE = InnoDB CHARACTER SET #{character_set} COLLATE #{collation}"
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_hash(property, model)
-            schema = super
-            schema.delete(:default) if schema[:primitive] == 'TEXT'
-            schema
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_statement(schema)
-            statement = super
-            statement << ' AUTO_INCREMENT' if supports_serial? && schema[:serial?]
-            statement
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def character_set
-            @character_set ||= show_variable('character_set_connection') || 'utf8'
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def collation
-            @collation ||= show_variable('collation_connection') || 'utf8_general_ci'
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def show_variable(name)
-            query('SHOW VARIABLES WHERE `variable_name` = ?', name).first.value rescue nil
-          end
-        end # module SQL
-
-        include SQL
-
-        module ClassMethods
-          # TypeMap for MySql databases.
-          #
-          # @return <DataMapper::TypeMap> default TypeMap for MySql databases.
-          #
-          # TODO: move to dm-more/dm-migrations
-          def type_map
-            @type_map ||= TypeMap.new(super) do |tm|
-              tm.map(Integer).to('INT').with(:size => 11)
-              tm.map(TrueClass).to('TINYINT').with(:size => 1)  # TODO: map this to a BIT or CHAR(0) field?
-              tm.map(Object).to('TEXT')
-            end
-          end
-        end # module ClassMethods
-      end # module Migration
-
-      include Migration
-      extend Migration::ClassMethods
     end # class MysqlAdapter
+
+    const_added(:MysqlAdapter)
   end # module Adapters
 end # module DataMapper

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

@@ -0,0 +1,249 @@
+require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
+
+require 'do_oracle'
+
+module DataMapper
+
+  class Property
+    # for custom sequence names
+    OPTIONS << :sequence
+  end
+
+  module Adapters
+    class OracleAdapter < DataObjectsAdapter
+      module SQL #:nodoc:
+        IDENTIFIER_MAX_LENGTH = 30
+
+        private
+
+        # Constructs INSERT statement for given query,
+        #
+        # @return [String] INSERT statement as a string
+        #
+        # @api private
+        def insert_statement(model, properties, serial)
+          statement = "INSERT INTO #{quote_name(model.storage_name(name))} "
+
+          custom_sequence = serial && serial.options[:sequence]
+
+          if supports_default_values? && properties.empty? && !custom_sequence
+            statement << "(#{quote_name(serial.field)}) " if serial
+            statement << default_values_clause
+          else
+            # do not use custom sequence if identity field was assigned a value
+            if custom_sequence && properties.include?(serial)
+              custom_sequence = nil
+            end
+            statement << "("
+            if custom_sequence
+              statement << "#{quote_name(serial.field)}"
+              statement << ", " unless properties.empty?
+            end
+            statement << "#{properties.map { |p| quote_name(p.field) }.join(', ')}) "
+            statement << "VALUES ("
+            if custom_sequence
+              statement << "#{quote_name(custom_sequence)}.NEXTVAL"
+              statement << ", " unless properties.empty?
+            end
+            statement << "#{(['?'] * properties.size).join(', ')})"
+          end
+
+          if supports_returning? && serial
+            statement << returning_clause(serial)
+          end
+
+          statement
+        end
+
+        # Oracle syntax for inserting default values
+        def default_values_clause
+          'VALUES (DEFAULT)'
+        end
+
+        # TODO: document
+        # @api private
+        def supports_returning?
+          true
+        end
+
+        # INTO :insert_id is recognized by Oracle DataObjects driver
+        def returning_clause(serial)
+          " RETURNING #{quote_name(serial.field)} INTO :insert_id"
+        end
+
+        # Constructs SELECT statement for given query,
+        # Overrides DataObjects adapter implementation with using subquery instead of GROUP BY to get unique records
+        #
+        # @return [String] SELECT statement as a string
+        #
+        # @api private
+        def select_statement(query)
+          model      = query.model
+          fields     = query.fields
+          conditions = query.conditions
+          limit      = query.limit
+          offset     = query.offset
+          order      = query.order
+          group_by   = nil
+
+          # FIXME: using a boolean for qualify does not work in some cases,
+          # such as when you have a self-referrential many to many association.
+          # if you don't qualfiy the columns with a unique alias, then the
+          # SQL query will fail.  This may mean though, that it might not
+          # be enough to pass in a Property, but we may need to know the
+          # table and the alias we should use for the column.
+
+          qualify = query.links.any?
+
+          if query.unique?
+            group_by = fields.select { |p| p.kind_of?(Property) }
+          end
+
+          # create subquery to find all valid keys and then use these keys to retrive all other columns
+          use_subquery = qualify
+
+          # when we can include ROWNUM condition in main WHERE clause
+          use_simple_rownum_limit = limit && (offset||0 == 0) && group_by.blank? && order.blank?
+
+          unless (limit && limit > 1) || offset > 0 || qualify
+            # TODO: move this method to Query, so that it walks the conditions
+            # and finds an OR operator
+
+            # TODO: handle cases where two or more properties need to be
+            # used together to be unique
+
+            # 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) }
+              order = nil
+              limit = nil
+            end
+          end
+
+          conditions_statement, bind_values = conditions_statement(conditions, qualify)
+
+          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)}"
+          end
+          statement << " FROM #{quote_name(model.storage_name(name))}"
+          statement << join_statement(query, qualify)                      if qualify
+          statement << " WHERE (#{conditions_statement})"                  unless conditions_statement.blank?
+          if use_subquery
+            statement << ")"
+          end
+          if use_simple_rownum_limit
+            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?
+
+          add_limit_offset!(statement, limit, offset, bind_values) unless use_simple_rownum_limit
+
+          return statement, bind_values
+        end
+
+        # Oracle does not support LIMIT and OFFSET
+        # 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
+            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
+            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)
+          "\"#{oracle_upcase(name)[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('"', '_')}\""
+        end
+
+        # If table or column name contains just lowercase characters then do uppercase
+        # as uppercase version will be used in Oracle data dictionary tables
+        def oracle_upcase(name)
+          name =~ /[A-Z]/ ? name : name.upcase
+        end
+
+        # CLOB value should be compared using DBMS_LOB.SUBSTR function
+        # 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) <> ?'
+          else
+            operand.nil? ? 'IS NOT' : '<>'
+          end
+        end
+
+        # TODO: document
+        # @api private
+        def include_operator(property, operand)
+          operator = case operand
+            when Array then 'IN'
+            when Range then 'BETWEEN'
+          end
+          if property.type == Types::Text
+            "DBMS_LOB.SUBSTR(%s) #{operator} ?"
+          else
+            operator
+          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
+    end # class PostgresAdapter
+
+    const_added(:OracleAdapter)
+  end # module Adapters
+end # module DataMapper