ydbi 0.5.6 → 0.5.7

data/lib/dbd/pg/exec.rb

@@ -0,0 +1,47 @@
+module DBI::DBD::Pg
+    ################################################################
+    # Convenience adaptor to hide details command execution API calls.
+    # See PgExecutorAsync subclass
+    class PgExecutor
+        def initialize(pg_conn)
+            @pg_conn = pg_conn
+        end
+
+        def exec(sql, parameters = nil)
+            @pg_conn.exec(sql, parameters)
+        end
+
+        def exec_prepared(stmt_name, parameters = nil)
+            @pg_conn.exec_prepared(stmt_name, parameters)
+        end
+
+        def prepare(stmt_name, sql)
+            @pg_conn.prepare(stmt_name, sql)
+        end
+    end
+
+    # Asynchronous implementation of PgExecutor, useful for 'green
+    # thread' implementations (e.g., MRI <= 1.8.x) which would otherwise
+    # suspend other threads while awaiting query results.
+    #--
+    # FIXME:  PQsetnonblocking + select/poll would make the exec*
+    #         methods truly 'async', though this is rarely needed in
+    #         practice.
+    class PgExecutorAsync < PgExecutor
+        def exec(sql, parameters = nil)
+            @pg_conn.async_exec(sql, parameters)
+        end
+
+        def exec_prepared(stmt_name, parameters = nil)
+            @pg_conn.send_query_prepared(stmt_name, parameters)
+            @pg_conn.block()
+            @pg_conn.get_last_result()
+        end
+
+        def prepare(stmt_name, sql)
+            @pg_conn.send_prepare(stmt_name, sql)
+            @pg_conn.block()
+            @pg_conn.get_last_result()
+        end
+    end
+end

data/lib/dbd/pg/statement.rb

@@ -0,0 +1,160 @@
+#
+# See DBI::BaseStatement, and DBI::DBD::Pg::Tuples.
+#
+#--
+# Peculiar Statement responsibilities:
+#  - Translate dbi params (?, ?, ...) to Pg params ($1, $2, ...)
+#  - Translate DBI::Binary objects to Pg large objects (lo_*)
+
+class DBI::DBD::Pg::Statement < DBI::BaseStatement
+
+    PG_STMT_NAME_PREFIX = 'ruby-dbi:Pg:'
+
+    def initialize(db, sql)
+        super(db)
+        @db  = db
+        @sql = sql
+        @stmt_name = PG_STMT_NAME_PREFIX + self.object_id.to_s + Time.now.to_f.to_s
+        @result = nil
+        @bindvars = []
+        @prepared = false
+    rescue PG::Error => err
+        raise DBI::ProgrammingError.new(err.message)
+    end
+
+    def bind_param(index, value, options)
+        @bindvars[index-1] = value
+    end
+
+    #
+    # See DBI::BaseDatabase#execute.
+    #
+    # This method will make use of PostgreSQL's native BLOB support if
+    # DBI::Binary objects are passed in.
+    #
+    def execute
+        # replace DBI::Binary object by oid returned by lo_import
+        @bindvars.collect! do |var|
+            if var.is_a? DBI::Binary then
+                oid = @db.__blob_create(PG::Connection::INV_WRITE)
+                @db.__blob_write(oid, var.to_s)
+                oid
+            else
+                var
+            end
+        end
+
+        internal_prepare
+
+        if not @db['AutoCommit'] then
+            #          if not SQL.query?(boundsql) and not @db['AutoCommit'] then
+            @db.start_transaction unless @db.in_transaction?
+        end
+
+        if @db["pg_native_binding"]
+            pg_result = @db._exec_prepared(@stmt_name, *@bindvars)
+        else
+            pg_result = @db._exec_prepared(@stmt_name)
+        end
+
+        @result = DBI::DBD::Pg::Tuples.new(@db, pg_result)
+    rescue PG::Error, RuntimeError => err
+        raise DBI::ProgrammingError.new(err.message)
+    end
+
+    def fetch
+        @result.fetchrow
+    end
+
+    def fetch_scroll(direction, offset)
+        @result.fetch_scroll(direction, offset)
+    end
+
+    def finish
+        internal_finish
+        @result = nil
+        @db = nil
+    end
+
+    #
+    # See DBI::DBD::Pg::Tuples#column_info.
+    #
+    def column_info
+        @result.column_info
+    end
+
+    def rows
+        if @result
+            @result.rows_affected
+        else
+            nil
+        end
+    end
+
+    #
+    # Attributes:
+    #
+    # If +pg_row_count+ is requested and the statement has already executed,
+    # postgres will return what it believes is the row count.
+    #
+    def [](attr)
+        case attr
+        when 'pg_row_count'
+            if @result
+                @result.row_count
+            else
+                nil
+            end
+        else
+            @attr[attr]
+        end
+    end
+
+    private
+
+    #
+    # A native binding helper.
+    #
+    class DummyQuoter
+        # dummy to substitute ?-style parameter markers by :1 :2 etc.
+        def quote(str)
+            str
+        end
+    end
+
+    # finish the statement at a lower level
+    def internal_finish
+        @result.finish if @result
+        @db._exec("DEALLOCATE \"#{@stmt_name}\"") if @prepared rescue nil
+    end
+
+    # prepare the statement at a lower level.
+    def internal_prepare
+        if @db["pg_native_binding"]
+            unless @prepared
+                @stmt = @db._prepare(@stmt_name, translate_param_markers(@sql))
+            end
+        else
+            internal_finish
+            @stmt = @db._prepare(@stmt_name, DBI::SQL::PreparedStatement.new(DBI::DBD::Pg, @sql).bind(@bindvars))
+        end
+        @prepared = true
+    end
+
+    # Prepare the given SQL statement, returning its PostgreSQL string
+    # handle.  ?-style parameters are translated to $1, $2, etc.
+    #--
+    # TESTME  do ?::TYPE qualifers work?
+    # FIXME:  DBI ought to supply a generic param converter, e.g.:
+    #         sql = DBI::Utils::convert_placeholders(sql) do |i|
+    #                 '$' + i.to_s
+    #               end
+    def translate_param_markers(sql)
+        translator = DBI::SQL::PreparedStatement.new(DummyQuoter.new, sql)
+        if translator.unbound.size > 0
+            arr = (1..(translator.unbound.size)).collect{|i| "$#{i}"}
+            sql = translator.bind( arr )
+        end
+        sql
+    end
+end # Statement

data/lib/dbd/pg/tuples.rb

@@ -0,0 +1,121 @@
+#
+# Tuples is a class to represent result sets.
+#
+# Many of these methods are extremely similar to the methods that deal with
+# result sets in DBI::BaseStatement and are wrapped by the StatementHandle.
+# Unless you plan on working on this driver, these methods should never be
+# called directly.
+#
+class DBI::DBD::Pg::Tuples
+
+    def initialize(db, pg_result)
+        @db = db
+        @pg_result = pg_result
+        @index = -1
+        @row = []
+    end
+
+    # See DBI::BaseStatement#column_info. Additional attributes:
+    #
+    # * array_of_type: True if this is actually an array of this type. In this
+    #   case, +dbi_type+ will be the type authority for conversion.
+    #
+    def column_info
+        a = []
+        0.upto(@pg_result.num_fields-1) do |i|
+            str = @pg_result.fname(i)
+
+            typeinfo = nil
+
+            begin
+                typmod = @pg_result.fmod(i)
+            rescue
+            end
+
+            if typmod and typ = @pg_result.ftype(i)
+                res = @db._exec("select format_type(#{typ}, #{typmod})")
+                typeinfo = DBI::DBD::Pg.parse_type(res[0].values[0])
+            end
+
+            map = @db.type_map[@pg_result.ftype(i)] || { }
+            h = { "name" => str }.merge(map)
+
+            if typeinfo
+                h["precision"]     = typeinfo[:size]
+                h["scale"]         = typeinfo[:decimal]
+                h["type"]          = typeinfo[:type]
+                h["array_of_type"] = typeinfo[:array]
+
+                if typeinfo[:array]
+                    h['dbi_type'] = 
+                        DBI::DBD::Pg::Type::Array.new(
+                            DBI::TypeUtil.type_name_to_module(typeinfo[:type])
+                    )
+                end
+            end
+
+            a.push h
+        end
+
+        return a
+    end
+
+    def fetchrow
+        @index += 1
+        if @index < @pg_result.num_tuples && @index >= 0
+            @row = Array.new
+            0.upto(@pg_result.num_fields-1) do |x|
+                @row.push(@pg_result.getvalue(@index, x))
+            end
+            @row
+        else
+            nil
+        end
+    end
+
+    #
+    # Just don't use this method. It'll be fixed soon.
+    #
+    def fetch_scroll(direction, offset)
+        # Exact semantics aren't too closely defined.  I attempted to follow the DBI:Mysql example.
+        case direction
+        when SQL_FETCH_NEXT
+            # Nothing special to do, besides the fetchrow
+        when SQL_FETCH_PRIOR
+            @index -= 2
+        when SQL_FETCH_FIRST
+            @index = -1
+        when SQL_FETCH_LAST
+            @index = @pg_result.num_tuples - 2
+        when SQL_FETCH_ABSOLUTE
+            # Note: if you go "out of range", all fetches will give nil until you get back
+            # into range, this doesn't raise an error.
+            @index = offset-1
+        when SQL_FETCH_RELATIVE
+            # Note: if you go "out of range", all fetches will give nil until you get back
+            # into range, this doesn't raise an error.
+            @index += offset - 1
+        else
+            raise NotSupportedError
+        end
+        self.fetchrow
+    end
+
+    #
+    # The number of rows returned.
+    #
+    def row_count
+        @pg_result.num_tuples
+    end
+
+    #
+    # The row processed count. This is analogue to DBI::StatementHandle#rows.
+    #
+    def rows_affected
+        @pg_result.cmdtuples
+    end
+
+    def finish
+        @pg_result.clear
+    end
+end # Tuples

data/lib/dbd/pg/type.rb

@@ -0,0 +1,209 @@
+#
+# Type Management for PostgreSQL-specific types.
+#
+# See DBI::Type and DBI::TypeUtil for more information.
+#
+module DBI::DBD::Pg::Type
+    #
+    # ByteA is a special escaped form of binary data, suitable for inclusion in queries.
+    #
+    # This class is an attempt to abstract that type so you do not have to
+    # concern yourself with the conversion issues.
+    #
+    class ByteA
+
+        attr_reader :original
+        attr_reader :escaped
+
+        #
+        # Build a new ByteA object.
+        #
+        # The data supplied is the unescaped binary data you wish to put in the
+        # database.
+        #
+        def initialize(obj)
+            @original = obj
+            @escaped = escape_bytea(obj)
+            @original.freeze
+            @escaped.freeze
+        end
+
+        #
+        # Escapes the supplied data. Has no effect on the object.
+        #
+        def escape_bytea(str)
+            PG::Connection.escape_bytea(str)
+        end
+
+        #
+        # Returns the original data.
+        #
+        def to_s
+            return @original.dup
+        end
+
+        #
+        # Class method to escape the data into ByteA format.
+        #
+        def self.escape_bytea(str)
+            self.new(str).escaped
+        end
+
+        #
+        # Class method to unescape the ByteA data and present it as a string.
+        #
+        def self.parse(obj)
+
+            return nil if obj.nil?
+
+            # FIXME there's a bug in the upstream 'pg' driver that does not
+            # properly decode bytea, leaving in an extra slash for each decoded
+            # character.
+            #
+            # Fix this for now, but beware that we'll have to unfix this as
+            # soon as they fix their end.
+            ret = PG::Connection.unescape_bytea(obj)
+
+            # XXX 
+            # String#split does not properly create a full array if the the
+            # string ENDS in the split regex, unless this oddball -1 argument is supplied.
+            #
+            # Another way of saying this:
+            # if foo = "foo\\\\\" and foo.split(/\\\\/), the result will be
+            # ["foo"]. You can add as many delimiters to the end of the string
+            # as you'd like - the result is no different.
+            #
+
+            ret = ret.split(/\\\\/, -1).collect { |x| x.length > 0 ? x.gsub(/\\[0-7]{3}/) { |y| y[1..3].oct.chr } : "" }.join("\\")
+            ret.gsub!(/''/, "'")
+            return ret
+        end
+    end
+
+    #
+    # PostgreSQL arrays are simply a specification that sits on top of normal
+    # types. They have a specialized string grammar and this class facilitates
+    # converting that syntax and the types within those arrays.
+    #
+    class Array
+
+        attr_reader :base_type
+
+        #
+        # +base_type+ is a DBI::Type that is used to parse the inner types when
+        # a non-array one is found.
+        #
+        # For instance, if you had an array of integer, one would pass
+        # DBI::Type::Integer here.
+        #
+        def initialize(base_type)
+            @base_type = base_type
+        end
+
+        #
+        # Object method. Please note that this is different than most DBI::Type
+        # classes! One must initialize an Array object with an appropriate
+        # DBI::Type used to convert the indices of the array before this method
+        # can be called.
+        #
+        # Returns an appropriately converted array.
+        #
+        def parse(obj)
+            if obj.nil?
+                nil
+            elsif obj.index('{') == 0 and obj.rindex('}') == (obj.length - 1)
+                convert_array(obj)
+            else
+                raise "Not an array"
+            end
+        end
+
+        #
+        # Parse a PostgreSQL-Array output and convert into ruby array. This
+        # does the real parsing work.
+        #
+        def convert_array(str)
+
+            array_nesting = 0         # nesting level of the array
+            in_string = false         # currently inside a quoted string ?
+            escaped = false           # if the character is escaped
+            sbuffer = ''              # buffer for the current element
+            result_array = ::Array.new  # the resulting Array
+
+            str.each_byte { |char|    # parse character by character
+                char = char.chr         # we need the Character, not it's Integer
+
+                if escaped then         # if this character is escaped, just add it to the buffer
+                    sbuffer += char
+                    escaped = false
+                    next
+                end
+
+                case char               # let's see what kind of character we have
+                    #------------- {: beginning of an array ----#
+                when '{'
+                    if in_string then     # ignore inside a string
+                        sbuffer += char
+                        next
+                    end
+
+                if array_nesting >= 1 then  # if it's an nested array, defer for recursion
+                    sbuffer += char
+                end
+                array_nesting += 1          # inside another array
+
+                #------------- ": string deliminator --------#
+                when '"'
+                    in_string = !in_string      
+
+                    #------------- \: escape character, next is regular character #
+                when "\\"     # single \, must be extra escaped in Ruby
+                    if array_nesting > 1
+                        sbuffer += char
+                    else
+                        escaped = true
+                    end
+
+                    #------------- ,: element separator ---------#
+                when ','
+                    if in_string or array_nesting > 1 then  # don't care if inside string or
+                        sbuffer += char                       # nested array
+                    else
+                        if !sbuffer.is_a? ::Array then
+                            sbuffer = @base_type.parse(sbuffer)
+                        end
+                        result_array << sbuffer               # otherwise, here ends an element
+                        sbuffer = ''
+                    end
+
+                #------------- }: End of Array --------------#
+                when '}' 
+                    if in_string then                # ignore if inside quoted string
+                        sbuffer += char
+                        next
+                    end
+
+                    array_nesting -=1                # decrease nesting level
+
+                    if array_nesting == 1            # must be the end of a nested array 
+                        sbuffer += char
+                        sbuffer = convert_array( sbuffer )  # recurse, using the whole nested array
+                    elsif array_nesting > 1          # inside nested array, keep it for later
+                        sbuffer += char
+                    else                             # array_nesting = 0, must be the last }
+                        if !sbuffer.is_a? ::Array then
+                            sbuffer = @base_type.parse( sbuffer )
+                        end
+
+                        result_array << sbuffer unless sbuffer.nil? # upto here was the last element
+                    end
+
+                    #------------- all other characters ---------#
+                else
+                    sbuffer += char                 # simply append
+                end
+            } 
+            return result_array
+        end # convert_array()
+    end
+end