DAM archivos - Página 3 de 18 - el blog de giltesa

9×04: Bicola generica usando un Vector o Referencias con Ficheros

24 May 201224 diciembre 2014 giltesa Deja un comentario

Código para Bicolas genéricas usando Vectores (con ficheros):

/**
 * Proyecto: 9x04-Bicola - Vector y Ficheros
 * Fichero:  Bicola.java
 * Fecha:    24/05/2012
 *
 * Licencia (CC) BY-NC-SA: giltesa.com
 *
 * http://docs.oracle.com/javase/7/docs/api/java/util/Vector.html
 * http://mundogeek.net/archivos/2009/03/11/generics-en-java/
 */


import java.util.Vector;
/*import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;*/
import java.io.*;


public class Bicola<G> implements Serializable
{

	// PROPIEDADES:
	private Vector<Nodo<G>>	  vNodos;
	private static final long	serialVersionUID	= 3717013638745390665L;


	// CONSTRUCTOR:
	// Se instancia un Vector de Nodos Genericos. (Del tipo con el que instanciamos la Bicola).
	public Bicola()
	{
		vNodos = new Vector<Nodo<G>>(5, 2);
	}


	// METODOS:
	// Se devuelve el numero de elementos usados en el Vector.
	public int getNumDeNodos()
	{
		return vNodos.size();
	}


	// Se añade un Nodo a la izquierda y se desplazan los demas una posicion a la derecha en el indice.
	public void addNodoIzquierda( G dato )
	{
		vNodos.add(0, new Nodo<G>(dato));
	}


	// Se añade al final del Vector un nuevo Nodo:	
	public void addNodoDerecha( G dato )
	{
		vNodos.addElement(new Nodo<G>(dato));
	}


	// Se copia el primer elemento en temp, despues se elimina del Vector.
	public G getNodoIzquierda()
	{
		G temp = vNodos.firstElement().getDatoNodo();
		vNodos.removeElementAt(0);
		return temp;
	}


	// Se copia el ultimo elemento en temp, despues se elimina del Vector.	
	public G getNodoDerecha()
	{
		G temp = vNodos.lastElement().getDatoNodo();
		vNodos.removeElementAt(vNodos.size() - 1);
		return temp;
	}


	// Se concatenan todos los elementos del Vector en cadena y luego se devuelve.
	public String toString()
	{
		String cadena = "";

		for( int i = 0; i < vNodos.size(); i++ )
			cadena += vNodos.get(i).getDatoNodo() + ", ";

		return cadena;
	}


	// Lee un objecto Bicola desde el fichero backup y se devuelve por "valor".
	public Bicola<G> readBicolaFichero()
	{
		FileInputStream fichEntrada = null;
		ObjectInputStream objEntrada = null;
		Bicola<G> temp = null;


		try
		{
			fichEntrada = new FileInputStream("backup.dat");
			objEntrada = new ObjectInputStream(fichEntrada);
			temp = (Bicola<G>) objEntrada.readObject();
		}
		catch( FileNotFoundException e )
		{
			System.out.println("El sistema no puede encontrar el archivo especificado");
		}
		catch( ClassNotFoundException e )
		{
			System.out.println("El contenido leido en \"backup.dat\" no era el esperado.");
		}
		catch( Exception e )
		{
			System.out.println(e);
		}
		finally
		{
			// Como ultimo paso se cierran los ficheros.
			try
			{
				if( objEntrada != null )
					objEntrada.close();
				if( fichEntrada != null )
					fichEntrada.close();
			}
			catch( Exception e )
			{
				System.out.println(e);
			}

		}

		return temp;
	}

	
	// Recibe por referencia un objeto Bicola que es guardado en el fichero backup.
	public void writeBicolaFichero( Bicola<G> bicola )
	{
		FileOutputStream fichSalida = null;
		ObjectOutputStream objSalida = null;

		try
		{
			fichSalida = new FileOutputStream("backup.dat");
			objSalida = new ObjectOutputStream(fichSalida);
			objSalida.writeObject(bicola);
		}
		catch( FileNotFoundException e )
		{
			System.out.println("El sistema no puede encontrar el archivo especificado");
		}
		catch( Exception e )
		{
			System.out.println(e);
		}
		finally
		{
			// Como ultimo paso se cierran los ficheros.
			try
			{
				if( objSalida != null )
					objSalida.close();
				if( fichSalida != null )
					fichSalida.close();
			}
			catch( Exception e )
			{
				System.out.println("No se pudo cerrar el fichero.");
			}

		}
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

/**

* Proyecto: 9x04-Bicola - Vector y Ficheros

* Fichero: Bicola.java

* Fecha: 24/05/2012

* Licencia (CC) BY-NC-SA: giltesa.com

* http://docs.oracle.com/javase/7/docs/api/java/util/Vector.html

* http://mundogeek.net/archivos/2009/03/11/generics-en-java/

import java.util.Vector;

/*import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;*/

import java.io.*;

public class Bicola<G> implements Serializable

{

// PROPIEDADES:

private Vector<Nodo<G>> vNodos;

private static final long serialVersionUID = 3717013638745390665L;

// CONSTRUCTOR:

// Se instancia un Vector de Nodos Genericos. (Del tipo con el que instanciamos la Bicola).

public Bicola()

{

vNodos = new Vector<Nodo<G>>(5, 2);

}

// METODOS:

// Se devuelve el numero de elementos usados en el Vector.

public int getNumDeNodos()

{

return vNodos.size();

}

// Se añade un Nodo a la izquierda y se desplazan los demas una posicion a la derecha en el indice.

public void addNodoIzquierda( G dato )

{

vNodos.add(0, new Nodo<G>(dato));

}

// Se añade al final del Vector un nuevo Nodo:

public void addNodoDerecha( G dato )

{

vNodos.addElement(new Nodo<G>(dato));

}

// Se copia el primer elemento en temp, despues se elimina del Vector.

public G getNodoIzquierda()

{

G temp = vNodos.firstElement().getDatoNodo();

vNodos.removeElementAt(0);

return temp;

}

// Se copia el ultimo elemento en temp, despues se elimina del Vector.

public G getNodoDerecha()

{

G temp = vNodos.lastElement().getDatoNodo();

vNodos.removeElementAt(vNodos.size() - 1);

return temp;

}

// Se concatenan todos los elementos del Vector en cadena y luego se devuelve.

public String toString()

{

String cadena = "";

for( int i = 0; i < vNodos.size(); i++ )

cadena += vNodos.get(i).getDatoNodo() + ", ";

return cadena;

}

// Lee un objecto Bicola desde el fichero backup y se devuelve por "valor".

public Bicola<G> readBicolaFichero()

{

FileInputStream fichEntrada = null;

ObjectInputStream objEntrada = null;

Bicola<G> temp = null;

try

{

fichEntrada = new FileInputStream("backup.dat");

objEntrada = new ObjectInputStream(fichEntrada);

temp = (Bicola<G>) objEntrada.readObject();

}

catch( FileNotFoundException e )

{

System.out.println("El sistema no puede encontrar el archivo especificado");

}

catch( ClassNotFoundException e )

{

System.out.println("El contenido leido en \"backup.dat\" no era el esperado.");

}

catch( Exception e )

{

System.out.println(e);

}

finally

{

// Como ultimo paso se cierran los ficheros.

try

{

if( objEntrada != null )

objEntrada.close();

if( fichEntrada != null )

fichEntrada.close();

}

catch( Exception e )

{

System.out.println(e);

}

return temp;

}

// Recibe por referencia un objeto Bicola que es guardado en el fichero backup.

public void writeBicolaFichero( Bicola<G> bicola )

{

FileOutputStream fichSalida = null;

ObjectOutputStream objSalida = null;

try

{

fichSalida = new FileOutputStream("backup.dat");

objSalida = new ObjectOutputStream(fichSalida);

objSalida.writeObject(bicola);

}

catch( FileNotFoundException e )

{

System.out.println("El sistema no puede encontrar el archivo especificado");

}

catch( Exception e )

{

System.out.println(e);

}

finally

{

// Como ultimo paso se cierran los ficheros.

try

{

if( objSalida != null )

objSalida.close();

if( fichSalida != null )

fichSalida.close();

}

catch( Exception e )

{

System.out.println("No se pudo cerrar el fichero.");

}

(más…)

9×03: Bicola generica usando un Vector o Referencias

17 May 201224 diciembre 2014 giltesa 2 comentarios

Código para Bicolas genéricas usando Vectores:

/**
 * Proyecto: 9x03-Bicola - Vector
 * Fichero:  Bicola.java
 * Fecha:    17/05/2012
 *
 * Licencia (CC) BY-NC-SA: giltesa.com
 *
 * http://docs.oracle.com/javase/7/docs/api/java/util/Vector.html
 * http://mundogeek.net/archivos/2009/03/11/generics-en-java/
 */


import java.util.Vector;

public class Bicola<G>
{

	// PROPIEDADES:
	private Vector<Nodo<G>>	vNodos;


	// CONSTRUCTOR:
	// Se instancia un Vector de Nodos Genericos. (Del tipo con el que instanciamos la Bicola).
	public Bicola()
	{
		vNodos = new Vector<Nodo<G>>(5, 2);
	}


	// METODOS:
	// Se devuelve el numero de elementos usados en el Vector.
	public int getNumDeNodos()
	{
		return vNodos.size();
	}

	
	// Se añade un Nodo a la izquierda y se desplazan los demas una posicion a la derecha en el indice.
	public void addNodoIzquierda( G dato )
	{
		vNodos.add(0, new Nodo<G>(dato));
	}

	
	// Se añade al final del Vector un nuevo Nodo:	
	public void addNodoDerecha( G dato )
	{
		vNodos.addElement(new Nodo<G>(dato));
	}
	
	
	// Se copia el primer elemento en temp, despues se elimina del Vector.
	public G getNodoIzquierda()
	{
		G temp = vNodos.firstElement().getDatoNodo();
		vNodos.removeElementAt(0);
		return temp;
	}

	
	// Se copia el ultimo elemento en temp, despues se elimina del Vector.	
	public G getNodoDerecha()
	{
		G temp = vNodos.lastElement().getDatoNodo();
		vNodos.removeElementAt(vNodos.size() - 1);
		return temp;
	}
	
	
	// Se concatenan todos los elementos del Vector en cadena y luego se devuelve.
	public String toString()
	{
		String cadena = "";

		for( int i = 0; i < vNodos.size(); i++ )
			cadena += vNodos.get(i).getDatoNodo() + ", ";

		return cadena;
	}

}

/**

* Proyecto: 9x03-Bicola - Vector

* Fichero: Bicola.java

* Fecha: 17/05/2012

* Licencia (CC) BY-NC-SA: giltesa.com

* http://docs.oracle.com/javase/7/docs/api/java/util/Vector.html

* http://mundogeek.net/archivos/2009/03/11/generics-en-java/

import java.util.Vector;

public class Bicola<G>

{

// PROPIEDADES:

private Vector<Nodo<G>> vNodos;

// CONSTRUCTOR:

// Se instancia un Vector de Nodos Genericos. (Del tipo con el que instanciamos la Bicola).

public Bicola()

{

vNodos = new Vector<Nodo<G>>(5, 2);

}

// METODOS:

// Se devuelve el numero de elementos usados en el Vector.

public int getNumDeNodos()

{

return vNodos.size();

}

// Se añade un Nodo a la izquierda y se desplazan los demas una posicion a la derecha en el indice.

public void addNodoIzquierda( G dato )

{

vNodos.add(0, new Nodo<G>(dato));

}

// Se añade al final del Vector un nuevo Nodo:

public void addNodoDerecha( G dato )

{

vNodos.addElement(new Nodo<G>(dato));

}

// Se copia el primer elemento en temp, despues se elimina del Vector.

public G getNodoIzquierda()

{

G temp = vNodos.firstElement().getDatoNodo();

vNodos.removeElementAt(0);

return temp;

}

// Se copia el ultimo elemento en temp, despues se elimina del Vector.

public G getNodoDerecha()

{

G temp = vNodos.lastElement().getDatoNodo();

vNodos.removeElementAt(vNodos.size() - 1);

return temp;

}

// Se concatenan todos los elementos del Vector en cadena y luego se devuelve.

public String toString()

{

String cadena = "";

for( int i = 0; i < vNodos.size(); i++ )

cadena += vNodos.get(i).getDatoNodo() + ", ";

return cadena;

}

(más…)

2×03: Función múltiple consulta (Fin MySQL)

15 May 2012 giltesa Deja un comentario

/*
	Pregunta 3 
	Realizar una función pregunta3 que calcule y devuelva el importe
	total de un pedido que se le pase como parámetro. La función
	devolverá -1 si no existe el pedido pasado como argumento.
*/
delimiter $$
drop function if exists 2x03 $$
create function 2x03(ped int) returns double
	begin

		if (select true from pedidos where num_pedido = ped) then

			return
				( select sum(a.precio_unidad * d.unidades)
				  from articulos a, detalle_pedidos d
				  where a.cod_articulo = d.cod_articulo and d.cod_pedido = ped
				)-
				(
				  select descuento
				  from pedidos
				  where num_pedido = ped
				);

		else
			return -1;
		end if;

	end $$
delimiter ;

-- select 2x03(43) as 'Total';

Pregunta 3

Realizar una función pregunta3 que calcule y devuelva el importe

total de un pedido que se le pase como parámetro. La función

devolverá -1 si no existe el pedido pasado como argumento.

delimiter $$

drop function if exists 2x03 $$

create function 2x03(ped int) returns double

begin

if (select true from pedidos where num_pedido = ped) then

return

( select sum(a.precio_unidad * d.unidades)

from articulos a, detalle_pedidos d

where a.cod_articulo = d.cod_articulo and d.cod_pedido = ped

(

select descuento

from pedidos

where num_pedido = ped

);

else

return -1;

end if;

end $$

delimiter ;

-- select 2x03(43) as 'Total';

2×02: Trigger de borrado y actualización en cascada

15 May 2012 giltesa Deja un comentario

/*
	Pregunta 2 
	Realiza un trigger de base de datos pregunta2 que se ejecute
	automáticamente en el momento de borrar pedidos no enviados.
	Dicho trigger se encargará de:

	- Reponer las existencias de cada artículo en la tabla artículos
	  en la cantidad que figura en los detalles del pedido que van a ser
	  borrados.
	- Borrar los detalles de ese pedido no enviado.
*/

-- show triggers;
-- drop trigger t_2x02;

delimiter $$
create trigger t_2x02 before delete on pedidos for each row
	begin

		update articulos a, detalle_pedidos d
		set a.existencias = a.existencias + d.unidades
		where a.cod_articulo = d.cod_articulo and d.cod_pedido = old.num_pedido;

		delete from detalle_pedidos where cod_pedido = old.num_pedido;

	end $$
delimiter ;

 -- delete from pedidos where enviado = 'N' and num_pedido = 42;

Pregunta 2

Realiza un trigger de base de datos pregunta2 que se ejecute

automáticamente en el momento de borrar pedidos no enviados.

Dicho trigger se encargará de:

- Reponer las existencias de cada artículo en la tabla artículos

en la cantidad que figura en los detalles del pedido que van a ser

borrados.

- Borrar los detalles de ese pedido no enviado.

-- show triggers;

-- drop trigger t_2x02;

delimiter $$

create trigger t_2x02 before delete on pedidos for each row

begin

update articulos a, detalle_pedidos d

set a.existencias = a.existencias + d.unidades

where a.cod_articulo = d.cod_articulo and d.cod_pedido = old.num_pedido;

delete from detalle_pedidos where cod_pedido = old.num_pedido;

end $$

delimiter ;

-- delete from pedidos where enviado = 'N' and num_pedido = 42;

2×01: Transacción con método optimista

15 May 201224 diciembre 2014 giltesa Deja un comentario

/*
	Examen de prueba:

	Pregunta 1 
	Realiza un procedimiento pregunta1 que a partir de un código de
	artículo y una cantidad disminuya las existencias de la tabla
	artículos de ese artículo en esa cantidad. Utiliza un tercer
	argumento de tipo out para indicar el resultado del procedimiento
	Ten en cuenta:
		- Si el artículo no existe entonces el tercer argumento devolverá -1. 
		- Si el artículo existe pero no hay suficientes unidades del mismo,
		  el tercer argumento devolverá -2 

	En los 2 casos anteriores no se llevará a cabo ninguna modificación
	 de las existencias.
	Si el artículo existe y dispone de existencias suficientes, realizar
	la operación y validar los cambios. Utiliza transacciones. Durante
	el tiempo que dure el proceso de modificación, se reservará
	(bloqueará) la fila implicada hasta que se validen los cambios.
	El tercer argumento devolverá 1. Para cualquier situación de error
	que se pueda producir se actuará deshaciendo la operación y devolviendo
	un 0 en el tercer argumento del procedimiento.  
*/

delimiter $$
drop procedure if exists 2x01 $$
create procedure 2x01( p_articulo char(4), p_cantidad int(11), out p_resultado int(1) )
	begin

		declare v_cod_articulo char(4);
		declare v_existencias int(11);


		declare continue handler for sqlexception
			begin
				rollback;
				set p_resultado = 0;
			end;

		-- El articulo existe y hay suficientes existencias:
		if ( select true from articulos where cod_articulo = p_articulo  and existencias >= p_cantidad ) then

			select cod_articulo, existencias into v_cod_articulo, v_existencias
			from articulos
			where cod_articulo = p_articulo
			for update;

			START TRANSACTION;
				update articulos set existencias = existencias - p_cantidad
				where cod_articulo = v_cod_articulo and existencias = v_existencias;
				set p_resultado = 1;
				commit;

		-- El articulo existe pero no hay existencias suficientes:
		elseif ( select true from articulos where cod_articulo = p_articulo ) then
			set p_resultado = -2;

		-- El articulo no existe:
		else
			set p_resultado = -1;
		end if;


	end $$
delimiter ;

-- call 2x01( 'A001', 3, @resultado );
-- select @resultado as 'Resultado';

Examen de prueba:

Pregunta 1

Realiza un procedimiento pregunta1 que a partir de un código de

artículo y una cantidad disminuya las existencias de la tabla

artículos de ese artículo en esa cantidad. Utiliza un tercer

argumento de tipo out para indicar el resultado del procedimiento

Ten en cuenta:

- Si el artículo no existe entonces el tercer argumento devolverá -1.

- Si el artículo existe pero no hay suficientes unidades del mismo,

el tercer argumento devolverá -2

En los 2 casos anteriores no se llevará a cabo ninguna modificación

de las existencias.

Si el artículo existe y dispone de existencias suficientes, realizar

la operación y validar los cambios. Utiliza transacciones. Durante

el tiempo que dure el proceso de modificación, se reservará

(bloqueará) la fila implicada hasta que se validen los cambios.

El tercer argumento devolverá 1. Para cualquier situación de error

que se pueda producir se actuará deshaciendo la operación y devolviendo

un 0 en el tercer argumento del procedimiento.

delimiter $$

drop procedure if exists 2x01 $$

create procedure 2x01( p_articulo char(4), p_cantidad int(11), out p_resultado int(1) )

begin

declare v_cod_articulo char(4);

declare v_existencias int(11);

declare continue handler for sqlexception

begin

rollback;

set p_resultado = 0;

end;

-- El articulo existe y hay suficientes existencias:

if ( select true from articulos where cod_articulo = p_articulo and existencias >= p_cantidad ) then

select cod_articulo, existencias into v_cod_articulo, v_existencias

from articulos

where cod_articulo = p_articulo

for update;

START TRANSACTION;

update articulos set existencias = existencias - p_cantidad

where cod_articulo = v_cod_articulo and existencias = v_existencias;

set p_resultado = 1;

commit;

-- El articulo existe pero no hay existencias suficientes:

elseif ( select true from articulos where cod_articulo = p_articulo ) then

set p_resultado = -2;

-- El articulo no existe:

else

set p_resultado = -1;

end if;

end $$

delimiter ;

-- call 2x01( 'A001', 3, @resultado );

-- select @resultado as 'Resultado';

1×29: Transacción optimista

15 May 2012 giltesa Deja un comentario

/*
	Ejercicio 29:

	Realizar un procedimiento que teniendo en cuenta el procedimiento
	transac6 del apartado 6.10.5 de los materiales implemente otro
	procedimiento similar pero utilizando la estrategia optimista, que
	asume que es muy poco probable que el valor de una fila que se acaba
	de leer con intención de modificarla un tiempo más tarde cambie antes
	de poder hacerlo; en ese caso como mínimo habrá que asegurarse de
	que la fila no ha sido modificada después de haber sido leída y si
	así ha sido entonces la transacción no debe llevarse a cabo aun
	pudiéndose realizar (ROLLBACK).
*/

delimiter $$
drop procedure if exists 1x29 $$
create procedure 1x29( p_id int, p_alumno varchar(30) )
	begin

		declare textoError tinytext;
		declare todoOk boolean default true;
		declare v_alumno varchar(30);

		declare v_antes_id int;
		declare v_antes_alumno varchar(30);

		declare continue handler for sqlexception
			begin
				set textoError = "Sql Exception";
				set todoOk = false;
			end;

		-- Se hace una copia del contenido antes de la transaccion:
		select id, alumno into v_antes_id, v_antes_alumno from alumnos where id = p_id;


		START TRANSACTION;
			-- select sleep(20);

			-- Se hace la actualizacion si los datos son los mismos que los obtenidos anteriormente:
			if (select true from alumnos where id = v_antes_id and alumno = v_antes_alumno) then
				update alumnos set id = p_id, alumno = p_alumno where id = v_antes_id and alumno = v_antes_alumno;
			else
				set textoError = "Los datos no eran los mismos, no se ha realizo la modificacion.";
				set todoOk = false;
			end if;


			if todoOk then
				commit;
			else
				select textoError;
				rollback;
			end if;

	end $$
delimiter ;


-- call 1x29( 2, 'Pedro');

Ejercicio 29:

Realizar un procedimiento que teniendo en cuenta el procedimiento

transac6 del apartado 6.10.5 de los materiales implemente otro

procedimiento similar pero utilizando la estrategia optimista, que

asume que es muy poco probable que el valor de una fila que se acaba

de leer con intención de modificarla un tiempo más tarde cambie antes

de poder hacerlo; en ese caso como mínimo habrá que asegurarse de

que la fila no ha sido modificada después de haber sido leída y si

así ha sido entonces la transacción no debe llevarse a cabo aun

pudiéndose realizar (ROLLBACK).

delimiter $$

drop procedure if exists 1x29 $$

create procedure 1x29( p_id int, p_alumno varchar(30) )

begin

declare textoError tinytext;

declare todoOk boolean default true;

declare v_alumno varchar(30);

declare v_antes_id int;

declare v_antes_alumno varchar(30);

declare continue handler for sqlexception

begin

set textoError = "Sql Exception";

set todoOk = false;

end;

-- Se hace una copia del contenido antes de la transaccion:

select id, alumno into v_antes_id, v_antes_alumno from alumnos where id = p_id;

START TRANSACTION;

-- select sleep(20);

-- Se hace la actualizacion si los datos son los mismos que los obtenidos anteriormente:

if (select true from alumnos where id = v_antes_id and alumno = v_antes_alumno) then

update alumnos set id = p_id, alumno = p_alumno where id = v_antes_id and alumno = v_antes_alumno;

else

set textoError = "Los datos no eran los mismos, no se ha realizo la modificacion.";

set todoOk = false;

end if;

if todoOk then

commit;

else

select textoError;

rollback;

end if;

end $$

delimiter ;

-- call 1x29( 2, 'Pedro');

1×28: Cursor de actualización

15 May 201215 mayo 2012 giltesa Deja un comentario

/*
	Ejercicio 28:

	“Representación gráfica de los salarios de los empleados”. Realizar
	un procedimiento que utilice un cursor de actualización para rellenar
	la columna estrellas de la tabla empleados con un asterisco por cada
	100 unidades de salario. Antes de realizar el ejercicio añade la columna
	estrellas a la tabla empleados (ALTER TABLE empleados ADD COLUMN
	estrellas VARCHAR(10)). Incluir los dos manejadores de error del
	ejercicio anterior.

		Ejemplo de funcionamiento:

			+-------+---------+-----------+
			| NUMEM | SALARIO | ESTRELLAS |
			+-------+---------+-----------+
			| 110   | 400     | ****      |
			| 120   | 350     | ***       |
			| 130   | 290     | **        |
			| 150   | 440     | ****      |
			| 160   | 310     | ***       |
			| 180   | 480     | ****      |
			| 190   | 420     | ****      |
			| 210   | 440     | ****      |
			| 240   | 280     | **        |
			| 250   | 450     | ****      |
			| 260   | 900     | ********* |
			| 270   | 380     | ***       |

			...
			...
*/
-- alter table empleados add    stars varchar(5);			 -- Añade una columna
-- alter table empleados change stars estrellas varchar(5);  -- Modifica el nombre de una columna
-- alter table empleados modify estrellas varchar(10);		 -- Cambia el tipo de una columna.


delimiter $$
drop procedure if exists 1x28 $$
create procedure 1x28()
	begin

		declare finCursor boolean default false;
		declare todoOk boolean default true;
		declare textoError tinytext;
		declare v_numem integer;

		declare c_empleados cursor for
			select numem from empleados
		for update;

		declare continue handler for not found set finCursor = true;
		
		declare continue handler for sqlexception
			begin
				set todoOk = false;
				set textoError = "Sql Exception";
			end;
		

		START TRANSACTION;
			open c_empleados;
			fetch c_empleados into v_numem;

			while finCursor = false do
				update empleados set estrellas = lpad('', salario div 100, '*') where numem = v_numem; -- Lpad nos ahorra tener que hacer una iteracion solo para concatenar estrellas.
				fetch c_empleados into v_numem;
			end while;

			close c_empleados;

			if todoOk then
				commit;
			else
				select textoError;
				rollback;
			end if;

	end $$
delimiter ;

-- call 1x28;
-- select numem, salario, estrellas from empleados;

Ejercicio 28:

“Representación gráfica de los salarios de los empleados”. Realizar

un procedimiento que utilice un cursor de actualización para rellenar

la columna estrellas de la tabla empleados con un asterisco por cada

100 unidades de salario. Antes de realizar el ejercicio añade la columna

estrellas a la tabla empleados (ALTER TABLE empleados ADD COLUMN

estrellas VARCHAR(10)). Incluir los dos manejadores de error del

ejercicio anterior.

Ejemplo de funcionamiento:

+-------+---------+-----------+

| NUMEM | SALARIO | ESTRELLAS |

+-------+---------+-----------+

| 110 | 400 | **** |

| 120 | 350 | *** |

| 130 | 290 | ** |

| 150 | 440 | **** |

| 160 | 310 | *** |

| 180 | 480 | **** |

| 190 | 420 | **** |

| 210 | 440 | **** |

| 240 | 280 | ** |

| 250 | 450 | **** |

| 260 | 900 | ********* |

| 270 | 380 | *** |

...

-- alter table empleados add stars varchar(5); -- Añade una columna

-- alter table empleados change stars estrellas varchar(5); -- Modifica el nombre de una columna

-- alter table empleados modify estrellas varchar(10); -- Cambia el tipo de una columna.

delimiter $$

drop procedure if exists 1x28 $$

create procedure 1x28()

begin

declare finCursor boolean default false;

declare todoOk boolean default true;

declare textoError tinytext;

declare v_numem integer;

declare c_empleados cursor for

select numem from empleados

for update;

declare continue handler for not found set finCursor = true;

declare continue handler for sqlexception

begin

set todoOk = false;

set textoError = "Sql Exception";

end;

START TRANSACTION;

open c_empleados;

fetch c_empleados into v_numem;

while finCursor = false do

update empleados set estrellas = lpad('', salario div 100, '*') where numem = v_numem; -- Lpad nos ahorra tener que hacer una iteracion solo para concatenar estrellas.

fetch c_empleados into v_numem;

end while;

close c_empleados;

if todoOk then

commit;

else

select textoError;

rollback;

end if;

end $$

delimiter ;

-- call 1x28;

-- select numem, salario, estrellas from empleados;

1×27: Transacción for update

15 May 2012 giltesa Deja un comentario

/*
	Ejercicio 27:

	Realizar un procedimiento que actualice el salario de los empleados,
	con una cantidad por hijo que se pase al procedimiento, para aquellos
	trabajadores que su comisión es nula. Durante el proceso de actualización
	debe garantizarse que ningún otro usuario pueda cambiar los datos que
	están siendo modificados. Utilizar un manejador de tipo SQLEXCEPTION
	(que incluya la operación ROLLBACK) para tratar cualquier situación de
	error distinta de la excepción NOT FOUND que también deberá manejarse.
	Al final del proceso, confirmar la transacción si la ejecución ha sido
	correcta.

		Ejemplo de funcionamiento. Antes de llamar al procedimiento de
		actualización:

			+-------+---------+----------+-------+
			| numem | salario | comision | numhi |
			+-------+---------+----------+-------+
			| 110   | 310     | NULL     | 3     |
			| 120   | 350     | 110      | 1     |
			| 130   | 290     | 110      | 2     |
			| 150   | 440     | NULL     | 0     |
			| 160   | 310     | 110      | 2     |
			| 180   | 480     | 50       | 2     |
			| 190   | 300     | NULL     | 4     |
			…
			….
			Después de ejecutar  CALL EJERCICIO3_1(30);

			+-------+---------+----------+-------+
			| numem | salario | comision | numhi |
			+-------+---------+----------+-------+
			| 110   | 400     | NULL     | 3     |
			| 120   | 350     | 110      | 1     |
			| 130   | 290     | 110      | 2     |
			| 150   | 440     | NULL     | 0     |
			| 160   | 310     | 110      | 2     |
			| 180   | 480     | 50       | 2     |
			| 190   | 420     | NULL     | 4     |

			...
			...
*/

delimiter $$
drop procedure if exists 1x27 $$
create procedure 1x27(prima int)
	begin
		declare v_numem integer;
		declare finCursor boolean default false;
		declare c_cursor cursor for
			select numem
				from empleados
				where comision is null and numhi > 0
			for update;

		declare continue handler for not found set finCursor = true;
		declare exit handler for sqlexception
			begin
				rollback;
				select "Ocurrio un error";
			end;

		START TRANSACTION;
			open c_cursor;

			fetch c_cursor into v_numem;

			while finCursor = false do
				update empleados
					set salario = salario + (prima * numhi)
					where numem = v_numem;
				fetch c_cursor into v_numem;
			end while;
		
			close c_cursor;
			commit;

	end $$
delimiter ;

-- select numem, salario, comision, numhi from empleados;
-- call 1x27(30);
-- select numem, salario, comision, numhi from empleados;

Ejercicio 27:

Realizar un procedimiento que actualice el salario de los empleados,

con una cantidad por hijo que se pase al procedimiento, para aquellos

trabajadores que su comisión es nula. Durante el proceso de actualización

debe garantizarse que ningún otro usuario pueda cambiar los datos que

están siendo modificados. Utilizar un manejador de tipo SQLEXCEPTION

(que incluya la operación ROLLBACK) para tratar cualquier situación de

error distinta de la excepción NOT FOUND que también deberá manejarse.

Al final del proceso, confirmar la transacción si la ejecución ha sido

correcta.

Ejemplo de funcionamiento. Antes de llamar al procedimiento de

actualización:

+-------+---------+----------+-------+

+-------+---------+----------+-------+

| 110 | 310 | NULL | 3 |

| 120 | 350 | 110 | 1 |

| 130 | 290 | 110 | 2 |

| 150 | 440 | NULL | 0 |

| 160 | 310 | 110 | 2 |

| 180 | 480 | 50 | 2 |

| 190 | 300 | NULL | 4 |

…

….

Después de ejecutar CALL EJERCICIO3_1(30);

+-------+---------+----------+-------+

+-------+---------+----------+-------+

| 110 | 400 | NULL | 3 |

| 120 | 350 | 110 | 1 |

| 130 | 290 | 110 | 2 |

| 150 | 440 | NULL | 0 |

| 160 | 310 | 110 | 2 |

| 180 | 480 | 50 | 2 |

| 190 | 420 | NULL | 4 |

...

delimiter $$

drop procedure if exists 1x27 $$

create procedure 1x27(prima int)

begin

declare v_numem integer;

declare finCursor boolean default false;

declare c_cursor cursor for

select numem

from empleados

where comision is null and numhi > 0

for update;

declare continue handler for not found set finCursor = true;

declare exit handler for sqlexception

begin

rollback;

select "Ocurrio un error";

end;

START TRANSACTION;

open c_cursor;

fetch c_cursor into v_numem;

while finCursor = false do

update empleados

set salario = salario + (prima * numhi)

where numem = v_numem;

fetch c_cursor into v_numem;

end while;

close c_cursor;

commit;

end $$

delimiter ;

-- select numem, salario, comision, numhi from empleados;

-- call 1x27(30);

-- select numem, salario, comision, numhi from empleados;

el blog de giltesa

Etiqueta: DAM

9×04: Bicola generica usando un Vector o Referencias con Ficheros

9×03: Bicola generica usando un Vector o Referencias

2×03: Función múltiple consulta (Fin MySQL)

2×02: Trigger de borrado y actualización en cascada

2×01: Transacción con método optimista

1×29: Transacción optimista

1×28: Cursor de actualización

1×27: Transacción for update

Archivos

Calendario

Meta