dm-core 0.10.2 → 1.0.0.rc1

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

@@ -1,42 +0,0 @@
-require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
-
-require 'do_mysql'
-
-module DataMapper
-  module Adapters
-    class MysqlAdapter < DataObjectsAdapter
-      module SQL #:nodoc:
-        IDENTIFIER_MAX_LENGTH = 64
-
-        private
-
-        # @api private
-        def supports_default_values? #:nodoc:
-          false
-        end
-
-        # @api private
-        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
-
-        # @api private
-        def regexp_operator(operand)
-          'REGEXP'
-        end
-
-        # @api private
-        def quote_name(name)
-          "`#{name[0, self.class::IDENTIFIER_MAX_LENGTH].gsub('`', '``')}`"
-        end
-      end #module SQL
-
-      include SQL
-    end # class MysqlAdapter
-
-    const_added(:MysqlAdapter)
-  end # module Adapters
-end # module DataMapper

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

@@ -1,229 +0,0 @@
-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))} "
-
-          no_properties   = properties.empty?
-          custom_sequence = serial && serial.options[:sequence]
-          serial_field    = serial && quote_name(serial.field)
-
-          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
-            if custom_sequence && properties.include?(serial)
-              custom_sequence = nil
-            end
-            statement << "("
-            if custom_sequence
-              statement << "#{serial_field}"
-              statement << ", " unless no_properties
-            end
-            statement << "#{properties.map { |property| quote_name(property.field) }.join(', ')}) "
-            statement << "VALUES ("
-            if custom_sequence
-              statement << "#{quote_name(custom_sequence)}.NEXTVAL"
-              statement << ", " unless no_properties
-            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
-
-        # @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)
-          name       = self.name
-          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 { |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) && no_group_by && no_order
-
-          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.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_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_statement
-          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 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
-
-          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)
-          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 positive_offset
-            statement.replace "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{statement}) raw_sql_) where raw_rnum_ > ?"
-            bind_values << offset
-          end
-        end
-
-        # @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 operand.nil?
-            'IS'
-          elsif property.type == Types::Text
-            'DBMS_LOB.SUBSTR(%s) = ?'
-          else
-            '='
-          end
-        end
-
-        # @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
-
-        # @api private
-        def regexp_operator(operand)
-          'REGEXP_LIKE(%s, ?)'
-        end
-
-      end #module SQL
-
-      include SQL
-    end # class PostgresAdapter
-
-    const_added(:OracleAdapter)
-  end # module Adapters
-end # module DataMapper

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

@@ -1,22 +0,0 @@
-require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
-
-require 'do_postgres'
-
-module DataMapper
-  module Adapters
-    class PostgresAdapter < DataObjectsAdapter
-      module SQL #:nodoc:
-        private
-
-        # @api private
-        def supports_returning?
-          true
-        end
-      end #module SQL
-
-      include SQL
-    end # class PostgresAdapter
-
-    const_added(:PostgresAdapter)
-  end # module Adapters
-end # module DataMapper

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

@@ -1,17 +0,0 @@
-require DataMapper.root / 'lib' / 'dm-core' / 'adapters' / 'data_objects_adapter'
-
-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)
-  end # module Adapters
-end # module DataMapper

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

@@ -1,114 +0,0 @@
-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

@@ -1,111 +0,0 @@
-require 'pathname'
-require 'yaml'
-
-module DataMapper
-  module Adapters
-    class YamlAdapter < AbstractAdapter
-      # @api semipublic
-      def create(resources)
-        update_records(resources.first.model) do |records|
-          resources.each do |resource|
-            initialize_serial(resource, records.size.succ)
-            records << resource.attributes(:field)
-          end
-        end
-      end
-
-      # @api semipublic
-      def read(query)
-        query.filter_records(records_for(query.model).dup)
-      end
-
-      # @api semipublic
-      def update(attributes, collection)
-        attributes = attributes_as_fields(attributes)
-
-        update_records(collection.model) do |records|
-          records_to_update = collection.query.filter_records(records.dup)
-          records_to_update.each { |resource| resource.update(attributes) }.size
-        end
-      end
-
-      # @api semipublic
-      def delete(collection)
-        update_records(collection.model) do |records|
-          records_to_delete = collection.query.filter_records(records.dup)
-          records.replace(records - records_to_delete)
-          records_to_delete.size
-        end
-      end
-
-      private
-
-      # @api semipublic
-      def initialize(name, options = {})
-        super
-        (@path = Pathname(@options[:path]).freeze).mkpath
-      end
-
-      # Retrieves all records for a model and yeilds them to a block.
-      #
-      # The block should make any changes to the records in-place. After
-      # the block executes all the records are dumped back to the file.
-      #
-      # @param [Model, #to_s] model
-      #   Used to determine which file to read/write to
-      #
-      # @yieldparam [Hash]
-      #   A hash of record.key => record pairs retrieved from the file
-      #
-      # @api private
-      def update_records(model)
-        records = records_for(model)
-        result = yield records
-        write_records(model, records)
-        result
-      end
-
-      # Read all records from a file for a model
-      #
-      # @param [#storage_name] model
-      #   The model/name to retieve records for
-      #
-      # @api private
-      def records_for(model)
-        file = yaml_file(model)
-        file.readable? && YAML.load_file(file) || []
-      end
-
-      # Writes all records to a file
-      #
-      # @param [#storage_name] model
-      #   The model/name to write the records for
-      #
-      # @param [Hash] records
-      #   A hash of record.key => record pairs to be written
-      #
-      # @api private
-      def write_records(model, records)
-        yaml_file(model).open('w') do |fh|
-          YAML.dump(records, fh)
-        end
-      end
-
-      # Given a model, gives the filename to be used for record storage
-      #
-      # @example
-      #   yaml_file(Article) #=> "/path/to/files/articles.yml"
-      #
-      # @param [#storage_name] model
-      #   The model to be used to determine the file name.
-      #
-      # @api private
-      def yaml_file(model)
-        @path / "#{model.storage_name(name)}.yml"
-      end
-
-    end # class YamlAdapter
-
-    const_added(:YamlAdapter)
-  end # module Adapters
-end # module DataMapper