drop ima_dbms_fis;
\p\g
register table ima_dbms_fis (
        server varchar(64) not null not default is
                'SERVER',
        id integer4 not null not default is
                'exp.adf.adg.fi_id',
        complement integer4 not null not default is
                'exp.adf.adg.fi_cmplmnt',
        type varchar(20) not null not default is
                'exp.adf.adg.fi_type',
        flags integer4 not null not default is
                'exp.adf.adg.fi_flags',
        opid integer4 not null not default is
                'exp.adf.adg.fi_opid',
        args integer4 not null not default is
                'exp.adf.adg.fi_numargs',
        dtresult integer4 not null not default is
                'exp.adf.adg.fi_dtresult',
        dtarg1 integer4 not null not default is
                'exp.adf.adg.fi_dtarg1',
        dtarg2 integer4 not null not default is
                'exp.adf.adg.fi_dtarg2',
        dtarg3 integer4 not null not default is
                'exp.adf.adg.fi_dtarg3',
        dtarg4 integer4 not null not default is
                'exp.adf.adg.fi_dtarg4'
)
as import from 'tables'
with dbms = IMA,
structure = sortkeyed,
key = (server);
\p\g
grant all on ima_dbms_fis to ingres;
\p\g
grant select on ima_dbms_fis to public;
\p\g

Adding this table to ima_dbms_types and ima_dbms_operators adds the ability to retrieve the list of functions and their signatures.  The query makes use of an internal function iitypename which translates the numeric type code into a name.

select
    a.name,
    case when a.type='COMPARISON' then
        trim(iitypename(b.dtresult)) + ' = ( ' +
        trim(iitypename(b.dtarg1)) + ' ' +
        a.name + ' ' +
        trim(iitypename(b.dtarg2)) + ' )'
        when a.type='OPERATOR' then
        trim(iitypename(b.dtresult)) + ' = ( ' +
        trim(iitypename(b.dtarg1)) + ' ' +
        a.name + ' ' +
        trim(iitypename(b.dtarg2)) + ' )'
    else
        trim(iitypename(b.dtresult)) + ' = ' +
        a.name + '( ' +
            case when b.dtarg1 != '' then trim(iitypename(b.dtarg1)) else '' end +
            case when b.dtarg2 != '' then ', ' + trim(iitypename(b.dtarg2)) else '' end +
            case when b.dtarg3 != '' then ', ' + trim(iitypename(b.dtarg3)) else '' end +
            case when b.dtarg4 != '' then ', ' + trim(iitypename(b.dtarg4)) else '' end
        + ' )'
    end as signature
from
    ima_dbms_operators a,
    ima_dbms_fis b
where
    a.opid = b.opid
group by a.name, 2
order by a.name

Some sample output from this query:

|name                          |signature                       |
|soundex                       |char = soundex( text )          |
|soundex                       |char = soundex( varchar )       |
|sqrt                          |float = sqrt( float )           |
|squeeze                       |nvarchar = squeeze( nchar )     |
|squeeze                       |nvarchar = squeeze( nvarchar )  |
|squeeze                       |text = squeeze( c )             |

So in answer to my own question; yes, it is useful.  I’ll be trying this on an IngresGeospatial build when I get my hands on one.

Related posts

• Debugging the Hibernate project with Eclipse
• Hibernate 3.5.0-Final released
• Google Summer of Code (GSoC) 2008
• IMA Guru (Pronounced, I’m A Guru) – I definitely am not
• Data Access Message Protocol – Wireshark dissector

I’m currently using 9.3.0 (int.w32/135) and decided to try out these features.
The CREATE PROCEDURE syntax for return a row has been extended to include column names, my clumsy attempt at a partial description of the syntax follows:

<database procedure> ::= CREATE PROCEDURE <procedure name> <procedure parameter list>
RESULT ROW <result row description>
<procedure name> ::= <identifier>

<procedure parameter list> ::= <None> |
<left paren> <SQL parameter declaration list> <right paren>

<result row description> ::= <result row column list> |
<result set identifier> <table procedure column list>

<result set identifier> ::= <identifier>

<result row column list> ::= <left paren> <row column list element>
[ { <comma> <row column list element> }... ] <right paren>

<row column list element> ::= <data type> [ <column constraint> ][ <default> ]

<table procedure column list> ::= <left paren> <table procedure column list element>
[ { <comma> <table procedure column list element> }... ] <right paren>

<table procedure column list element> ::= <column name> <data type> [ <column constraint> ][ <default> ]

The procedure can now be exceuted directly from an EXECUTE PROCEDURE statement (requiring esqlc) or as the table procedure in the FROM clause of a SELECT statement.  The latter releasing row producing procedures from the shackles of embedded SQL.

Time for a few simple contrived examples to demonstrate the syntax and use.

A simple table with some data.
create table t1 (c1 integer not null, c2 char(1) not null);

insert into t1 (c1, c2) values (1, 'A');
insert into t1 (c1, c2) values (2, 'B');
insert into t1 (c1, c2) values (2, 'B');
insert into t1 (c1, c2) values (3, 'C');
insert into t1 (c1, c2) values (3, 'C');
insert into t1 (c1, c2) values (3, 'C');
insert into t1 (c1, c2) values (4, 'D');
insert into t1 (c1, c2) values (4, 'D');
insert into t1 (c1, c2) values (4, 'D');
insert into t1 (c1, c2) values (4, 'D');

A monadic procdure that returns a row from the table t1 restricted by value.

create procedure  p1 (a1 integer not null)
    result row resrow (r1 integer, r2 char(1))
as
declare
    ival integer not null;
    cval char(1) not null;
begin
    for select c1, c2 into :ival, :cval
        from t1
        where c1 = :a1
        do
            return row ( :ival, :cval );
    endfor;
end

A dyadic procedure that returns a row from table t1 restricted by values.

create procedure  p2 (a1 integer not null, a2 char(1) not null)
    result row resrow (r1 integer, r2 char(1))
as
declare
    ival integer not null;
    cval char(1) not null;
begin
    for select c1, c2 into :ival, :cval
        from t1
        where c1 = :a1 and c2 = :a2
        do
            return row ( :ival, :cval );
    endfor;
end

The original syntax to execute the procedure must be executed from esqlc.

# include <stdio.h>
void
main()
{
exec sql begin declare section;
    int     aval;
    int     ival;
    char    array[2];
    char    *cval = array;
    exec sql end declare section;
    aval = 2;
    exec sql connect test;
    exec sql execute procedure p1(a1 = :aval) result row (:ival, :cval);
    exec sql begin;
        printf("r1 = %d, r2 = %s\n", ival, cval);
    exec sql end;
    exec sql disconnect;
}

With the feature to execute the procedure in the FROM clause of a SELECT statement you can execute the procedure using
SELECT r1, r2 FROM p1(a1=2);

Parameters can be named, positional or a mixture.  Positional parameters must always appear first in the parameter list in a mixture of named and positional parameters.

An example of positional parameters
SELECT r1, r2 FROM p1(2);
SELECT r1, r2 FROM p2(1, 'A');

An example of named parameters
SELECT r1, r2 FROM p1(a1=2);
SELECT r1, r2 from p2(a2='A', a1=1);

An example of mixed parameters
SELECT r1, r2 FROM p2(1, a2='A');

The SELECT query statement that executes the procedure can be used in a VIEW definition and used as usual.

CREATE VIEW v1 AS SELECT r1, r2 FROM p1(2);

Some simple example queries.

-- Aggregate query
SELECT COUNT(p1.r1) AS count, SUM(p1.r1) AS sum FROM p1(4);
+-------------+----------------------+
|count        |sum                   |
+-------------+----------------------+
|            4|                    16|
+-------------+----------------------+
(1 row)
continue
Executing . . .
-- Query using the view defined from table procedure
SELECT t1.*, v1.* FROM t1, v1 WHERE v1.r2='B';
+-------------+----------+-------------+------+
|c1           |c2        |r1           |r2    |
+-------------+----------+-------------+------+
|            1|A         |            2|B     |
|            1|A         |            2|B     |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            3|C         |            2|B     |
|            3|C         |            2|B     |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            3|C         |            2|B     |
|            3|C         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
|            3|C         |            2|B     |
|            3|C         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
|            4|D         |            2|B     |
+-------------+----------+-------------+------+
(20 rows)
continue
Executing . . .
-- Query using both table and view
SELECT t1.*, v1.* FROM (t1 LEFT JOIN v1 ON t1.c1 = v1.r1 AND v1.r2='B');
+-------------+----------+-------------+------+
|c1           |c2        |r1           |r2    |
+-------------+----------+-------------+------+
|            1|A         |             |      |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            3|C         |             |      |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            3|C         |             |      |
|            4|D         |             |      |
|            3|C         |             |      |
|            4|D         |             |      |
|            4|D         |             |      |
|            4|D         |             |      |
+-------------+----------+-------------+------+
(12 rows)
continue
Executing . . .
-- Query using both table and table procedure
SELECT t1.*, p1.* FROM t1, p1(t1.c1) p1 WHERE p1.r2='B';
+-------------+----------+-------------+------+
|c1           |c2        |r1           |r2    |
+-------------+----------+-------------+------+
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
|            2|B         |            2|B     |
+-------------+----------+-------------+------+
(4 rows)

Related posts

• Useful or useless? Follow on post …