ydbi 0.5.2 → 0.5.7

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.rb

@@ -9,16 +9,16 @@ module DBI; end
 #
 # Copyright (c) 2001, 2002, 2003 Michael Neumann <mneumann@ntecs.de>
 # Copyright (c) 2008 Erik Hollensbe <erik@hollensbe.org>
-# 
+#
 # All rights reserved.
 #
-# Redistribution and use in source and binary forms, with or without 
-# modification, are permitted provided that the following conditions 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
 # are met:
-# 1. Redistributions of source code must retain the above copyright 
+# 1. Redistributions of source code must retain the above copyright
 #    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright 
-#    notice, this list of conditions and the following disclaimer in the 
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
 #    documentation and/or other materials provided with the distribution.
 # 3. The name of the author may not be used to endorse or promote products
 #    derived from this software without specific prior written permission.
@@ -57,6 +57,7 @@ require 'dbi/exceptions'
 require 'dbi/binary'
 require 'dbi/handles'
 require 'dbi/base_classes'
+require 'dbi/version'
 require "date"
 require "thread"
 require 'monitor'
@@ -127,7 +128,7 @@ module DBI
 
     class << self
 
-        # Establish a database connection.  
+        # Establish a database connection.
         #
         # Format goes as such: "dbi:Driver:database_conn_args"
         #
@@ -178,7 +179,7 @@ module DBI
         # Return a list (of String) of the available drivers.
         #
         # NOTE:: This is non-functional for gem installations, due to the
-        #        nature of how it currently works. A better solution for 
+        #        nature of how it currently works. A better solution for
         #        this will be provided in DBI 0.6.0.
         def collect_drivers
             drivers = { }
@@ -203,7 +204,7 @@ module DBI
             drivers = []
             collect_drivers.each do |key, value|
                 drivers.push("dbi:#{key}:")
-            end 
+            end
             return drivers
         end
 
@@ -251,7 +252,7 @@ module DBI
                     rescue LoadError => e1
                         # see if you can find it in the path
                         unless @@caseless_driver_name_map
-                            @@caseless_driver_name_map = { } 
+                            @@caseless_driver_name_map = { }
                             collect_drivers.each do |key, value|
                                 @@caseless_driver_name_map[key.downcase] = value
                             end
@@ -305,17 +306,13 @@ module DBI
                     # FIXME trace
                     # drh.trace(@@trace_mode, @@trace_output)
                     @@driver_map[driver_name] = [drh, dbd_dr]
-                    return driver_name 
+                    return driver_name
                 else
                     return driver_name
                 end
             end
         rescue LoadError, NameError
-            if $SAFE >= 1
-                raise InterfaceError, "Could not load driver (#{$!.message}). Note that in SAFE mode >= 1, driver URLs have to be case sensitive!"
-            else
-                raise InterfaceError, "Could not load driver (#{$!.message})"
-            end
+          raise InterfaceError, "Could not load driver (#{$!.message})"
         end
 
         # Splits a DBI URL into two components - the database driver name
@@ -326,7 +323,7 @@ module DBI
         # the proper format for the URL.  If it isn't correct, an Interface
         # error is raised.
         def parse_url(driver_url)
-            if driver_url =~ /^(DBI|dbi):([^:]+)(:(.*))$/ 
+            if driver_url =~ /^(DBI|dbi):([^:]+)(:(.*))$/
                 [$2, $4]
             else
                 raise InterfaceError, "Invalid Data Source Name"

data/lib/dbi/utils/date.rb

@@ -1,3 +1,7 @@
+require 'deprecated'
+require 'dbi/types'
+require 'dbi/binary'
+require 'dbi/typeutil'
 module DBI
     #
     # Represents a Date.
@@ -30,7 +34,7 @@ module DBI
             sprintf("%04d-%02d-%02d", @year, @month, @day)
         end
 
-        private 
+        private
 
         # DBI::Date.new(year = 0, month = 0, day = 0)
         # DBI::Date.new(Date)
@@ -42,10 +46,10 @@ module DBI
         def initialize(year=0, month=0, day=0)
             case year
             when ::Date
-                @year, @month, @day = year.year, year.month, year.day 
+                @year, @month, @day = year.year, year.month, year.day
                 @original_date = year
             when ::Time
-                @year, @month, @day = year.year, year.month, year.day 
+                @year, @month, @day = year.year, year.month, year.day
                 @original_time = year
             else
                 @year, @month, @day = year, month, day

data/lib/dbi/version.rb

@@ -1,3 +1,3 @@
 module DBI
-  VERSION = "0.5.2"
+  VERSION = "0.5.7"
 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,3 +1,9 @@
+# Release a new 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.
     It is similar, but not identical to, Perl's DBI module.
@@ -75,6 +81,15 @@
     gem install dbd-sqlite3
     gem install dbd-sqlite
 
+If you have a non standard path of postgres use something like
+
+    gem install pg -- --with-pg-config=/usr/local/pgsql-10.1/bin/pg_config
+
+Or if you are using bundler
+
+    bundle config build.pg --with-pg-config=/usr/local/pgsql-10.1/bin/pg_config
+    bundle install
+
 ## Without rubygems:
 
     ruby setup.rb config