# = Warning
#
# <em>For documentation purpose, the modules PLRuby, PLRuby::Description
# are defined but don't exist in reality</em>
# 
# = PLRuby
#
# PLRuby is a loadable procedural language for the PostgreSQL database
# system that enables the Ruby language to create functions and
# trigger procedures.
# 
# Functions and triggers are singleton methods of the module PLtemp.
# 
# = WARNING
# 
# <b>if PLRuby was NOT compiled with <em>--enable-conversion</em>
# all arguments (to the function or the triggers) are passed as string 
# values, except for NULL values represented by <em>nil</em>.</b>
# 
# <b>In this case, you must explicitely call a conversion function (like to_i)
# if you want to use an argument as an integer</b>
# 
# = See
#
# * PLRuby::Description::Function
#
#   To create a function 
#
# * PLRuby::Description::Function::SFRM
#
#   To create a function returning SET (SFRM Materialize)
#
# * PLRuby::Description::Function::ExprMultiResult
#
#   To create a function returning SET (ExprMultiResult)
#
# * PLRuby::Description::Trigger
#
#   To define a trigger
#
# * PLRuby::Description::Singleton_method
#
#   To define singleton methods
#
# * PLRuby::Description::Conversion
#
#   What conversions are done when this option is not disabled
#   (<em>--disable-conversion</em>)
#
# = Class hierarchy
#
# * PLRuby::PL
#
# * PLRuby::PL::Plan
#
# * PLRuby::PL::Cursor
#
# * PLRuby::PL::Transaction
#
# * PLRuby::BitString
#
# * PLRuby::Tinterval
#
# * PLRuby::NetAddr
#
# * PLRuby::MacAddr
#
# * PLRuby::Box
#
# * PLRuby::Circle
#
# * PLRuby::Path
#
# * PLRuby::Point
#
# * PLRuby::Polygon
#
# * PLRuby::Segment
#
# Global variable
#
# $Plans:: can be used to store prepared plans. (hash, tainted)
#
# 
module PLRuby
   #
   # Create a new transaction and yield an object <em>PL::Transaction</em>
   #
   # Only available with PostgreSQL >= 8.0
   def transaction()
      yield txn
   end

    # Ruby interface to PostgreSQL elog()
    #
    # Possible value for <tt>level</tt> are <tt>NOTICE</tt>, 
    # <tt>DEBUG</tt> and <tt>NOIND</tt>
    #
    # Use <tt>raise()</tt> if you want to simulate <tt>elog(ERROR, "...")</tt>
    def warn(level = NOTICE, message)
    end
end
#
# Pseudo module to describe the syntax to define function and triggers
#
# There is documentation for
# * PLRuby::Description::Function
#
#   To create a function 
#
# * PLRuby::Description::Function::SFRM
#
#   To create a function returning SET (SFRM Materialize)
#
# * PLRuby::Description::Function::ExprMultiResult
#
#   To create a function returning SET (ExprMultiResult)
#
# * PLRuby::Description::Trigger
#
#   To define a trigger
#
# * PLRuby::Description::Singleton_method
#
#   To define singleton methods
#
# * PLRuby::Description::Conversion
#
#   What conversions are done when this option is not disabled
#   (<em>--disable-conversion</em>)
module PLRuby::Description
end
# 
# To create a function in the PLRuby language use the syntax
# 
#    CREATE FUNCTION funcname(arguments_type) RETURNS type AS '
# 
#     # PLRuby function body
# 
#    ' LANGUAGE 'plruby';
# 
# when calling the function in a query, the arguments are given
# in the array <em>args</em>. To create a little max
# function returning the higher of two int4 values write :
# 
#    CREATE FUNCTION ruby_max(int4, int4) RETURNS int4 AS '
#        if args[0] > args[1]
#            return args[0]
#        else
#            return args[1]
#        end
#    ' LANGUAGE 'plruby';
# 
# 
# Tuple arguments are given as hash. Here is an example that defines
# the overpaid_2 function (as found in the older Postgres documentation)
# in PLRuby.
# 
#    CREATE FUNCTION overpaid_2 (EMP) RETURNS bool AS '
#        args[0]["salary"] > 200000 || 
#           (args[0]["salary"] > 100000 && args[0]["age"] < 30)
#    ' LANGUAGE 'plruby';
# 
# 
# === Warning : with PostgreSQL >= 7.4 "array" are given as a ruby Array
# 
# For example to define a function (int4[], int4) and return int4[],
# in version < 7.4 you write
# 
#    CREATE FUNCTION ruby_int4_accum(_int4, int4) RETURNS _int4 AS '
#        if /\\{(\\d+),(\\d+)\\}/ =~ args[0]
#            a, b = $1, $2
#            newsum = a + args[1]
#            newcnt = b + 1
#        else
#            raise "unexpected value #{args[0]}"
#        end
#        "{#{newsum},#{newcnt}}"
#    ' LANGUAGE 'plruby';
# 
# This must now (>= 7.4) be written
# 
#    CREATE FUNCTION ruby_int4_accum(_int4, int4) RETURNS _int4 AS '
#       a = args[0]
#       [a[0] + args[1], a[1] + 1]
#    ' LANGUAGE 'plruby';
# 
# === Release PostgreSQL 8.0
# 
# With this version, plruby can have named arguments and the previous functions
# can be written
# 
#    CREATE FUNCTION ruby_max(a int4, b int4) RETURNS int4 AS '
#        if a > b
#            a
#        else
#            b
#        end
#    ' LANGUAGE 'plruby';
# 
# 
#    CREATE FUNCTION overpaid_2 (emp EMP) RETURNS bool AS '
#        emp["salary"] > 200000 || 
#           (emp["salary"] > 100000 && emp["age"] < 30)
#    ' LANGUAGE 'plruby';
# 
# With this version, you can also use transaction. For example
# 
#    plruby_test=# create table tu (a int, b int);
#    CREATE TABLE
#    plruby_test=# create or replace function tt(abort bool) returns bool as '
#    plruby_test'#    transaction do |txn|
#    plruby_test'#       PL.exec("insert into tu values (1, 2)")
#    plruby_test'#       transaction do |txn1|
#    plruby_test'#          PL.exec("insert into tu values (3, 4)")
#    plruby_test'#          txn1.abort
#    plruby_test'#       end
#    plruby_test'#       PL.exec("insert into tu values (5, 6)")
#    plruby_test'#       txn.abort if abort
#    plruby_test'#    end
#    plruby_test'#    abort
#    plruby_test'# ' language 'plruby';
#    CREATE FUNCTION
#    plruby_test=# 
#    plruby_test=# select tt(true);
#     tt 
#    ----
#     t
#    (1 row)
#    
#    plruby_test=# select * from tu;
#     a | b 
#    ---+---
#    (0 rows)
#    
#    plruby_test=# select tt(false);
#     tt 
#    ----
#     f
#    (1 row)
#    
#    plruby_test=# select * from tu;
#     a | b 
#    ---+---
#     1 | 2
#     5 | 6
#    (2 rows)
#    
#    plruby_test=# 
# 
# 
module PLRuby::Description::Function
end
# 
# == Function returning SET (SFRM Materialize)
# 
# The return type must be declared as SETOF
# 
# The function must call <em>yield</em> to return rows or return a String
# which must be a valid SELECT statement
# 
# For example to concatenate 2 rows create the function
# 
#    plruby_test=# CREATE FUNCTION tu(varchar) RETURNS setof record
#    plruby_test-# AS '
#    plruby_test'#    size = PL.column_name(args[0]).size
#    plruby_test'#    res = nil
#    plruby_test'#    PL::Plan.new("select * from #{args[0]}", 
#    plruby_test'#                 "block" => 50).each do |row|
#    plruby_test'#       if res.nil?
#    plruby_test'#          res = row.values
#    plruby_test'#       else
#    plruby_test'#          res.concat row.values
#    plruby_test'#          yield res
#    plruby_test'#          res = nil
#    plruby_test'#       end
#    plruby_test'#    end
#    plruby_test'#    if res
#    plruby_test'#       res.concat Array.new(size)
#    plruby_test'#       yield res
#    plruby_test'#    end
#    plruby_test'# ' language 'plruby';
#    CREATE FUNCTION
#    plruby_test=# 
#    plruby_test=# select * from tt;
#     a | b  
#    ---+----
#     1 |  2
#     3 |  4
#     5 |  6
#     7 |  8
#     9 | 10
#    (5 rows)
#    
#    plruby_test=# select * from tu('tt') as tbl(a int, b int, c int, d int);
#     a | b  | c | d 
#    ---+----+---+---
#     1 |  2 | 3 | 4
#     5 |  6 | 7 | 8
#     9 | 10 |   |  
#    (3 rows)
#    
#    plruby_test=# 
# 
class PLRuby::Description::Function::SFRM
end
# == Function returning SET (ExprMultiResult)
# 
# The return type must be declared as SETOF
# 
# The function is called until it returns nil
# 
# The method PL#context and PL#context= give the possibility to store
# information between the call
# 
# For example
# 
#    plruby_test=# create or replace function vv(int) returns setof int as '
#    plruby_test'#    i = PL.context || 0
#    plruby_test'#    if i >= args[0]
#    plruby_test'#       nil
#    plruby_test'#    else
#    plruby_test'#       PL.context = i + 1
#    plruby_test'#    end
#    plruby_test'# ' language plruby;
#    CREATE FUNCTION
#    plruby_test=# 
#    plruby_test=# select * from uu;
#     b 
#    ---
#     2
#    (1 row)
#    
#    plruby_test=# 
#    plruby_test=# select *,vv(3) from uu;
#     b | vv 
#    ---+----
#     2 |  1
#     2 |  2
#     2 |  3
#    (3 rows)
#    
#    plruby_test=# 
# 
class PLRuby::Description::Function::ExprMultiResult
end
# 
# Trigger procedures are defined in Postgres as functions without
# arguments and a return type of trigger. In PLRuby the procedure is
# called with 4 arguments :
# 
# * new (hash, tainted)
#
#   an hash containing the values of the new table row on INSERT/UPDATE
#   actions, or empty on DELETE. 
# * old (hash, tainted)
#
#   an hash containing the values of the old table row on UPDATE/DELETE
#   actions, or empty on INSERT 
# * args (array, tainted, frozen)
#
#   An array of the arguments to the procedure as given in the CREATE
#   TRIGGER statement 
# * tg (hash, tainted, frozen)
#
#   The following keys are defined
#
#   - name
#
#     The name of the trigger from the CREATE TRIGGER statement.
#
#   - relname
#
#     The name of the relation who has fired the trigger
#
#   - relid
#
#     The object ID of the table that caused the trigger procedure to be invoked.
# 
#   - relatts
#
#     An array containing the name of the tables field.
# 
#   - when
#
#     The constant <em>PL::BEFORE</em>, <em>PL::AFTER</em> or
#     <em>PL::UNKNOWN</em> depending on the event of the trigger call.
# 
#   - level
#
#     The constant <em>PL::ROW</em> or <em>PL::STATEMENT</em>
#     depending on the event of the trigger call.
# 
#   - op
#
#     The constant <em>PL::INSERT</em>, <em>PL::UPDATE</em> or 
#     <em>PL::DELETE</em> depending on the event of the trigger call.
# 
# 
# The return value from a trigger procedure is one of the constant
# <em>PL::OK</em> or <em>PL::SKIP</em>, or an hash. If the
# return value is <em>PL::OK</em>, the normal operation
# (INSERT/UPDATE/DELETE) that fired this trigger will take
# place. Obviously, <em>PL::SKIP</em> tells the trigger manager to
# silently suppress the operation. The hash tells
# PLRuby to return a modified row to the trigger manager that will be
# inserted instead of the one given in <em>new</em> (INSERT/UPDATE
# only). Needless to say that all this is only meaningful when the
# trigger is BEFORE and FOR EACH ROW.
# 
# Here's a little example trigger procedure that forces an integer
# value in a table to keep track of the # of updates that are performed
# on the row. For new row's inserted, the value is initialized to 0 and
# then incremented on every update operation :
# 
#     CREATE FUNCTION trigfunc_modcount() RETURNS TRIGGER AS '
#         case tg["op"]
#         when PL::INSERT
#             new[args[0]] = 0
#           when PL::UPDATE
#               new[args[0]] = old[args[0]] + 1
#           else
#               return PL::OK
#           end
#           new
#       ' LANGUAGE 'plruby';
# 
#       CREATE TABLE mytab (num int4, modcnt int4, descr text);
# 
#       CREATE TRIGGER trig_mytab_modcount BEFORE INSERT OR UPDATE ON mytab
#           FOR EACH ROW EXECUTE PROCEDURE trigfunc_modcount('modcnt');
# 
# 
# 
# A more complex example (extract from test_setup.sql in the distribution)
# which use the global variable <em>$Plans</em> to store a prepared
# plan
# 
#    create function trig_pkey2_after() returns trigger as '
#       if ! $Plans.key?("plan_dta2_upd")
#           $Plans["plan_dta2_upd"] = 
#                PL::Plan.new("update T_dta2 
#                              set ref1 = $3, ref2 = $4
#                              where ref1 = $1 and ref2 = $2",
#                             ["int4", "varchar", "int4", "varchar" ]).save
#           $Plans["plan_dta2_del"] = 
#                PL::Plan.new("delete from T_dta2 
#                              where ref1 = $1 and ref2 = $2", 
#                             ["int4", "varchar"]).save
#       end
# 
#       old_ref_follow = false
#       old_ref_delete = false
# 
#       case tg["op"]
#       when PL::UPDATE
#           new["key2"] = new["key2"].upcase
#           old_ref_follow = (new["key1"] != old["key1"]) || 
#                            (new["key2"] != old["key2"])
#       when PL::DELETE
#           old_ref_delete = true
#       end
# 
#       if old_ref_follow
#           n = $Plans["plan_dta2_upd"].exec([old["key1"], old["key2"], new["key1"],
#    new["key2"]])
#           warn "updated #{n} entries in T_dta2 for new key in T_pkey2" if n != 0
#       end
# 
#       if old_ref_delete
#           n = $Plans["plan_dta2_del"].exec([old["key1"], old["key2"]])
#           warn "deleted #{n} entries from T_dta2" if n != 0
#       end
# 
#       PL::OK
#    ' language 'plruby';
# 
#    create trigger pkey2_after after update or delete on T_pkey2
#     for each row execute procedure
#     trig_pkey2_after();
# 
#
class PLRuby::Description::Trigger
end 
# == plruby_singleton_methods
# 
# Sometime it can be usefull to define methods (in pure Ruby) which can be
# called from a PLRuby function or a PLRuby trigger.
# 
# In this case, you have 2 possibilities
# 
# * the "stupid" way :-) :-) :-)
# 
# just close the current definition of the function (or trigger) with a
# <em>end</em> and define your singleton method without the final <em>end</em>
# 
# Here a small and useless example
# 
#           plruby_test=# CREATE FUNCTION tutu() RETURNS int4 AS '
#           plruby_test'#     toto(1, 3) + toto(4, 4)
#           plruby_test'# end
#           plruby_test'# 
#           plruby_test'# def PLtemp.toto(a, b)
#           plruby_test'#     a + b
#           plruby_test'# ' LANGUAGE 'plruby';
#           CREATE
#           plruby_test=# select tutu();
#           tutu
#           ----
#             12
#           (1 row)
#           
#           plruby_test=#
# 
# 
# * create a table plruby_singleton_methods with the columns (name, args, body)
# 
# At load time, PLRuby look if it exist a table plruby_singleton_methods 
# and if found try, for each row, to define singleton methods with the 
# template :
# 
#           def PLtemp.#{name}(#{args})
#               #{body}
#           end
# 
# The previous example can be written (you have a more complete example in
# test/plp/test_setup.sql)
# 
#           
#           plruby_test=# SELECT * FROM plruby_singleton_methods;
#           name|args|body 
#           ----+----+-----
#           toto|a, b|a + b
#           (1 row)
#           
#           plruby_test=# CREATE FUNCTION tutu() RETURNS int4 AS '
#           plruby_test'#     toto(1, 3) + toto(4, 4)
#           plruby_test'# ' LANGUAGE 'plruby';
#           CREATE
#           plruby_test=# select tutu();
#           tutu
#           ----
#             12
#           (1 row)
#           
#           plruby_test=#
#
# * Another example, if PLRuby was compiled with --enable-conversion and it 
#   exist  a column with the name '***' then it can create a singleton method
#   from a PLRuby function
# 
# 
#           plruby_test=# select * from plruby_singleton_methods;
#            name | args | body 
#           ------+------+------
#            ***  |      | 
#           (1 row)
#           
#           plruby_test=# create function add_value(int, int) returns int as '
#           plruby_test'# args[0] + args[1]
#           plruby_test'# ' language 'plruby';
#           CREATE FUNCTION
#           plruby_test=# 
#           plruby_test=# select add_value(10, 2);
#            add_value 
#           -----------
#                   12
#           (1 row)
#           
#           plruby_test=# 
#           plruby_test=# create function add_one(int) returns int as '
#           plruby_test'# add_value(args[0], 1)
#           plruby_test'# ' language 'plruby';
#           CREATE FUNCTION
#           plruby_test=# 
#           plruby_test=# select add_one(11);
#            add_one 
#           ---------
#                 12
#           (1 row)
#           
#           plruby_test=# 
# 
# 
# 
class PLRuby::Description::Singleton_method
end
#If the conversions was not disabled (--disable-conversion),  the following
#conversions are made
#
#                  PostgreSQL             Ruby
#                  ----------             ----
#                  OID                    Fixnum
#                  INT2OID                Fixnum
#                  INT4OID                Fixnum
#                  INT8OID                Fixnum (or Bignum)
#                  FLOAT4OID              Float
#                  FLOAT8OID              Float
#                  CASHOID                Float
#                  NUMERICOID             Float
#                  BOOLOID                true, false
#                  ABSTIMEOID             Time
#                  RELTIMEOID             Time
#                  TIMEOID                Time
#                  TIMETZOID              Time
#                  TIMESTAMPOID           Time
#                  TIMESTAMPTZOID         Time
#                  DATEOID                Time
#                  INTERVALOID            Time
#                  TINTERVALOID           Tinterval (new Ruby class)
#                  BITOID                 BitString (new Ruby class)
#                  VARBITOID              BitString (new Ruby class)
#                  INETOID                NetAddr   (new Ruby class)
#                  CIDROID                NetAddr   (new Ruby class)
#                  MACADDROID             MacAddr   (new Ruby class)
#                  POINTOID               Point     (new Ruby class)
#                  LSEGOID                Segment   (new Ruby class)
#                  BOXOID                 Box       (new Ruby class)
#                  PATHOID                Path      (new Ruby class)
#                  POLYGONOID             Polygon   (new Ruby class)
#                  CIRCLEOID              Circle    (new Ruby class)
#
#all others OID are converted to a String object
#
class PLRuby::Description::Conversion
end
#
# general module
# 
module PLRuby::PL
   class << self
   # 
   #Return the type of the arguments given to the function
   #
   def  args_type
   end
   # 
   #Return the name of the columns for the table
   #
   def  column_name(table)
   end
   # 
   #return the type of the columns for the table
   #
   def  column_type(table)
   end
   # 
   #Return the context (or nil) associated with a SETOF function 
   #(ExprMultiResult)
   #
   def  context
   end
   # 
   #Set the context for a SETOF function (ExprMultiResult)
   #
   def  context=
   end
   # 
   # 
   #Duplicates all occurences of single quote and backslash
   #characters. It should be used when variables are used in the query
   #string given to spi_exec or spi_prepare (not for the value list on
   #execp).
   #
   def  quote(string)
   end
   # 
   #Return the name of the columns for a function returning a SETOF
   #
   def  result_name
   end
   # 
   #Return the type of the columns for a function returning a SETOF
   #or the type of the return value
   #
   def  result_type
   end
   # 
   #Return the number of columns  for a function returning a SETOF
   #
   def  result_size
   end
   # 
   #Return the table description given to a function returning a SETOF
   #
   def  result_description
   end
   # 
   #
   #Call parser/planner/optimizer/executor for query. The optional
   #<em>count</em> value tells spi_exec the maximum number of rows to be
   #processed by the query.
   #    
   #* SELECT
   #If the query is a SELECT statement, an array is return (if count is
   #not specified or with a value > 1). Each element of this array is an
   #hash where the key is the column name.
   #    
   #If type is specified it can take the value
   #
   #* "array" return for each column an array with the element
   #["name", "value", "type", "len", "typeid"]
   #* "hash" return for each column an hash with the keys 
   #{"name", "value", "type", "len", "typeid"}
   #* "value" return all values
   #
   #For example this procedure display all rows in the table pg_table.
   #    
   #    CREATE FUNCTION pg_table_dis() RETURNS int4 AS '
   #       res = PL.exec("select * from pg_class")
   #       res.each do |x|
   #          warn "======================"
   #          x.each do |y, z|
   #             warn "name = #{y} -- value = #{z}"
   #         end
   #         warn "======================"
   #       end
   #       return res.size
   #    ' LANGUAGE 'plruby';
   #    
   #A block can be specified, in this case a call to yield() will be
   #made.
   #    
   #If count is specified with the value 1, only the first row (or
   #FALSE if it fail) is returned as a hash. Here a little example :
   #    
   #    
   #    CREATE FUNCTION pg_table_dis() RETURNS int4 AS '
   #       PL.exec("select * from pg_class", 1) { |y, z|
   #          warn "name = #{y} -- value = #{z}"
   #       }
   #       return 1
   #    ' LANGUAGE 'plruby';
   #    
   #Another example with count = 1
   #    
   #    create table T_pkey1 (
   #        skey1        int4,
   #        skey2        varchar(20),
   #        stxt         varchar(40)
   #    );
   #            
   #    create function toto() returns bool as '
   #       warn("=======")
   #       PL.exec("select * from T_pkey1", 1, "hash") do |a|
   #          warn(a.inspect)
   #       end
   #       warn("=======")
   #       PL.exec("select * from T_pkey1", 1, "array") do |a|
   #          warn(a.inspect)
   #       end
   #       warn("=======")
   #       PL.exec("select * from T_pkey1", 1) do |a|
   #          warn(a.inspect)
   #       end
   #       warn("=======")
   #       return true
   #    ' language 'plruby';
   #           
   #    plruby_test=# select toto();
   #    NOTICE:  =======
   #    NOTICE:  {"name"=>"skey1", "typeid"=>23, "type"=>"int4", "value"=>"12", "len"=>4}
   #    NOTICE:  {"name"=>"skey2", "typeid"=>1043, "type"=>"varchar", "value"=>"a", "len"=>20}
   #    NOTICE:  {"name"=>"stxt", "typeid"=>1043, "type"=>"varchar", "value"=>"b", "len"=>40}
   #    NOTICE:  =======
   #    NOTICE:  ["skey1", "12", "int4", 4, 23]
   #    NOTICE:  ["skey2", "a", "varchar", 20, 1043]
   #    NOTICE:  ["stxt", "b", "varchar", 40, 1043]
   #    NOTICE:  =======
   #    NOTICE:  ["skey1", "12"]
   #    NOTICE:  ["skey2", "a"]
   #    NOTICE:  ["stxt", "b"]
   #    NOTICE:  =======
   #     toto 
   #    ------
   #     t
   #    (1 row)
   #      
   #    plruby_test=# 
   #    
   #    
   #* SELECT INTO, INSERT, UPDATE, DELETE
   #return the number of rows insered, updated, deleted, ...
   #    
   #    
   #* UTILITY
   #return TRUE
   #    
   def  exec(string [, count [, type]])
   end
   #same than <em> exec</em>
   def  spi_exec(string [, count [, type]])
   end

   # 
   #
   #Deprecated : See <em>PL::Plan::new</em> and <em>PL::Plan#save</em>
   #
   #Prepares AND SAVES a query plan for later execution. It is a bit
   #different from the C level SPI_prepare in that the plan is
   #automatically copied to the toplevel memory context.
   #
   #If the query references arguments, the type names must be given as a
   #Ruby array of strings. The return value from prepare is a
   #<em>PL::Plan</em> object to be used in subsequent calls to
   #<em>PL::Plan#exec</em>.
   #
   #If the hash given has the keys <em>count</em>, <em>output</em> these values
   #will be given to the subsequent calls to <em>each</em>
   def  prepare(string[, types])
   end
   #same than <em> prepare</em>
   def  spi_prepare(string[, types])
   end
end
#
# class for prepared plan
#
class PL::Plan
   # 
   #
   #Prepares a query plan for later execution.
   #
   #If the query references arguments, the type names must be given as a
   #Ruby array of strings.
   #
   #If the hash given has the keys <em>output</em>, <em>count</em> these values
   #will be given to the subsequent calls to <em>each</em>
   #
   #If <em>"save"</em> as a true value, the plan will be saved 
   #
   #
   def  initialize(string, "types" => types, "count" => count, "output" => type, "save" => false)
   end
   # 
   #
   #Execute a prepared plan from <em>PL::Plan::new</em> with variable
   #substitution. The optional <em>count</em> value tells
   #<em>PL::Plan#exec</em> the maximum number of rows to be processed by the
   #query.
   #
   #If there was a typelist given to <em>PL::Plan::new</em>, an array
   #of <em>values</em> of exactly the same length must be given to
   #<em>PL::Plan#exec</em> as first argument. If the type list on
   #<em>PL::Plan::new</em> was empty, this argument must be omitted.
   #
   #If the query is a SELECT statement, the same as described for
   #<em>PL#exec</em> happens for the loop-body and the variables for
   #the fields selected.
   #
   #If type is specified it can take the values
   #* "array" return an array with the element ["name", "value", "type", "len", "typeid"]
   #* "hash" return an hash with the keys {"name", "value", "type", "len", "typeid"}
   #* "value" return an array with all values
   #
   #Here's an example for a PLRuby function using a prepared plan : 
   #
   #   CREATE FUNCTION t1_count(int4, int4) RETURNS int4 AS '
   #       if ! $Plans.key?("plan")
   #           # prepare the saved plan on the first call
   #           $Plans["plan"] = PL::Plan.new("SELECT count(*) AS cnt FROM t1 
   #                                          WHERE num >= $1 AND num <= $2",
   #                                         ["int4", "int4"]).save
   #       end
   #       n = $Plans["plan"].exec([args[0], args[1]], 1)
   #       n["cnt"]
   #   ' LANGUAGE 'plruby';
   #
   def  exec(values, [count [, type]])
   end
   #same than <em> exec</em>
   def  execp(values, [count [, type]])
   end
   #same than <em> exec</em>
   def  execp("values" => values, "count" => count, "output" => type)
   end
   # 
   # 
   #Create a new object PL::Cursor
   #
   #If output is specified it can take the values
   #* "array" return an array with the element ["name", "value", "type", "len", "typeid"]
   #*  "hash" return an hash with the keys {"name", "value", "type", "len", "typeid"}
   #* "value" return an array with all values
   #
   #If there was a typelist given to <em>PL::Plan::new</em>, an array
   #of <em>values</em> of exactly the same length must be given to
   #<em>PL::Plan#cursor</em>
   #
   def  cursor(name = nil, "values" => values, "output" => type)
   end
   # 
   #
   #Same then #exec but a call to SPI_cursor_open(), SPI_cursor_fetch() is made.
   #
   #Can be used only with a block and a SELECT statement
   #    
   #   create function toto() returns bool as '
   #          plan = PL::Plan.new("select * from T_pkey1")
   #          warn "=====> ALL"
   #          plan.each do |x|
   #             warn(x.inspect)
   #          end
   #          warn "=====> FIRST 2"
   #          plan.each("count" => 2) do |x|
   #             warn(x.inspect)
   #          end
   #          return true
   #   ' language 'plruby';
   #   
   #   plruby_test=# select * from T_pkey1;
   #    skey1 | skey2 | stxt 
   #   -------+-------+------
   #       12 | a     | b
   #       24 | c     | d
   #       36 | e     | f
   #   (3 rows)
   #   
   #   plruby_test=# 
   #   plruby_test=# select toto();
   #   NOTICE:  =====> ALL
   #   NOTICE:  {"skey1"=>"12", "skey2"=>"a", "stxt"=>"b"}
   #   NOTICE:  {"skey1"=>"24", "skey2"=>"c", "stxt"=>"d"}
   #   NOTICE:  {"skey1"=>"36", "skey2"=>"e", "stxt"=>"f"}
   #   NOTICE:  =====> FIRST 2
   #   NOTICE:  {"skey1"=>"12", "skey2"=>"a", "stxt"=>"b"}
   #   NOTICE:  {"skey1"=>"24", "skey2"=>"c", "stxt"=>"d"}
   #    toto 
   #   ------
   #    t
   #   (1 row)
   #   
   #   plruby_test=# 
   #
   def  each(values, [count [, type ]]) { ... }
   end
   #same than <em> each</em>
   def  fetch(values, [count [, type ]]) { ... }
   end
   #same than <em> each</em>
   def  fetch("values" => values, "count" => count, "output" => type) { ... }
   end
   # 
   #
   #Release a query plan
   #
   def  release
   end
   # 
   #  
   #Save a query plan for later execution. The plan is copied to the
   #toplevel memory context.
   #
   def  save
   end
end
end

#
# A cursor is created with the method PL::Plan#cursor
#
class PLRuby::PL::Cursor
   #Closes a cursor
   #
   def  close
   end
   # 
   # 
   #Iterate over all rows (forward)
   #
   def  each 
      yield row
   end
   # 
   #
   #Fetches some rows from a cursor
   #
   #if count > 0 fetch forward else backward
   #
   def  fetch(count = 1)
   end
   #same than <em> fetch</em>
   def  row(count = 1)
   end
   # 
   #
   #Move a cursor : if count > 0 move forward else backward
   #
   def  move(count)
   end
   # 
   #
   #Iterate over all rows (backward)
   #
   def  reverse_each 
      yield row
   end
end

#
# A transaction is created with the global function #transaction
#
# Only available with PostgreSQL >= 8.0
#
class PLRuby::PL::Transaction

   # abort the transaction
   def abort
   end

   # commit the transaction
   def commit
   end
end
#
# The class PLRuby::BitString implement the PostgreSQL type <em>bit</em>
# and <em>bit varying</em>
#
class PLRuby::BitString
   include Comparable
   include Enumerable

   class << self

      # Convert a <em>String</em> to a <em>BitString</em>
      def from_string(string, length = strlen(string))
      end
   end

   # comparison function for 2 <em>BitString</em> objects
   #
   # All bits are considered and additional zero bits may make one string
   # smaller/larger than the other, even if their zero-padded values would
   # be the same.
   def <=>(other)
   end

   # Concatenate <em>self</em> and <em>other</em>
   def +(other)
   end

   # AND operator
   def &(other)
   end

   # OR operator
   def |(other)
   end

   # XOR operator
   def ^(other)
   end

   # NOT operator
   def ~()
   end

   # LEFT SHIFT operator
   def <<(lshft)
   end

   # RIGHT SHIFT operator
   def >>(rshft)
   end

   # Element reference with the same syntax that for a <em>String</em> object
   #
   # Return a <em>BitString</em> or a <em>Fixnum</em> 0, 1
   #
   #   bitstring[fixnum]
   #   bitstring[fixnum, fixnum]
   #   bitstring[range]
   #   bitstring[regexp]
   #   bitstring[regexp, fixnum]
   #   bitstring[string]
   #   bitstring[other_bitstring]
   def [](*args)
   end

   # Element assignment with the same syntax that for a <em>String</em> object
   #
   #   bitstring[fixnum] = fixnum
   #   bitstring[fixnum] = string_or_bitstring
   #   bitstring[fixnum, fixnum] = string_or_bitstring
   #   bitstring[range] = string_or_bitstring
   #   bitstring[regexp] = string_or_bitstring
   #   bitstring[regexp, fixnum] = string_or_bitstring
   #   bitstring[other_str] = string_or_bitstring
   def []=(*args)
   end

   # append <em>other</em> to <em>self</em>
   def concat(other)
   end

   # iterate other each bit
   def each
   end

   # return <em>true</em> if <em>other</em> is included in <em>self</em>
   def include?(other)
   end

   # return the position of <em>other</em> in <em>self</em>
   #
   # return <em>nil</em> if <em>other</em> is not included in <em>self</em>
   def index(other)
   end

   # create a new <em>BitString</em> object with <em>nbits</em> bits
   #
   # <em>init</em> can be a <em>Fixnum</em> or a <em>String</em>
   #
   # For a <em>String</em> the first character can be 'x', 'X' for and
   # hexadecimal representation, or 'b', 'B' for a binary representation. 
   # The default is a binary representation
   def initialize(init, nbits = -1)
   end

   # return the length of <em>self</em> in bits
   def length
   end

   # return the length of <em>self</em> in octets
   def octet_length
   end

   # append <em>other</em> to <em>self</em>
   def push(other)
   end

   # convert <em>self</em> to a <em>Fixnum</em>
   def to_i
   end

   # convert <em>self</em> to a <em>String</em>
   def to_s
   end

end

#
# The class PLRuby::NetAddr implement the PostgreSQL type <em>inet</em>
# and <em>cidr</em>
#
class PLRuby::NetAddr
   include Comparable

   class << self

      # Convert a <em>String</em> to a <em>NetAddr</em>
      def from_string(string, cidr = false)
      end
   end

   # comparison function for 2 <em>NetAddr</em> objects
   #
   # comparison is first on the common bits of the network part, then on
   # the length of the network part, and then on the whole unmasked address.
   def <=>(other)
   end

   # return the abbreviated display format as a <em>String</em> object
   def abbrev
   end

   # return the broadcast address from the network
   def broadcast
   end

   # return true if <em>other</em> is included in <em>self</em>
   def contain?(other)
   end

   # return true if <em>other</em> is included in <em>self</em>, or equal
   def contain_or_equal?(other)
   end

   # return true if <em>self</em> is included in <em>other</em>
   def contained?(other)
   end

   # return true if <em>self</em> is included in <em>other</em>, or equal
   def contained_or_equal?(other)
   end

   # return the String "AF_INET" or "AF_INET6"
   def family
   end

   # return the first address in the network
   def first
   end

   # extract the IP address and return it as a <em>String</em> 
   def host
   end

   # return the host mask for network
   def hostmask
   end

   # create a <em>NetAddr</em> from a <em>String</em>
   def initialize(string, cidr = false)
   end

   # return the last address in the network
   def last
   end

   # return the length of the netmask
   def masklen
   end

   # return the netmask for the network
   def netmask
   end

   # return the network part of the address
   def network
   end

   # return a new <em>NetAddr</em> with netmask length <em>len</em>
   def set_masklen(len)
   end 

   # return the string representation of the address
   def to_s
   end

end

#
# The class PLRuby::MacAddr implement the PostgreSQL type <em>macaddr</em>
#
class PLRuby::MacAddr
   include Comparable

   class << self

      # Convert a <em>String</em> to a <em>MacAddr</em>
      def from_string(string, cidr = false)
      end
   end

   # comparison function for 2 <em>MacAddr</em> objects
   def <=>(other)
   end

   # create a <em>MacAddr</em> from a <em>String</em>
   def initialize(string)
   end

   # return the string representation of the MAC address
   def to_s
   end

   # return a new object with the last 3 bytes set to zero
   def truncate
   end

end

#
# The class PLRuby::Tinterval implement the PostgreSQL type <em>tinterval</em>
#
class PLRuby::Tinterval
   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Tinterval</em>
      def from_string(string)
      end
   end

   # return a <em>Time</em> which is the high value of the interval
   def high
   end

   # set the high value for the interval
   def high=(time)
   end

   # create a <em>Tinterval</em> with the 2 <em>Time</em> objects
   # <em>low</em> and <em>high</em>
   def initialize(low, high)
   end

   # return a <em>Time</em> which is the low value of the interval
   def low
   end

   # set the low value for the interval
   def low=(time)
   end
 
   # return the string representation of the object
   def to_s
   end

end

#
# The class PLRuby::Box implement the PostgreSQL type <em>box</em>
#
class PLRuby::Box
   include Comparable

   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Box</em> object
      def from_string(string)
      end
   end

   # translate (right, up) <em>self</em>
   def +(point)
   end

   # translate (left, down) <em>self</em>
   def -(point)
   end

   # scale and rotate <em>self</em>
   def *(point)
   end

   # scale and rotate <em>self</em>
   def /(point)
   end

   # return true if the 2 boxes <em>self</em> and <em>other</em> are identical
   def ===(other)
   end

   # comparison operator for 2 Box based on the area of the 2 objects, i.e.
   # self.area <=> box.area
   def <=>(other)
   end

   # return true if  <em>self</em> is above <em>other</em>
   def above?(other)
   end

   # return the area of the Box
   def area
   end

   # return true if  <em>self</em> is below <em>other</em>
   def below?(other)
   end

   # return the center point of the Box
   def center
   end

   # closest point to <em>other</em>
   #
   # <em>other</em> can be a Point, or Segment
   def closest(other)
   end

   # return true if  <em>self</em> contain <em>other</em>
   def contain?(other)
   end

   # return true if  <em>self</em> is contained by <em>other</em>
   def contained?(other)
   end

   # return a line Segment which happens to be the
   # positive-slope diagonal of Box
   def diagonal
   end

   # return the height of the Box (vertical magnitude)
   def height
   end

   # return true if  <em>self</em> is contained by <em>other</em>
   def in?(other)
   end

   # create a new Box object
   #
   # <em>args</em> can be 2 Point objects (low, high) or 4 Float objects
   # (low.x, low.y, high.x, high.y)
   def initialize(*args)
   end

   # returns the overlapping portion of two boxes,
   # or <em>nil</em> if they do not intersect.
   def intersection(other)
   end

   # returns  true if the Segment <em>segment</em>
   # intersect with the Box
   #
   # Segment completely inside box counts as intersection.
   # If you want only segments crossing box boundaries,
   # try converting Box to Path first.
   # 
   def intersect?(segment)
   end

   # return true if <em>self</em> is strictly left of <em>other</em>
   def left?(other)
   end

   # return true if <em>self</em> overlap <em>other</em>
   def overlap?(other)
   end
 
   # return true if the right edge of <em>self</em> is to the left of
   # the right edge of <em>other</em>
   def overleft?(other)
   end

   # return true if the left edge of <em>self</em> is to the right of
   # the left edge of <em>other</em>
   def overright?(other)
   end

   # return true if <em>self</em> is strictly right of <em>other</em>
   def right?(other)
   end

   # return true if the 2 boxes <em>self</em> and <em>other</em> are identical
   def same?(other)
   end

   # convert a Box to a Circle
   def to_circle
   end

   # return the center Point of the Box
   def to_point
   end

   # convert a Box to a Polygon
   def to_polygon
   end

   # return a line Segment which happens to be the
   # positive-slope diagonal of Box
   def to_segment
   end

   # return the width of the Box (horizontal magnitude)
   def width
   end
end

#
# The class PLRuby::Path implement the PostgreSQL type <em>path</em>
#
class PLRuby::Path
   include Comparable

   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Path</em>
      def from_string(string)
      end
   end

   # concatenate the two paths (only if they are both open)
   def <<(path)
   end

   # translate (right, up) <em>self</em>
   def +(point)
   end

   # translate (left, down) <em>self</em>
   def -(point)
   end

   # scale and rotate <em>self</em>
   def *(point)
   end

   # scale and rotate <em>self</em>
   def /(point)
   end

   # comparison function based on the path cardinality, i.e.
   # self.npoints <=> other.npoints
   def <=>(other)
   end

   # make a closed path
   def close
   end

   # return true if <em>self</em> is a closed path
   def closed?
   end

   # concatenate the two paths (only if they are both open)
   def concat(path)
   end

   # create a new Path object from the Array of Point <em>points</em>
   def initialize(points, closed = false)
   end

   # return the length of <em>self</em>
   def length
   end

   # return the path cardinality
   def npoints
   end

   # make an open path
   def open
   end

   # convert <em>self</em> to a Polygon object
   def to_polygon
   end
end
#
# The class PLRuby::Point implement the PostgreSQL type <em>point</em>
#
class PLRuby::Point
   include Comparable

   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Point</em>
      def from_string(string)
      end
   end

   # translate (right, up) <em>self</em>
   def +(point)
   end

   # translate (left, down) <em>self</em>
   def -(point)
   end

   # scale and rotate <em>self</em>
   def *(point)
   end

   # scale and rotate <em>self</em>
   def /(point)
   end

   # return the coordinate
   #
   # <em>indice</em> can have the value 0 or 1
   def [](indice)
   end

   # set the coordinate
   #
   # <em>indice</em> can have the value 0 or 1
   def []=(indice, value)
   end

   # return true if <em>self</em> and <em>other</em> are the same,
   # i.e. self.x == other.x && self.y == other.y
   def ==(other)
   end

   # return true if <em>self</em> is above <em>other</em>,
   # i.e. self.y > other.y
   def above?(other)
   end

   # return true if <em>self</em> is below <em>other</em>,
   # i.e. self.y < other.y
   def below?(other)
   end

   # return true if <em>self</em> is contained in <em>other</em>
   # 
   # <em>other</em> can be Point, Polygon or a Circle object
   def contained?(other)
   end

   # return true if <em>self</em> and <em>other</em> are horizontal,
   # i.e. self.y == other.y
   def horizontal?(other)
   end

   # return true if <em>self</em> is contained in <em>other</em>
   # 
   # <em>other</em> can be Point, Polygon or a Circle object
   def in?(other)
   end

   # create a Point with the 2 Float object (x, y)
   def initialize(x, y)
   end

   # return true if <em>self</em> is at the left of <em>other</em>,
   # i.e. self.x < other.x
   def left?(other)
   end

   # return true if <em>self</em> is on <em>other</em>
   # 
   # <em>other</em> can be Point, Segment, Box or Path object
   def on?(other)
   end

   # return true if <em>self</em> is at the right of <em>other</em>,
   # i.e. self.x > other.x
   def right?(other)
   end

   # return true if <em>self</em> and <em>other</em> are vertical,
   # i.e. self.x == other.x
   def vertical?(other)
   end

   # return <em>x</em> for <em>self</em>
   def x
   end

   # set the <em>x</em> value for <em>self</em>
   def x=(value)
   end

   # return <em>y</em> for <em>self</em>
   def y
   end

   # set the <em>y</em> value for <em>self</em>
   def y=(value)
   end

end

#
# The class PLRuby::Segment implement the PostgreSQL type <em>lseg</em>
#
class PLRuby::Segment
   include Comparable

   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Segment</em>
      def from_string(string)
      end
   end

   # comparison function for the 2 segments, returns
   #
   #  0  if self[0] == other[0] && self[1] == other[1]
   #
   #  1  if distance(self[0], self[1]) > distance(other[0], other[1]) 
   #
   #  -1 if distance(self[0], self[1]) < distance(other[0], other[1]) 
   def <=>(other)
   end

   # return the center of the segment
   def center
   end

   # closest point to other
   #
   # <em>other</em> can be a Point, Segment or Box
   #
   # With a point, take the closest endpoint 
   # if the point is left, right, above, or below the segment, otherwise 
   # find the intersection point of the segment and its perpendicular through
   # the point.
   def closest(other)
   end

   # returns true if <em>self</em> is a horizontal Segment
   def horizontal?
   end

   # create a Segment from the 2 Point p0, p1
   def initialize(point0, point1)
   end

   # returns true if <em>self</em> and <em>other</em> intersect
   def intersect?(other)
   end

   # returns the Point where the 2 Segment <em>self</em> and <em>other</em>
   # intersect or nil
   def intersection(other)
   end

   # return the length of <em>self</em>, i.e. the distnace between the 2 points
   def length
   end

   # return true if <em>self</em> is on <em>other</em>
   #
   # <em>other</em> can be a Segment, or a Box object
   def on?(other)
   end

   # returns true if the 2 Segment <em>self</em> and <em>other</em> 
   # are parallel
   def parallel?(other)
   end

   # returns true if <em>self</em> is perpendicular to <em>other</em>
   def perpendicular?(other)
   end

   # conversion function to a Point, return the center of the segment
   def to_point
   end

   # returns true if <em>self</em> is a vertical Segment
   def vertical?
   end
end
#
# The class PLRuby::Polygon implement the PostgreSQL type <em>polygon</em>
#
class PLRuby::Polygon
   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Polygon</em>
      def from_string(string)
      end
   end

   # return true if <em>self</em> is the same as <em>other</em>, i.e. all
   # the points are the same
   def ==(other)
   end

   # return the center of <em>self</em>, i.e. create a circle and return its 
   # center
   def center
   end

   # return true if <em>self</em> contains <em>other</em>
   #
   # <em>other</em> can be a Point or a Polygon
   def contain?(other)
   end

   # return true if <em>self</em> is contained in <em>other</em> by determining
   # if <em>self</em> bounding box is contained by <em>other</em>'s bounding box.
   def contained?(other)
   end

   # return true if <em>self</em> is contained in <em>other</em> by determining
   # if <em>self</em> bounding box is contained by <em>other</em>'s bounding box.
   def in?(other)
   end

   # create a new Polygon object from the Array of Point <em>points</em>
   def initialize(points, closed = false)
   end

   # return true if <em>self</em> is strictly left of <em>other</em>, i.e.
   # the right most point of <em>self</em> is left of the left
   # most point of <em>other</em>
   def left?(other)
   end

   # return true if <em>self</em> is overlapping or left of <em>other</em>,
   # i.e. the left most point of <em>self</em> is left of the right
   # most point of <em>other</em>
   def overleft?(other)
   end

   # return true if <em>self</em> is overlapping or right of <em>other</em>,
   # i.e. the right most point of <em>self</em> is right of the left
   # most point of <em>other</em>
   def overright?(other)
   end

   # return true if <em>self</em> and <em>other</em> overlap by determining if
   # their bounding boxes overlap.
   def overlap?(other)
   end

   # return the number of points in <em>self</em>
   def npoints
   end

   # return true if <em>self</em> is strictly right of <em>other</em>, i.e.
   # the left most point of <em>self</em> is right of the left
   # most point of <em>other</em>
   def right?(other)
   end

   # return true if <em>self</em> is the same as <em>other</em>, i.e. all 
   # the points are the same
   def same?(other)
   end

   # convert <em>self</em> to a Box
   def to_box
   end

   # convert <em>self</em> to a Circle
   def to_circle
   end

   # convert <em>self</em> to a Path
   def to_path
   end

   # convert <em>self</em> to a Point by returning its center
   def to_point
   end
end

#
# The class PLRuby::Circle implement the PostgreSQL type <em>circle</em>
#
class PLRuby::Circle
   include Comparable

   class << self

      # Convert a <em>String</em> (PostgreSQL representation)
      # to a <em>Circle</em>
      def from_string(string)
      end
   end

   # translate (right, up) <em>self</em>
   def +(point)
   end

   # translate (left, down) <em>self</em>
   def -(point)
   end

   # scale and rotate <em>self</em>
   def *(point)
   end

   # scale and rotate <em>self</em>
   def /(point)
   end

   # comparison function based on area,
   # i.e. self.area <=> other.area
   def <=>(other)
   end

   # return the area
   def area
   end

   # return true if <em>self</em> is entirely above <em>other</em>
   def above?(other)
   end

   # return true if <em>self</em> is entirely below <em>other</em>
   def below?(other)
   end

   # return true if <em>self</em> contain <em>other</em>
   def contain?(other)
   end

   # return true if <em>self</em> is contained in <em>other</em>
   def contained?(other)
   end

   # return the diameter
   def diameter
   end

   # create a Circle object with <em>center</em> and <em>radius</em>
   #
   # <em>center</em> can be a Point or an Array [x, y]
   def initialize(center, radius)
   end

   # return true if <em>self</em> overlap <em>other</em>
   def overlap?(other)
   end

   # return true if the right edge of <em>self</em> is to the left of
   # the right edge of <em>other</em>
   def overleft?(other)
   end

   # return true if <em>self</em> is strictly left of <em>other</em>
   def left?(other)
   end

   # return true if the left edge of <em>self</em> is to the right of
   # the left edge of <em>other</em>
   def overright?(other)
   end

   # return the radius
   def radius
   end

   # return true if <em>self</em> is strictly right of <em>other</em>
   def right?(other)
   end

   # return true if <em>self</em> is the same than <em>other</em>, i.e.
   # self.center == other.center && self.radius == other.radius
   def same?(other)
   end

   # convert <em>self</em> to a Box
   def to_box
   end

   # convert <em>self</em> to a Point by returning its center
   def to_point
   end

   # convert <em>self</em> to a Polygon with <em>npts</em> Points
   def to_polygon(npts)
   end

end
