datamapper 0.2.3 → 0.2.4

data/plugins/dataobjects/do.rb

@@ -1,348 +0,0 @@
-require 'date'
-
-# Thanks http://www.rubyweeklynews.org/20051120
-class DateTime
- def to_time
-   Time.mktime(year, mon, day, hour, min, sec)
- end
- 
- def to_date
-   Date.new(year, mon, day)
- end
-end
-
-class Time
-  def to_datetime
-    DateTime.civil(year, mon, day, hour, min, sec)
-  end
-  
-  def to_s_db
-    strftime("%Y-%m-%d %X")
-  end
-end
-
-module DataObject
-  STATE_OPEN   = 0
-  STATE_CLOSED = 1
-
-  class Connection
-
-    attr_reader :timeout, :database, :datasource, :server_version, :state
-    
-    def initialize(connection_string)
-    end
-    
-    def logger
-      @logger || @logger = Logger.new(nil)
-    end
-    
-    def logger=(value)
-      @logger = value
-    end
-    
-    def begin_transaction
-      # TODO: Hook this up
-      Transaction.new
-    end
-    
-    def change_database(database_name)
-      raise NotImplementedError
-    end
-    
-    def open
-      raise NotImplementedError
-    end
-    
-    def close
-      raise NotImplementedError
-    end
-    
-    def create_command(text)
-      logger.debug { text }
-      Command.new(self, text)
-    end
-    
-    def closed?
-      @state == STATE_CLOSED
-    end
-    
-  end
-  
-  class Transaction
-    
-    attr_reader :connection
-    
-    def initialize(conn)
-      @connection = conn
-    end
-    
-    # Commits the transaction
-    def commit
-      raise NotImplementedError
-    end
-    
-    # Rolls back the transaction
-    def rollback(savepoint = nil)
-      raise NotImplementedError
-    end
-    
-    # Creates a savepoint for rolling back later (not commonly supported)
-    def save(name)
-      raise NotImplementedError
-    end
-    
-  end
-  
-  class Reader
-    include Enumerable
-    
-    attr_reader :field_count, :records_affected, :fields
-    
-    def each
-      raise NotImplementedError
-    end
-    
-    def has_rows?
-      @has_rows
-    end
-    
-    def current_row
-      ret = []
-      field_count.times do |i|
-        ret[i] = item(i)
-      end
-      ret
-    end
-    
-    def open?
-      @state != STATE_CLOSED
-    end
-    
-    def close        
-      real_close
-      @reader = nil
-      @state = STATE_CLOSED
-      true
-    end
-    
-    def real_close
-      raise NotImplementedError
-    end
-    
-    # retrieves the Ruby data type for a particular column number
-    def data_type_name(col)
-      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?      
-    end
-    
-    # retrieves the name of a particular column number
-    def name(col)
-      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?      
-    end
-    
-    # retrives the index of the column with a particular name
-    def get_index(name)
-      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?
-    end
-    
-    def item(idx)
-      raise ReaderClosed, "You cannot ask for information once the reader is closed" if state_closed?
-    end
-
-    # returns an array of hashes containing the following information
-    #            
-    # name:         the column name
-    # index:        the index of the column
-    # max_size:     the maximum allowed size of the data in the column
-    # precision:    the precision (for column types that support it)
-    # scale:        the scale (for column types that support it)
-    # unique:       boolean specifying whether the values must be unique
-    # key:          boolean specifying whether this column is, or is part
-    #               of, the primary key
-    # catalog:      the name of the database this column is part of
-    # base_name:    the original name of the column (if AS was used,
-    #               this will provide the original name)
-    # schema:       the name of the schema (if supported)
-    # table:        the name of the table this column is part of
-    # data_type:    the name of the Ruby data type used
-    # allow_null:   boolean specifying whether nulls are allowed
-    # db_type:      the type specified by the DB
-    # aliased:      boolean specifying whether the column has been
-    #               renamed using AS
-    # calculated:   boolean specifying whether the field is calculated
-    # serial:       boolean specifying whether the field is a serial
-    #               column
-    # blob:         boolean specifying whether the field is a BLOB
-    # readonly:     boolean specifying whether the field is readonly
-    def get_schema
-      raise ReaderClosed, "You cannot ask for metadata once the reader is closed" if state_closed?
-    end
-    
-    # specifies whether the column identified by the passed in index
-    # is null.
-    def null?(idx)
-      raise ReaderClosed, "You cannot ask for column information once the reader is closed" if state_closed?
-    end
-    
-    # Consumes the next result. Returns true if a result is consumed and
-    # false if none is
-    def next
-      raise ReaderClosed, "You cannot increment the cursor once the reader is closed" if state_closed?
-    end
-    
-    protected
-    def state_closed?
-      @state == STATE_CLOSED
-    end
-    
-    def native_type
-      raise ReaderClosed, "You cannot check the type of a column once the reader is closed" if state_closed?
-    end
-    
-  end
-  
-  class ResultData
-    
-    def initialize(conn, affected_rows, last_insert_row = nil)
-      @conn, @affected_rows, @last_insert_row = conn, affected_rows, last_insert_row
-    end
-  
-    attr_reader :affected_rows, :last_insert_row
-    alias_method :to_i, :affected_rows
-    
-  end
-  
-  class Schema < Array
-    
-  end
-  
-  class Command
-    
-    attr_reader :text, :timeout, :connection
-    
-    # initialize creates a new Command object
-    def initialize(connection, text)
-      @connection, @text = connection, text
-    end
-    
-    def execute_non_query(*args)
-      raise LostConnectionError, "the connection to the database has been lost" if @connection.closed?
-    end
-    
-    def execute_reader(*args)
-      raise LostConnectionError, "the connection to the database has been lost" if @connection.closed?
-    end
-    
-    def prepare
-      raise NotImplementedError
-    end
-    
-    # Escape a string of SQL with a set of arguments.
-    # The first argument is assumed to be the SQL to escape,
-    # the remaining arguments (if any) are assumed to be
-    # values to escape and interpolate.
-    #
-    # ==== Examples
-    #   escape_sql("SELECT * FROM zoos")
-    #   # => "SELECT * FROM zoos"
-    # 
-    #   escape_sql("SELECT * FROM zoos WHERE name = ?", "Dallas")
-    #   # => "SELECT * FROM zoos WHERE name = `Dallas`"
-    #
-    #   escape_sql("SELECT * FROM zoos WHERE name = ? AND acreage > ?", "Dallas", 40)
-    #   # => "SELECT * FROM zoos WHERE name = `Dallas` AND acreage > 40"
-    # 
-    # ==== Warning
-    # This method is meant mostly for adapters that don't support
-    # bind-parameters.
-    def escape_sql(args)
-      sql = text.dup
-    
-      unless args.empty?
-        sql.gsub!(/\?/) do |x|
-          quote_value(args.shift)
-        end
-      end
-      
-      sql
-    end
-    
-    def quote_value(value)
-      return 'NULL' if value.nil?
-
-      case value
-        when Numeric then quote_numeric(value)
-        when String then quote_string(value)
-        when Class then quote_class(value)
-        when Time then quote_time(value)
-        when DateTime then quote_datetime(value)
-        when Date then quote_date(value)
-        when TrueClass, FalseClass then quote_boolean(value)
-        when Array then quote_array(value)
-        else 
-          if value.respond_to?(:to_sql)
-            value.to_sql
-          else
-            raise "Don't know how to quote #{value.inspect}"
-          end
-      end
-    end
-    
-    def quote_numeric(value)
-      value.to_s
-    end
-    
-    def quote_string(value)
-      "'#{value.gsub("'", "''")}'"
-    end
-    
-    def quote_class(value)
-      "'#{value.name}'"
-    end
-    
-    def quote_time(value)
-      "'#{value.xmlschema}'"
-    end
-    
-    def quote_datetime(value)
-      "'#{value.dup}'"
-    end
-    
-    def quote_date(value)
-      "'#{value.strftime("%Y-%m-%d")}'"
-    end
-    
-    def quote_boolean(value)
-      value.to_s.upcase
-    end
-    
-    def quote_array(value)
-      "(#{value.map { |entry| quote_value(entry) }.join(', ')})"
-    end
-    
-  end
-  
-  class NotImplementedError < StandardError
-  end
-  
-  class ConnectionFailed < StandardError
-  end
-  
-  class ReaderClosed < StandardError
-  end
-  
-  class ReaderError < StandardError
-  end
-  
-  class QueryError < StandardError
-  end
-  
-  class NoInsertError < StandardError
-  end
-  
-  class LostConnectionError < StandardError
-  end
-  
-  class UnknownError < StandardError
-  end
-  
-end

data/plugins/dataobjects/do_mysql.rb

@@ -1,212 +0,0 @@
-require 'mysql_c'
-require 'do'
-
-module DataObject
-  module Mysql
-    TYPES = Hash[*Mysql_c.constants.select {|x| x.include?("MYSQL_TYPE")}.map {|x| [Mysql_c.const_get(x), x.gsub(/^MYSQL_TYPE_/, "")]}.flatten]    
-    
-    QUOTE_STRING = "\""
-    QUOTE_COLUMN = "`"
-    
-    class Connection < DataObject::Connection
-      
-      attr_reader :db
-      
-      def initialize(connection_string)        
-        @state = STATE_CLOSED
-        @connection_string = connection_string
-        opts = connection_string.split(" ")
-        opts.each do |opt|
-          k, v = opt.split("=")
-          raise ArgumentError, "you specified an invalid connection component: #{opt}" unless k && v
-          instance_variable_set("@#{k}", v)
-        end
-      end
-      
-      def change_database(database_name)
-        @dbname = database_name
-        @connection_string.gsub(/db_name=[^ ]*/, "db_name=#{database_name}")
-      end
-      
-      def open
-        @db = Mysql_c.mysql_init(nil)
-        raise ConnectionFailed, "could not allocate a MySQL connection" unless @db
-        conn = Mysql_c.mysql_real_connect(@db, @host, @user, @password, @dbname, @port || 0, @socket, @flags || 0)
-        raise ConnectionFailed, "The connection with connection string #{@connection_string} failed\n#{Mysql_c.mysql_error(@db)}" unless conn
-        @state = STATE_OPEN
-        true
-      end
-      
-      def close
-        if @state == STATE_OPEN
-          Mysql_c.mysql_close(@db)
-          @state = STATE_CLOSED        
-          true
-        else
-          false
-        end
-      end
-      
-      def create_command(text)
-        logger.debug { text }
-        Command.new(self, text)
-      end
-      
-    end
-    
-    class Field
-      attr_reader :name, :type
-      
-      def initialize(ptr)
-        @name, @type = ptr.name.to_s, ptr.type.to_s
-      end
-    end
-    
-    class Reader < DataObject::Reader
-      
-      def initialize(db, reader)        
-        @reader = reader
-        unless @reader
-          if Mysql_c.mysql_field_count(db) == 0
-            @records_affected = Mysql_c.mysql_affected_rows(db)
-            close
-          else
-            raise UnknownError, "An unknown error has occured while trying to process a MySQL query.\n#{Mysql_c.mysql_error(db)}"
-          end
-        else
-          @field_count = @reader.field_count
-          @state = STATE_OPEN
-          
-          @native_fields, @fields = Mysql_c.mysql_c_fetch_field_types(@reader, @field_count), Mysql_c.mysql_c_fetch_field_names(@reader, @field_count)
-
-          raise UnknownError, "An unknown error has occured while trying to process a MySQL query. There were no fields in the resultset\n#{Mysql_c.mysql_error(db)}" if @native_fields.empty?
-          
-          @has_rows = !(@row = Mysql_c.mysql_c_fetch_row(@reader)).nil?
-        end
-      end
-      
-      def close
-        if @state == STATE_OPEN
-          Mysql_c.mysql_free_result(@reader)
-          @state = STATE_CLOSED
-          true
-        else
-          false
-        end
-      end
-      
-      def name(col)
-        super
-        @fields[col]
-      end
-      
-      def get_index(name)
-        super
-        @fields.index(name)
-      end
-      
-      def null?(idx)
-        super
-        @row[idx] == nil
-      end
-      
-      def current_row
-        @row
-      end
-      
-      def item(idx)
-        super
-        typecast(@row[idx], idx)
-      end
-      
-      def next
-        super
-        @row = Mysql_c.mysql_c_fetch_row(@reader)
-        close if @row.nil?
-        @row ? true : nil
-      end      
-      
-      def each
-        return unless has_rows?
-        
-        while(true) do
-          yield
-          break unless self.next
-        end
-      end
-      
-      protected
-      def native_type(col)
-        super
-        TYPES[@native_fields[col].type]
-      end
-      
-      def typecast(val, idx)
-        return nil if val.nil?
-        field = @native_fields[idx]
-        case TYPES[field]
-          when "TINY"
-            val != "0"
-          when "BIT"
-            val.to_i(2)
-          when "SHORT", "LONG", "INT24", "LONGLONG"
-            val.to_i
-          when "DECIMAL", "NEWDECIMAL", "FLOAT", "DOUBLE", "YEAR"
-            val.to_f
-          when "TIMESTAMP", "DATETIME"
-            DateTime.parse(val) rescue nil
-          when "TIME"
-            DateTime.parse(val).to_time rescue nil
-          when "DATE"
-            Date.parse(val) rescue nil
-          when "NULL"
-            nil
-          else
-            val
-        end
-      end      
-    end
-    
-    class Command < DataObject::Command
-      
-      def execute_reader(*args)
-        super
-        result = Mysql_c.mysql_query(@connection.db, escape_sql(args))
-        # TODO: Real Error
-        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0
-        reader = Reader.new(@connection.db, Mysql_c.mysql_use_result(@connection.db))
-        if block_given?
-          result = yield(reader)
-          reader.close
-          result
-        else
-          reader
-        end
-      end
-      
-      def execute_non_query(*args)
-        super
-        result = Mysql_c.mysql_query(@connection.db, escape_sql(args))
-        raise QueryError, "Your query failed.\n#{Mysql_c.mysql_error(@connection.db)}\n#{@text}" unless result == 0         
-        reader = Mysql_c.mysql_store_result(@connection.db)
-        raise QueryError, "You called execute_non_query on a query: #{@text}" if reader
-        rows_affected = Mysql_c.mysql_affected_rows(@connection.db)
-        Mysql_c.mysql_free_result(reader)
-        return ResultData.new(@connection, rows_affected, Mysql_c.mysql_insert_id(@connection.db))
-      end
-      
-      def quote_time(value)
-        "DATE('#{value.xmlschema}')"
-      end
-      
-      def quote_datetime(value)
-        "DATE('#{value}')"
-      end
-      
-      def quote_date(value)
-        "DATE('#{value.strftime("%Y-%m-%d")}')"
-      end
-    end
-    
-  end
-end