Mostrando entradas con la etiqueta procedures. Mostrar todas las entradas
Mostrando entradas con la etiqueta procedures. Mostrar todas las entradas

viernes, 21 de marzo de 2025

Funciones Javascript en BigQuery

 

BigQuery permite crear Stored Procedures y/o funciones usando como lenguaje base a Javascript. En este post veremos las UDF o las funciones definidas por el usuario.

Una función definida por el usuario (UDF) nos permite crear una función mediante una expresión SQL o código JavaScript.

Una UDF puede ser:

  1. Persistente o 
  2. Temporal (en el alcance de una única consulta).

Aquí podemos ver un ejemplo sacado de la página de documentación oficial de GCP:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
CREATE TEMP FUNCTION multiplyInputs(x FLOAT64, y FLOAT64)
RETURNS FLOAT64
LANGUAGE js
AS r"""
  return x*y;
""";

WITH numbers AS
  (SELECT 1 AS x, 5 as y
  UNION ALL
  SELECT 2 AS x, 10 as y
  UNION ALL
  SELECT 3 as x, 15 as y)
SELECT x, y, multiplyInputs(x, y) AS product
FROM numbers;

Se trata de una UDF temporal (usando TEMPORARY o TEMP)  que multiplica dos números tipo FLOAT64. Dentro del privote ``numbers`` habrá dos uniones con los datos a trabajar; invocaremos la función mediante una consulta SELECT y asignará el resultado como ``product``.

Tipos de datos permitidos

 Tipos de datos en BigQuery   Tipos de datos en Javascript  
 ARRAY  ARRAY
 BOOL  BOOLEAN
 BYTES  STRING base 64
 NUMERIC, BIGNUMERIC  Valor punto flotante
 STRING  STRING
 STRUCT  OBJECT
 TIMESTAMP  DATE
 DATE  DATE
 JSON  OBJECTS, ARRAY

Recordar que en Javascript no existen los tipos de manera explícita.

Ejemplo 1. Crearemos una función (persistente) BigQuery que use JS como lenguaje base para obtener la longitud de una cadena.

1
2
3
4
5
6
7
CREATE OR REPLACE FUNCTION `myproject.mydataset.longitud`(input STRING) RETURNS STRING LANGUAGE js AS '''
   if(input === '' || input ===null){
      return "La cadena tiene una longitud de 0 caracteres.";
   }else{
      return "La cadena tiene una longitud de: "+input.length+" caracteres.";
   }
'''

Para hacer uso de ella la invocaremos de esta forma:

1
2
DECLARE cadena STRING DEFAULT '';
SELECT `myproject.mydataset.longitud`(cadena) as resultado; 

El dato de entrada será la variable ``cadena`` cuyo valor será vacío. Lo que nos devolverá:

1
La cadena tiene una longitud de: 0 caracteres.

Está función obtiene la longitud de una cadena introducida por el usuario. No mucho por explicar.

Ejemplo 2. Crear una sencilla función para evaluar si una condición o valor booleano es "correcta" si es true, "incorrecta" si es false.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
CREATE OR REPLACE FUNCTION `myproject.mydataset.checkAssert`(condition BOOL) RETURNS STRING LANGUAGE js AS '''

  var result = "Evaluacion: "+condition+".";

  if(condition){
    result += " Es correcta.";
  }else{
    result += " Es incorrecta.";
  } 

  return result;

'''

Invocamos la función:

1
2
3
4
DECLARE condition BOOL;
SET condition= 34 > 0;

SELECT `myproject.mydataset.checkAssert`(condition) AS resultado ;

Hacer uso de UDF con Javascript como lenguaje base puede ayudarnos a resolver tareas que quizás de una manera más nativa sería algo más complicado.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://cloud.google.com/bigquery/docs/user-defined-functions
https://stackoverflow.com/questions/62271743/bringing-in-a-function-from-javascript-to-big-query-standardsql
https://hoffa.medium.com/new-in-bigquery-persistent-udfs-c9ea4100fd83
https://briangrinstead.com/blog/js-functions-bigquery/

jueves, 23 de enero de 2025

GCP: Crear un archivo CSV a partir de una consulta en BigQuery

En esta ocasión veremos como crear un archivo CSV a partir del resultado de una consulta en GCP BigQuery.

¿Qué haremos?

  1. Crearemos una tabla temporal. 
  2. Consultaremos una tabla de la cual queremos los datos.
  3. Con los datos obtenidos crearemos un archivo CSV.

¿Qué es una tabla temporal en BigQuery?

Es una tabla creada temporalmente. Nos servirá como pivote para obtener ciertos datos de una consulta.

¿Cómo exportamos datos en BigQuery?

Usaremos la siguiente sentencia para exportar datos:

EXPORT DATA

El código es el siguiente:

CREATE OR REPLACE PROCEDURE `myproject.mydataset.create_file_csv`(input_fecha STRING)
BEGIN
  -- Crear una tabla temporal con los datos de la consulta
  CREATE TEMP TABLE temp_table AS
  SELECT * FROM `myproject.mydataset.Informe`
  WHERE fecha = CAST(input_fecha AS DATE);

  -- Exportar la tabla temporal a un archivo CSV en GCS, ya que BigQuery no soporta TXT directamente
  EXPORT DATA OPTIONS(
    uri='gs://your_bucket/path/to/file*.csv',
    format='CSV',
    overwrite=true,
    header=true
  ) AS
  SELECT * FROM temp_table;

END;

Para invocar el SP:

CALL `myproject.mydataset.create_file_csv`('2025-01-23');

Tendremos que ir a nuestro Bucket para comprobar que el archivo se ha creado.

En próximas entregas continuaremos con este tema.

Enlaces:

https://cloud.google.com/bigquery/docs/exporting-data

lunes, 18 de noviembre de 2024

Stored procedures Oracle PL/SQL / GCP BigQuery

Haciendo un poco de memoria, recordaremos lo que es un Stored Procedure.

Un Stored Procedure (procedimiento almacenado) es:

  • Un subprograma que ejecuta una acción específica.
  • No devuelve valor alguno (pero mediante un mecanismo podemos recuperar valores).
  • Posee un nombre y puede o no tener parámetros y un bloque donde se efectuarán las acciones a realizar.
  • Se puede llamar desde otros Stored Procedures y/o consultas SQL.

Si usamos Oracle, está será será su sintaxis:

CREATE {OR REPLACE} PROCEDURE nombre_proc( param1 [IN | OUT | IN OUT] tipo,... )
IS
  -- Declaración de variables locales
  BEGIN
  -- Instrucciones de ejecución
  [EXCEPTION]
  -- Instrucciones de excepción
END;

En BigQuery, sería de esta forma:

CREATE PROCEDURE dataset_name.procedure_name(OUT param1 TYPE, ...)
BEGIN
-- statements here
  [EXCEPTION]
  -- statements here
END

La forma de invocar un Stored Procedure en Oracle:

CALL miprocedimiento();

En BigQuery:

CALL mydataset.miprocedimiento();

Lenguaje procedimental

Tanto GCP BigQuery como Oracle PL/SQL poseen sus propias peculiaridades. Empecemos con los bloques.

En PL/SQL:

DECLARE
BEGIN
   dbms_output.put_line('Hola, mundo');
END;
/

En BigQuery:

BEGIN
   SELECT FORMAT('Hola, mundo');
END;

También podemos hacer esto:

DECLARE saludo STRING DEFAULT 'Hola, mundo';
SELECT FORMAT(saludo);

Para declarar variables en PL/SQL:

DECLARE 
   entero integer := 10;
   numero NUMBER(3):= 123;
   nombre VARCHAR2(45);
   flotante real;
   tiempo_salida TIMESTAMP(3):= '23-JUL-2024 07:22:53.175';
   verdadero BOOLEAN:= FALSE;
   fecha DATE;
   ...
BEGIN
 -- SENTENCIAS
END;
/
     
   

En BigQuery:

DECLARE nombre STRING DEFAULT 'MARIA';
DECLARE fecha DATE;
DECLARE verdadero BOOL DEFAULT TRUE;
DECLARE numero INT64;
DECLARE otro_num NUMERIC DEFAULT 12.0;

SET numero = 9;
SET fecha = '2024-09-12';

...    
   

Es muy parecida la forma en que se declaran las variables.

Al ser lenguajes procedimentales tendrán:

  1. Sentencias Top-Down o de arriba hacia abajo. 
  2. Sentencias iterativas o repetitivas. 
  3. Sentencias selectivas o condicionales.

Sentencias Top-Down

Sentencias de arriba hacia abajo. No hay mucha ciencia e ello. Comencemos con PL/SQL:

DECLARE
-- Declaramos las variables
numero INTEGER;
verdadero BOOLEAN;
fecha DATE;
presente NUMBER;

BEGIN
-- Seteamos sus valores
numero := 33;
verdadero := FALSE;
fecha := TO_DATE('2024/07/09', 'yyyy/mm/dd');
presente := 2300.23;


--
END;
/

En BigQuery:

BEGIN
DECLARE numero INT64;
DECLARE verdadero BOOL;
DECLARE fecha DATE;
DECLARE presente NUMERIC;

-- Seteamos sus valores
SET numero = 33;
SET verdadero = FALSE;
SET fecha = FORMAT_DATE("%Y-%d-%m",'2024/07/09');
SET presente = 2300.23;


--
END;

Sentencias iterativas o repetitivas

Bucle FOR en PL/SQL

FOR contador IN 1..20
LOOP
   contador := contador + 1;
END LOOP;

Bucle WHILE en PL/SQL

WHILE contador <= 100
LOOP
   contador := contador + 1;
END LOOP;

Bucle FOR en BigQuery

DECLARE vector_a ARRAY<STRING>;
SET vector_a = ['_01', '_02', '_03'];

FOR loop_variable_name IN (SELECT * FROM UNNEST(vector_a))
DO
  -- Hacer algo aquí;
END FOR;

Bucle WHILE en BigQuery

declare cont int64 default 0;
set TAM = (select count(*) from `project.dataset.tabla1`);
set cont = 1;

while cont <= TAM do
   -- 
   SET cont = cont + 1;
end while;

Solo son algunas sentencias repetitivas. Ambos incluyen otras como: LOOP.

Sentencias selectivas o condicionales

IF en PL/SQL

DECLARE 
  numero INTEGER;
  titulo VARCHAR2(5):="ABCD";

BEGIN
  numero:=33;
IF numero = 33 THEN
   SELECT "Hola, "||numero FROM dual;
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

END;
/

IF en BigQuery

DECLARE numero INT64;
DECLARE titulo DEFAULT 'ABCD';
SET numero = 33;

IF numero = 33 THEN
   SELECT FORMAT('Hola, ', CAST(numero AS STRING));
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

Solo mostramos algunas sentencias. Si quieres ver sentencias condicionales en BigQuery, puedes echar un vistazo en este link:

https://codemonkeyjunior.blogspot.com/2024/11/gcp-funciones-condicionales-en-bigquery.html

Continuaremos con este tema en siguientes posts.

Enlaces:

https://elbauldelprogramador.com/plsql-procedimientos-y-funciones/
https://docs.oracle.com/cd/B28359_01/appdev.111/b28843/tdddg_procedures.htm

sábado, 19 de octubre de 2024

PL/SQL: creando Stored Procedures (1era parte)

PL/SQL es un lenguaje de programación procedimental diseñado para operar en entornos Oracle.

Con este lenguaje podemos hacer:

  • Automatizar tareas complejas dentro de la base de datos mediante procedimientos y funciones.
  • Implementar reglas de negocio complejas con triggers y validaciones. 
  • Gestionar transacciones y manejar errores de manera robusta. 
  • Manipular conjuntos de datos utilizando cursores. 
  • Integrar lógica de negocios en aplicaciones que interactúan con bases de datos Oracle.

En esta ocasión veremos cómo crear Stored Procedures o procedimientos almacenados. Los cuales son procedimiento que pueden o no devolver algún valor (contrario a las funciones que siempre devuelven algún valor). Estos podrán, una vez que sean creado, ser invocados en tus scripts.

La sintaxis para crear un Stored Procedure es la siguiente:

-- Sintaxis para crear un Stored Procedure 
CREATE [OR REPLACE] PROCEDURE procedure_name
    [ (parameter [,parameter]) ]

IS
    [declaration_section]

BEGIN
    executable_section

[EXCEPTION
    exception_section]

END [procedure_name];

Para su invocación debemos anteponer la palabra ``CALL`` seguido del nombre.

CALL miprocedimiento();
CALL miprocedimiento(arg1, arg2, argN);

En un anterior post vimos cómo crear bloques PL/SQL. Un Stored procedure contiene bloques que harán determinada tarea que nosotros definamos.

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hola desde PL/SQL');
END;

Ejemplo 1. Crear un Stored procedure para mandar un mensaje a pantalla.

hola.sql

CREATE OR REPLACE PROCEDURE hola 
IS 
  nombre VARCHAR2(6):='Thomas';
BEGIN 
  IF nombre IS NOT NULL THEN 
    dbms_output.put_line('Hola, '||nombre);
  END IF;
END;
/

Lo invocamos de está forma:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

-- Invocar Stored procedure
CALL hola;

Ejemplo 2. Crear un Stored Procedure para ver la versión de Oracle instalada.

mi_proc.sql

CREATE OR REPLACE PROCEDURE mi_proc
    IS
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';    
BEGIN
    dbms_output.put_line('Version instalada: ');
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line(version_inst);
END;
/

Lo invocamos:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

CALL mi_proc;

Enlaces:

https://codemonkeyjunior.blogspot.com/2023/07/plsql-bloques.html
https://www.plsqltutorial.com/

lunes, 27 de mayo de 2024

GCP: Crear Stored Procedures y Funciones en BigQuery

En esta ocasión veremos cómo crear Stored Procedures y funciones en BigQuery. Un procedimiento almacenado es un conjunto de instrucciones que se pueden llamar desde otras consultas o desde otros procedimientos almacenados.

  • Puede tomar argumentos de entrada y mostrar valores como resultados.
  • Puede acceder a los datos o modificarlos en varios conjuntos de datos de varios usuarios.
  • También puede contener una consulta de varias instrucciones.

Ejemplo. Crear un Stored Procedure que mande un simple mensaje de "Hola, mundo". En este caso también le pasamos un párametro de nombre (name).

CREATE OR REPLACE PROCEDURE `myproject.mydataset.decirHola`(name STRING)
BEGIN
  SELECT FORMAT("Hola, %s",name);
END;

Para invocarlo:

CALL`myproject.mydataset.decirHola`('Thomas Muller');

Ejemplo. Teniendo esta sentencia SQL que nos devuelve la definición de un Stored Procedure en BigQuery:

-- Obtener la definición de un Stored Procedure en BigQuery
SELECT 
  routine_catalog, 
  routine_schema, 
  routine_name, 
  routine_type, 
  routine_definition
FROM your_dataset.INFORMATION_SCHEMA.ROUTINES    
WHERE routine_name = 'nombre_stored_procedure';

Crear un Stored Procedure que nos devuelva cada uno de los campos.

CREATE OR REPLACE PROCEDURE `myproject.mydataset.getDetallesStored`(nameStored STRING)
BEGIN
  -- Ejecutar la consulta y retornar los resultados
  DECLARE routine_catalog STRING;
  DECLARE routine_schema STRING;
  DECLARE routine_name STRING;
  DECLARE routine_type STRING;
  DECLARE routine_definition STRING;

  SELECT
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition
  INTO 
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition
  FROM
    myproject.mydataset.INFORMATION_SCHEMA.ROUTINES
  WHERE
    routine_name = nameStored;

  -- Seleccionar los resultados para retornarlos
  SELECT
    routine_catalog,
    routine_schema,
    routine_name,
    routine_type,
    routine_definition;
END;

Hacemos el llamado:

CALL `myproject.mydataset.getDetallesStored`('decirHola');

El resultado de este llamado nos arrojará los detalles del Stored Procedure indicado.


¿Y las funciones?

Una función es similar a un Stored Procedure (Procedimiento Almacenado), pero devolverá un valor. Además cambia la manera en la que lo invocamos. Mientras que un Stored Procedure es invocado con CALL, a una función la invocaremos con SELECT.

Ejemplo. Crear una función para dividir dos números.

CREATE OR REPLACE FUNCTION `myproject.mydataset.getDiv`(
  x FLOAT64, y FLOAT64) RETURNS FLOAT64
AS (
  SELECT DIV(X, Y) AS RESULT;
);

Para usar la función:

SELECT `myproject.mydataset.getDiv`(3.4,5.2);

Para quienes han usado PL/pgSQL (PostgreSQL) o PL/SQL (Oracle) la sintaxis es muy similar, por no decir idéntica. Salvo por algunas excepciones.

En próximas entregas continuaremos con este tema.

Enlaces:

https://cloud.google.com/bigquery/docs/procedures?hl=es-419

sábado, 29 de julio de 2023

PL/SQL - Bloques

PL/SQL es un lenguaje de programación procedimental para manipular datos de una BD Oracle. Con este lenguaje podemos crear scripts para poder manipular información de tablas, ejecutar otros scripts, crear procedimientos que se activen ante un evento(triggers), que devuelvan valores (funciones) o que simplementen realicen una operación al invocar un procedimiento (stored procedures).

Si queremos saber la versión instalada podemos ejecutar esta sentencia:

-- Con una consulta 
SELECT * FROM v$version;

En PL/SQL podríamos ejecutar el siguiente bloque de código:


-- Con un bloque PL/SQL
SET SERVEROUTPUT ON;
DECLARE
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
END;
/

Si queremos podríamos crear excepciones:

-- Con un bloque PL/SQL con manejo de excepción
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200);
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

Como se puede ver, creamos una excepción (NULL_STRING) para verificar que la cadena de consulta es nula (vacía). Usamos PRAGMA la cual es una palabra reservada de Oracle para añadir directivas al compilador. Ésta le dice al compilador que se comporte de cierta manera, en este caso es una excepción (un error en el flujo del programa).

El pragma EXCEPTION_INIT asocia un nombre de excepción con un número de error de Oracle. Puede interceptar cualquier error ORA- y escribir un controlador específico para él en lugar de usar el controlador OTROS (OTHERS).

La sección de EXCEPTION WHEN se ejecuta cuando ocurre alguna excepción. Dependiendo de la programación se podrá (o no) cachar correctamente la excepción. Recordar que una excepción es una anomalía en el flujo de un programa, no necesariamente es un error grave. En caso de un error, el programa se terminará abruptamente.


Al final tendríamos algo como esto:

-- Con un bloque PL/SQL y verificando consulta
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    IF LENGTH(consulta) > 0 THEN
       -- Ejecutamos consulta
       EXECUTE IMMEDIATE consulta INTO version_inst;
       dbms_output.put_line('Version instalada: '||version_inst);
    END IF;
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

En próximos post veremos más ejemplos.

Enlaces:

https://livesql.oracle.com/
https://www.techonthenet.com/oracle
http://www.rebellionrider.com
https://docs.oracle.com
https://www.codifica.me/pragma/
https://elbauldelprogramador.com/plsql-excepciones/

martes, 13 de diciembre de 2011

Ejemplo de uso de MySQL: una pequeña bitácora




Tener una bitácora nos ayuda a tener un mejor control de nuestra información:

  • Ver quien hace cambios por “error”.
  • Ver la fecha de la operación,
  • Tipo de operación (inserción, actualización y/o borrado).


Bueno he aquí los pasos para crear una pequeña bitácora


1. Crear la base de datos

$ create database prueba1;
$ show databases;
$ use prueba1;
2. Crear una tabla llamadas personas

create table personas (id_persona int auto_increment primary key, 
nombre varchar (50), 
apellido_p varchar (50), 
apellido_m varchar(50), 
edad int, 
peso double, 
talla double);
3. Crear un procedimiento almacenado para insertar registros


DELIMITER $$
DROP PROCEDURE IF EXISTS `prueba1`.`Insertar` $$
CREATE PROCEDURE `prueba1`.`Insertar`(in nombre varchar (50), apellido_p varchar (50), apellido_m varchar(50), edad int, peso double, talla double)

BEGIN
INSERT INTO personas (nombre,apellido_p, apellido_m , edad , peso , talla) VALUES (nombre,apellido_p, apellido_m , edad , peso , talla );

END $$

DELIMITER ;

4. Crear un procedimiento almacenado para actualizar registros
DELIMITER $$
DROP PROCEDURE IF EXISTS `prueba1`.`Actualizar` $$
CREATE PROCEDURE `prueba1`.`Actualizar` (in id_personax int,edadx int,pesox double)
BEGIN
update personas set edad=edadx,peso=pesox where id_persona=id_personax;
END $$

DELIMITER ;



5. Crear un procedimiento almacenado para eliminar registros


DELIMITER $$

DROP PROCEDURE IF EXISTS `prueba1`.`Borrar` $$
CREATE PROCEDURE `prueba1`.`Borrar` (in id int)
BEGIN
delete from personas where id_persona=id;
END $$

DELIMITER ; 


6. Invocar los procedimientos almacenados

Call Insertar (Horacio,Gomez,Carmona,25,65,1.68);
Call Insertar (Hugo,Torres,Mendez,32,67,1.70);
Call Actualizar (1, 26, 66);
Call Borrar (2);

Ver registros

select * from personas;

7. Crear un procedimiento almacenado que muestre todos los registros

DELIMITER $$

DROP PROCEDURE IF EXISTS `sp_verPersonas` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verPersonas`()
select *from personas $$

DELIMITER ;


Para invocarlo

CALL sp_verPersonas();




8. Crear tabla que lleve un control de quien hace cambios en la base de datos prueba1

CREATE TABLE infobase (usuario varchar (50), 
descripcion varchar (50),
fecha TIMESTAMP default now());


9. Crear trigger para la inserción

delimiter $$

create trigger tr_insercion
befote insert on personas
for each row
begin
insert into infobase values(user(),persona creada,now());

end $$


10. Crear trigger para la actualización

delimiter $$

create trigger tr_actualizacion
befote update on personas
for each row
begin
insert into infobase(usuario,descripcion,fecha) values(user(),persona modificada,now());

end $$


11. Crear trigger para la eliminación

delimiter $$

create trigger tr_borrado
befote delete on personas
for each row
begin
insert into infobase values(user(),persona eliminada,now());

end $$


Ver cambios

select * from infobase;


12. Crear procedimiento almacenado para ver un registro en particular

DELIMITER $$

DROP PROCEDURE IF EXISTS `sp_verPersona` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verPersona`(in id_buscar int)
select *from personas where id_persona=id_buscar $$

DELIMITER ;

13. Ahora hacer una operación: calcular el I.M.C. (Índice de Masa Corporal) de las personas registradas

Fórmula: peso/(talla*talla)

DELIMITER $$

DROP PROCEDURE IF EXISTS `sp_verImc` $$
CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_verImc`()
select id_persona,nombre,edad,peso,talla,peso/(talla*talla) from personas $$

DELIMITER ;


14. Programa en Java para ver los registros
package control.pruebas;

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;

public class Codemonkey {

public static void main(String[] args) {
try{
 Class.forName("com.mysql.jdbc.Driver");
 Connection conecta=(Connection)  DriverManager.getConnection("jdbc:mysql://localhost:3306/prueba1","root","root");
 System.out.println("\tConexión exitosa\n");
 Statement sentencia= conecta.createStatement();
ResultSet registro=sentencia.executeQuery("select id_persona,nombre,edad,peso,talla,peso/(talla*talla) from personas");

   while(registro.next()){
    System.out.println("\t\nId: "+registro.getInt("id_persona"));
    System.out.println("Nombre: "+registro.getString("nombre"));
    System.out.println("Edad:"+registro.getInt("edad"));
    System.out.println("Peso:"+registro.getDouble("peso"));
    System.out.println("Talla: "+registro.getDouble("talla"));
    System.out.println("IMC: "+registro.getDouble("peso/(talla*talla)"));
  }
   conecta.close();
   System.out.println("\tConexión cerrada");
}catch(Exception ex){
    ex.printStackTrace();
}

}


}



Enlaces:

https://dev.mysql.com/doc/refman/8.4/en/create-procedure.html


Jai un lenguaje de programación inspirado en C++

Hoy hablaremos de un nuevo lenguaje de programación llamado Jai . Se trata de un lenguaje de programación que está desarrolland...

Etiquetas

Archivo del blog