ydbi 0.5.0 → 0.5.1

data/lib/dbd/sqlite/statement.rb

@@ -1,125 +0,0 @@
-#
-# See DBI::BaseStatement.
-#
-class DBI::DBD::SQLite::Statement < DBI::BaseStatement
-    DBI_TYPE_MAP = [
-        [ /^INT(EGER)?$/i,          DBI::SQL_INTEGER ],
-        [ /^(OID|ROWID|_ROWID_)$/i, DBI::SQL_OTHER   ],
-        [ /^FLOAT$/i,               DBI::SQL_FLOAT   ],
-        [ /^REAL$/i,                DBI::SQL_REAL    ],
-        [ /^DOUBLE$/i,              DBI::SQL_DOUBLE  ],
-        [ /^DECIMAL/i,              DBI::SQL_DECIMAL ],
-        [ /^(BOOL|BOOLEAN)$/i,      DBI::SQL_BOOLEAN ], 
-        [ /^TIME$/i,                DBI::SQL_TIME    ],
-        [ /^DATE$/i,                DBI::SQL_DATE    ],
-        [ /^TIMESTAMP$/i,           DBI::SQL_TIMESTAMP ], 
-        [ /^(VARCHAR|TEXT)/i,       DBI::SQL_VARCHAR ],
-        [ /^CHAR$/i,                DBI::SQL_CHAR    ],
-    ]
-
-    def initialize(stmt, dbh)
-        @dbh       = dbh
-        @statement = DBI::SQL::PreparedStatement.new(@dbh, stmt)
-        @attr      = { }
-        @params    = [ ]
-        @rows      = [ ]
-        @result_set = nil
-        @dbh.open_handles += 1
-    end
-
-    #
-    # See DBI::BaseStatement#bind_param. This method will also raise
-    # DBI::InterfaceError if +param+ is not a Fixnum, to prevent incorrect
-    # binding.
-    #
-    def bind_param(param, value, attributes=nil)
-        unless param.kind_of? Fixnum
-            raise DBI::InterfaceError, "Only numeric parameters are supported"
-        end
-
-        @params[param-1] = value
-
-        # FIXME what to do with attributes? are they important in SQLite?
-    end
-
-    #
-    # See DBI::BaseStatement#execute.
-    #
-    # In the event AutoCommit is off and no transaction is currently executing,
-    # one will be opened at this point. It is your responsibility to #finish,
-    # #cancel, #rollback, or #commit.
-    #
-    def execute
-        sql = @statement.bind(@params)
-        # XXX sqlite re-escapes this for us automatically, it's causing trouble with everything else.
-        #     this will probably break in a horrible manner and I will be forced to "fix" it again.
-        sql.gsub!(/\\\\/) { '\\' } 
-        DBI::DBD::SQLite.check_sql(sql)
-
-        begin
-            unless @dbh.db.transaction_active?
-                @dbh.db.transaction 
-            end
-            @result_set = @dbh.db.query(sql)
-            @dbh.commit if @dbh["AutoCommit"]
-        rescue Exception => e
-            raise DBI::DatabaseError, e.message
-        end
-    end
-
-    alias :finish :cancel
-
-    def finish
-        # nil out the result set
-        @result_set.close if @result_set
-        @result_set = nil
-        @rows = nil
-        @dbh.open_handles -= 1
-    end
-
-    def fetch
-        return nil if @result_set.eof?
-
-        row = @result_set.next
-        return nil unless row
-
-        return row
-    end
-
-    def column_info
-        columns = [ ]
-
-        # FIXME this shit should *really* be abstracted into DBI
-        # FIXME this still doesn't handle nullable/unique/default stuff.
-        @result_set.columns.each_with_index do |name, i|
-            columns[i] = { } unless columns[i]
-            columns[i]["name"] = name
-            type_name = @result_set.types[i]
-
-            if type_name
-                m = DBI::DBD::SQLite.parse_type(type_name)
-
-                columns[i]["type_name"] = m[1]
-                columns[i]["precision"] = m[3].to_i if m[3]
-                columns[i]["scale"]     = m[5].to_i if m[5]
-                DBI_TYPE_MAP.each do |map|
-                    if columns[i]["type_name"] =~ map[0]
-                        columns[i]["sql_type"] = map[1]
-                        break
-                    end
-                end
-
-                case columns[i]["type_name"]
-                when 'double'
-                    columns[i]["dbi_type"] = DBI::Type::Float
-                end
-            end
-        end
-
-        return columns
-    end
-
-    def rows
-        return @dbh.db.changes
-    end
-end

data/lib/dbd/sqlite3/database.rb

@@ -1,201 +0,0 @@
-#
-# See DBI::BaseDatabase.
-#
-class DBI::DBD::SQLite3::Database < DBI::BaseDatabase
-    #
-    # Constructor. Valid attributes:
-    #
-    # * AutoCommit: Commit after every statement execution.
-    #
-    # The following attributes go directly to the low-level SQLite3 driver. 
-    # Please consult it's documentation for more information.
-    #
-    # * auto_vacuum
-    # * cache_size
-    # * default_cache_size
-    # * default_synchronous
-    # * default_temp_store
-    # * full_column_names
-    # * synchronous
-    # * temp_store
-    # * type_translation
-    #
-    def initialize(dbname, attr)
-        @db = ::SQLite3::Database.new(dbname)
-
-        @db.type_translation = false
-
-        @attr = {'AutoCommit' => true}
-        if attr then
-            attr.each_pair do |key, value|
-                begin
-                    self[key] = value
-                rescue DBI::NotSupportedError
-                end
-            end
-        end
-        __generate_attr__
-    end
-
-    def disconnect()
-        @db.rollback if @db.transaction_active?
-        @db.close
-    end
-
-    def prepare(statement)
-        DBI::DBD::SQLite3::Statement.new(statement, @db)
-    end
-
-    def database_name
-        st = DBI::DBD::SQLite3::Statement.new('PRAGMA database_list', @db)
-        st.execute
-        row = st.fetch
-        st.finish
-
-        return row[2]
-    end
-
-    def ping()
-        not @db.closed?
-    end
-
-    def commit()
-        if @db.transaction_active?
-            @db.commit
-            @db.transaction
-        else
-            raise DBI::ProgrammingError.new("No active transaction.")
-        end
-    end
-
-    #
-    # See DBI::BaseDatabase#rollback.
-    #
-    # If all statements were not closed before the rollback occurs, a
-    # DBI::Warning may be raised if the database encounters an error because of
-    # it.
-    #
-    # This method will also raise DBI::ProgrammingError if not in a
-    # transaction.
-    #
-    def rollback()
-        if @db.transaction_active?
-            begin 
-                @db.rollback 
-                @db.transaction
-            rescue Exception => e
-                raise DBI::Warning, "Statements were not closed prior to rollback"
-            end
-        else
-            raise DBI::ProgrammingError.new("No active transaction.")
-        end
-    end
-
-    def tables()
-        ret = []
-        result = @db.execute(%q(
-            SELECT name FROM sqlite_master WHERE type IN ('table', 'view') 
-            UNION ALL 
-            SELECT name FROM sqlite_temp_master WHERE type in ('table', 'view') ORDER BY 1
-        ))
-        result.each{|row| ret.push(row[0])}
-        ret
-    end
-
-    #
-    # See DBI::BaseDatabase#columns.
-    #
-    # Additional Attributes:
-    #
-    # * sql_type: XOPEN integer SQL Type.
-    # * nullable: true if NULL is allowed in this column.
-    # * default: the value that will be used in new rows if this column
-    #   receives no data.
-    #
-    def columns(table)
-        @db.type_translation = false
-        ret =
-            @db.table_info(table).map do |hash|
-                m = DBI::DBD::SQLite3.parse_type(hash['type'])
-                h = { 
-                    'name' => hash['name'],
-                    'type_name' => m[1],
-                    'sql_type' => 
-                        begin
-                            DBI.const_get('SQL_'+hash['type'].upcase)
-                        rescue NameError
-                            DBI::SQL_OTHER
-                        end,
-                    'nullable' => (hash['notnull'] == '0'),
-                    'default' => (@attr['type_translation'] && (not hash['dflt_value'])) ? 
-                                    @db.translator.translate(hash['type'], hash['dflt_value']) :
-                                    hash['dflt_value'] 
-                }
-
-                h['precision'] = m[3].to_i if m[3]
-                h['scale']     = m[5].to_i if m[5]
-
-                h
-            end
-        @db.type_translation = @attr['type_translation']
-        ret
-    end
-
-    def quote(value)
-        ::SQLite3::Database.quote(value.to_s)
-    end
-
-    #
-    # This method is used to aid the constructor and probably should not be
-    # used independently.
-    #
-    def __generate_attr__()
-        tt = @db.type_translation
-        @db.type_translation = false
-        [ 'auto_vacuum', 'cache_size', 'default_cache_size',
-        'default_synchronous', 'default_temp_store', 'full_column_names',
-        'synchronous', 'temp_store', 'type_translation' ].each do |key|
-            unless @attr.has_key?(key) then
-                @attr[key] = @db.__send__(key)
-            end
-        end
-        @db.type_translation = tt
-    end
-
-    #
-    # See #new for valid attributes.
-    #
-    # If Autocommit is set to true, commit happens immediately if a transaction
-    # is open.
-    #
-    def []=(attr, value)
-        case attr
-        when 'AutoCommit'
-            if value
-                @db.commit if @db.transaction_active?
-            else
-                @db.transaction unless @db.transaction_active?
-            end
-        @attr[attr] = value
-        when 'auto_vacuum', 'cache_size', 'count_changes',
-          'default_cache_size', 'encoding', 'full_column_names',
-          'page_size', 'short_column_names', 'synchronous',
-          'temp_store', 'temp_store_directory'
-          @db.__send__((attr+'='), value)
-            @attr[attr] = @db.__send__(attr)
-        when 'busy_timeout'
-            @db.busy_timeout(value)
-            @attr[attr] = value
-        when 'busy_handler'
-            @db.busy_timeout(&value)
-            @attr[attr] = value
-        when 'type_translation'
-            @db.type_translation = value
-            @attr[attr] = value
-        else
-            raise DBI::NotSupportedError
-        end
-
-        return value
-    end
-end

data/lib/dbd/sqlite3/statement.rb

@@ -1,78 +0,0 @@
-#
-# See DBI::BaseStatement.
-#
-class DBI::DBD::SQLite3::Statement < DBI::BaseStatement
-    def initialize(sql, db)
-        sql.gsub!(/\\\\/) { '\\' } # sqlite underneath does this for us automatically, and it's causing trouble with the rest of the system.
-        @sql = sql
-        @db = db
-        @stmt = db.prepare(sql)
-        @result = nil
-    rescue ::SQLite3::Exception, RuntimeError => err
-        raise DBI::ProgrammingError.new(err.message)
-    end
-
-    #
-    # See DBI::BaseStatement#bind_param. This method will also raise
-    # DBI::InterfaceError if +param+ is not a Fixnum, to prevent incorrect
-    # binding.
-    #
-    def bind_param(param, value, attribs=nil)
-        raise DBI::InterfaceError, "Bound parameter must be an integer" unless param.kind_of? Fixnum 
-        @stmt.bind_param(param, value)
-    end
-
-    def execute()
-        @result = @stmt.execute
-        @rows = DBI::SQL.query?(@sql) ? 0 : @db.changes
-    end
-
-    def finish()
-        @stmt.close rescue nil
-        @result = nil
-    end
-
-    def fetch()
-        ret = @result.next
-        return ret unless ret
-        [ret].flatten
-    end
-
-    def column_info()
-        @stmt.columns.zip(@stmt.types).map{|name, type_name|
-            m = DBI::DBD::SQLite3.parse_type(type_name)
-            h = { 
-              'name' => name,
-              'type_name' => m[1],
-              'sql_type' => 
-                    begin
-                        DBI.const_get('SQL_'+m[1].upcase)
-                    rescue NameError
-                        DBI::SQL_OTHER
-                    end,
-            }
-            h['precision'] = m[3].to_i if m[3]
-            h['scale']     = m[5].to_i if m[5]
-
-            case h['type_name']
-            when 'double'
-                h['dbi_type'] = DBI::Type::Float
-            end
-
-            h
-        }
-    end
-
-    def rows()
-        @rows
-    end
-
-    def bind_params(*bindvars)
-        @stmt.bind_params(bindvars)
-    end
-
-    def cancel()
-        @result = nil
-        @index = 0
-    end
-end

data/prototypes/types2.rb

@@ -1,237 +0,0 @@
-require 'date'
-require 'time'
-
-#
-# General example, these would be types that would exist in DBI proper
-#
-
-module DBI
-    class DBI::Type
-        def self.parse(obj, type=nil, dbh=nil)
-            if type 
-                sym = ( "to_" + type.to_s ).to_sym
-                begin
-                    return self.__send__(sym, obj) 
-                rescue ::NoMethodError 
-                    self.to_type(obj)
-                end
-            else
-                return self.to_type(obj)
-            end
-        end
-
-        def self.coerce(obj, type=nil, dbh=nil)
-            if type
-                sym = ( "from_" + type.to_s ).to_sym
-                begin
-                    return self.__send__(sym, obj) 
-                rescue ::NoMethodError 
-                    self.from_type(obj)
-                end
-            else
-                return self.from_type(obj)
-            end
-        end
-
-        def self.from_type(obj)
-            obj.to_s rescue obj.to_str rescue obj
-        end
-
-        def self.to_type(obj)
-            obj
-        end
-    end
-
-    class DBI::Type::Null < DBI::Type
-        def self.to_type(obj)
-            return obj unless obj
-            return nil if obj.to_s.match(/^null$/i)
-            return obj
-        end
-
-        def self.from_type(obj)
-            obj
-        end
-    end
-
-    class DBI::Type::Integer < DBI::Type::Null
-        def self.parse(obj)
-            obj = super
-            return obj unless obj
-            return obj.to_i if obj.respond_to? :to_i
-            return obj
-        end
-    end
-
-    class DBI::Type::Timestamp < DBI::Type::Null
-        def self.to_type(obj)
-            obj = super
-            return obj unless obj
-
-            case obj
-            when ::DateTime
-                return obj
-            when ::Date
-                return ::DateTime.strptime(obj.to_s, "%Y-%m-%d")
-            when ::Time
-                return ::DateTime.parse(obj.to_s)
-            when ::Integer
-                return ::DateTime.parse(::Time.at(obj).to_s)
-            else
-                return ::DateTime.parse(obj.to_s)   if obj.respond_to? :to_s
-                return ::DateTime.parse(obj.to_str) if obj.respond_to? :to_str
-                return obj
-            end
-        end
-
-        def self.from_type(obj)
-            obj = super
-            return obj unless obj
-
-            case obj
-            when ::DateTime
-                return obj.to_s # produces ISO8601
-            when ::Time
-                return obj.iso8601
-            when ::Integer
-                return ::Time.at(obj).iso8601
-            else
-                return obj
-            end
-        end
-    end
-end
-
-module DBI::DBD
-    class Pg
-
-        #
-        # during connect time, after DatabaseHandle initialization, the hash
-        # that DatabaseHandle#type_map provides would be tweaked to take
-        # advantage of the available date formats.
-        #
-        # See 'PgDatabaseHandle' below for a mock.
-        #
-
-        class Type
-            class Timestamp < DBI::Type::Timestamp
-                def self.from_dmy(obj)
-                    return obj if DBI::Type::Null.parse(obj).nil?
-
-                    case obj
-                    when ::DateTime, ::Time
-                        obj.strftime("%d/%m/%Y %H:%M:%S")
-                    when ::Integer
-                        ::Time.at(obj).strftime("%d/%m/%Y %H:%M:%S")
-                    else
-                        # punt... this will actually try the baseline
-                        # conversion at this point
-                        raise "Crap!"
-                    end
-                end
-
-                def self.to_dmy(obj)
-                    return obj if DBI::Type::Null.parse(obj).nil?
-
-                    # realistically all there needs to be is a check for the
-                    # type ruby-pg typically returns and string, but to be
-                    # complete I'm showing how it could be done if the type was
-                    # less clear.
-
-                    case obj
-                    when ::DateTime
-                        return obj
-                    when ::Time  
-                        return ::DateTime.parse(obj.to_s)
-                    else
-                        return ::DateTime.strptime(obj, "%d/%m/%Y %H:%M:%S")
-                    end
-                end
-            end
-        end
-    end
-end 
-
-#
-# this is just used to emulate the methods a DatabaseHandle would have to
-# faciliate this.. certainly not a full (or correct) mirroring of the DBI API.
-#
-class DatabaseHandle
-
-    attr_accessor :columns
-    
-    def outbound_type_map
-        {
-            'timestamp' => [DBI::Type::Timestamp]
-        }
-    end
-
-    def inbound_type_map
-        {
-            ::DateTime => [DBI::Type::Timestamp],
-            ::Time     => [DBI::Type::Timestamp]
-        }
-    end
-
-    # humor me while I completely break DBI for the sake of brevity..
-    def execute(*bindvars)
-        bindvars.collect do |var|
-            type_info = inbound_type_map[var.class]
-            type_info[0].coerce(var, type_info[1], self)
-        end
-    end
-
-    def fetch(*bindvars)
-        ret = []
-
-        bindvars.each_with_index do |var, i|
-            type_info = outbound_type_map[columns[i]]
-            ret.push type_info[0].parse(var, type_info[1], self)
-        end
-        
-        return ret
-    end
-end
-
-class PgDatabaseHandle < DatabaseHandle
-    def outbound_type_map
-        {
-            'timestamp' => [DBI::DBD::Pg::Type::Timestamp, :dmy]
-        }
-    end
-
-    def inbound_type_map
-        {
-            ::DateTime => [DBI::DBD::Pg::Type::Timestamp, :dmy],
-            ::Time     => [DBI::DBD::Pg::Type::Timestamp, :dmy]
-        }
-    end
-end
-
-# ok! now for the functional example:
-
-if __FILE__ == $0
-
-    dbh = DatabaseHandle.new
-    dbh.columns = %w(timestamp timestamp)
-    # this would go TO the database..
-    p dbh.execute(DateTime.now, Time.now)
-    # this would come FROM the database...
-    p dbh.fetch(Time.now.iso8601, DateTime.now.to_s)
-
-    # now the Pg example:
-    dbh = PgDatabaseHandle.new
-    dbh.columns = %w(timestamp timestamp)
-
-    # this would go TO the database..
-    p dbh.execute(DateTime.now, Time.now)
-    # this would come FROM the database...
-    p dbh.fetch(Time.now.strftime("%d/%m/%Y %H:%M:%S"), DateTime.now.strftime("%d/%m/%Y %H:%M:%S"))
-    
-    # this should fail appropriately
-    begin
-        dbh.fetch(Time.now.iso8601, DateTime.now.to_s)
-    rescue Exception
-        puts "this failed like it should"
-    end
-end