datamapper-dm-core 0.9.11 → 0.10.0

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

@@ -1,91 +1,161 @@
-gem 'data_objects', '~>0.9.12'
 require 'data_objects'
 
 module DataMapper
   module Adapters
-    # You must inherit from the DoAdapter, and implement the
-    # required methods to adapt a database library for use with the DataMapper.
+    # DataObjectsAdapter is the base class for all adapers for relational
+    # databases. If you want to add support for a new RDBMS, it makes
+    # sense to make your adapter class inherit from this class.
     #
-    # NOTE: By inheriting from DataObjectsAdapter, you get a copy of all the
+    # By inheriting from DataObjectsAdapter, you get a copy of all the
     # standard sub-modules (Quoting, Coersion and Queries) in your own Adapter.
     # You can extend and overwrite these copies without affecting the originals.
     class DataObjectsAdapter < AbstractAdapter
+      extend Chainable
+
+      # For each model instance in resources, issues an SQL INSERT
+      # (or equivalent) statement to create a new record in the data store for
+      # the instance
+      #
+      # Note that this method does not update identity map. A plugin needs to use
+      # adapter directly, it is up to plugin developer to keep identity map
+      # up to date.
+      #
+      # @param [Enumerable(Resource)] resources
+      #   The list of resources (model instances) to create
+      #
+      # @return [Integer]
+      #   The number of records that were actually saved into the database
+      #
+      # @api semipublic
       def create(resources)
-        created = 0
         resources.each do |resource|
-          repository = resource.repository
           model      = resource.model
+          serial     = model.serial(name)
           attributes = resource.dirty_attributes
 
-          # TODO: make a model.identity_field method
-          identity_field = model.key(repository.name).detect { |p| p.serial? }
+          properties  = []
+          bind_values = []
 
-          statement = create_statement(repository, model, attributes.keys, identity_field)
-          bind_values = attributes.values
+          # make the order of the properties consistent
+          model.properties(name).each do |property|
+            next unless attributes.key?(property)
 
-          result = execute(statement, *bind_values)
+            bind_value = attributes[property]
 
-          if result.to_i == 1
-            if identity_field
-              identity_field.set!(resource, result.insert_id)
+            # skip insering NULL for columns that are serial or without a default
+            next if bind_value.nil? && (property.serial? || !property.default?)
+
+            # if serial is being set explicitly, do not set it again
+            if property.equal?(serial)
+              serial = nil
             end
-            created += 1
-          end
-        end
-        created
-      end
 
-      def read_many(query)
-        Collection.new(query) do |collection|
-          with_connection do |connection|
-            command = connection.create_command(read_statement(query))
-            command.set_types(query.fields.map { |p| p.primitive })
+            properties  << property
+            bind_values << bind_value
+          end
 
-            begin
-              bind_values = query.bind_values.map do |v|
-                v == [] ? [nil] : v
-              end
-              reader = command.execute_reader(*bind_values)
+          statement = insert_statement(model, properties, serial)
+          result    = execute(statement, *bind_values)
 
-              while(reader.next!)
-                collection.load(reader.values)
-              end
-            ensure
-              reader.close if reader
-            end
+          if result.to_i == 1 && serial
+            serial.set!(resource, result.insert_id)
           end
         end
       end
 
-      def read_one(query)
+      # Constructs and executes SELECT query, then instantiates
+      # one or many object from result set.
+      #
+      # @param [Query] query
+      #   composition of the query to perform
+      #
+      # @return [Array]
+      #   result set of the query
+      #
+      # @api semipublic
+      def read(query)
+        fields = query.fields
+        types  = fields.map { |property| property.primitive }
+
+        statement, bind_values = select_statement(query)
+
+        records = []
+
         with_connection do |connection|
-          command = connection.create_command(read_statement(query))
-          command.set_types(query.fields.map { |p| p.primitive })
+          command = connection.create_command(statement)
+          command.set_types(types)
 
-          begin
-            reader = command.execute_reader(*query.bind_values)
+          reader = command.execute_reader(*bind_values)
 
-            if reader.next!
-              query.model.load(reader.values, query)
+          begin
+            while reader.next!
+              records << fields.zip(reader.values).to_hash
             end
           ensure
-            reader.close if reader
+            reader.close
           end
         end
+
+        records
       end
 
-      def update(attributes, query)
-        statement = update_statement(attributes.keys, query)
-        bind_values = attributes.values + query.bind_values
+      # Constructs and executes UPDATE statement for given
+      # attributes and a query
+      #
+      # @param [Hash(Property => Object)] attributes
+      #   hash of attribute values to set, keyed by Property
+      # @param [Collection] collection
+      #   collection of records to be updated
+      #
+      # @return [Integer]
+      #   the number of records updated
+      #
+      # @api semipublic
+      def update(attributes, collection)
+        query = collection.query
+
+        # TODO: if the query contains any links, a limit or an offset
+        # use a subselect to get the rows to be updated
+
+        properties  = []
+        bind_values = []
+
+        # make the order of the properties consistent
+        query.model.properties(name).each do |property|
+          next unless attributes.key?(property)
+          properties  << property
+          bind_values << attributes[property]
+        end
+
+        statement, conditions_bind_values = update_statement(properties, query)
+
+        bind_values.concat(conditions_bind_values)
+
         execute(statement, *bind_values).to_i
       end
 
-      def delete(query)
-        statement = delete_statement(query)
-        execute(statement, *query.bind_values).to_i
+      # Constructs and executes DELETE statement for given query
+      #
+      # @param [Collection] collection
+      #   collection of records to be deleted
+      #
+      # @return [Integer]
+      #   the number of records deleted
+      #
+      # @api semipublic
+      def delete(collection)
+        query = collection.query
+
+        # TODO: if the query contains any links, a limit or an offset
+        # use a subselect to get the rows to be deleted
+
+        statement, bind_values = delete_statement(query)
+        execute(statement, *bind_values).to_i
       end
 
       # Database-specific method
+      # TODO: document
+      # @api public
       def execute(statement, *bind_values)
         with_connection do |connection|
           command = connection.create_command(statement)
@@ -93,21 +163,30 @@ module DataMapper
         end
       end
 
+      # TODO: document
+      # @api public
       def query(statement, *bind_values)
-        with_reader(statement, bind_values) do |reader|
+        with_connection do |connection|
+          reader = connection.create_command(statement).execute_reader(*bind_values)
+          fields = reader.fields
+
           results = []
 
-          if (fields = reader.fields).size > 1
-            fields = fields.map { |field| Extlib::Inflection.underscore(field).to_sym }
-            struct = Struct.new(*fields)
+          begin
+            if fields.size > 1
+              fields = fields.map { |field| Extlib::Inflection.underscore(field).to_sym }
+              struct = Struct.new(*fields)
 
-            while(reader.next!) do
-              results << struct.new(*reader.values)
-            end
-          else
-            while(reader.next!) do
-              results << reader.values.at(0)
+              while reader.next!
+                results << struct.new(*reader.values)
+              end
+            else
+              while reader.next!
+                results << reader.values.at(0)
+              end
             end
+          ensure
+            reader.close
           end
 
           results
@@ -116,601 +195,470 @@ module DataMapper
 
       protected
 
-      def normalize_uri(uri_or_options)
-        if uri_or_options.kind_of?(String) || uri_or_options.kind_of?(Addressable::URI)
-          uri_or_options = DataObjects::URI.parse(uri_or_options)
-        end
-
-        if uri_or_options.kind_of?(DataObjects::URI)
-          return uri_or_options
-        end
-
-        query = uri_or_options.except(:adapter, :username, :password, :host, :port, :database).map { |pair| pair.join('=') }.join('&')
-        query = nil if query.blank?
-
-        return DataObjects::URI.parse(Addressable::URI.new(
-          :scheme   => uri_or_options[:adapter].to_s,
-          :user     => uri_or_options[:username],
-          :password => uri_or_options[:password],
-          :host     => uri_or_options[:host],
-          :port     => uri_or_options[:port],
-          :path     => uri_or_options[:database],
-          :query    => query
-        ))
+      # TODO: document
+      # @api private
+      def normalized_uri
+        @normalized_uri ||=
+          begin
+            query = @options.except(:adapter, :user, :password, :host, :port, :path, :fragment, :scheme, :query, :username, :database)
+            query = nil if query.empty?
+
+            DataObjects::URI.new(
+              @options[:adapter],
+              @options[:user] || @options[:username],
+              @options[:password],
+              @options[:host],
+              @options[:port],
+              @options[:path] || @options[:database],
+              query,
+              @options[:fragment]
+            ).freeze
+          end
       end
 
-      # TODO: clean up once transaction related methods move to dm-more/dm-transactions
-      def create_connection
-        if within_transaction?
-          current_transaction.primitive_for(self).connection
-        else
+      chainable do
+        protected
+
+        # Instantiates new connection object
+        #
+        # @api semipublic
+        def open_connection
           # DataObjects::Connection.new(uri) will give you back the right
-          # driver based on the Uri#scheme.
-          DataObjects::Connection.new(@uri)
+          # driver based on the DataObjects::URI#scheme
+          connection = connection_stack.last || DataObjects::Connection.new(normalized_uri)
+          connection_stack << connection
+          connection
         end
-      end
 
-      # TODO: clean up once transaction related methods move to dm-more/dm-transactions
-      def close_connection(connection)
-        connection.close unless within_transaction? && current_transaction.primitive_for(self).connection == connection
+        # Takes connection and closes it
+        #
+        # @api semipublic
+        def close_connection(connection)
+          connection_stack.pop
+          connection.close if connection_stack.empty?
+        end
       end
 
       private
 
+      # TODO: document
+      # @api public
       def initialize(name, uri_or_options)
         super
 
-        # Default the driver-specifc logger to DataMapper's logger
-        if driver_module = DataObjects.const_get(@uri.scheme.capitalize) rescue nil
+        # Default the driver-specific logger to DataMapper's logger
+        if driver_module = DataObjects.const_get(normalized_uri.scheme.capitalize)
           driver_module.logger = DataMapper.logger if driver_module.respond_to?(:logger=)
         end
       end
 
+      # TODO: document
+      # @api private
+      def connection_stack
+        connection_stack_for = Thread.current[:dm_do_connection_stack] ||= {}
+        connection_stack_for[self] ||= []
+      end
+
+      # TODO: document
+      # @api private
       def with_connection
-        connection = nil
         begin
-          connection = create_connection
-          return yield(connection)
-        rescue => e
-          DataMapper.logger.error(e.to_s)
-          raise e
+          yield connection = open_connection
+        rescue Exception => exception
+          DataMapper.logger.error(exception.to_s)
+          raise exception
         ensure
           close_connection(connection) if connection
         end
       end
 
-      def with_reader(statement, bind_values = [])
-        with_connection do |connection|
-          reader = nil
-          begin
-            reader = connection.create_command(statement).execute_reader(*bind_values)
-            return yield(reader)
-          ensure
-            reader.close if reader
+      # This module is just for organization. The methods are included into the
+      # Adapter below.
+      module SQL #:nodoc:
+        IDENTIFIER_MAX_LENGTH = 128
+
+        # TODO: document
+        # @api semipublic
+        def property_to_column_name(property, qualify)
+          if qualify
+            table_name = property.model.storage_name(name)
+            "#{quote_name(table_name)}.#{quote_name(property.field)}"
+          else
+            quote_name(property.field)
           end
         end
-      end
 
-      # This model is just for organization. The methods are included into the
-      # Adapter below.
-      module SQL
         private
 
         # Adapters requiring a RETURNING syntax for INSERT statements
         # should overwrite this to return true.
+        #
+        # @api private
         def supports_returning?
           false
         end
 
         # Adapters that do not support the DEFAULT VALUES syntax for
         # INSERT statements should overwrite this to return false.
+        #
+        # @api private
         def supports_default_values?
           true
         end
 
-        def create_statement(repository, model, properties, identity_field)
-          statement = "INSERT INTO #{quote_table_name(model.storage_name(repository.name))} "
+        # Constructs SELECT statement for given query,
+        #
+        # @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_by   = 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.
 
-          if supports_default_values? && properties.empty?
-            statement << 'DEFAULT VALUES'
-          else
-            statement << <<-EOS.compress_lines
-              (#{properties.map { |p| quote_column_name(p.field(repository.name)) } * ', '})
-              VALUES
-              (#{(['?'] * properties.size) * ', '})
-            EOS
-          end
+          qualify = query.links.any?
 
-          if supports_returning? && identity_field
-            statement << " RETURNING #{quote_column_name(identity_field.field(repository.name))}"
+          if qualify || query.unique?
+            group_by = fields.select { |property| property.kind_of?(Property) }
           end
 
-          statement
-        end
-
-        def read_statement(query)
-          statement = "SELECT #{fields_statement(query)}"
-          statement << " FROM #{quote_table_name(query.model.storage_name(query.repository.name))}"
-          statement << links_statement(query)                        if query.links.any?
-          statement << " WHERE #{conditions_statement(query)}"       if query.conditions.any?
-          statement << " GROUP BY #{group_by_statement(query)}"      if query.unique? && query.fields.any? { |p| p.kind_of?(Property) }
-          statement << " ORDER BY #{order_statement(query)}"         if query.order.any?
-          statement << " LIMIT #{quote_column_value(query.limit)}"   if query.limit
-          statement << " OFFSET #{quote_column_value(query.offset)}" if query.offset && query.offset > 0
-          statement
-        rescue => e
-          DataMapper.logger.error("QUERY INVALID: #{query.inspect} (#{e})")
-          raise e
-        end
-
-        def update_statement(properties, query)
-          statement = "UPDATE #{quote_table_name(query.model.storage_name(query.repository.name))}"
-          statement << " SET #{set_statement(query.repository, properties)}"
-          statement << " WHERE #{conditions_statement(query)}" if query.conditions.any?
-          statement
-        end
-
-        def set_statement(repository, properties)
-          properties.map { |p| "#{quote_column_name(p.field(repository.name))} = ?" } * ', '
-        end
-
-        def delete_statement(query)
-          statement = "DELETE FROM #{quote_table_name(query.model.storage_name(query.repository.name))}"
-          statement << " WHERE #{conditions_statement(query)}" if query.conditions.any?
-          statement
-        end
+          unless (limit && limit > 1) || offset > 0 || qualify
+            # TODO: move this method to Query, so that it walks the conditions
+            # and finds an OR operator
 
-        def fields_statement(query)
-          qualify = query.links.any?
-          query.fields.map { |p| property_to_column_name(query.repository, p, qualify) } * ', '
-        end
+            # TODO: handle cases where two or more properties need to be
+            # used together to be unique
 
-        def links_statement(query)
-          table_list = [query.model.storage_name(query.repository.name)]
-
-          statement = ''
-          query.links.each do |relationship|
-            parent_table_name = relationship.parent_model.storage_name(query.repository.name)
-            child_table_name  = relationship.child_model.storage_name(query.repository.name)
-
-            join_table_name = if table_list.include?(parent_table_name)
-              child_table_name
-            elsif table_list.include?(child_table_name)
-              parent_table_name
-            else
-              raise ArgumentError, 'you\'re trying to join a table with no connection to this query'
+            # 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_by = nil
+              limit    = nil
             end
-            table_list << join_table_name
-
-            # We only do INNER JOIN for now
-            statement << " INNER JOIN #{quote_table_name(join_table_name)} ON "
-
-            statement << relationship.parent_key.zip(relationship.child_key).map do |parent_property,child_property|
-              condition_statement(query, :eql, parent_property, child_property)
-            end * ' AND '
           end
 
-          statement
-        end
+          conditions_statement, bind_values = conditions_statement(conditions, qualify)
 
-        def conditions_statement(query)
-          query.conditions.map { |o,p,b| condition_statement(query, o, p, b) } * ' AND '
-        end
+          statement = "SELECT #{columns_statement(fields, qualify)}"
+          statement << " FROM #{quote_name(model.storage_name(name))}"
+          statement << join_statement(query, qualify)                      if qualify
+          statement << " WHERE #{conditions_statement}"                    unless conditions_statement.blank?
+          statement << " GROUP BY #{columns_statement(group_by, qualify)}" if group_by && group_by.any?
+          statement << " ORDER BY #{order_statement(order_by, qualify)}"   if order_by && order_by.any?
 
-        def group_by_statement(query)
-          repository = query.repository
-          qualify    = query.links.any?
-          query.fields.select { |p| p.kind_of?(Property) }.map { |p| property_to_column_name(repository, p, qualify) } * ', '
-        end
+          add_limit_offset!(statement, limit, offset, bind_values)
 
-        def order_statement(query)
-          repository = query.repository
-          qualify    = query.links.any?
-          query.order.map { |i| order_column(repository, i, qualify) } * ', '
+          return statement, bind_values
         end
 
-        def order_column(repository, item, qualify)
-          property, descending = nil, false
-
-          case item
-            when Property
-              property = item
-            when Query::Direction
-              property  = item.property
-              descending = true if item.direction == :desc
+        # default construction of LIMIT and OFFSET
+        # overriden in Oracle adapter
+        def add_limit_offset!(statement, limit, offset, bind_values)
+          if limit
+            statement   << ' LIMIT ?'
+            bind_values << limit
           end
 
-          order_column = property_to_column_name(repository, property, qualify)
-          order_column << ' DESC' if descending
-          order_column
+          if limit && offset > 0
+            statement   << ' OFFSET ?'
+            bind_values << offset
+          end
         end
 
-        def condition_statement(query, operator, left_condition, right_condition)
-          return left_condition if operator == :raw
+        # 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))} "
 
-          qualify = query.links.any?
-
-          conditions = [ left_condition, right_condition ].map do |condition|
-            if condition.kind_of?(Property) || condition.kind_of?(Query::Path)
-              property_to_column_name(query.repository, condition, qualify)
-            elsif condition.kind_of?(Query)
-              opposite = condition == left_condition ? right_condition : left_condition
-              query.merge_subquery(operator, opposite, condition)
-              "(#{read_statement(condition)})"
-
-            # [].all? is always true
-            elsif condition.kind_of?(Array) && condition.any? && condition.all? { |p| p.kind_of?(Property) }
-              property_values = condition.map { |p| property_to_column_name(query.repository, p, qualify) }
-              "(#{property_values * ', '})"
-            else
-              '?'
-            end
+          if supports_default_values? && properties.empty?
+            statement << default_values_clause
+          else
+            statement << <<-SQL.compress_lines
+              (#{properties.map { |property| quote_name(property.field) }.join(', ')})
+              VALUES
+              (#{(['?'] * properties.size).join(', ')})
+            SQL
           end
 
-          comparison = case operator
-            when :eql, :in then equality_operator(right_condition)
-            when :not      then inequality_operator(right_condition)
-            when :like     then 'LIKE'
-            when :gt       then '>'
-            when :gte      then '>='
-            when :lt       then '<'
-            when :lte      then '<='
-            else raise "Invalid query operator: #{operator.inspect}"
+          if supports_returning? && serial
+            statement << returning_clause(serial)
           end
 
-          "(" + (conditions * " #{comparison} ") + ")"
+          statement
         end
 
-        def equality_operator(operand)
-          case operand
-            when Array, Query then 'IN'
-            when Range        then 'BETWEEN'
-            when NilClass     then 'IS'
-            else                   '='
-          end
+        # by default PostgreSQL syntax
+        # overrided in Oracle adapter
+        def default_values_clause
+          'DEFAULT VALUES'
         end
 
-        def inequality_operator(operand)
-          case operand
-            when Array, Query then 'NOT IN'
-            when Range        then 'NOT BETWEEN'
-            when NilClass     then 'IS NOT'
-            else                   '<>'
-          end
+        # by default PostgreSQL syntax
+        # overrided in Oracle adapter
+        def returning_clause(serial)
+          " RETURNING #{quote_name(serial.field)}"
         end
 
-        def property_to_column_name(repository, property, qualify)
-          table_name = property.model.storage_name(repository.name) if property && property.respond_to?(:model)
+        # Constructs UPDATE statement for given query,
+        #
+        # @return [String] UPDATE statement as a string
+        #
+        # @api private
+        def update_statement(properties, query)
+          conditions_statement, bind_values = conditions_statement(query.conditions)
 
-          if table_name && qualify
-            "#{quote_table_name(table_name)}.#{quote_column_name(property.field(repository.name))}"
-          else
-            quote_column_name(property.field(repository.name))
-          end
-        end
+          statement = "UPDATE #{quote_name(query.model.storage_name(name))}"
+          statement << " SET #{properties.map { |property| "#{quote_name(property.field)} = ?" }.join(', ')}"
+          statement << " WHERE #{conditions_statement}" unless conditions_statement.blank?
 
-        # TODO: once the driver's quoting methods become public, have
-        # this method delegate to them instead
-        def quote_table_name(table_name)
-          table_name.gsub('"', '""').split('.').map { |part| "\"#{part}\"" } * '.'
+          return statement, bind_values
         end
 
-        # TODO: once the driver's quoting methods become public, have
-        # this method delegate to them instead
-        def quote_column_name(column_name)
-          "\"#{column_name.gsub('"', '""')}\""
-        end
+        # Constructs DELETE statement for given query,
+        #
+        # @return [String] DELETE statement as a string
+        #
+        # @api private
+        def delete_statement(query)
+          conditions_statement, bind_values = conditions_statement(query.conditions)
 
-        # TODO: once the driver's quoting methods become public, have
-        # this method delegate to them instead
-        def quote_column_value(column_value)
-          return 'NULL' if column_value.nil?
+          statement = "DELETE FROM #{quote_name(query.model.storage_name(name))}"
+          statement << " WHERE #{conditions_statement}" unless conditions_statement.blank?
 
-          case column_value
-            when String
-              if (integer = column_value.to_i).to_s == column_value
-                quote_column_value(integer)
-              elsif (float = column_value.to_f).to_s == column_value
-                quote_column_value(integer)
-              else
-                "'#{column_value.gsub("'", "''")}'"
-              end
-            when DateTime
-              quote_column_value(column_value.strftime('%Y-%m-%d %H:%M:%S'))
-            when Date
-              quote_column_value(column_value.strftime('%Y-%m-%d'))
-            when Time
-              quote_column_value(column_value.strftime('%Y-%m-%d %H:%M:%S') + ((column_value.usec > 0 ? ".#{column_value.usec.to_s.rjust(6, '0')}" : '')))
-            when Integer, Float
-              column_value.to_s
-            when BigDecimal
-              column_value.to_s('F')
-            else
-              column_value.to_s
-          end
+          return statement, bind_values
         end
-      end #module SQL
 
-      include SQL
-
-      # TODO: move to dm-more/dm-migrations
-      module Migration
-        # TODO: move to dm-more/dm-migrations
-        def upgrade_model_storage(repository, model)
-          table_name = model.storage_name(repository.name)
-
-          if success = create_model_storage(repository, model)
-            return model.properties(repository.name)
-          end
+        # Constructs comma separated list of fields
+        #
+        # @return [String]
+        #   list of fields as a string
+        #
+        # @api private
+        def columns_statement(properties, qualify)
+          properties.map { |property| property_to_column_name(property, qualify) }.join(', ')
+        end
 
-          properties = []
+        # Constructs joins clause
+        #
+        # @return [String]
+        #   joins clause
+        #
+        # @api private
+        def join_statement(query, qualify)
+          statement = ''
 
-          model.properties(repository.name).each do |property|
-            schema_hash = property_schema_hash(repository, property)
-            next if field_exists?(table_name, schema_hash[:name])
-            statement = alter_table_add_column_statement(table_name, schema_hash)
-            execute(statement)
-            properties << property
+          query.links.reverse_each do |relationship|
+            statement << " INNER JOIN #{quote_name(relationship.source_model.storage_name(name))} ON "
+            statement << relationship.target_key.zip(relationship.source_key).map do |target_property, source_property|
+              "#{property_to_column_name(target_property, qualify)} = #{property_to_column_name(source_property, qualify)}"
+            end.join(' AND ')
           end
 
-          properties
+          statement
         end
 
-        # TODO: move to dm-more/dm-migrations
-        def create_model_storage(repository, model)
-          return false if storage_exists?(model.storage_name(repository.name))
+        # Constructs where clause
+        #
+        # @return [String]
+        #   where clause
+        #
+        # @api private
+        def conditions_statement(conditions, qualify = false)
+          case conditions
+            when Query::Conditions::NotOperation
+              negate_operation(conditions, qualify)
+
+            when Query::Conditions::AbstractOperation
+              # TODO: remove this once conditions can be compressed
+              if conditions.operands.size == 1
+                # factor out operations with a single operand
+                conditions_statement(conditions.operands.first, qualify)
+              else
+                operation_statement(conditions, qualify)
+              end
 
-          execute(create_table_statement(repository, model))
+            when Query::Conditions::AbstractComparison
+              comparison_statement(conditions, qualify)
 
-          (create_index_statements(repository, model) + create_unique_index_statements(repository, model)).each do |sql|
-            execute(sql)
+            when Array
+              statement, bind_values = conditions  # handle raw conditions
+              [ "(#{statement})", bind_values ]
           end
-
-          true
         end
 
-        # TODO: move to dm-more/dm-migrations
-        def destroy_model_storage(repository, model)
-          execute(drop_table_statement(repository, model))
-          true
-        end
+        # Constructs order clause
+        #
+        # @return [String]
+        #   order clause
+        #
+        # @api private
+        def order_statement(order, qualify)
+          statements = order.map do |direction|
+            statement = property_to_column_name(direction.target, qualify)
+            statement << ' DESC' if direction.operator == :desc
+            statement
+          end
 
-        # TODO: move to dm-more/dm-transactions
-        def transaction_primitive
-          DataObjects::Transaction.create_for_uri(@uri)
+          statements.join(', ')
         end
 
-        module SQL
-          private
-
-          # Adapters that support AUTO INCREMENT fields for CREATE TABLE
-          # statements should overwrite this to return true
-          #
-          # TODO: move to dm-more/dm-migrations
-          def supports_serial?
-            false
-          end
-
-          # TODO: move to dm-more/dm-migrations
-          def alter_table_add_column_statement(table_name, schema_hash)
-            "ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{property_schema_statement(schema_hash)}"
+        # TODO: document
+        # @api private
+        def negate_operation(operation, qualify)
+          @negated = !@negated
+          begin
+            conditions_statement(operation.operands.first, qualify)
+          ensure
+            @negated = !@negated
           end
+        end
 
-          # TODO: move to dm-more/dm-migrations
-          def create_table_statement(repository, model)
-            repository_name = repository.name
+        # TODO: document
+        # @api private
+        def operation_statement(operation, qualify)
+          statements  = []
+          bind_values = []
 
-            statement = <<-EOS.compress_lines
-              CREATE TABLE #{quote_table_name(model.storage_name(repository_name))}
-              (#{model.properties_with_subclasses(repository_name).map { |p| property_schema_statement(property_schema_hash(repository, p)) } * ', '}
-            EOS
+          operation.each do |operand|
+            statement, values = conditions_statement(operand, qualify)
 
-            if (key = model.key(repository_name)).any?
-              statement << ", PRIMARY KEY(#{ key.map { |p| quote_column_name(p.field(repository_name)) } * ', '})"
+            if operand.respond_to?(:operands) && operand.operands.size > 1
+              statement = "(#{statement})"
             end
 
-            statement << ')'
-            statement
+            statements << statement
+            bind_values.concat(values)
           end
 
-          # TODO: move to dm-more/dm-migrations
-          def drop_table_statement(repository, model)
-            "DROP TABLE IF EXISTS #{quote_table_name(model.storage_name(repository.name))}"
-          end
+          join_with = operation.kind_of?(@negated ? Query::Conditions::OrOperation : Query::Conditions::AndOperation) ? 'AND' : 'OR'
+          statement = statements.join(" #{join_with} ")
 
-          # TODO: move to dm-more/dm-migrations
-          def create_index_statements(repository, model)
-            table_name = model.storage_name(repository.name)
-            model.properties(repository.name).indexes.map do |index_name, fields|
-              <<-EOS.compress_lines
-                CREATE INDEX #{quote_column_name("index_#{table_name}_#{index_name}")} ON
-                #{quote_table_name(table_name)} (#{fields.map { |f| quote_column_name(f) } * ', '})
-              EOS
-            end
-          end
+          return statement, bind_values
+        end
 
-          # TODO: move to dm-more/dm-migrations
-          def create_unique_index_statements(repository, model)
-            table_name = model.storage_name(repository.name)
-            model.properties(repository.name).unique_indexes.map do |index_name, fields|
-              <<-EOS.compress_lines
-                CREATE UNIQUE INDEX #{quote_column_name("unique_index_#{table_name}_#{index_name}")} ON
-                #{quote_table_name(table_name)} (#{fields.map { |f| quote_column_name(f) } * ', '})
-              EOS
-            end
-          end
+        # Constructs comparison clause
+        #
+        # @return [String]
+        #   comparison clause
+        #
+        # @api private
+        def comparison_statement(comparison, qualify)
+          value = comparison.value
 
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_hash(repository, property)
-            schema = self.class.type_map[property.type].merge(:name => property.field(repository.name))
-            # TODO: figure out a way to specify the size not be included, even if
-            # a default is defined in the typemap
-            #  - use this to make it so all TEXT primitive fields do not have size
-            if property.primitive == String && schema[:primitive] != 'TEXT'
-              schema[:size] = property.length
-            elsif property.primitive == BigDecimal || property.primitive == Float
-              schema[:precision] = property.precision
-              schema[:scale]     = property.scale
-            end
+          # TODO: move exclusive Range handling into another method, and
+          # update conditions_statement to use it
 
-            schema[:nullable?] = property.nullable?
-            schema[:serial?]   = property.serial?
+          # break exclusive Range queries up into two comparisons ANDed together
+          if value.kind_of?(Range) && value.exclude_end?
+            operation = Query::Conditions::Operation.new(:and,
+              Query::Conditions::Comparison.new(:gte, comparison.subject, value.first),
+              Query::Conditions::Comparison.new(:lt,  comparison.subject, value.last)
+            )
 
-            if property.default.nil? || property.default.respond_to?(:call)
-              # remove the default if the property is not nullable
-              schema.delete(:default) unless property.nullable?
-            else
-              if property.type.respond_to?(:dump)
-                schema[:default] = property.type.dump(property.default, property)
-              else
-                schema[:default] = property.default
-              end
-            end
+            statement, bind_values = conditions_statement(operation, qualify)
 
-            schema
+            return "(#{statement})", bind_values
+          elsif comparison.relationship?
+            return conditions_statement(comparison.foreign_key_mapping, qualify)
           end
 
-          # TODO: move to dm-more/dm-migrations
-          def property_schema_statement(schema)
-            statement = quote_column_name(schema[:name])
-            statement << " #{schema[:primitive]}"
-
-            if schema[:precision] && schema[:scale]
-              statement << "(#{[ :precision, :scale ].map { |k| quote_column_value(schema[k]) } * ','})"
-            elsif schema[:size]
-              statement << "(#{quote_column_value(schema[:size])})"
-            end
+          operator = case comparison
+            when Query::Conditions::EqualToComparison              then @negated ? inequality_operator(comparison.subject, value) : equality_operator(comparison.subject, value)
+            when Query::Conditions::InclusionComparison            then @negated ? exclude_operator(comparison.subject, value)    : include_operator(comparison.subject, value)
+            when Query::Conditions::RegexpComparison               then @negated ? not_regexp_operator(value) : regexp_operator(value)
+            when Query::Conditions::LikeComparison                 then @negated ? unlike_operator(value)     : like_operator(value)
+            when Query::Conditions::GreaterThanComparison          then @negated ? '<='                       : '>'
+            when Query::Conditions::LessThanComparison             then @negated ? '>='                       : '<'
+            when Query::Conditions::GreaterThanOrEqualToComparison then @negated ? '<'                        : '>='
+            when Query::Conditions::LessThanOrEqualToComparison    then @negated ? '>'                        : '<='
+          end
 
-            statement << ' NOT NULL' unless schema[:nullable?]
-            statement << " DEFAULT #{quote_column_value(schema[:default])}" if schema.has_key?(:default)
-            statement
+          # if operator return value contains ? then it means that it is function call
+          # and it contains placeholder (%s) for property name as well (used in Oracle adapter for regexp operator)
+          if operator.include?('?')
+            return operator % property_to_column_name(comparison.subject, qualify), [ value ]
+          else
+            return "#{property_to_column_name(comparison.subject, qualify)} #{operator} #{value.nil? ? 'NULL' : '?'}", [ value ].compact
           end
+        end
 
-          # TODO: move to dm-more/dm-migrations
-          def relationship_schema_hash(relationship)
-            identifier, relationship = relationship
+        # TODO: document
+        # @api private
+        def equality_operator(property, operand)
+          operand.nil? ? 'IS' : '='
+        end
 
-            self.class.type_map[Integer].merge(:name => "#{identifier}_id") if identifier == relationship.name
-          end
+        # TODO: document
+        # @api private
+        def inequality_operator(property, operand)
+          operand.nil? ? 'IS NOT' : '<>'
+        end
 
-          # TODO: move to dm-more/dm-migrations
-          def relationship_schema_statement(hash)
-            property_schema_statement(hash) unless hash.nil?
-          end
-        end # module SQL
-
-        include SQL
-
-        module ClassMethods
-          # Default TypeMap for all data object based adapters.
-          #
-          # @return <DataMapper::TypeMap> default TypeMap for data objects adapters.
-          #
-          # TODO: move to dm-more/dm-migrations
-          def type_map
-            @type_map ||= TypeMap.new(super) do |tm|
-              tm.map(Integer).to('INT')
-              tm.map(String).to('VARCHAR').with(:size => Property::DEFAULT_LENGTH)
-              tm.map(Class).to('VARCHAR').with(:size => Property::DEFAULT_LENGTH)
-              tm.map(DM::Discriminator).to('VARCHAR').with(:size => Property::DEFAULT_LENGTH)
-              tm.map(BigDecimal).to('DECIMAL').with(:precision => Property::DEFAULT_PRECISION, :scale => Property::DEFAULT_SCALE_BIGDECIMAL)
-              tm.map(Float).to('FLOAT').with(:precision => Property::DEFAULT_PRECISION)
-              tm.map(DateTime).to('DATETIME')
-              tm.map(Date).to('DATE')
-              tm.map(Time).to('TIMESTAMP')
-              tm.map(TrueClass).to('BOOLEAN')
-              tm.map(DM::Object).to('TEXT')
-              tm.map(DM::Text).to('TEXT')
-            end
+        # TODO: document
+        # @api private
+        def include_operator(property, operand)
+          case operand
+            when Array then 'IN'
+            when Range then 'BETWEEN'
           end
-        end # module ClassMethods
-      end # module Migration
-
-      include Migration
-      extend Migration::ClassMethods
-    end # class DataObjectsAdapter
-  end # module Adapters
+        end
 
-  # TODO: move to dm-ar-finders
-  module Model
-    #
-    # Find instances by manually providing SQL
-    #
-    # @param sql<String>   an SQL query to execute
-    # @param <Array>    an Array containing a String (being the SQL query to
-    #   execute) and the parameters to the query.
-    #   example: ["SELECT name FROM users WHERE id = ?", id]
-    # @param query<DataMapper::Query>  a prepared Query to execute.
-    # @param opts<Hash>     an options hash.
-    #     :repository<Symbol> the name of the repository to execute the query
-    #       in. Defaults to self.default_repository_name.
-    #     :reload<Boolean>   whether to reload any instances found that already
-    #      exist in the identity map. Defaults to false.
-    #     :properties<Array>  the Properties of the instance that the query
-    #       loads. Must contain DataMapper::Properties.
-    #       Defaults to self.properties.
-    #
-    # @note
-    #   A String, Array or Query is required.
-    # @return <Collection> the instance matched by the query.
-    #
-    # @example
-    #   MyClass.find_by_sql(["SELECT id FROM my_classes WHERE county = ?",
-    #     selected_county], :properties => MyClass.property[:id],
-    #     :repository => :county_repo)
-    #
-    # -
-    # @api public
-    def find_by_sql(*args)
-      sql = nil
-      query = nil
-      bind_values = []
-      properties = nil
-      do_reload = false
-      repository_name = default_repository_name
-      args.each do |arg|
-        if arg.is_a?(String)
-          sql = arg
-        elsif arg.is_a?(Array)
-          sql = arg.first
-          bind_values = arg[1..-1]
-        elsif arg.is_a?(DataMapper::Query)
-          query = arg
-        elsif arg.is_a?(Hash)
-          repository_name = arg.delete(:repository) if arg.include?(:repository)
-          properties = Array(arg.delete(:properties)) if arg.include?(:properties)
-          do_reload = arg.delete(:reload) if arg.include?(:reload)
-          raise "unknown options to #find_by_sql: #{arg.inspect}" unless arg.empty?
+        # TODO: document
+        # @api private
+        def exclude_operator(property, operand)
+          "NOT #{include_operator(property, operand)}"
         end
-      end
 
-      repository = repository(repository_name)
-      raise "#find_by_sql only available for Repositories served by a DataObjectsAdapter" unless repository.adapter.is_a?(DataMapper::Adapters::DataObjectsAdapter)
+        # TODO: document
+        # @api private
+        def regexp_operator(operand)
+          '~'
+        end
 
-      if query
-        sql = repository.adapter.send(:read_statement, query)
-        bind_values = query.bind_values
-      end
+        # TODO: document
+        # @api private
+        def not_regexp_operator(operand)
+          '!~'
+        end
 
-      raise "#find_by_sql requires a query of some kind to work" unless sql
+        # TODO: document
+        # @api private
+        def like_operator(operand)
+          'LIKE'
+        end
 
-      properties ||= self.properties(repository.name)
+        # TODO: document
+        # @api private
+        def unlike_operator(operand)
+          'NOT LIKE'
+        end
 
-      Collection.new(Query.new(repository, self)) do |collection|
-        repository.adapter.send(:with_connection) do |connection|
-          command = connection.create_command(sql)
+        # TODO: document
+        # @api private
+        def quote_name(name)
+          "\"#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('"', '""')}\""
+        end
+      end #module SQL
 
-          begin
-            reader = command.execute_reader(*bind_values)
+      include SQL
+    end # class DataObjectsAdapter
 
-            while(reader.next!)
-              collection.load(reader.values)
-            end
-          ensure
-            reader.close if reader
-          end
-        end
-      end
-    end
-  end # module Model
+    const_added(:DataObjectsAdapter)
+  end # module Adapters
 end # module DataMapper