Procedimientos Almacenados de PostgreSQL y pgAdmin con JAVA

Los procedimientos almacenados de MySQL , en postgreSQL se llaman funciones, pueden crearse

desde consola, pero es mucho mas fcil utilizar pgAdmin.
Para este tutorial, se emplearan dos tablas que consisten en una tabla llamada PERSONA y otra tabla,
llamada TORNEO, el cdigo para su creacin esta ms abajo, la tabla Torneo ademas hace uso de un
SEQUENCE para generar un ID autoincrementable.
Campo autoincrement en PostgreSQL con pgAdminIII
En Postgres a diferencia de MySQL, colocar un campo con un valor autonumerico incrementable es
un poco ms complicado pero no imposible, puede realizarse a travs de comandos SQL, pero
para facilitar el trabajo es preferible utilizar una interfaz grfica como pgAdminIII.

- Conctate a Postgres y abre el pgAdminIII, selecciona la base de datos con la que trabajaras y busca
el campo Sequences, dale click derecho y elegi la opcin New Sequence.

- En la ventana que aparece New Sequence, debes rellenar el campo Name: nombre para la
secuencia, Owner: el propietario que hara uso de la secuencia, en mi caso se llama postgres,
Increment: el incremento, si lo dejas vacio, incrementara de 1 en 1, pero es mejor especificarlo, Start:
en que valor iniciara el incremento, tenemos otros valores para completar, pero por el momento lo que
tenemos es suficiente. Para terminar dale OK

- Para agregar esta secuencia en un campo de cualquier tabla, debemos darle un nombre a la columna,
en este caso sera tambien id, el tipo de dato Data Type sera Integer y en campo Default Value,
debemos agregar la secuencia que creamos en el paso anterior, de la siguiente
manera: NEXTVAL(secuencia_id), es decir:

Y dale OK para crear la columna

Ya tenemos nuestra campo creado con un valor autoincrementable de 1 en 1, cada vez que se agregue
un registro a nuestra tabla, la secuencia aade 1 a nuestro campo id.

CREATE TABLE persona

(
"CI" character(7) NOT NULL,
"Nombre" character(32) NOT NULL,
edad integer NOT NULL DEFAULT 18,
CONSTRAINT "CI" PRIMARY KEY ("CI")
)
CREATE SEQUENCE id_secuencia
INCREMENT 1
MINVALUE 1
MAXVALUE 9223372036854775807
START 18
CACHE 1;
ALTER TABLE id_secuencia OWNER TO postgres;
CREATE TABLE torneo
(
"ID" integer NOT NULL DEFAULT nextval('id_secuencia'::regclass),
ci_participante character(7) NOT NULL,
categoria character(16) NOT NULL,
CONSTRAINT "ID" PRIMARY KEY ("ID")
)

El ejemplo que crearemos es muy simple, teniendo algunos registros en la tabla PERSONA, crearemos
una funcin que nos permita registrar participantes en la tabla TORNEO, con la restriccin de que si la
edad es mayor o igual de 18 aos, se registren en la categora Mayores, caso contrario si la edad es
menor de 18 aos, corresponden a la categora Menores. Un ejemplo muy simple, pero que nos sirve
para ver en su mayora las instruccin ms utilizadas en las funciones, parmetros, variables, consultas,
instrucciones condicionales, etc.
la funcin completa la tienes en el siguiente cdigo:

declare
-- se declaran las variables a utilizar
ci character(7); -- ID de tabla persona = CEDULA DE IDENTIDAD
edad integer; -- la edad del participante
--la funcion va entre BEGIN y END
begin
ci = $1 ; -- ci toma valor del parametro de entrada
-- el valor de edad, sera calculado mediante una consulta a la tabla persona
edad = ( select p."edad" from "persona" as p where p."CI" = ci );
-- de acuerdo al valor de EDAD registramos al participante en la categoria
-- >=18 Mayores <18 Menores sino, NO SE REGISTRA NADA
if( edad >= 18 ) then
insert into torneo( ci_participante, categoria ) values ( ci, 'Mayores' );
return 'Participante registrado en la categoria MAYORES';
elsif ( edad <18 ) then
insert into torneo( ci_participante, categoria ) values ( ci, 'Menores' );
return 'Participante registrado en la categoria MENORES';
else
return 'Error: No se pudo completar el registro';
end if;
end;

Vimos como ejecutar la funcin desde el propio postgreSQL/pgAdminIII, ahora veremos como
ejecutarlo desde java, el que conozca sobre procedimientos almacenados en MySQL sabr que para
ejecutar un PROCEDURE, se hace uso de CallableStatement, eso es totalmente vlido, sin embargo,
como nuestra funcin solo retorna un resultado, nosotros utilizaremos otra forma :), utilizaremos la
instruccin executeQuery();
Englobaremos todo en una sola clase la cual se llama, pgFunctions, el cdigo es:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @web http://www.jc-mouse.net
* @author Mouse
*/
public class pgFunctions {
/* DATOS PARA LA CONEXION */
/** Nombre de la base de datos */
private String db = "dbTemp";
/** Usuario postgreSQL */
private String user = "postgres";
/** Contrasea postgreSQL */
private String password = "";
/** Cadena de conexin */
private String url = "jdbc:postgresql://localhost:5432/"+db;
/** Conexion a base de datos */
private Connection conn = null;
/** Para obtener los resultados de las consultas SQL de la base de datos */
private ResultSet resultSet = null;

/** Para enviar comandos SQL a la base de datos */

private Statement statement = null;
/** Constructor de la clase
* Realiza una conexin a la base de datos de PostgreSQL
* @exception SQLException Los datos son incorrectos
* @exception ClassNotFoundException No existe libreria JDBC:Postgresql
*/
public pgFunctions(){
this.url = "jdbc:postgresql://localhost:5432/"+db;
try{
//obtenemos el driver de para mysql
Class.forName("org.postgresql.Driver");
//obtenemos la conexin
conn = DriverManager.getConnection(this.url, this.user , this.password );
}catch(SQLException e){
System.err.println( e.getMessage() );
}catch(ClassNotFoundException e){
System.err.println( e.getMessage() );
}
}
/**
* Ejecuta la instruccion SQL para llamar a la funcin en postgreSQL
* @param Cedula_Identidad String que es el identificador de la persona
* @return String el resultado de la funcin
*/
public String CallFunction( String Cedula_Identidad )
{
String res="";
try {
statement = conn.createStatement();
resultSet = statement.executeQuery("SELECT registrar('"+Cedula_Identidad+"'); ");
while (resultSet.next())
{
res=resultSet.getString(1);
}
}
catch (SQLException ex) {
System.err.println( ex.getMessage() );
}
return res;
}
}

Explicacin: En el constructor de clase, se realiza la conexin a PostreSQL y se almacena en la

variable conn, el mtodo CallFunction nos sirve para ejecutar la funcin y devolver el resultado
en un String.
Por dems esta decir que para ejecutarlo en tu pc, debes cambiar los datos de conexin, base de datos,
usuario y contrasea, por los tuyos.
Ejecutamos esta clase de la siguiente manera:
pgFunctions pgf = new pgFunctions();

System.out.println( pgf.CallFunction("1234567") );

Obteniendo como resultado:

Procedimientos almacenados en PostgreSql

Edgar Ramrez | octubre 3, 2015 | Bases de datos, PostgreSQL | No hay comentarios
En PostgreSql a diferencia de otros motores de bases de datos, no existe una distincin explicita entre
una funcin y un procedimiento almacenado. En PostgreSql solo existen funciones, claro que estas
pueden ser usadas a modo de una funcin o de un procedimiento almacenado. Adems de esta
diferencia con otros motores de bases de datos, es importante mencionar que PostgreSql nos ofrece ms
de un lenguaje para crear nuestros procedimientos almacenados, pudiendo elegir entre los siguientes
lenguajes:
PL/PgSQL
C.
C++.
Java PL/Java web.
PL/Perl.
plPHP.
PL/Python.
PL/Ruby.
PL/sh.
PL/Tcl.
PL/Scheme.
En lo personal siempre me he inclinado por Pl/PgSQL pues es un lenguaje procedural basado en SQL y
que sigue el estndar ANSI SQL. Si deseas conocer ms de Pl/PgSQL aqu puedes encontrar la
documentacin oficial.
En este artculo veremos cmo se crean funciones en PostgreSql que nos devuelven un recordset y para
ello usaremos la misma lgica del procedimiento almacenado creado en Mysql para el artculo
Procedimientos almacenados de Mysql desde Excel Con VBA y ADO. Y de igual forma al
procedimiento en mysql, crearemos una funcin en PostgreSql que nos devuelva un recordset
conteniendo una lista de pases, esto claro, dependiendo del valor pasado a travs de un parmetro de
entrada.

Para crear la funcin, ejecutaremos pgAdmin III

Y una vez autenticados en nuestro servidor y seleccionada la base de datos en que trabajaremos
ejecutaremos el editor de consultas SQL que se encuentra en la barra de herramientas:

Y se nos mostrar el editor de consultas, en el que podremos ejecutar tanto cdigo PLSQL como SQL.

Una vez abierto nuestro editor el primer paso ser crear la tabla lista_paises y para ello deberemos
ejecutar el siguiente bloque SQL, modificando antes el userpostgre por el usuario que usas en tu
servidor.
?
1
2
3
4
5
6
7
8
9
10

CREATE TABLE lista_paises

(
id integer DEFAULT 0,
opcion character varying(100) DEFAULT ''::character varying
)
WITH (
OIDS=FALSE
);
ALTER TABLE lista_paises
OWNER TO userpostgre;

Ya que tenemos la tabla comenzaremos a crear nuestra funcin. Para ello primero definimos el
encabezado, y aqu es importante mencionar que en este caso, donde vamos a devolver un recordset,
deberemos declarar tantos parmetros de salida como columnas tenga nuestra consulta:

?
CREATE OR REPL
1
( IN PV_OP
2
OUT colu
3
OUT colu
4
)
RETURNS
5
Dado que la funcin devolver un recordset conteniendo las columnas id y opcin, hemos agregado
ambos parmetros de salida a la funcin y hemos agregado el parmetro de entrada Pv_Opcion que
usaremos a manera de men de seleccin para decirle a la funcin que bloque deber ejecutar. Al final
del encabezado establecemos el tipo de dato que devolver la funcin que en este caso ser un
recordset o setof record.
Declarado el encabezado vamos a continuar con el cuerpo de la funcin que contendr las operaciones
a realizar:
?
1
$BODY$
begin
2
IF PV_OPCION = 'DAMETODOS' THEN
3
return query select id, opcion from lista_paises;
4
END IF;
5
IF PV_OPCION = 'DAMECINCO' THEN
6
return query select id, opcion from lista_paises limit 5;
7
END
IF;
8
return;
9
10 end;
11 $BODY$
12 LANGUAGE 'plpgsql';
Como podemos ver, el cdigo es muy parecido al usado en Mysql, con las variantes de que aqu
debemos establecer con return query el recordset a devolver, adems de tener que indicar el lenguaje a
usar y el inicio y fin del cuerpo de la funcin.
Para ejecutar el procedimiento almacenado ejecutaremos la sentencia que nos devolver el listado:
?
1

Select * From SP_DamePaises('DAMETODOS');

Una vez que lo hayamos ejecutado obtendremos el siguiente resultado:

Y para terminar aqu est el bloque completo de la funcin:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

CREATE OR REPLACE FUNCTION SP_DamePaises

( IN PV_OPCION VARCHAR(10) default 'DAMETODOS',
OUT columna1 int,
OUT columna2 varchar(100)
) RETURNS setof record AS
$BODY$
begin
IF PV_OPCION = 'DAMETODOS' THEN
return query select id, opcion from lista_paises;
END IF;
IF PV_OPCION = 'DAMECINCO' THEN
return query select id, opcion from lista_paises limit 5;
END IF;
return;
end;

16
17

$BODY$
LANGUAGE 'plpgsql';

No vamos a explicar el potencial que tienen los procedimientos

almacenados , solamente mencionaremos que desde JDBC
podemos crear y llamar a ellos , en el siguiente ejemplo vamos
a trabajar con la siguiente base de dato

que ocupa el lenguaje plpgsql;

Desarrollo:
1.- primero tenemos que cargamos el jar de prostgres en nuestro
proyecto de netbeans .
2.- cargar nuestro procedimiento almacenado en la base de dato ,
para lo cual abrimos nuestra base de datos y lo ejecutamos.
---------- Procedimiento almacenado -----------------------CREATE or replace FUNCTION estafunc()
RETURNS INTEGER AS '
DECLARE

cantidad INTEGER := 30;

i integer := 1;
BEGIN
while (i <= 30) loop
RAISE NOTICE ''Cantidad contiene aqui %'',i;
i := i + 1;
end loop;
cantidad := 50;
RETURN cantidad;
END;' LANGUAGE 'plpgsql';
------------------------------------------------------------3.- lo llamamos desde nuestro codigo
try{
Class.forName("org.postgresql.Driver");
Connection con =
DriverManager.getConnection(
"jdbc:postgresql://localhost/eliminar", "postgres", "1234");
CallableStatement cs = con.prepareCall("{call estafunc()}");
ResultSet rs = cs.executeQuery();
if(rs.next()){
System.out.println("valor"+rs.getInt(1));
}
}catch(Exception e){
System.out.println("fallo conexion ");
e.printStackTrace();
}
//////////////////////////////////////////////////
lo importante del codigo es
CallableStatement: que es para ejecutar procedimientos
almacenados en la BD.

En postgreSQL no existe el trmino STORED PROCEDURE, en su lugar existen STORED

FUNCTION. Pues son tan potentes y prcticos como los stored procedure.
Alguin preguntaba De buena f Me pueden decir porque no existe procedimientos almacenados
en PostgreSQL?. Pues en algn momento la desesperacin quiz nos invada y es cierto: PostreSQL
tiene un modo diferente de trabajar. Al inicio quiz sea duro, pero como en todo con la prctica se
hace simple.
Una Funcin (FUNCTION) en PostgreSQL se puede escribir en multiples lenguajes de programacin.
En una instalacin por defecto de PostgreSQL podremos tener disponibles los siguientes lenguajes:
PL/pgSQL, PL/Perl, PL/Tcl y PL/Python. Tambien existen muchos otros lenguajes disponibles como
mdulos adicionales, entre ellos, PL/Java, PL/PHP, PL/R, PL/Ruby, PL/Sheme y PL/sh, pero estos
tienen que descargarse e instalarse por separado.
PL/pgSQL es un lenguaje estructurado en bloques. Siempre habr un bloque principal en nuestra
funcin y dentro de este podremos tener subbloques. Un bloque se define de la siguiente manera (lo
que haye entre corchetes [] es opcional).
1

CREATE [ OR REPLACE ] FUNCTION

2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

nombre_funcion([ [ argmodo ]
[ argnombre ] argtipo [, ...] ])
RETURNS tipo AS $$
[ DECLARE ]
[ declaraciones de variables ]
BEGIN
aqu va el cuerpo de la funcin:
el codigo

END;
$$ LANGUAGE plpgsql
| IMMUTABLE | STABLE | VOLATILE
| CALLED ON NULL INPUT | RETURNS
NULL ON NULL INPUT | STRICT
| [ EXTERNAL ] SECURITY INVOKER
| [ EXTERNAL ] SECURITY DEFINER
| COST execution_cost
| ROWS result_rows
| SET configuration_parameter
{ TO value | = value | FROM CURRENT }
;
No se desanimen si parece mucho cdigo seguid leyendo que describiremos las opciones y valores ms
importantes.
argmodo: El modo de un argumento puede ser IN, OUT, or INOUT. Por defecto se usa IN si no se
define.
argtipo: Los tipos que podemos utilizar son todos los disponibles en PostgreSQL y todos los definidos
por el usuario
declaraciones de variables: Las declaraciones de variables se pueden realizar de la siguiente manera ($n
= orden de declaracin del argumento.):
nombre_variable ALIAS FOR $n;
nombre_variable [ CONSTANT ] tipo [
1
NOT NULL ] [ { DEFAULT | := }
2
expresion ];
cdigo: la parte del codigo lo veremos unas lineas ms abajo. Pero adelanto que es lo que realmente
queremos hacer (el procedimiento en s).
IMMUTABLE | STABLE | VOLATILE:
IMMUTABLE: Indica que la funcin no puede alterar a la base de datos y que siempre devolver el
mismo resultado, dados los mismos valores como argumentos. Este tipo de funciones no pueden
realizar consultas en la base de datos.
STABLE: Indica que la funcin no puede alterar a la base de datos y que siempre devolver el mismo
resultado en una consulta individual de una tabla, dados los mismos valores como argumentos. El
resultado podria cambiar entre sentencias SQL.
VOLATILE: Indica que la funcin puede devolver diferentes valores, incluso dentro de una consulta

individual de una tabla (valor por defecto)

CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT:
CALLED ON NULL INPUT: Indica que la funcin se ejecutar aunque algunos de los argumentos
sean NULL. El usuario tiene la responsabilidad de comprobar si algn argumento es NULL cuando sea
necesario tener esto en cuenta.(valor por defecto)
RETURNS NULL ON NULL INPUT / STRICT: Indican que la funcin no se ejecutar y devolver el
valor NULL si alguno de los argumentos es NULL.
SECURITY INVOKER | SECURITY DEFINER:
SECURITY INVOKER: Indica que la funcin se ejecutar con los privilegios del usuario que la
ejecuta (valor por defecto)
SECURITY DEFINER: Indica que la funcin se ejecutar con los privilegios del usuario que la creo.
Ahora vamos a crear una Base de datos y unas tablas para poder crear nuestras funciones.
Los interesados en ver ms teoria en la pgina oficial de PostgreSQL hay buena documentacin.
Como estamos trabajando desde PgAdmin III, vamos al panel Object Browser/Servers/Nombre de tu
Conexion/ Databases/ Click derecho y New Database, Puedes poner el nombre que desees, yo le
pondre prueba.
Para habilitar el lenguaje PL/pgSQL en el panel Objects Browser buscamos la opcin
Servers/Nombre de tu conexin/Databases/Nombre de tu Base de Datos(prueba en este
post)/Languages. Click derecho en Languages y seleccionamos New Language y cuando nos
salgue la ventana para buscar los lenguajes disponibles elegimos PL/pgSQL y le damos click en OK.
Ahora creamos las tablas.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

-- creamos una secuencia que

empezar en 10. Nos sirve para
controlar en que nmero iniciar el
campo autonmerico.
-- tambin pudimos usar el tipo de
dato SERIAL(PostgreSQL) ==
AUTO_NUMERIC(Mysql) == IDENTITY(SQL
Server).
CREATE SEQUENCE usuarioSequence START
10;
-- Creamos las tablas pais y
usuarios
CREATE TABLE pais(
codpais SERIAL NOT NULL,
pais VARCHAR(50) NOT NULL,
PRIMARY KEY (codpais)
);
CREATE TABLE usuarios(
codusuario INT4 PRIMARY KEY DEFAULT
nextval ('usuarioSequence'),-- aqui

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

llamamos a la secuencia
codpais INT4 NOT NULL,
nombres VARCHAR(20) NOT NULL,
apellidos VARCHAR(50) NOT NULL,
email VARCHAR(50) NOT NULL,
clave VARCHAR(20) NOT NULL,
estado CHAR(1) NOT NULL,
FOREIGN KEY(codpais) REFERENCES pais
(codpais) ON DELETE CASCADE ON UPDATE
CASCADE
);
-- insertamos registros
INSERT INTO pais(pais) VALUES
('Per');
INSERT INTO pais(pais) VALUES
('Argentina');
INSERT INTO pais(pais) VALUES
('Brasil');
INSERT INTO pais(pais) VALUES
('Inglaterra');
INSERT INTO usuarios (codpais,
nombres, apellidos, email, clave,
estado ) VALUES (1,'mittaus',
'ragio', 'mittaus@gmail.com',
'admin', 'A' );
INSERT INTO usuarios (codpais,
nombres, apellidos, email, clave,
estado ) VALUES (2,'andrea',
'montes', 'andrea@gmail.com',
'unodos', 'A' );
INSERT INTO usuarios (codpais,
nombres, apellidos, email, clave,
estado ) VALUES (4,'sonia',
'marisol', 'sonia@gmail.com',
'123456', 'A' );
INSERT INTO usuarios (codpais,
nombres, apellidos, email, clave,
estado ) VALUES (3,'zeze', 'souza',
'zeze@gmail.com', 'loquesea', 'I' );
/* Ejemplo de funciones simples*/
-- Funcin sumar uno
CREATE OR REPLACE FUNCTION adduno(INT)
RETURNS INT AS
$$
BEGIN
RETURN $1 + 1;

END; $$ LANGUAGE plpgsql;

SELECT adduno(5);
-- Funcin ver usuarios por Nombre
CREATE OR REPLACE FUNCTION
usuarios_byname(nombre TEXT)
RETURNS SETOF INT AS
$$
BEGIN
RETURN QUERY SELECT codusuario
FROM usuarios WHERE nombres LIKE
nombre || '%';
END;
$$ LANGUAGE plpgsql STABLE;
SELECT usuarios_byname('m');
Ahora compliquemos un poquito. Vamos a crear las funciones clsicas de SELECT, INSERT, UPDATE
y DELETE. Fijense bien la parte como y el tipo de dato que retornan las funciones. Estas funciones lo
usaremos en otro post de C# con PostgreSQL as que pongan mucha antencin.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/* ************************* BEGIN
FUNCIONES EN PL/pgSQL
*****************************/
-- Funcin SELECT: El parmetro es
el nombre cursor que nos traer los
datos
-- Si usamos variables con nombres
combinados de Maysculas y
Minsculas debemos ponerlos entre
comillas dobles (" ").
-- Ejemplo: CREATE FUNCTION
"verAllUsuarios" ...
CREATE OR REPLACE FUNCTION
verusuarios(refcursor) RETURNS
refcursor AS
$BODY$
BEGIN
OPEN $1 FOR SELECT * FROM usuarios;
RETURN $1;
END;
$BODY$ LANGUAGE 'plpgsql' VOLATILE;
--Selecciona las 6 primeras filas
BEGIN
SELECT verusuarios('hola') AS Answer;
FETCH FORWARD 6 in "hola"; -- Si no
existe 6 nos devuelve solo las que

29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

encuentre
COMMIT;
--Selecciona las 3 primeras filas y
la fila anterior de la seleccin
(ose la fila 2)
select verusuarios('micursor');
FETCH FORWARD 3 in micursor;
FETCH BACKWARD 1 in miCursor;
-- SELECT: El primer parmetro es el
nombre cursor que nos traer los
datos, y el segundo el campo por el
que haremos la busqueda
CREATE OR REPLACE FUNCTION
usuariosbyname(refcursor,text)
RETURNS refcursor AS
$BODY$
BEGIN
OPEN $1 FOR SELECT * FROM usuarios
WHERE nombres LIKE $2 || '%';
RETURN $1;
END;
$BODY$ LANGUAGE 'plpgsql' VOLATILE;
BEGIN
SELECT
usuariosbyname('otrocursor','m');
FETCH ALL IN otrocursor;
COMMIT;
-- Funcin INSERT: Insertamos un
registro a la tabla
CREATE OR REPLACE FUNCTION
insertar_usuarios(INT, VARCHAR(20),
VARCHAR(50),
VARCHAR(50),VARCHAR(20), CHAR(1))
RETURNS VOID AS
$BODY$
BEGIN
INSERT INTO usuarios (codpais,
nombres, apellidos, email, clave,
estado )
VALUES ($1, $2, $3, $4, $5,$6);
END;
$BODY$ LANGUAGE 'plpgsql' VOLATILE;
BEGIN
SELECT insertar_usuarios(1,'martin',
'dino', 'martin@gmail.com',

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

'mariquin', 'A' )
COMMIT;
SELECT * FROM usuarios;
-- Funcin UPDATE: Actualizamos un
registro por el campo Cdigo,
devolvemos TRUE si se actualiza
CREATE OR REPLACE FUNCTION
update_usuarios(INT, INT,
VARCHAR(20), VARCHAR(50),
VARCHAR(50),VARCHAR(20), CHAR(1))
RETURNS BOOL AS
$BODY$
DECLARE
codigo ALIAS FOR $1;
registro usuarios%ROWTYPE;
BEGIN
SELECT * INTO registro FROM
usuarios WHERE codusuario = codigo;
IF FOUND THEN
UPDATE usuarios SET
codpais = $2, nombres = $3,
apellidos = $4, email = $5, clave =
$6, estado = $7 WHERE codusuario =
codigo;
RETURN TRUE;
END IF;
RETURN FALSE;
END;
$BODY$ LANGUAGE 'plpgsql' VOLATILE;
SELECT update_usuarios(14,3,'marin',
'kino', 'marin@gmail.com', 'marin',
'I' )
SELECT * FROM usuarios;
-- Funcin DELETE: Si se elimina un
registro devolvemos TRUE
CREATE OR REPLACE FUNCTION
del_usuariobycod(INT) RETURNS BOOL AS
$$
DECLARE codigo ALIAS FOR $1;
BEGIN
DELETE FROM usuarios WHERE
codusuario = codigo;
IF FOUND THEN
RETURN TRUE;
ELSE
RETURN FALSE;

END IF;
END; $$ LANGUAGE plpgsql;
SELECT * FROM del_usuariobycod(14);
SELECT * FROM usuarios;
-- Funcin SELECT usando RECORD
CREATE OR REPLACE FUNCTION
traer_usuarios() RETURNS SETOF record
AS
$$
DECLARE rec record;
BEGIN
FOR rec IN SELECT * FROM usuarios
LOOP
return next rec;
END LOOP;
RETURN;
END; $$ LANGUAGE plpgsql;
BEGIN
SELECT * FROM traer_usuarios() AS
(codusuario INT,codpais INT, nombres
VARCHAR(50), apellidos VARCHAR(50),
email VARCHAR(50), clave
VARCHAR(50), estado CHAR(1) );
COMMIT;
/* ************************* END
FUNCIONES EN PL/pgSQL
*****************************/
Las funciones que hemos escrito se pueden haber escrito de otros modos. Los que ya tienen algn
tiempo en esto me darn la razn. Pero pienso que para empezar esta bien. Y en los otros posts usar
otras sintxis por ejemplo como adelanto cambiemos la funcin del_usuariobycod. En lugar de los
simbolos $$ pudimos haber usado la comilla simple [ ], tambin asignar defrente el parmetro, fijense
tambin la seccin del IF
1
2
3
4
5
6
7
8
9
10
11
12

-- Funcin DELETE: Si se elimina un

registro devolvemos TRUE
CREATE OR REPLACE FUNCTION
del_usuariobycod(INT) RETURNS BOOL
AS
'
BEGIN
DELETE FROM usuarios WHERE
codusuario = $1; -- le asignamos
defrente el parmetro
IF FOUND THEN
RETURN TRUE;

13

END IF; -- ya no usamos ELSE

RETURN FALSE; -- por defecto
ser false
END; ' LANGUAGE plpgsql;

SELECT * FROM del_usuariobycod(14);

SELECT * FROM usuarios;
Bien pues!!! Espero haye sido de provecho lo que escrib y pues no olviden mucha prctica okok!, nos
vemos hasta la prxima