rpbertp13-dm-core 0.9.11.1

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

@@ -0,0 +1,87 @@
+module DataMapper
+  module Adapters
+    class InMemoryAdapter < AbstractAdapter
+      def initialize(name, uri_or_options)
+        @records = Hash.new { |hash,model| hash[model] = Array.new }
+      end
+
+      def create(resources)
+        resources.each do |resource|
+          @records[resource.model] << resource
+        end.size # just return the number of records
+      end
+
+      def update(attributes, query)
+        read_many(query).each do |resource|
+          attributes.each do |property,value|
+            property.set!(resource, value)
+          end
+        end.size
+      end
+
+      def read_one(query)
+        read(query, query.model, false)
+      end
+
+      def read_many(query)
+        Collection.new(query) do |set|
+          read(query, set, true)
+        end
+      end
+
+      def delete(query)
+        records = @records[query.model]
+
+        read_many(query).each do |resource|
+          records.delete(resource)
+        end.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)
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+gem 'do_mysql', '~>0.10.0'
+require 'do_mysql'
+
+module DataMapper
+  module Adapters
+    # Options:
+    # host, user, password, database (path), socket(uri query string), port
+    class MysqlAdapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def supports_default_values?
+          false
+        end
+
+        def quote_table_name(table_name)
+          "`#{table_name.gsub('`', '``')}`"
+        end
+
+        def quote_column_name(column_name)
+          "`#{column_name.gsub('`', '``')}`"
+        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
+        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')
+              tm.map(DateTime).to('DATETIME')
+              tm.map(Time).to('DATETIME')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class MysqlAdapter
+  end # module Adapters
+end # module DataMapper

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

@@ -0,0 +1,189 @@
+gem 'do_postgres', '~>0.10.0'
+require 'do_postgres'
+
+module DataMapper
+  module Adapters
+    class PostgresAdapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def supports_returning?
+          true
+        end
+      end #module SQL
+
+      include SQL
+
+      # TODO: move to dm-more/dm-migrations (if possible)
+      module Migration
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          statement = <<-SQL.compress_lines
+            SELECT COUNT(*)
+            FROM "information_schema"."tables"
+            WHERE "table_type" = 'BASE TABLE'
+            AND "table_schema" = current_schema()
+            AND "table_name" = ?
+          SQL
+
+          query(statement, storage_name).first > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, column_name)
+          statement = <<-SQL.compress_lines
+            SELECT COUNT(*)
+            FROM "information_schema"."columns"
+            WHERE "table_schema" = current_schema()
+            AND "table_name" = ?
+            AND "column_name" = ?
+          SQL
+
+          query(statement, storage_name, column_name).first > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def upgrade_model_storage(repository, model)
+          add_sequences(repository, model)
+          super
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_model_storage(repository, model)
+          add_sequences(repository, model)
+          without_notices { super }
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_model_storage(repository, model)
+          return true unless storage_exists?(model.storage_name(repository.name))
+          success = without_notices { super }
+          model.properties(repository.name).each do |property|
+            drop_sequence(repository, property) if property.serial?
+          end
+          success
+        end
+
+        protected
+
+        # TODO: move to dm-more/dm-migrations
+        def create_sequence(repository, property)
+          return if sequence_exists?(repository, property)
+          execute(create_sequence_statement(repository, property))
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def drop_sequence(repository, property)
+          without_notices { execute(drop_sequence_statement(repository, property)) }
+        end
+
+        module SQL
+          private
+
+          # TODO: move to dm-more/dm-migrations
+          def drop_table_statement(repository, model)
+            "DROP TABLE #{quote_table_name(model.storage_name(repository.name))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def without_notices
+            # execute the block with NOTICE messages disabled
+            begin
+              execute('SET client_min_messages = warning')
+              yield
+            ensure
+              execute('RESET client_min_messages')
+            end
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def add_sequences(repository, model)
+            model.properties(repository.name).each do |property|
+              create_sequence(repository, property) if property.serial?
+            end
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sequence_name(repository, property)
+            "#{property.model.storage_name(repository.name)}_#{property.field(repository.name)}_seq"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sequence_exists?(repository, property)
+            statement = <<-EOS.compress_lines
+              SELECT COUNT(*)
+              FROM "information_schema"."sequences"
+              WHERE "sequence_name" = ?
+              AND "sequence_schema" = current_schema()
+            EOS
+
+            query(statement, sequence_name(repository, property)).first > 0
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def create_sequence_statement(repository, property)
+            "CREATE SEQUENCE #{quote_column_name(sequence_name(repository, property))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def drop_sequence_statement(repository, property)
+            "DROP SEQUENCE IF EXISTS #{quote_column_name(sequence_name(repository, property))}"
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_statement(schema)
+            statement = super
+
+            if schema.has_key?(:sequence_name)
+              statement << " DEFAULT nextval('#{schema[:sequence_name]}') NOT NULL"
+            end
+
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_hash(repository, property)
+            schema = super
+
+            if property.serial?
+              schema.delete(:default)  # the sequence will be the default
+              schema[:sequence_name] = sequence_name(repository, property)
+            end
+
+            # TODO: see if TypeMap can be updated to set specific attributes to nil
+            # for different adapters.  precision/scale are perfect examples for
+            # Postgres floats
+
+            # Postgres does not support precision and scale for Float
+            if property.primitive == Float
+              schema.delete(:precision)
+              schema.delete(:scale)
+            end
+
+            schema
+          end
+        end # module SQL
+
+        include SQL
+
+        module ClassMethods
+          # TypeMap for PostgreSQL databases.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap for PostgreSQL databases.
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new(super) do |tm|
+              tm.map(Integer).to('INTEGER')
+              tm.map(BigDecimal).to('NUMERIC').with(:precision => Property::DEFAULT_PRECISION, :scale => Property::DEFAULT_SCALE_BIGDECIMAL)
+              tm.map(Float).to('DOUBLE PRECISION')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class PostgresAdapter
+  end # module Adapters
+end # module DataMapper

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

@@ -0,0 +1,105 @@
+gem 'do_sqlite3', '~>0.10.0'
+require 'do_sqlite3'
+
+module DataMapper
+  module Adapters
+    class Sqlite3Adapter < DataObjectsAdapter
+      module SQL
+        private
+
+        def quote_column_value(column_value)
+          case column_value
+            when TrueClass  then quote_column_value('t')
+            when FalseClass then quote_column_value('f')
+            else
+              super
+          end
+        end
+      end # module SQL
+
+      include SQL
+
+      # TODO: move to dm-more/dm-migrations (if possible)
+      module Migration
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          query_table(storage_name).size > 0
+        end
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, column_name)
+          query_table(storage_name).any? do |row|
+            row.name == column_name
+          end
+        end
+
+        private
+
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def query_table(table_name)
+          query('PRAGMA table_info(?)', table_name)
+        end
+
+        module SQL
+#          private  ## This cannot be private for current migrations
+
+          # TODO: move to dm-more/dm-migrations
+          def supports_serial?
+            sqlite_version >= '3.1.0'
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def create_table_statement(repository, model)
+            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
+
+            # skip adding the primary key if one of the columns is serial.  In
+            # SQLite the serial column must be the primary key, so it has already
+            # been defined
+            unless model.properties(repository.name).any? { |p| p.serial? }
+              if (key = model.properties(repository.name).key).any?
+                statement << ", PRIMARY KEY(#{key.map { |p| quote_column_name(p.field(repository.name)) } * ', '})"
+              end
+            end
+
+            statement << ')'
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def property_schema_statement(schema)
+            statement = super
+            statement << ' PRIMARY KEY AUTOINCREMENT' if supports_serial? && schema[:serial?]
+            statement
+          end
+
+          # TODO: move to dm-more/dm-migrations
+          def sqlite_version
+            @sqlite_version ||= query('SELECT sqlite_version(*)').first
+          end
+        end # module SQL
+
+        include SQL
+
+        module ClassMethods
+          # TypeMap for SQLite 3 databases.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap for SQLite 3 databases.
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new(super) do |tm|
+              tm.map(Integer).to('INTEGER')
+              tm.map(Class).to('VARCHAR')
+            end
+          end
+        end # module ClassMethods
+      end # module Migration
+
+      include Migration
+      extend Migration::ClassMethods
+    end # class Sqlite3Adapter
+  end # module Adapters
+end # module DataMapper