In Files

PLRuby::PL

general module

Public Class Methods

args_type() click to toggle source

Return the type of the arguments given to the function

# File plruby.rb, line 635
def  args_type
end
column_name(table) click to toggle source

Return the name of the columns for the table

# File plruby.rb, line 640
def  column_name(table)
end
column_type(table) click to toggle source

return the type of the columns for the table

# File plruby.rb, line 645
def  column_type(table)
end
context() click to toggle source

Return the context (or nil) associated with a SETOF function (ExprMultiResult)

# File plruby.rb, line 651
def  context
end
context=() click to toggle source

Set the context for a SETOF function (ExprMultiResult)

# File plruby.rb, line 656
def  context=
end
exec(string [, count [, type]]) click to toggle source

Call parser/planner/optimizer/executor for query. The optional count 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

# File plruby.rb, line 789
def  exec(string [, count [, type]])
end
prepare(string[, types]) click to toggle source

Deprecated : See PL::Plan::new and PL::Plan#save

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 PL::Plan object to be used in subsequent calls to PL::Plan#exec.

If the hash given has the keys count, output these values will be given to the subsequent calls to each

# File plruby.rb, line 810
def  prepare(string[, types])
end
quote(string) click to toggle source

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

# File plruby.rb, line 665
def  quote(string)
end
result_description() click to toggle source

Return the table description given to a function returning a SETOF

# File plruby.rb, line 686
def  result_description
end
result_name() click to toggle source

Return the name of the columns for a function returning a SETOF

# File plruby.rb, line 670
def  result_name
end
result_size() click to toggle source

Return the number of columns for a function returning a SETOF

# File plruby.rb, line 681
def  result_size
end
result_type() click to toggle source

Return the type of the columns for a function returning a SETOF or the type of the return value

# File plruby.rb, line 676
def  result_type
end
spi_exec(string [, count [, type]]) click to toggle source

same than exec

# File plruby.rb, line 792
def  spi_exec(string [, count [, type]])
end
spi_prepare(string[, types]) click to toggle source

same than prepare

# File plruby.rb, line 813
def  spi_prepare(string[, types])
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.