globegit-postgresql-plruby 0.5.4

data/Changes

@@ -0,0 +1,121 @@
+-- 0.1.0 - 0.2.5
+
+ adaptation for new version of PostgreSQL
+
+-- 0.2.6
+
+ #exec can have an optional output of type "array", "hash"
+ (see the example in plruby.html)
+
+-- 0.2.7
+
+ PLrubyplan#each
+
+--- 0.2.8
+  
+ adapted for 7.3b3
+
+--- 0.2.9
+
+ adapted for 1.8.0
+ corrected stupid bug with GC 
+
+--- 0.3.0
+
+ *experimental* timeout (--with-timeout)
+ fixed SPI_execp()
+
+--- 0.3.1
+
+ corrected for_numvals() (Thanks  Brad Hilton <bhilton@vpop.net>)
+
+--- 0.3.2
+
+ functions returning set (PostgreSQL >= 7.3)
+
+--- 0.3.3
+
+ corrected timeout
+ corrected bug with GC
+ new classes PL::Plan, PL::Cursor
+
+--- 0.3.4
+
+ adapted for 7.4
+ Warning : array as input and output (7.4)
+ anyarray/anyelement in input/output for 7.4
+
+--- 0.3.6
+
+ corrected "EACH STATEMENT"
+ added ExprMultiResult
+
+--- 0.3.7
+
+ corrected full qualified type names for SPI_prepare
+ #each return nil for PL::Plan
+ protected PL::PLan::new against parse error
+ protected thread value when there is a timeout
+
+--- 0.3.8
+
+ stupid bug portalActive (only 7.4)
+
+--- 0.3.9
+
+ corrected rb_hash_delete for 1.6  (Thanks Dennis Vshivkov <walrus@amur.ru>)
+ decode arrays in tuples (Thanks Dennis Vshivkov <walrus@amur.ru>)
+ corrected pl_yield (Thanks Dennis Vshivkov <walrus@amur.ru>)
+ convert arguments (--enable-conversion at compile time : experimental)
+ conversion plfunction ==> method (only with --enable-conversion)
+ add network, geometry (experimental)
+ corrected function returning table
+
+--- 0.4.0
+
+ --enable-shared
+ array for trigger
+
+--- 0.4.1
+
+ add bitstring
+
+--- 0.4.2
+
+ by default convert arguments ( --disable-conversion to remove it)
+
+--- 0.4.3
+
+ IMPORTANT : work only with postgres >= 7.3
+ transaction and named arguments for 8.0
+
+--- 0.4.4
+
+* patch written by Dennis Vshivkov <walrus@amur.ru>
+  - Time-conversion-fix
+  - typtypmod-fix
+  - Integer-conversion-fix
+  - extconf.rb-PG_TRY-test-fix
+  - redundant-ReleaseSysCache-fix
+  - BYTEA-conv
+  - MONEY-conv-fix
+  - Float-conv-back-fix
+
+--- 0.4.5
+
+* corrected ReleaseSysCache() (Thanks to Peter Eisentraut <peter_e@gmx.net>)
+* conversion function String#to_datum (Thanks to Dennis Vshivkov <walrus@amur.ru>)
+
+--- 0.4.5 - 0.5.3 (2008-03-03)
+
+* adapted for 8.1, 8.2, and 8.3
+
+The original author Guy Decoux passed away in the beginning of the
+month of July 2008 at the age of 53.  The development is inherited by
+Akinori MUSHA.
+
+--- 0.5.4 (2010-01-02)
+
+* adapted for 8.4
+* bug-fix
+* extconf.rb changed to make use of pg_config(1)

data/README.markdown

@@ -0,0 +1,155 @@
+PL/ruby
+=======
+
+  PL/Ruby is a loadable procedural language for the PostgreSQL database
+  system that enables the Ruby language to create functions and trigger
+  procedures.
+
+
+Prerequisite
+------------
+
+> * ruby 1.8.7 or later
+> * postgresql >= 7.3
+
+  All PostgreSQL development headers need to be installed. If you installed
+  using a package manager of some sort, be sure to install the "dev" package.
+
+  If you built from source you can run the following command:
+
+        make install-all-headers
+
+Installation
+------------
+
+  If you're installing the gem:
+
+        gem install postgresql-plruby
+
+  If you want to allow the ability to require external libraries:
+
+        gem install postgresql-plruby -- --with-safe-level=0
+
+  If you're doing things the old fashioned way:
+
+        ruby extconf.rb
+        make
+        make install
+
+  You may need to specify some of the following extconf.rb options:
+
+        --with-pg-config=<location of the pg_config command of PostgreSQL>
+
+  Specifies the location of pg_config.
+  e.g. --with-pg-config=/usr/local/bin/pg_config
+
+        --with-greenplum
+
+  Builds plruby for Greenplum instead of PostgreSQL.
+
+        --disable-conversion
+
+  By default plruby tries to convert a postgres type to a ruby class.
+  This option gives the possibility to disable all conversions.
+
+       --with-suffix=<suffix to add>
+
+  Specifies a suffix to add to the extension module file.
+  e.g. `ruby extconf.rb --with-suffix=_geo` will create
+  `plruby_geo.so`.
+
+        --with-safe-level
+
+  Lowers the safe level which the plruby functions are run under.
+  (default: 12; meaning the maximum)
+
+        --with-timeout=<seconds>
+
+  Sets the timeout for each function call. (default: none)
+
+        --with-main-safe-level
+
+  Lowers the safe level which the main thread waiting for timeouts is
+  run under. (default: 3) This option is read only when --with-timeout
+  is given.
+
+
+Test (and examples)
+-------------------
+
+  WARNING: if plruby was compiled without --disable-conversion you
+  must **FIRST** run `make install` before `make test`.
+
+        make test
+
+  This will run the following two commands:
+
+        ( cd test/plt; ./runtest )
+        ( cd test/plp; ./runtest )
+
+  The database `plruby_test` is created and then destroyed.  Don't use
+  it if you have such a database.
+
+  Now you are ready to create the PL/Ruby language in PostgreSQL.
+
+  Since the `pg_language` system catalog is private to each database,
+  the new language can be created only for individual databases, or in
+  the template1 database.  In the latter case, it is automatically
+  available in all newly created databases.
+
+  The commands to create the new language are:
+
+        create function plruby_call_handler () returns language_handler
+        as 'path-to-plruby-shared-lib'
+        language 'C';
+
+        create trusted language 'plruby'
+        handler plruby_call_handler
+        lancompiler 'PL/Ruby';
+
+
+  The `trusted` keyword on `create language` tells PostgreSQL,
+  that all users (not only those with superuser privilege) are
+  permitted to create functions with `LANGUAGE 'plruby'`. This is
+  absolutely safe, because there is nothing a normal user can do
+  with PL/Ruby, to get around access restrictions he/she has.
+
+Sample Functions
+----------------
+    CREATE FUNCTION ruby_max(int4, int4) RETURNS int4 AS '
+       if args[0] > args[1]
+           return args[0]
+       else
+           return args[1]
+       end
+    ' LANGUAGE 'plruby';
+
+    select ruby_max(1,2);
+
+    CREATE FUNCTION ruby_max2(x int4, y int4) RETURNS int4 AS '
+       return x > y ? x : y
+    ' LANGUAGE 'plruby';
+
+    select ruby_max2(7,8);
+
+Documentation
+-------------
+
+  see `plruby.rd` and `plruby.html`
+
+Development
+-----------
+
+  New releases and sources can be obtained from <http://github.com/knu/postgresql-plruby>
+
+Copying
+-------
+
+  This extension module is copyrighted free software by Guy Decoux.
+
+  You can redistribute it and/or modify it under the same term as Ruby.
+
+* * *
+
+Guy Decoux <ts@moulon.inra.fr> (original author, deceased in July 2008)
+Akinori MUSHA <knu@idaemons.org> (current maintainer)

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rbconfig'
+include Config
+
+# TODO: Reorganize code to use Rake compiler.
+
+CLEAN.include(
+  '**/*.gem',               # Gem files
+  '**/*.rbc',               # Rubinius
+  '**/*.o',                 # C object file
+  '**/*.log',               # Ruby extension build log
+  '**/Makefile',            # C Makefile
+  '**/conftest.dSYM',       # OS X build directory
+  "**/*.#{CONFIG['DLEXT']}" # C shared object
+)
+
+desc 'Build the postgresql-plruby source code'
+task :build => [:clean] do
+  ruby "extconf.rb"
+  sh "make"
+end
+
+namespace :gem do
+  desc 'Create the gem'
+  task :create => [:clean] do
+    spec = eval(IO.read('postgresql-plruby.gemspec'))
+    Gem::Builder.new(spec).build
+  end
+
+  desc 'Install the gem'
+  task :install => [:create] do
+    file = Dir["*.gem"].first
+    sh "gem install #{file}" 
+  end
+end
+
+# TODO: Reorganize tests to make them work.
+Rake::TestTask.new do |t|
+  task :test => [:build]
+  t.libs << 'ext'
+  t.test_files = FileList['test/**/*.rb']
+  t.warning = true
+  t.verbose = true
+end
+
+task :default => :test

data/docs/plruby.rb

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