ydbi 0.5.8 → 0.6.0

data/lib/dbd/sqlite3/database.rb

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

@@ -0,0 +1,78 @@
+#
+# 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/lib/dbi/version.rb

@@ -1,3 +1,3 @@
 module DBI
-  VERSION = "0.5.8"
+  VERSION = "0.6.0"
 end

data/prototypes/types2.rb

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

data/readme.md

@@ -1,9 +1,8 @@
 # Release a new ydbi gem
 
-* bundle exec rake test test_dbd test_dbi
-* rake ydbd-pg:clobber_package; rake ydbd-pg:clobber_package; rake ydbi:gem ydbd-pg:gem
-* bundle exec gem push pkg/ydbd-*.gem
-* bundle exec gem push pkg/ydbi-*.gem
+* rake ydbd-pg:clobber_package rake ydbd-pg:clobber_package; rake ydbi:gem ydbd-pg:gem
+* gem push ydbd-pg-0.5.4.gem
+* gem push ydbi-0.5.4.gem
 
 # Description
     The DBI package is a vendor independent interface for accessing databases.