CONEXIÓN DE BASE DE DATOS CON JAVA

CONEXIÓN DE BASE DE DATOS CON JAVA

Un controlador JDBC(Java Database Connectivity), el cual es un interfase de comunicación que permite la ejecución entre Java y cualquier motor de Base de Datos.

1. Conexión directa.

A la derecha, el controlador JDBC accede directamente al controlador del fabricante Ya que estas no necesitan un puente para comunicarse, el trabajo y la conexión son mucho más rápidos que la otra conexión.

2. Conexión indirecta.

A la izquierda el controlador JDBC hace de “puente” con el controlador ODBC, que es el que accede a la base de datos, este es un esquema de un controlador JDBC de nivel tipo 1.

Partes que posee un programa de java básico para la conexión de este con la base de datos.

Java.sql.* Este paquete contiene clases e interfaces diseñadas teniendo en mente la arquitectura tradicional cliente-servidor. Su funcionalidad se centra primordialmente en servicios de programación básicos de bases de datos, como creación de conexiones, ejecución de instrucciones e instrucciones preparadas.

Dentro de los paquetes que más usaremos en esta sección se encuentran:

java.sql.DriverManager.- Esta clase proporciona la funcionalidad necesaria para gestionar uno o más drivers de base de datos.

http://aby17ekbalam.blog.com/files/2010/06/antonio.jpg

java.sql.ResultSetMetaData.- Esta interfaz proporciona métodos para acceder a metadatos del Resultset, como los nombres de las columnas, sus tipos, el nombre de tabla correspondiente y otras propiedades.

java.sql.SQLException.- Esta excepción representa todas las condiciones de excepción relacionadas con JDBC.

java.sql.Connection.- representa una conexi6n con una base de datos.

LOS URL de JDBC

La noción de un URL en JDBC es muy similar al modo en que los URL se utilizan en otras situaciones. Para poder entender la base lógica de los URL de JDBC.

Los URL de JDBC proporcionan un modo de identificar un driver de base de datos, en el caso de una conexión directa. Un URL de JDBC representa un dirver y la información adicional específica del driver para localizar una base de datos y conectarla a él. La sintaxis del URL de JDBC es como sigue:

jdbc:<subprotocolo>:<subname>

Se puede observar que están separadas en tres partes por dos puntos.

Protocolo: jdbc es el protocolo. Este es el único protocolo permitido en JDBC.

Sub-protocolo: el sub-protocolo es utilizado para identificar un driver de base de datos o el nombre de un mecanismo de conectividad de una base de datos, elegido por los proveedores del driver de base de datos.

Subnombre: la sintaxis del subnombre es específica de driver. Un driver puede elegir cualquier sintaxis apropiada para su implementación.

DRIVER MANAGER.-

El propósito de la clase java.sql.DriverManager (gestor de driver) en JDBC es proporcionar una capa de acceso común encima de diferentes drivers de base de datos utilizados en una aplicación.

Por ejemplo para Ms SQL Server el driver seria:

try{

Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);}

catch(ClassNotFoundException e){

}

En el ejemplo basado en Ms SQL Server, el código utiliza un driver ODBC , donde “libros” es un DNS fijado en la configuración de ODBC (después explicaré como realizar esta configuración de ODBC). Este DNS corresponde a una base de datos que requiere un nombre de usuario y una contraseña para obtener una conexión:

String URL=”jdbc:odbc:libros”;

String user=”sa”;

String pass=””;

Connection conn=DriverManager.getConnection(URL,user,password);

En muchas ocasiones es necesario especificar el tiempo máximo que debe esperar un driver mientras intenta conectar a una base de datos. Los siguientes dos métodos pueden ser utilizados para fijar/obtener (set/get) el tiempo límite de registro:

public static void setLoginTimeout(int segundos){ }

public static void getLoginTimeout( ){ }

Para resumir la teoría mencionada creare una clase netamente para la conexión con una base de datos, usaremos en este ejemplo la conexión con SQL Server:

Ahora si deseamos conectarnos con MySQL, el proceso es similar que el anterior hecho para Ms SQL Server, solo debemos de cambiar el contenido de Driver, URL, user, pass tal como se muestra:

String Driver = “com.mysql.jdbc.Driver”;

String URL = “jdbc:mysql://localhost:3306/libros”;

String user = “root”;

http://aby17ekbalam.blog.com/files/2010/06/antonio1.jpg

String pass = “root”; _ la contraseña puede variar según el usuario.

Esta parte observemos, la diferencia que hay con los parámetros antes puestos para establecer la conexión con Ms SQL Server. Como la conexión con MySQL con Java es directa, observamos que en la parte de URL, no hay ningún puente ODBC. Debemos de recordar que para cada manejador de base de datos de conexión directa existen drivers distintos, el cual debemos de instalar antes. Pero para las últimas versiones del NetBeans y otros IDE’s para java, los driver más usados están contenidos dentro de la instalación del Netbeans.

CREAR Y EJECUTAR SENTENCIAS SQL

En esta sección es recomendable que el lector tenga conocimiento en cómo realizar consultas o listados en SQL, tal como el uso del SELECT – también para Insertar (INSERT), modificar (UPDATE) y eliminar (DELETE). Podemos utilizar un objeto Connection para ejecutar instrucciones SQL creando un Statement, un PreparedStatement o un CallableStatement. Estos objetos abstraen instrucciones SQL normales, instrucciones preparadas y procedimientos almacenados respectivamente. Una vez hemos obtenidos unos de esos objetos de instrucciones, podemos ejecutar la instrucción y leer resultados gracias a un objeto ResultSet..

OBTENCIÓN DEL ORIGEN DE DATOS ODBC (Open Database Connectivity).

Definición: Una aplicación de Conectividad abierta de bases de datos (ODBC) utiliza un origen de datos ODBC para conectarse a una instancia de Microsoft SQL Server.

Un origen de datos ODBC es una definición almacenada que registra:

· El controlador ODBC que se va a utilizar para las conexiones que especifican el origen de datos.

· La información que utiliza el controlador ODBC para conectarse a un origen de datos.

Opciones específicas del controlador que se van a utilizar para la conexión.

Por ejemplo, un SQL Server origen de datos ODBC puede registrar las opciones de ISO que va a utilizar o si los controladores deben registrar estadísticas de rendimiento.


Cada origen de datos ODBC de un cliente tiene un nombre del origen de datos (DSN) exclusivo. Un origen de datos ODBC para el controlador ODBC de SQL Server incluye toda la información utilizada para conectarse a una instancia de SQL Server, más las opciones fundamentales.

OPERACIONES BÁSICAS EN JAVA PARA MYSQL

Consulta

JAVA:

1. import java.sql.*; 2. 3. public class DBconsulta 4. {

1. static String login = “root”; 2. static String password = “´pass”; 3. static String url = “jdbc:mysql://localhost/MyDB”;

1. 2. public static void main(String[] args) throws Exception 3. { 4. Connection conn = null; 5. try 6. { 7.

Class.forName(“com.mysql.jdbc.Driver”).newInstance(); 8. conn =

DriverManager.getConnection(url,login,password); 9. 10. if (conn != null) 11. { 12. Statement stmt = conn.createStatement(); 13. ResultSet res =

stmt.executeQuery(“SELECT * FROM Alumno”); 14. System.out.println(“\nNombre \t\t

Direccion\n“); 15. 16. while(res.next()) 17. { 18. String Nombre =

res.getString(“Nombre”); 19. String Direccion =

res.getString(“Direccion”); 20. System.out.println(Nombre

+” \t “+ Direccion);

21. } 22. res.close(); 23. stmt.close(); 24. conn.close(); 25. } 26. } 27. catch(SQLException ex) { 28. System.out.println(ex); 29. } 30. catch(ClassNotFoundException ex) { 31. System.out.println(ex); } 32. } 33. }

Insertar

JAVA:

1. import java.sql.*; 2. 3. public class DBInsertar 4. { 5. static String login = “root”; 6. static String password = “pass”; 7. static String url = “jdbc:mysql://localhost/MyDB”; 8. 9. public static void main(String[] args) throws Exception 10. { 11. Connection conn = null; 12. try { 13. Class.forName(“com.mysql.jdbc.Driver”).newInstance(); 14. conn = DriverManager.getConnection(url,login,password); 15. if (conn != null) 16. { 17. int rows_updated = 0; 18. 19. PreparedStatement stmt1 = conn.prepareStatement(“INSERT INTO

ALUMNO (ID, Nombre , Carrera ,Direccion) ” + ”VALUES (?,?,?,?)”); 20. 21. stmt1.setInt(1,1); // ID 22. stmt1.setString(2,”Allan Duvallier”); // Nombre 23. stmt1.setString(3,”Ing Sistemas”); // Carrera 24. stmt1.setString(4,”Pie de casa”); // Direccion 25. 26. rows_updated = stmt1.executeUpdate(); 27. 28. }

29. } 30. catch(SQLException ex) { 31. System.out.println(ex); 32. } 33. catch(ClassNotFoundException ex) { 34. System.out.println(ex); } 35. } 36. }

Eliminar

JAVA:

1. import java.sql.*; 2. 3. public class DBconsulta 4. { 5. static String login = “root”; 6. static String password = “pass”; 7. static String url = “jdbc:mysql://localhost/MyDB”; 8. 9. public static void main(String[] args) throws Exception 10. { 11. Connection conn = null; 12. try { 13. Class.forName(“com.mysql.jdbc.Driver”).newInstance(); 14. conn = DriverManager.getConnection(url,login,password); 15. if (conn != null) 16. { 17. Statement stmt = conn.createStatement(); 18. int row2 = stmt.executeUpdate(“DELETE FROM Alumno WHERE ID> 01

“); 19. } 20. } 21. catch(SQLException ex) { 22. System.out.println(ex); 23. } 24. catch(ClassNotFoundException ex) { 25. System.out.println(ex); } 26. } 27. }

CONEXIÓN DE BASE DE DATOS CON PHP

Cuando se desarrolla una aplicación, muchas veces se necesita conectar a una base de datos. PHP permite conectarse a las mayorías de las base de datos, por tanto que existe un driver ODBC o mejor, un driver PHP.

Driver ODBC

Un driver ODBC (Open Database Connectivity) permite utilizar un driver “genérico” para conectarse a une base de datos. Así PHP se conecta al driver ODBC, y el driver ODBC se conecta a la base de datos. Es el medio más fácil de conectarse a una base de datos, pero es mucho menos eficiente que un driver PHP.

Driver PHP

PHP provee drivers con funciones predefinidas para la mayoría de las bases de datos.

Para MySQL, existen dos drivers diferentes: mysql y mysqli. El segundo solo esta disponible en PHP versiones 4.1.3 y arriba, y es una versión mejorada de del driver mysql. Permite entre otros llamar a procedimientos, preparar consultas, etc…

En este curso, bien que hemos instalado los dos drivers, solo vamos a utilizar mysqli.

Con el fin de ayudar a depurar el programa, cuando falla una consulta SQL o que se proba de conectar, después de la instrucción se utiliza ‘or die (‘Mensaje de depuración’)’. En caso de error aparcera el mensaje de depuración en la página PHP del navegador.

Conexión

Para conectarse a la base de datos MySQL com mysqli, hay que llamar a mysqli_connect con 4 parametros: el servidor MySQL, el nombre de usuario, la clave, y la base de datos deseada.

Ejemplo:

<?php

$db =mysqli_connect(“localhost”,”root”,”SolJava”,”curso”) or die(‘No se pudo conectar a la BD:

‘ . mysqli_error());

?>

Ejecución de instrucciones SQL

Para poder ejecutar instrucciones SQL en la base de datos, hay que ser conectado a la a base de datos.

Una vez conectado, hay que crear la instrucción, ejecutarla, y eventualmente recoger el resultado.

Dependiendo de si la instrucción debería de regresar datos, o no, se va utilizar una lista de resultados o solamente ejecutar la instrucción.

Ejemplo: mysql.php

<?php



?>

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”

“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>

<html>

<head>

<?php

$titulo=”Conectarse a MySQL”;

?>

<title><?PHP echo $titulo; ?></title>

</head>

<body bgcolor=”#FFFFFF”>

<h1><?PHP echo $titulo; ?></h1>

<hr>

<p>

Lista de paises</p>

<table border=”1″>

<tr><th>Pais</th></tr>

<?php

$result = mysqli_query($db,”select * from country order by country”) or die(‘consulta 1

falló: ‘ . mysqli_error());

while ($myrow = mysqli_fetch_array($result)) {

print(“<tr><td>”.$myrow["country"].”</td></tr>”);

}

mysqli_free_result($result); // Liberar conjunto de resultados

mysqli_close($db);

?>

</table>

</body>

</html>

Consultas preparadas

Para evitar problemas con juegos de carácter o caracteres especiales, es mejor utilizar consultas preparadas.

Ejemplo de consulta preparada:

<?php

$action = $_POST["action"];

$no_country = $_POST["no_country"];

$country = $_POST["country"];

$currency = $_POST["currency"];



if ($action==”insert” && $country!=null)

{

/* Preparar la consulta */

$stmt = mysqli_prepare($db, “insert into country (country, currency) values(?,?)”) or

die(‘consulta 1 falló: ‘ . mysqli_error());

/* ligar los parametros */

mysqli_stmt_bind_param($stmt, “ss”, $country,$currency);

/* executar la consulta */

mysqli_stmt_execute($stmt);

/* cerrar la consulta */

mysqli_stmt_close($stmt);

}

?>



<html>

<head>

<?php


?>


</head>



<hr>

<form action=”mysql2.php” method=”post”>

<p>Lista de paises (limitar al pais numero:

<input size=”4″ maxlength=”4″ value=”<?

php print $no_country ?>”>)

</form></p>


<tr><th>No</th><th>Pais</th><th>Moneda</th></tr>

<?php

if ($no_country!=null && intval($no_country)>0){


$stmt = mysqli_prepare($db, “SELECT country,currency FROM country WHERE no_country=?”) or

die(‘consulta 2 falló: ‘ . mysqli_error());


mysqli_stmt_bind_param($stmt, “s”, $no_country);



/* ligar los campos del resultado */

mysqli_stmt_bind_result($stmt, $country2, $currency2);

/* captar el valor */

mysqli_stmt_fetch($stmt);

printf(“<tr><td>%f</td><td>%s</td><td>%s</td></tr>”,$no_country,$country2,$currency2);



}

else {




print(“<tr><td>”.$myrow["no_country"].”</td><td>”.$myrow["country"].”</td><td>”.

$myrow["currency"].”</td></tr>”);

}


}

mysqli_close($db);

?>

<form action=”mysql2.php” method=”post”>

<tr>

<td><input value=”Adjuntar”></td>

<td><input value=”insert”>

<input size=”10″ maxlength=”10″></td>

<td><input size=”8″ maxlength=”10″></td>

</tr>

</form>

</table>

</body>

</html>

Llamado a procedimientos

De PHP se pueden también llamar a procedimientos y funciones de la base de datos.

Ejemplo: mysql3.php

<?php

$action = $_POST["action"];

$no_country = $_POST["no_country"];



if ($action==”delete” && intval($no_country)>0)

{


$stmt = mysqli_prepare($db, “CALL country_d (?)”) or die(‘consulta 1 falló: ‘ .

mysqli_error());


mysqli_stmt_bind_param($stmt, “i”, $no_country);





}

?>



<html>

<head>

<?php


?>


</head>



<hr>

<p>Lista de paises</p>


<tr><th>No</th><th>Pais</th><th>Moneda</th></tr>

<?php

$fromNr=0;




print(“<form action=\”mysql3.php\” name=\”form$fromNr\” method=\”post\”>”);

print(“<input type=\”hidden\” name=\”action\” value=\”delete\”>”);

print(“<input type=\”hidden\” name=\”no_country\” value=\”".$myrow["no_country"].”\”>”);

print(“<tr><td>”.$myrow["no_country"].”</td><td>”.$myrow["country"].”</td><td>”.

$myrow["currency"].”</td>”);

print(“<td><input type=\”submit\” value=\”Borrar\”></td>”);

print(“</form></tr>”);

$fromNr++;

}


mysqli_close($db);

?>

</table>

</body>

</html>

Recuperación de fotos en la base de datos

PHP permite recuperar archivos binario de la base de datos y enviarlos al navegador. Un archivo

binario puede ser una foto, un archivo de texto, un archivo audio,…

Ejemplo de recuperación de imagen en la base de datos: imagen.php

<?php


‘ . mysql_error());

$id = $_GET["no_photo"];

$sql = “select data, photo_filename, photo_caption, photo_filesize from photo_gallery where

photo_id = $id”;

$result= mysqli_query($db,$sql) or die(‘consulta 1 falló: ‘ . mysqli_error());


$data = $myrow["data"];

$photo_filename = $myrow["photo_filename"];

$photo_filetype = $myrow["photo_filetype"];

$photo_caption = $myrow["photo_caption"];

$photo_filesize = $myrow["photo_filesize"];

}


header(“Content-type: $photo_filetype”);

header(“Content-length: $photo_filesize”);

header(“Content-Disposition: attachment; filename=$photo_filename”);

header(“Content-Description: PHP Generated Data”);

echo $data;

// Cerrar la conexión

mysqli_close($db);

exit;

?>

Ejemplo de página utilizando la foto: index_imagen.php



<html>

<head>

<?php

$titulo=”Mi primera Página PHP con foto extraida de la BD”;

$nrPagina=1;

?>


</head>


<img src=”imagen.php?no_photo=1″ align=”right”>


<hr>

<p>

Este es mi página en PHP numero <?PHP echo $nrPagina; ?>.

</p>

</body>

</html>

Clase en php para conectar con la base de datos MySQL

La clase MySQLGuardamos esta clase en un archivo llamado mysql.php

1. <?php 2. class MySQL{ 3. private $conexion; 4. private $total_consultas; 5. public function MySQL(){

6. if(!isset($this->conexion)){ 7. $this->conexion = (mysql_connect(“Servidor”,”usuario”,”password”)) or die(mys

ql_error()); 8. mysql_select_db(“nombreBD”,$this->conexion) or die(mysql_error()); 9. } 10. } 11. public function consulta($consulta){ 12. $this->total_consultas++; 13. $resultado = mysql_query($consulta,$this->conexion); 14. if(!$resultado){ 15. echo ’MySQL Error: ’ . mysql_error(); 16. exit; 17. } 18. return $resultado; 19. } 20. public function fetch_array($consulta){ 21. return mysql_fetch_array($consulta); 22. } 23. public function num_rows($consulta){ 24. return mysql_num_rows($consulta); 25. } 26. public function getTotalConsultas(){ 27. return $this->total_consultas; 28. } 29. }?>

Ejemplo de UsoVeamos el código que crearíamos para seleccionar los elementos de una tabla y mostrarlos por pantalla

1. include(“mysql.php”); 2. $db = new MySQL(); 3. $consulta = $db->consulta(“SELECT id FROM mitabla1″); 4. if($db->num_rows($consulta)>0){ 5. while($resultados = $db->fetch_array($consulta)){ 6. echo ”ID: ”.$resultados['id'].”<br />”; 7. } 8. }

Programas de java:

Todos estos programas fueron realizados y ejecutados en el Software NetBeans IDE 6.8

/*

* Programa que hace la consulta desde java hacia MySQL.

*/

package consulta;

/**

*

* @author Antonio

*/

import java.sql.*;

public class programaconsulta {

static String login = “root”;

static String password = “antonio”;

static String url = “jdbc:mysql://localhost/tienda”;

public static void main(String[] args) throws Exception{

Connection conn = null;

try{

Class.forName(“com.mysql.jdbc.Driver”).newInstance();

conn = DriverManager.getConnection(url,login,password);

if(conn !=null){

Statement stmt = conn.createStatement();

ResultSet res = stmt.executeQuery(“SELECT * FROM categoria”);

System.out.println(“\nid_categoria \t\t Nombre \t\t Descripcion\n”);

while(res.next())

{

String id_categoria = res.getString(“id_categoria”);

String nombre = res.getString(“Nombre”);

String descripcion=res.getString(“Descripcion”);

System.out.println(id_categoria+”\t”+ nombre +” \t “+ descripcion);

}

res.close();

stmt.close();

conn.close();

}

}

catch(SQLException ex){

System.out.println(ex);

}

catch(ClassNotFoundException ex){


}

}

}

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package insercion;

/**

*

* @author Antonio

*/

import java.sql.*;

public class programainsercion {






public static void main(String[] args) throws Exception {

Connection conn=null;

try{



if(conn !=null){

int rows_updated = 0;

PreparedStatement stmt1 = conn.prepareStatement(“INSERT INTO categoria

(id_categoria,nombre,descripcion) ” + “VALUES (?,?,?)”);

stmt1.setInt(1,1); // id_Categoria

stmt1.setString(2,”frutas”); // Nombre

stmt1.setString(3,”null”); // Descripcion

rows_updated = stmt1.executeUpdate();

}

}



}



}

}

}

Ahí en la pantalla cmd se muestra que en la tabla categoría no posee ningún dato almacenado.

En la pantalla del software NetBeans IDE 6.8 se muestra el código de java que hace posible una inserción de datos en la tabla categoría de la base de datos tienda.




En esta pantalla tenemos la demostración de la inserción de los datos que se llevo a cabo desde NetBeans IDE 6.8 en código java.

package eliminacion;

import java.sql.*;

public class programaeliminacion {




public static void main(String[] args)throws Exception {


try{



if(conn!=null){


int row2 = stmt.executeUpdate(“DELETE FROM categoria WHERE id_categoria= 01 “);

}

}



}



}

}

}

Ahí se muestra el código en el NetBeans IDE 6.8 para la eliminación de los datos de la tabla categoría en mysql.

Con la sentencia select*from categoría se quiso mostrar los datos en la tabla pero no me mostro nada porque fueron eliminados desde el programa de java que se hiso en el NetBeans IDE 6.8

package modificacion;

import java.sql.*;

public class programamodificaciones {






public static void main(String[] args)throws Exception {


try{



if(conn!=null){


int row2 = stmt.executeUpdate(“update categoria set descripcion=’null’ where id_categoria=2″);

}

}



}



}

}

}


Se muestra el código de modificaciones en el NetBeans IDE 6.8

Bueno ahí se presenta en la pantalla en la que la tabla categoría tiene nuevos datos almacenados y que posteriormente en la descripción del producto que posee el id 2 se le puso un valor null.

Conclusión

Para poder realizar la conexión de una base de datos como MySQL con Java es necesario poseer controladores que nos permitan una interacción entre ambas, Un controlador JDBC (Java Database Connectivity) es una interfaz de comunicación que la ejecución de java en cualquier motor de base de datos y esta conexión se realiza de dos maneras una es la conexión directa o indirecta, en la primera el JDBC accede directamente al controlador del fabricante, la otra JDBC hace un puente con el controlador ODBC (accede a la base de datos), para realizar operaciones básicas como la consulta, creación, modificación, entre otra pero para esto se tiene que contar con permiso.

Como sabes vemos posee una gran importancia las base de datos ya que nos permiten el almacenamiento y ordenamiento de los datos pero estas se apoyan en el lenguaje java para tener una interacción más fácil mediante interfaces para persona que no están en el ámbito de la informática o de la ingeniería de sistemas computaciones o de otra, por ellos las base de datos con este lenguaje de java o ya se otras como otros tipos de lenguajes va de la mano.

Leave a Comment more...

Proyecto de base de datos:Tienda de abarrotes.

Posted by aby-ekbalam in Jun 03, 2010, under Uncategorized

Partes que contempla el proyecto.

1. Diseñar o modificar 2. Normalizar 3. Incluir 3 o más tablas. 4. Generar el script de base de datos con DBDesigner.


5. Usar un cliente grafico para la inclusión de datos. 6. Exponer con diapositivas y Software a ocupar.

Las tablas que se obtuvieron:

Como ejecutar un script desde cmd.

Encontramos dos formas basica para ejecutar un script estas son:

* source c:\Users\Antonio\Desktop\tiendanueva.sql (comando + ubicacion del script).

* mysql -u “root” –password=“antonio” < nuevaBD.txt

Como crear usuarios de MySQL desde cmd

grant all privileges on *.* to ‘usuario’@'localhost’ identified by ‘nuevo’ with grant option;

on *.* =permisos globales.

on db_name .*= permisos a nivel de base de datos.

Grant all= asigna solo los permisos que existen en el nivel que esta otorgándolos.

on db_name.tbl_name =permisos a nivel de tabla.

comandos que nos permite realizar cambio y visualizacion en las cuentas creadas.

show grants; (es para mostrar los privilegios de la cuenta).

show grants for usurio@localhost; (para mostrar privilegios de una cuenta en especifico).

drop user usuario@localhost; (para eliminar una cuenta).

http://aby17ekbalam.blog.com/files/2010/05/Sin-t%C3%ADtulo1.png

http://aby17ekbalam.blog.com/files/2010/05/Sin-t%C3%ADtulo2.png

set password for usuario@localhost=password(‘contraseña’); (para cambiar password de cuenta).

revoke all privileges, grant option from user [user]…. (remover todos los permisos globales,de nivel de base de datos).


Preguntas:

Posted by aby-ekbalam in May 31, 2010, under Uncategorized

Preguntas de Taller de Base de Datos

1. ¿Cuales son los tipos de tablas que podemos crear en mysql?

1. ISAM.- es el formato de almacenaje mas antiguo, y posiblemente pronto desaparecerá. Presentaba limitaciones (los ficheros no eran transportables entre máquinas con distinta arquitectura, no podía manejar ficheros de tablas superiores a 4 gigas). Si aun tienes tablas tipo ISAM, cambialas a MYISAM ya!

2. MYISAM.- es el tipo de tabla por defecto en MySQL desde la versión 3.23. Optimizada para sistemas operativos de 64 bits, permite ficheros de mayor tamaño que ISAM. Además los datos se almacenan en un formato independiente, con lo que se pueden copiar tablas de una máquina a otra de distinta plataforma. Posibilidad de indexar campos BLOB y TEXT.

Un inconveniente es que las tablas pueden llegar a corromperse, almacenando datos incorrectos. Esto puede ser causado por:

- El proceso mysqld haya sido eliminado en el transcurso de una escritura.- problemas de hardware.- Una caida del sistema durante su utilización.- Un gusano en el código Mysql o MyISAM.

1. HEAP.- Crea tablas en memoria. Son temporales y desaparecen cuando el servidor se cierra; a diferencia de una tabla TEMPORARY, que solo puede ser accedida por el usuario que la crea, una tabla HEAP puede ser utilizada por diversos usuarios.

2. BDB.- Base de datos Berkeley. TST. Solo en MySQL MAX 3. INNODB.- TST, ACID, con posibilidad de commit, rollback, recuperación de

errores y bloqueo a nivel de fila. 4. MERGE mas que un tipo de tabla es la posibilidad de dividir tablas MYISAM de

gran tamaño (solo útil si son verdaderamente de GRAN tamaño) y hacer consultas sobre todas ellas con mayor rapidez. Las tablas deben ser myisam e idénticas en su estructura.

Con MySQL puedes variar el tipo de tabla después de creada:

TST se refiere a ‘Transactions safe tables’, o tablas para transacciones seguras. A este tipo pertenecen DBD y INNODB.

Las tablas tipo TST son menos rápidas y ocupan mas memoria, pero a cambio ofrecen mayor seguridad frente a fallos durante la consulta.

Aunque ya disponibles, imagino que las tablas TST solo se popularizarán cuando el uso de la versión 4.0 de MySQL se generalice (actualmente en fase gamma)

Las tablas TST permiten ir introduciendo consultas y finalizar con un COMMIT (que las ejecuta) o ROLLBACK (que ignora los cambios)

ACID es un acrónimo de atomicidad, consistencia, separacion (isolation) y durabilidad. Por atomicidad se quiere significar que son posibles consultas complejas tratadas como una sola, de tal forma que solo se ejecutan cuando todas ellas tienen éxito, en caso de que alguna falle no se ejecuta ninguna. Consistencia significa que solo datos válidos pueden ser escritos en la base de datos. Si se ejecuta una transacción que compromete la consistencia interna de la base de datos, toda la transacción debe deshacerse. Por isolation se entiende que las transacciones que tengan lugar simultaneamente deben ejecutarse aisladas unas de otras hasta que finalizan. Y durabilidad, la garantía de que una transacción enviada a la base de datos no se perderá aunque la transacción sea interrumpida por cualquier motivo.

2. ¿Como podemos hacer integridad referencial en mysql?

Podemos entender como Integridad Refencial a la propiedad, aplicada en las Bases de Datos, que nos garantiza que una Entidad (fila o registro) se relaciona con otra entidad que EXISTE en la Base de Datos. Nos aseguramos en todo momento que la información no esté repetida innecesariamente, que exita tal información, relaciones mal hechas…

3. ¿Que clientes graficos podemos encontrar para mysql?

4. ¿Como podemos hacer vacos, respaldos en mysl?

Hacer una copia de seguridad de las tablas y bases de datos MySQL

Cuando una base de datos crece, es importante hacer backups de forma regular. Hay varias formas de realizar un backup en MySQL, desde la linea de comandos (usando el comando mysqldump) o usando una aplicación externa como phpMyAdmin.

Hacer un backup con Linux

Si estamos en un servidor linux podemos ejecutar el siguiente código en la linea de comandos para realizar un backup

1. mysqldump –opt -u nombredeusuario -p basededatos tabla1 > archivodebackup

mysqldump --opt -u nombredeusuario -p basededatos tabla1 > archivodebackup

nombredeusuario: es el nombre del usuario que tiene permisos para acceder a la base de datos.basededatos: el nombre de la base de datos de la que queremos realizar el backup.tabla1: es un parámetro opcional necesario si queremos realizar el backup de sólo una tabla de la base de datos. Podemos escribir más tablas separadas por espacios en blanco. No es necesario especificar ninguna tabla si queremos hacer un respaldo de toda la base de datos.archivodebackup: es el nombre del archivo que contendrá el backup de la base de datos (la estructura de las tablas y los datos).

Una vez ejecutado este comando nos pedirá la password del usuario y se creará el archivo de backup en el directorio en el que nos encontramos.

Hacer un backup con Windows

Si queremos realizar una copia de seguridad desde entornos Windows, deberemos utilizar la linea de comandos (“cmd”). Para abrir la linea de comandos en Windows podemos ir al menú Inicio>Ejecutar, escribir cmd y pulsar enter). Se nos abrirá la linea de comandos de Windows. Ahora hemos de situarnos en la carpeta donde tenemos instalados los binarios de MySQL por ejemplo: c:\mysql\bin (esta ruta depende de dónde instalaste MYSQL) y escribimos el mismo comando que en linux:

1. mysqldump –opt -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

mysqldump --opt -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

Comprimir un backup en Linux

Podemos comprimir el archivo resultante de hacer el backup tras ejecutar el comando mysql dump. Por ejemplo:

1. mysqldump –opt -u nombredeusuario –password=clave basededatos > archivodebackup.sql

2. tar -cfv archivodebackup.sql.tar archivodebackup.sql 3. gzip archivodebackup.sql

mysqldump --opt -u nombredeusuario --password=clave basededatos > archivodebackup.sqltar -cfv archivodebackup.sql.tar archivodebackup.sqlgzip archivodebackup.sql

Backup de una base de datos InnoDB

Para una base de datos transaccional (de tipo InnoDB o BDB) y de gran tamaño, se puede utilizar este comando

1. mysqldump –opt -q –single-transaction -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

mysqldump --opt -q --single-transaction -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

El parámetro -q es útil para bases de datos de gran tamaño.

Backup con phpMyAdmin

phpMyAdmin es una aplicación para navegar a través de las tablas creadas en la base de datos mysql que te permite realizar muchas operaciones.

Es muy sencillo exportar tablas y bases de datos con esta aplicación. Una vez lo hayas instalado, puedes hacer click en la base de datos de la que quieras una copia de seguridad. En el menú de arriba puedes hacer click sobre EXPORT. Entrarás en una página donde podrás escoger el tipo de archivo en que quieres guardar el backup (txt,pdf,csv,etc) y después si quieres exportar sólamente la estructura de la tabla, sólo los datos o los dos. También hay la posibilidad de comprimir el archivo, útil para grandes bases de datos. Finalmente, presionas sobre el botón EXPORT del formulario y te podrás descargar el creado con todos los datos de tus tablas.

5. ¿Como recuperar la contraseña de root?

Usted puede recuperar la contraseña del servidor de base de datos MySQL con los siguientes pasos:

Paso 1: Detener cualquier proceso del servidor MySQL.Paso 2: Iniciar el proceso del servidor MySQL (mysqld) con la opción –skip-grant-tables por lo cual este no preguntará por la contraseña.Paso 3: Conectar al servidor MySQL como el usuario rootPaso 4: Configurar una nueva contraseña para la nueva contraseña rootPaso 5: Salir y reiniciar el servidor MySQL

A continuación están los comandos necesarios para cada uno de los pasos mencionados anteriormente (iniciar sesión como el usuario root):

Paso # 1: Detener el servicio mysql

# /etc/init.d/mysql stop

Salida:

Stopping MySQL database server: mysqld.

Paso # 2: Iniciar el servidor MySQL sin contraseña:

# mysqld_safe --skip-grant-tables

Salida:

[1] 5988

Iniciando el motor de mysqld de las bases de datos desde /var/lib/mysql

mysqld_safe[6025]: started

Paso # 3: Conectar al servidor mysql usando el cliente mysql:

# mysql -u root

Salida:

Bienvenido al monitor de MySQL. Comandos y con ; o \g.

Your MySQL connection id is 1 to server version: 5.0.21-log

Tipiar ‘help;’ o ‘\h’ para obtener ayuda. Tipiar ‘\c’ para en vaciar el buffer.

mysql>

Paso # 4: Configurar una nueva contraseña del servidor MySQL para el usuario root:

mysql> use mysql;mysql> update user set password=PASSWORD("NEW-ROOT-PASSWORD") where User='root';mysql> flush privileges;mysql> quit

Paso # 5: Detener el servidor MySQL:

# /etc/init.d/mysql stop

Salida:

Stopping MySQL database server: mysqld

STOPPING server from pid file /var/run/mysqld/mysqld.pid

mysqld_safe[6121]: ended

[1]+ Done mysqld_safe –skip-grant-tables

Paso # 6: Iniciar el servidor MySQL y verificar la contraseña:

# /etc/init.d/mysql start# mysql -u root -p

Bibliografia:

http://www.webtaller.com/construccion/lenguajes/mysql/lecciones/tipos_tablas_usadas_mysql.php

http://www.codigomaestro.com/mysql/recuperar-contrasena-root-de-mysql/

http://translate.google.com.mx/translate?hl=es&langpair=en%7Ces&u=http://www.databasejournal.com/features/mysql/article.php/2248101/Referential-Integrity-in-MySQL.htm

http://www.bibigeek.com/2009/08/30/crear-foreign-key-con-mysql/


Comandos: source y grant.


Introducción………………………………………………. 2Sentencia de administración de base de datos………… 5 Sentencias para la gestión de cuentas:……………. 5 Sintaxis de GRANT y REVOKE………….. 5Ejemplos del sentencia grant………………………….. 12Sentencia source……………………………………….. 14

———————————————————————————————-

Introducción

Seguridad de base de datos.

Conceptos de Seguridad

Cuentas

Estamos acostumbrados a que una cuenta de acceso a un sistema se componga de usuario y contraseña. Pero en MySQL tendremos que acostumbrarnos a añadir también el “host”, el ordenador desde el que se conecta el usuario.

Para MySQL, un usuario “juan” que se conecta desde la máquina “localhost”, es totalmente diferente de otro usuario “juan” que se conecta desde la máquina “united_crakers.com”. Y pueden tener distintos permisos de acceso.

¡OJO! Si una cuenta queda identificada por su usuario/clave/host, esto no incluye la base de datos. Es decir, que la cuenta juan/miclave/localhost tiene la misma clave de acceso ¡para todas las bases de datos del servidor! Pero que tenga la misma clave de acceso, no significa que tenga los mismos permisos.

Comprobaciones

Para cada conexión, MySQL realiza tres tipos de comprobaciones:

õ Autenticación

“Y tú ¿quién eres?” -

Para cada nueva conexión, MySQL comprueba la cuenta en base al nombre de usuario, la clave y el host de origen. Esta información determinará los privilegios del usuario.

õ Autorización

“¿Qué es lo que puedes hacer?” -

Para cada operación, MySQL comprueba que el usuario tiene permiso para realizarla. No es lo mismo tener permiso para cargar datos de un fichero (FILE) datos que para cerrar (SHUTDOWN) el servidor.

õ Control de Acceso

“¿A qué datos puedes acceder?” -

Para cada operación, MySQL comprueba que el usuario tiene permiso para ver o modificar las tablas y columnas involucradas.

Privilegios

En MySQL podemos utilizar dos tipos de privilegios: Privilegios sobre objetos de la base de datos (relacionados con el control de acceso) y Privilegios Globales (relacionados con la autorización).

õ Privilegios sobre Objetos

Cada cuenta de acceso puede tener privilegios distintos para los diferentes objetos del servidor.

Los objetos disponibles son:

● Bases de Datos

● Tablas

● Columnas

● Índices

Y, para cada uno de ellos, el usuario puede tener concedidos o denegados privilegios. Algunos de estos son: Select, Insert, Update, Index, Delete, Drop, Index, Alter, Create, Grant, References… También hay algunos nombres de permisos que agrupan a otros. Este es el caso de All y Usage. Ten en cuenta que los privilegios son booleanos. O se tienen o no se tienen.

No hay valores intermedios (no sé si lo tiene), ni numéricos (tiene un permiso de 3).

õ Globales

Para comprobar las autorizaciones de operación MySQL dispone de privilegios globales. Frente a los anteriores, que se aplican a objetos del servidor (datos), los privilegios globales se aplican a todo el servidor. Son los siguientes:

● Reload: Muy inofensivo, permite al usuario realizar FLUSH.

● Shutdown: Para cerrar el servidor.

● Process: Permite ver la lista de procesos (SHOW PROCESSLIST) y matar (KILL) sus procesos. El acceso a la lista de procesos permite verlos datos de las mismas, incluyendo las claves de acceso.

● File: Permite cargar datos de ficheros (LOAD DATA FILE).

● Super: Permite matar cualquier proceso (del servidor de base de datos), incluso los que no pertenezcan al usuario.

Tablas Involucradas

MySQL guarda la información de permisos en la base de datos “mysql”, en distintas tablas.

Son las siguientes:

õ user: Contiene los privilegios globales y las claves encriptadas. Es responsable de determinar que hosts y usuarios pueden conectarse al servidor.

õ host: Asigna privilegios por host, independientemente del usuario. No es modificada por los comandos de GRANT y REVOKE, así que hay que manejarla “a mano”.

õ db: Establece los privilegios para bases de datos.

õ tables_priv: Establece los privilegios para cada tabla. No suele ser utilizada.

õ columns_priv: Establece los privilegios para cada columna de cada tabla. No suele ser utilizada.

Aplicación

En primer lugar, MySQL comprueba la tabla user para decidir si acepta o no una determinada conexión.

Para cada consulta (de las conexiones aceptadas, obviamente), MySQL aplica los permisos “en cascada”.

Es decir, en primer lugar consulta la tabla user. Los permisos que ahí encuentra los “pasa” a la tabla a la tabla host. El resultado de esta, es pasado a db, de ahí a tables_priv y de ahí a columns_priv.

Los criterios de aplicación (matching) son distintos para cada tabla:

1. En user se utilizan host, user y password.

2. En host se utilizan host y db.

3. En db se utilizan user, host y db.

4. En tables_priv se utilizan user, host, db y table.

5. En columns_priv se utilizan user, host, db, table y column.

La aplicación de hosts es más específica. Como es posible utilizar comodines para esta regla (%9), podría ocurrir que varias entradas de la tabla cumplieran los criterios y, por lo tanto, sus permisos fueran aplicables. MySQL resuelve el problema estableciendo una regla de aplicación: las entradas más genéricas se aplicarán primero (menor preferencia).

Mantenimiento

Técnicamente es posible dar, quitar y modificar permisos, tanto sobre objetos como globales, accediendo a estas tablas y lanzando consultas (INSERT, UPDATE…). De hecho, muchos administradores lo hacen así.

Pero no es la forma recomendada.

Podría ocurrir que, en un futuro, se modificara la estructura de estas tablas. O podrías cometer un pequeño error, pasar por alto una relación, etc. Concón secuencias imprevisibles para la seguridad de tu servidor.

Sentencia de administración de base de datos

Sentencias para la gestión de cuentas:

Sintaxis de GRANT y REVOKE

Los comandos GRANT y REVOKE permiten a los administradores de sistemas crear cuentas de usuario

MySQL y darles permisos y quitarlos de las cuentas. La información de cuenta de MySQL se almacena en las tablas de la base de datos mysql.

Si las tablas de permisos tienen registros de permisos que contienen nombres de tablas o bases de datos con mayúsculas y minúsculas y la variable de sistema lower_case_table_names está activa, REVOKE no puede usarse para quitar los permisos. Es necesario manipular las tablas de permisos directamente. (GRANT no creará estos registros cuando está activo lower_case_table_names , pero tales registros pueden haberse creado préviamente a activar la variable.)

Los permisos pueden darse en varios niveles:

õ Nivel global

http://aby17ekbalam.blog.com/files/2010/05/Dibujo72.jpg


Los permisos globales se aplican a todas las bases de datos de un servidor dado. Estos permisos se almacenan en la tabla mysql.user. GRANT ALL ON *.* y REVOKE ALL ON *.* otorgan y quitan sólo permisos globales.

õ Nivel de base de datos

Los permisos de base de datos se aplican a todos los objetos en una base de datos dada. Estos permisos se almacenan en las tablas mysql.db y mysql.host . GRANT ALL ON db_name.* y REVOKE ALL ON db_name.* otorgan y quitan sólo permisos de bases de datos.

õ Nivel de tabla

Los permisos de tabla se aplican a todas las columnas en una tabla dada. Estos permisos se almacenan en la tabla mysql.tables_priv . GRANT ALL ON db_name.tbl_name y REVOKE ALL ON db_name.tbl_name otorgan y quian permisos sólo de tabla.

õ Nivel de columna

Los permisos de columna se aplican a columnas en una tabla dada. Estos permisos se almacenan en la tabla mysql.columns_priv . Usando REVOKE, debe especificar las mismas columnas que se otorgaron los permisos.

õ Nivel de rutina

Los permisos CREATE ROUTINE, ALTER ROUTINE, EXECUTE, y GRANT se aplican a rutinas almacenadas. Pueden darse a nivel global y de base de datos. Además, excepto para CREATE ROUTINE, estos permisos pueden darse en nivel de rutinas para rutinas individuales y se almacenan en la tabla mysql.procs_priv.

La cláusula object_type se añadió en MySQL 5.0.6. Debe especificarse como TABLE, FUNCTION, o PROCEDURE cuando el siguiente objeto es una tabla, una función almacenada, o un procedimiento almacenado. Para usar esta cláusula cuando actualice de una versión anterior de MySQL a la 5.0.6, debe actualizar las tablas de permisos.

Para usar GRANT o REVOKE, debe tener el permiso GRANT OPTION , y debe tener los permisos que está dando o quitando.

Para hacer fácil de quitar todos los permisos, MySQL 5.0 tiene la siguiente sintaxis, que borra todos los permisos globales, de nivel de base de datos y de nivel de tabla para los usuarios nombrados:

Para usar esta sintaxis REVOKE , debe tener el permiso CREATE USER global o el permiso UPDATE para la base de datos mysql.

Para los comandos GRANT y REVOKE , priv_type pueden especificarse como cualquiera de los siguientes:

El permiso EXECUTE no es operacional hasta MySQL 5.0.3. CREATE VIEW y SHOW VIEW se añadieron en MySQL 5.0.1. CREATE USER, CREATE ROUTINE, y ALTER ROUTINE se añadieron en MySQL 5.0.3. Para usar estos permisos al actualizar desde una versión anterior de MySQL que no los tenga, debe actualizar primero las tablas de permisos.

El permiso REFERENCES actualmente no se usa.

USAGE puede especificarse cuando quiere crear un usuario sin permisos.

Use SHOW GRANTS para determinar qué permisos tiene la cuenta.

Puede asignar permisos globales usando sintaxis ON *.* o permisos a nivel de base de datos usando la sintaxis ON db_name.*. Si especifica ON * y tiene seleccionada una base de datos por defecto, los permisos se dan en esa base de datos. (Atención: Si especifica ON * y no ha seleccionado una base de datos por defecto, los permisos dados son globales.).



Los permisos FILE, PROCESS, RELOAD, REPLICATION CLIENT, REPLICATION SLAVE, SHOW DATABASES, SHUTDOWN, y SUPER son permisos administrativos que sólo pueden darse globalmente (usando sintaxis ON *.* ).

Otros permisos pueden darse globalmente o a niveles más específicos.

Los únicos valores priv_type que puede especificar para una tabla son SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, GRANT OPTION, INDEX, y ALTER.

Los únicos valores priv_type que puede especificar para una columna (cuando usa la cláusula column_list ) son SELECT, INSERT, y UPDATE.

Los únicos valores priv_type que puede especificar a nivel de rutina son ALTER ROUTINE, EXECUTE, y GRANT OPTION. CREATE ROUTINE no es un permiso de nivel de rutina porque debe tener este permiso para ser capaz de crear una rutina en primer lugar.

Para el nivel global, base de datos, tabla y rutina, GRANT ALL asigna sólo los permisos que existen en el nivel que está otorgándolos. Por ejemplo, si usa GRANT ALL ON db_name.*, este es un comando de nivel de base de datos, así que ninguno de los permisos únicamente globales tales como FILE se otorgan.

MySQL le permite dar permisos incluso en objetos de bases de datos que no existen. En tales casos, los permisos a dar deben incluir el permiso CREATE . Este es el comportamiento diseñado, y se pretende permitir al administrador de la base de datos perparar cuentas de usuario y permisos para objetos de base de datos que se crearán posteriormente.

MySQL no elimina automáticamente nigún permiso si borra una tabla o base de datos. Si borra una rutina, se quita cualquier permiso dado a nivel de rutina para la misma.

Nota: los carácters comodín ‘_’ y ‘%’ se permiten al especificar nombres de base de datos en comandos GRANT que otorgan permisos a nivel global o de base de datos. Esto significa, por ejemplo, que si quiere usar un carácter ‘_’ como parte de un nombre de base de datos, debe especificarlo como ‘\_’ en el comando GRANT , para evitar que el usuario sea capaz de acceder a bases de datos adicionales que coincidan con el patrón de los comodines, por ejemplo GRANT … ON `foo\_bar`.* TO ….

Para acomodar los permisos a los usuarios de equipos arbitrários, MySQL soporta especificar el valor user con la forma user_name@host_name. Si un valor user_name o host_name es legal como identificador sin poner entre comillas, no necesita hacerlo. Sin embargo, las comillas son necesarias para especificar una cadena user_name conteniendo carácteres especiales (tales como ‘-’), o una cadena host_name conteniendo carácteres especiales o comodín (tales como ‘%’); por ejemplo, ‘test-user’@'test-hostname’. Entrecomille el nombre de usuario y de equipo separadamente.

Puede especificar carácteres comodín en el nombre de equipo. Por ejemplo, user_name@’%.loc.gov’ se aplica a user_name para cualquier equipo en el dominio loc.gov , y user_name@’144.155.166.%’ se aplica a user_name para cualquier equipo en la clase subred clase C 144.155.166 .

La forma simple user_name es sinónimo de user_name@’%’.

MySQL no soporta comodines en el nombre de usuario. Los usuarios anónimos se definen insertando entradas con User=” en la tabla mysql.user o creando un usuario con un nombre vacío con el comando GRANT :

Al especificar valores delimitados, use comillas simples para delimitar los nombres de bases de datos, tabla, columna y de rutina (‘`’). Para los nombres de equipo, nombres de usuario, y contraseñas como cadenas, use apóstrofes (”’).

Advertencia: Si permite conectar con el servidor a usuarios anónimos, debe dar permisos a todos los usuarios locales como user_name@localhost. De otro modo, la cuenta de usuario anónimo para localhost en la tabla mysql.user (creada durante la instalación de MySQL) se usa cuando los usuarioa con nombre intentan loguear con el servidor MySQL desde la máquina local.

Puede determinar si esto se aplica a su sistema ejecutando la siguiente consulta, que lista cualquier usuario anónimo:

Si quiere borrar la cuenta anónima local para evitar el problema descrito, use estos comandos:

GRANT soporta nombres de equipo de hasta 60 carácteres. Los nombres de bases de datos, tablas, columnas y rutinas pueden tener hasta 64 carácteres. Los nombres de usuario pueden tener hasta 16 carácteres. Los nombres de usuario pueden tener hasta 16 carácteres. Estos límites están harcodeados en el software MySQL y no pueden cambiarse alterando las tablas de permisos.

Los permisos para una tabla o columna se forman de forma aditiva como una OR lógica de los permisos en cada uno de los cuatro niveles de permisos. Por ejemplo, si la tabla mysql.user especifica que un usuario tiene un permiso SELECT global, el permiso no puede denegarse mediante una entrada en el nivel de base de datos, tabla o columna.




Los permisos de una columna pueden calcularse como sigue:

En la mayoría de casos, puede dar derecho a un usuario en sólo uno de los niveles de permisos, así que la vida normalmente no es tan complicada.

Si otorga permisos para una combinación usuario/equipo que no existe en la tabla mysql.user se añade una entrada que permite allí hasta que se borra con un comando DELETE. En otras palabras, GRANT puede crear entradas user pero REVOKE no los borra; debe hacerlo explícitamente usando DROP USER o DELETE.

Si se crea un nuevo usuario o si tiene permisos globales para otorgar permisos, la contraseña de usuario se cambia con la contraseña especificada por la cláusula IDENTIFIED BY , si se da una. Si el usuario ya tiene una contraseña, esta se reemplaza por la nueva.

Atención: Si crea un nuevo usuario pero no especifica una cláusula IDENTIFIED BY, el usuario no tiene contraseña. Esto es muy poco seguro. Desde MySQL 5.0.2, puede activar el modo SQL NO_AUTO_CREATE_USER para evitar que GRANT cree un nuevo usuario si lo hiciese de otro modo, a no ser que IDENTIFIED BY se de para proporcionar la nueva contraseña de usuario.

Las contraseñas pueden ponerse con el comando SET PASSWORD .

En la cláusula IDENTIFIED BY , la contraseña debe darse como el valor de contraseña literal. No es necesario usar la función PASSWORD() como lo es para el comando SET PASSWORD . Por ejemplo:

Si no quiere enviar la contraseña en texto plano y conoce el valor haseado que PASSWORD() retornaría para la contraseña, puede especificar el valor hasheado precedido por la palabra clave PASSWORD:

En un programa C , puede obtener el valor haseado usando la función make_ scrambled_password() de la API de C.

Si da permisos para una base de datos, se crea una entrada en la tabla mysql.db si es necesario. Si todos los permisos para la base de datos se eliminan con REVOKE, esta entrada se borra.




Si un usuario no tiene permisos para una tabla, el nombre de tabla no se muestra cuando el usuario pide una lista de talbas (por ejemplo, con el comando SHOW TABLES ).

El permiso SHOW DATABASES le permite a la cuenta ver nombres de bases de datos realizando el comando SHOW DATABASE . Las cuentas que no tienen este permiso sólo ven las bases de datos para las que tienen algún permiso, y no pueden usar el comando para nada si el servidor se arranca con la opción –skip-show-database.

La cláusula WITH GRANT OPTION le da al usuario la habilidad para dar a otros usuarios cualquier permiso que tenga el usuario en el nivel de permiso especificado. Debe tener cuidado de a quién da el permiso GRANT OPTION, ya que dos usuarios con permisos distintos pueden ser capaces de juntar permisos!

No puede dar a otro usuario un permiso que no tenga usted mismo; el permiso GRANT OPTION le permite asignar sólo los permisos que tenga usted.

Tenga en cuenta que cuando le da a un usuario el permiso GRANT OPTION a un nivel de permisos particular, cualquier permiso que tenga el usuario (o que se de en el futuro!) a este nivel también son otorgables por este usuario. Suponga que le da a un usuario el permiso INSERT en una base de datos.

Si otorga el permiso SELECT en la base de datos y especifica WITH GRANT OPTION, el usuario puede quitar no sólo el permiso SELECT sino también INSERT. Si luego otorga el permiso UPDATE al usuario en la base de datos, el usuario puede quitar INSERT, SELECT, y UPDATE.

No debe otorgar permisos ALTER a un usuario normal. Si lo hace, el usuario puede intentar engañar al sistema de permisos renombrando tablas!

Las opciones MAX_QUERIES_PER_HOUR count, MAX_UPDATES_PER_HOUR count, y MAX_CONNECTIONS_PER_HOUR count limitan el número de consultas, actualizaciones, y logueos que puede realizar un usuario durante cualquier período de una hora. Si count es 0 (por defecto), esto significa que no hay limitación para ese usuario.

La MAX_USER_CONNECTIONS count opción, implementada en MySQL 5.0.3, limita el máximo número de conexiones simultáneas que la cuenta puede hacer. Si count es 0 (por defecto), la max_user_connections variable de sistema determina el número de conexiones simultáneas para la cuenta.

Nota: para especificar cualquiera de estas opciones de limitación de recursos para un usuario existente sin afectar a los permisos existentes, use GRANT USAGE ON *.* … WITH MAX_….

MySQL puede chequear atributos certificados X509 además que la autenticación usual que se basa en el nombre de usuario y contraseña. Para especificar opciones relacionadas con SSL para la cuenta MySQL, use la cláusula REQUIRE del comando GRANT.

Hay distintas posibilidades para limitar tipos de conexión para una cuenta:

õ Si una cuenta no tiene requerimientos de SSL o X509, se permiten conexiones sin encriptar si la contraseña y nombre de usuario son válidos. Sin embargo, las conexiones no encriptadas pueden usarse en las opciones de cliente, si el cliente tiene los ficheros clave y de certificado apropiados.

õ La opción REQUIRE SSL le dice al servidor que permita sólo conexiones SSL encriptadas para la cuenta. Tenga en cuenta que esta opción puede omitirse si hay algunos registros de control de acceso que permitan conexiones no SSL.

õ REQUIRE X509 significa que el cliente debe tener un certificado válido pero que el certificador exacto y el asunto no importan. El único requerimiento que debe ser posible de verificar es la firma con uno de las AC certificadas.

õ REQUIRE ISSUER ‘issuer‘ crea una restricción de intentos de conexión en que el cliente debe presentar un certificado X509 válido presentado por la AC issuer. Si el cliente presenta un certificado válido pero de otra AC, el servidor rehúsa la conexión. El uso de certificados X509 siempre implica encripción, por lo que la opción SSL no es necesaria.

Tenga en cuenta que el valor ISSUER debe entrarse como una cadena única.

õ REQUIRE SUBJECT ‘subject‘ crea la restricción en los intentos de conexión de que el cliente debe presentar un certificado X509 válido con el asunto subject. Si el cliente presenta un certificado válido pero con un asunto distinto, el servidor rehúsa la conexión.

Tenga en cuenta que el valor SUBJECT debe entrarse como una única cadena.




õ REQUIRE CIPHER ‘cipher‘ se necesita para asegurar que se usan cifradores suficientemente fuertes y longitudes de claves acordes. SSL por sí mismo puede ser débil si se usan algoritmos antiguos con claves de encriptación cortas. Con esta opción, puede especificar el método de cifrado exacto para permitir una conexión.

Las opciones SUBJECT, ISSUER, y CIPHER pueden combinarse en la cláusula REQUIRE así:

Tenga en cuenta que los valores SUBJECT y ISSUER deben entrarse como una única cadena.

En MySQL 5.0, la palabra clave AND es opcional entre las opciones REQUIRE .

El orden de las opciones no importa, pero no puede especificarse ninguna opción dos veces.

Cuando mysqld arranca, todos los permisos se leen en memoria.

Tenga en cuenta que si usa permisos de tablas o de columnas para un usuario, el servidor examina los permisos de tablas y usuarios para todos los usuarios y esto ralentiza MySQL ligeramente. De forma similar, si limita el número de consultas, actualizaciones o conexiones para cualquier usuario, el servidor debe monitorizar estos valores.

Las mayores diferencias entre las versiones de GRANT de MySQL y SQL estándar son:

õ En MySQL, los permisos se asocian con una combinación de nombre de usuario/equipo y no sólo con el usuario.

õ SQL estándar no tienen permisos globales o a nivel de base de datos, ni soporta todos los tipos de permisos que soporta MySQL .

õ MySQL no soporta los permisos de SQL estándar TRIGGER o UNDER.



õ Los permisos de SQL estándar se estructuran de forma jerárquica. Si borra un usuario, todos los permisos que tuviera el usuario se eliminan. Esto es cierto a partir de MySQL 5.0.2 y si usa DROP USER.

õ En SQL estándar, cuando borra una tabla, todos los permisos para la tabla se eliminan. Con SQL estándar, cuando quita un permiso, todos los permisos otorgados basados en ese permiso también se eliminaban. En MySQL, los permisos sólo pueden borrarse con comandos REVOKE explícitos o manipulando las tablas de permisos de MySQL.

õ En MySQL, es posible tener el permiso INSERT sólo para algunas de las columnas en la tabla. En este caso, todavía puede ejecutar comandos INSERT en la tabla mientras omita esas columnas para las que no tiene el permiso INSERT . Las columnas omitidas obtienen su valor por defecto implícito si no está activado el modo SQL estricto. En modo estricto, el comando se rehúsa si algunas de las columnas omitidas no tienen valor por defecto.

Las columnas para las que no tiene el permiso INSERT se ponen a su valor por defecto. SQL estándar requiere que tenga el permiso INSERT en todas las columnas.

En MySQL, si tiene el permiso INSERT sólo en alguna de las columnas de la tabla, puede ejecutar comandos INSERT — mientras omita las columnas para las que no tiene el permiso de su comando INSERT; tales columnas obtendrán su valor por defecto. En modo estricto (cuando sql_mode=”traditional”), si alguna de las columnas omitidas no tiene valor por defecto, el comando INSERT se rehúsa.

Ejemplos de la utilización de este comando

En este ejemplo se muestra como visualizar los privilegios del usuario actual, y como crear usuario con la sintaxis create user +nombre del usuario identifiend by ‘contraseña’; estos usuarios que fueron creados con esta sintaxis no tendrán permisos ya que no le asigno porque es una sintaxis de creación de usuarios pero con las sentencia grant se le otorgara los permisos.

El comando show grants for +nombre del usuario; visualiza los privilegios del usuario.


IMPORTAR BASES DE DATOS MYSQL CON EL COMANDO SOURCE.

Después de haber generado un archivo .sql con toda la información de las bases de datos de mi instalación de linux anterior, intenté restaurar a través de phpmyadmin pero no me lo permitía por el tamaño del archivo (hay formas de hacerlo, pero no es el tema de este post). Una forma alternativa de hacerlo es utilizando el comando source de MySQL desde consola, que por lo que noté no considera limitantes de tamaño en el archivo a importar.

Para usarlo:

$ mysql -u root -p$ Enter password:mysql > source archivo.sql

Hay que tener mucho cuidado en revisar bajo que código de caracteres se almacenó el archivo y bajo cual estaban almacenadas las bases de datos en la instalación que se respaldo, en mi caso tuve un problema al importar como les acabo de mostrar, ya que muchos acentos desaparecieron, para resovlerlo tenemos que entrar a MySQL de la siguiente forma:



$mysql –default-character-set=utf8 -u root -p$Enter password:mysql > souce archivo.sql

Con el parámetro –default-character-set podemos establecer el código de caractér deseado sin perder información o almacenarla de manera errónea.

———————————————————————————————-

mysql>source c:/ruta/script;

… irá perfecto. Pero mi pregunta es… No existe forma alguna de darle la ruta por una variable, o en el my.ini. Así nos ahorramos escribir toda la ruta del script y sólo pondríamos…

mysql>source script;

porque el servidor ya sabrá dónde tiene que buscar el

archivo. Un ejemplo…

Sabemos que existen estos directorios de configuración…

basedir=C:/MySQL/MySQLServer4.1/ # la ruta base de instalación

datadir=C:/MySQL/MySQLServer4.1/Data/ # la ruta donde se guardan los datos de la BD

Lo que intento hacer es crear otro directorio de configuración tal que…

scriptdir=C:/Scripts/ donde se busquen automáticamente los archivos de script


Stored Procedure (Procedimientos Almacenados) y Triggers (Disparadores).


Índice

Stored Procedure (Procedimientos Almacenados)……………………………..

2

Implementación………………………………………………………………… 2Ejecución………………………………………………………………………. 2

Usos…………………………………………………………………………… 2Ventajas y desventajas………………………………………………………….. 2Diferencias entre Motores. Características de los procedimientos almacenados…….

3

Procedimientos almacenados en Mysql…………………………………………

4

Procedimientos almacenados y funciones………………………………………..

4

Procedimientos almacenados y las tablas de permisos……………………. 4Sintaxis de procedimientos almacenados………………………………… 4CREATE PROCEDURE y CREATE FUNCTION………………. 5ALTER PROCEDURE y ALTER FUNCTION………………………… 7DROP PROCEDURE y DROP FUNCTION…………………….. 8SHOW CREATE PROCEDURE y SHOW CREATE FUNCTION.. 8SHOW PROCEDURE STATUS y SHOW FUNCTION STATUS… 8La sentencia CALL……………………………………………… 8Sentencia compuesta BEGIN …END……………………………. 9Sentencia DECLARE …………………………………………… 9Variables en procedimientos almacenados……………………….. 9 Conditions and Handlers……………………………………….. 10Cursores………………………………………………………… 11Constructores de control de flujo………………………………… 12Triggers……………………………………………………………………….. 15Relación-Diferencia con los Stored Procedure……………………………………

15

La estructura básica de un trigger………………………………………………..

15

Tipos de triggers según la cantidad de ejecuciones que realizan……………………

15

Diferencias entre motores………………………………………………………. 15Los Errores de integridad referencial…………………………………………….

16

Disparadores en Mysql…………………………………………………………

16

Disparadores (triggers)…………………………………………………………..16 Sintaxis de CREATE TRIGGER………………………………………..

16

Sintaxis de DROP TRIGGER…………………………………………….

18

Utilización de disparadores………………………………………………

18

——————————————————————————————————————————————————————Stored Procedure (Procedimientos Almacenados)

Un Stored Procedure o Procedimiento Almacenado es un programa (o función) que se almacena físicamente en una base de datos. La implementación de un stored procedure varía de un gestor de bases de datos a otro. En la mayoría de los casos, no obstante, los stored procedures permiten definir una API (capa de abstracción) para que el gestor de bases de datos interactúe con tablas u otros objetos de la base de datos, en vez de tener un cliente de la aplicación interactuando directamente.

Implementación

Los Stored procedures se usan a menudo para realizar consultas SQL, insertar, actualizar o eliminar registros sobre los objetos de la base de datos de una manera transparente, desde el punto de vista del cliente de la aplicación. Un Stored Procedure, permite agrupar en forma exclusiva parte de una tarea específica que se desee realizar o mejor dicho el SQL apropiado para dicha acción.

Son implementados desde la aplicación mediante CALL procedure (…).

Pueden devolver un conjunto de resultados, es decir, los resultados de un comando SELECT y dichos conjuntos de resultados pueden ser procesados por otros procedimientos almacenados utilizando cursores.

Los Procedimientos Almacenados también pueden contener variables declaradas para el procesamiento de los datos y cursores, que le permiten a los bucles actuar sobre las múltiples filas de una tabla.

Ejecución

Los Procedimientos almacenados se ejecutan directamente en el servidor de base de datos.

Usos

Un uso común es el encapsulamiento de un API para un proceso complejo o que podría requerir la ejecución de varias consultas SQL, tales como la manipulación de un gran conjunto de datos para producir un resultado resumido.

También pueden ser usados para el control de gestión de operaciones, y ejecutar procedimientos almacenados dentro de una transacción de tal manera que las transacciones sean efectivamente transparentes para ellos.

Cuando los procedimientos almacenados se aplican en la validación de datos, y el control de la integridad dentro de la estructura de la base de datos se ejecutan a través de los denominados “triggers” que se describen más adelante.

Ventajas y desventajas

1. 1. Simplificación de la Gestión

Los Procedimientos almacenados pueden permitir que la lógica del negocio se encuentre como una API en la base de datos, que puede simplificar la gestión de datos y reducir la necesidad de codificar la lógica en el resto de los programas cliente.

1. 2. Seguridad

Es mucho mejor usar Stored procedure por seguridad. Los procedimientos almacenados facilitan algunas tareas de administración de seguridad y asignación de permisos.

1. 3. Centralización de la definición

Al formar parte de la base de datos los procedimientos almacenados están en un lugar centralizado y pueden ser ejecutados por cualquier aplicación que tenga acceso a la misma.

4. Reducción del tráfico de red

una sentencia formada por decenas, cientos o incluso miles de líneas de código SQL puede escribirse como un procedimiento almacenado en el servidor y ejecutarse simplemente mediante el nombre de dicho procedimiento, en lugar de enviar todas las líneas de código por la red desde el cliente hasta el servidor

1. 5. Encapsulamiento

Los procedimientos almacenados encapsulan gran parte de la lógica del negocio a las aplicaciones que los utilizan.

1. 6. Ejecución centralizada en el Servidor

Esta ejecución puede verse como una ventaja o desventaja dependiendo de los recursos con los que se cuenta.

La ventaja es que cuando está en acción, en respuesta a una petición de usuario, el procedimiento almacenado corre directamente bajo el control del motor de bases de datos, generalmente en un servidor separado aumentando con ello, generalmente, la rapidez del procesamiento del requerimiento.

1. 7. Reducción de la escalabilidad

los procedimientos almacenados nos esclavizan al motor de base de datos. Para migrar de un gestor de base de datos con muchos procedimientos almacenados a otro, se deberá reescribir casi la totalidad de los mismos.

Diferencias entre Motores. Características de los procedimientos almacenados

Sybase y SQL Server de Microsoft: Pueden entregar varias filas, pero no soportan cursores. Deben usar Transact-SQL, un lenguaje procedimental propietario, para

crearlos, que se compilan en un solo paso y se guardan en el catálogo. Se llaman con el comando EXECUTE de SQL y pasando a éste el nombre del procedimiento y del servidor en el que se halla.

ORACLE: Entregan una sola fila, pero sí soportan cursores. Deben usar PL/SQL, un lenguaje procedimental propietario. Son llamados anteponiendo al nombre del procedimiento o de la función un link a la base de datos que apunte al servidor remoto.

DB2/UDB de IBM: Esta familia los implementa como funciones DLL (dynamic link libraries, bibliotecas de enlace dinámico) o de las bibliotecas compartidas escritas en lenguajes de programación comunes. Además, es posible escribirlos como clases Java.

Se alojan en el mismo servidor que la base de datos, pero no se guardan dentro de ella.

No es necesario que las aplicaciones Cliente que llaman a los procedimientos almacenados de DB2 sepan qué lenguaje se empleó para escribir el código del procedimiento.

Soporta tipos de datos definidos por el usuario, como en SQL3, denominados complementos (extenders). Se puede usar estos tipos de datos abstractos para extender la base de datos con funciones y tipos nuevos. Actualmente IBM ofrece complementos para texto, imagen, audio, video y huellas digitales. Los DBA y terceros pueden agregar sus propios complementos.

Informix: Proporciona un lenguaje (Store Procedure Lenguage) que no permite que las transacciones compartan procedimientos almacenados. Soporta procedimientos basados en Java: también soporta cuchillas de datos (DataBlades) que permiten extender la base de datos con tipos de objetos propios.

MySql: Los cursores del lado del servidor están implementados a partir de MySQL 5.0.2 a través de la función de la API de C mysql_stmt_attr_set(). Un cursor del lado del servidor permite a un resultado ser generado del lado del servidor, pero no transmitido al cliente excepto para aquellos registros que el cliente solicite. Por ejemplo, si un cliente ejecuta una consulta pero de ésta sólo le interesa el primer registro, los registros sobrantes no son transferidos.

Los cursores son de sólo lectura; no puede usar un cursor para actualizar registros. Los cursores no son nombrados. El proceso de la sentencia actúa como el ID del cursor.

Procedimientos almacenados en Mysql

procedimientos almacenados y Funciones

Los procedimientos almacenados y funciones son nuevas funcionalidades de la versión de MySQL 5.0. Un procedimiento almacenado es un conjunto de comandos SQL que pueden almacenarse en el servidor. Una vez que se hace, los clientes no necesitan relanzar los comandos individuales pero pueden en su lugar referirse al procedimiento almacenado.

Algunas situaciones en que los procedimientos almacenados pueden ser particularmente útiles:

Cuando múltiples aplicaciones cliente se escriben en distintos lenguajes o funcionan en distintas plataformas, pero necesitan realizar la misma operación en la base de datos.

Cuando la seguridad es muy importante. Los bancos, por ejemplo, usan procedimientos almacenados para todas las operaciones comunes. Esto proporciona un entorno seguro y consistente, y los procedimientos pueden asegurar que cada operación se loguea apropiadamente.

Los procedimientos almacenados pueden mejorar el rendimiento ya que se necesita enviar menos información entre el servidor y el cliente. El intercambio que hay es que aumenta la carga del servidor de la base de datos ya que la mayoría del trabajo se realiza en la parte del servidor y no en el cliente.

Los procedimientos almacenados le permiten tener bibliotecas o funciones en el servidor de base de datos. Esta característica es compartida por los lenguajes de programación modernos que permiten este diseño interno, por ejemplo, usando clases. Usando estas características del lenguaje de programación cliente es beneficioso para el programador incluso fuera del entorno de la base de datos.

Procedimientos almacenados y las tablas de Permisos

Los procedimientos almacenados requieren la tabla proc en la base de datos mysql. Si está actualizando a MySQL 5.0 desde una versión anterior, asegúrese de actualizar sus tablas de permisos para asegurar que la tabla proc existe.

Desde MySQL 5.0.3, el sistema de permisos se ha modificado para tener en cuenta los procedimientos almacenados como sigue:

El permiso CREATE ROUTINE se necesita para crear procedimientos almacenados.

El permiso ALTER ROUTINE se necesita para alterar o borrar procedimientos almacenados.

Este permiso se da automáticamente al creador de una rutina.

El permiso EXECUTE se requiere para ejectuar procedimientos almacenados. Sin embargo, este permiso se da automáticamente al creador de la rutina. También, la característica SQL SECURITY por defecto para una rutina es DEFINER, lo que permite a los usuarios que tienen acceso a la base de datos ejecutar la rutina asociada.

Sintaxis de procedimientos almacenados

Los procedimientos almacenados y rutinas se crean con comandos CREATE PROCEDURE y CREATE FUNCTION. Una rutina es un procedimiento o una función. Un procedimiento se invoca usando un comando CALL, y sólo puede pasar valores usando variables de salida. Una función puede llamarse desde dentro de un comando como cualquier otra función (esto es, invocando el nombre de la función), y puede retornar un valor escalar. Las rutinas almacenadas pueden llamar otras rutinas almacenadas.

Esto tiene varias implicaciones:

Cuando se invoca la rutina, se realiza implícitamente USE db_name ( y se deshace cuando acaba la rutina). Los comandos USE dentro de procedimientos almacenados no se permiten.

Puede calificar los nombres de rutina con el nombre de la base de datos. Esto puede usarse para referirse a una rutina que no esté en la base de datos actual. Por ejemplo, para invocar procedimientos almacenados p o funciones f esto se asocia con la base de datos test , puede decir CALL test.p() o test.f().

Cuando se borra una base de datos, todos los procedimientos almacenados asociados con ella también se borran.

La siguiente sección describe la sintaxis usada para crear, alterar, borrar, y consultar procedimientos almacenados y funciones.

Estos comandos crean una rutina almacenada. Para crear una rutina, es necesario tener el permiso CREATE ROUTINE , y los permisos ALTER ROUTINE y EXECUTE se asignan automáticamente a su creador. Si se permite logueo binario necesita también el permisos.

Por defecto, la rutina se asocia con la base de datos actual. Para asociar la rutina explícitamente con una base de datos, especifique el nombre como db_name.sp_name al crearlo.

http://aby17ekbalam.blog.com/files/2010/05/imagen1.png


Si el nombre de rutina es el mismo que el nombre de una función de SQL, necesita usar un espacio entre el nombre y el siguiente paréntesis al definir la rutina, o hay un error de sintaxis. Esto también es cierto cuando invoca la rutina posteriormente.

La cláusula RETURNS puede especificarse sólo con FUNCTION, donde es obligatorio. Se usa para indicar el tipo de retorno de la función, y el cuerpo de la función debe contener un comando RETURN value.

La lista de parámetros entre paréntesis debe estar siempre presente. Si no hay parámetros, se debe usar una lista de parámetros vacía () . Cada parámetro es un parámetro IN por defecto. Para especificar otro tipo de parámetro, use la palabra clave OUT o INOUT antes del nombre del parámetro. Especificando IN, OUT, o INOUT sólo es válido para una PROCEDURE.

El comando CREATE FUNCTION se usa en versiones anteriores de MySQL para soportar UDFs (User Defined Functions) (Funciones Definidas por el Usuario). UDFs se soportan, incluso con la existencia de procedimientos almacenados. Un UDF puede tratarse como una función almacenada externa. Sin embargo, tenga en cuenta que los procedimientos almacenados comparten su espacio de nombres con UDFs.

Un marco para procedimientos almacenados externos se introducirá en el futuro. Esto permitirá escribir procedimientos almacenados en lenguajes distintos a SQL. Uno de los primeros lenguajes a soportar será PHP ya que el motor central de PHP es pequeño, con flujos seguros y puede empotrarse fácilmente. Como el marco es público, se espera soportar muchos otros lenguajes.

Un procedimiento o función se considera “determinista” si siempre produce el mismo resultado para los mismos parámetros de entrada, y “no determinista” en cualquier otro caso. Si no se da ni DETERMINISTIC ni NOT DETERMINISTIC por defecto es NOT DETERMINISTIC.

Para replicación, use la función NOW() (o su sinónimo) o RAND() no hace una rutina no determinista necesariamente. Para NOW(), el log binario incluye el tiempo y hora y replica correctamente. RAN() también replica correctamente mientras se invoque sólo una vez dentro de una rutina. (Puede considerar el tiempo y hora de ejecución de la rutina y una semilla de número aleatorio como entradas implícitas que son idénticas en el maestro y el esclavo.)

Actualmente, la característica DETERMINISTIC se acepta, pero no la usa el optimizador. Sin embargo, si se permite el logueo binario, esta característica afecta si MySQL acepta definición de rutinas.

Varias características proporcionan información sobre la naturaleza de los datos usados por la rutina. CONTAINS SQL indica que la rutina no contiene comandos que leen o escriben datos. NO SQL indica que la rutina no contiene comandos SQL . READS SQL DATA indica que la rutina contiene comandos que leen datos, pero no comandos que escriben datos. MODIFIES SQL DATA indica que la rutina contiene comandos que pueden escribir

datos. CONTAINS SQL es el valor por defecto si no se dan explícitamente ninguna de estas características.

La característica SQL SECURITY puede usarse para especificar si la rutina debe ser ejecutada usando los permisos del usuario que crea la rutina o el usuario que la invoca. El valor por defecto es DEFINER. Esta característica es nueva en SQL:2003. El creador o el invocador deben tener permisos para acceder a la base de datos con la que la rutina está asociada. Desde MySQL 5.0.3, es necesario tener el permiso EXECUTE para ser capaz de ejecutar la rutina. El usuario que debe tener este permiso es el definidor o el invocador, en función de cómo la característica SQL SECURITY.

MySQL almacena la variable de sistema sql_mode que está en efecto cuando se crea la rutina, y siempre ejecuta la rutina con esta inicialización.

La cláusula COMMENT es una extensión de MySQL, y puede usarse para describir el procedimiento almacenado. Esta información se muestra con los comandos SHOW CREATE PROCEDURE y SHOW CREATE FUNCTION .

MySQL permite a las rutinas que contengan comandos DDL (tales como CREATE y DROP) y comandos de transacción SQL (como COMMIT). Esto no lo requiere el estándar, y por lo tanto, es específico de la implementación.

Los procedimientos almacenados no pueden usar LOAD DATA INFILE.

Nota: Actualmente, los procedimientos almacenados creados con CREATE FUNCTION no pueden tener referencias a tablas. (Esto puede incluir algunos comandos SET que pueden contener referencias a tablas, por ejemplo SET a:= (SELECT MAX(id) FROM t), y por otra parte no pueden contener comandos SELECT , por ejemplo SELECT ‘Hello world!’ INTO var1.) Esta limitación se elminará en breve.

Los comandos que retornan un conjunto de resultados no pueden usarse desde una función almacenada. Esto incluye comandos SELECT que no usan INTO para tratar valores de columnas en variables, comandos SHOW y otros comandos como EXPLAIN. Para comandos que pueden determinarse al definir la función para que retornen un conjunto de resultados, aparece un mensaje de error Not allowed to return a result set from a function (ER_SP_NO_RETSET_IN_FUNC). Para comandos que puede determinarse sólo en tiempo de ejecución si retornan un conjunto de resultados, aparece el error PROCEDURE %s can’t return a result set in the given context (ER_SP_BADSELECT).

El siguiente es un ejemplo de un procedimiento almacenado que use un parámetro OUT . El ejemplo usa el cliente mysql y el comando delimiter para cambiar el delimitador del comando de ; a / / mientras se define el procedimiento . Esto permite pasar el delimitador; usado en el cuerpo del procedimiento a través del servidor en lugar de ser interpretado por el mismo mysql.

Al usar el comando delimiter, debe evitar el uso de la antibarra (‘\’) ya que es el carácter de escape de MySQL.

El siguiente es un ejemplo de función que toma un parámetro, realiza una operación con una función SQL, y retorna el resultado:

Si el comando RETURN en un procedimiento almacenado retorna un valor con un tipo distinto al especificado en la cláusula RETURNS de la función, el valor de retorno se coherciona al tipo apropiado. Por ejemplo, si una función retorna un valor ENUM o SET, pero el comando RETURN retorna un entero, el valor retornado por la función es la cadena para el mienbro de ENUM correspondiente de un comjunto de miembros SET.

ALTER PROCEDURE y ALTER FUNCTION

Este comando puede usarse para cambiar las características de un procedimiento o función almacenada. Debe tener el permiso ALTER ROUTINE para la rutina desde MySQL. El permiso se otorga automáticamente al creador de la rutina. Si está activado el logueo binario, necesitará el permiso SUPER.

Pueden especificarse varios cambios con ALTER PROCEDURE o ALTER FUNCTION.

DROP PROCEDURE y DROP FUNCTION




Este comando se usa para borrar un procedimiento o función almacenada. Esto es, la rutina especificada se borra del servidor. Debe tener el permiso ALTER ROUTINE para las rutinas desde MySQL. Este permiso se otorga automáticamente al creador de la rutina.

La cláusula IF EXISTS es una extensión de MySQL . Evita que ocurra un error si la función o procedimiento no existe. Se genera una advertencia que puede verse con SHOW WARNINGS.

SHOW CREATE PROCEDURE y SHOW CREATE FUNCTION

Este comando es una extensión de MySQL . Similar a SHOW CREATE TABLE, retorna la cadena exacta que puede usarse para recrear la rutina nombrada.

SHOW PROCEDURE STATUS y SHOW FUNCTION STATUS

Este comando es una extensión de MySQL . Retorna características de rutinas, como el nombre de la base de datos, nombre, tipo, creador y fechas de creación y modificación. Si no se especifica un patrón, le lista la información para todos los procedimientos almacenados, en función del comando que use.

También puede obtener información de rutinas almacenadas de la tabla ROUTINES en INFORMATION_ SCHEMA. Consulte Sección 22.1.14, “La tabla INFORMATION_SCHEMA ROUTINES”.

La sentencia CALL






El comando CALL invoca un procedimiento definido préviamente con CREATE PROCEDURE.

CALL puede pasar valores al llamador usando parámetros declarados como OUT o INOUT . También “retorna” el número de registros afectados, que con un programa cliente puede obtenerse a nivel SQL llamando la función ROW_COUNT() y desde C llamando la función de la API C mysql_affected_rows() .

Los procedimientos almacenados pueden contener varios comandos, usnado un comando compuesto BEGIN … END .

Un comando compuesto puede etiquetarse. end_label no puede darse a no ser que también esté presente begin_label , y si ambos lo están, deben ser el mismo.

Tenga en cuenta que la cláusula opcional [NOT] ATOMIC no está soportada. Esto significa que no hay un punto transaccional al inicio del bloque de instrucciones y la cláusula BEGIN usada en este contexto no tiene efecto en la transacción actual.

Usar múltiples comandos requiere que el cliente sea capaz de enviar cadenas de consultas con el delimitador de comando ;. Esto se trata en el cliente de línea de comandos mysql con el comando delimiter. Cambiar el delimitador de final de consulta ; end-of-query (por ejemplo, a //) permite usar ; en el cuerpo de la rutina.

Sentencia DECLARE

El comando DECLARE se usa para definir varios iconos locales de una rutina: las variables locales y cursores. Los comandos SIGNAL y RESIGNAL no se soportan en la actualidad. DECLARE puede usarse sólo dentro de comandos compuestos BEGIN … END y deben ser su inicio, antes de cualquier otro comando.

Los cursores deben declararse antes de declarar los handlers, y las variables y condiciones deben declararse antes de declarar los cursores o handlers.

Variables en procedimientos almacenados

Pude declarar y usar una variable dentro de una rutina.

Declarar variables locales con DECLARE



Este comando se usa para declarar variables locales. Para proporcionar un valor por defecto para la variable, incluya una cláusula DEFAULT . El valor puede especificarse como expresión, no necesita ser una constante. Si la cláusula DEFAULT no está presente, el valor inicial es NULL.

La visibilidad de una variable local es dentro del bloque BEGIN … END donde está declarado.

Puede usarse en bloques anidados excepto aquéllos que declaren una variable con el mismo nombre.

Sentencia SET para variables

El comando SET en procedimientos almacenados es una versión extendida del comando general SET. Las variables referenciadas pueden ser las declaradas dentro de una rutina, o variables de servidor globales.

El comando SET en procedimientos almacenados se implemnta como parte de la sintaxis SET preexistente. Esto permite una sintaxis extendida de SET a=x, b=y, … donde distintos tipos de variables (variables declaradas local y globalmente y variables de sesión del servidor) pueden mezclarse.

Esto permite combinaciones de variables locales y algunas opciones que tienen sentido sólo para variables de sistema; en tal caso, las opciones se reconocen pero se ignoran.

La sentencia SELECT … INTO

Esta sintaxis SELECT almacena columnas seleccionadas directamente en variables. Por lo tanto, sólo un

registro puede retornarse.

Conditions and Handlers

Ciertas condiciones pueden requerir un tratamiento específico. Estas condiciones pueden estar relacionadas con errores, así como control de flujo general dentro de una rutina.

Condiciones DECLARE



http://aby17ekbalam.blog.com/files/2010/05/a.png

Este comando especifica condiciones que necesitan tratamiento específico. Asocia un nombre con una condición de error específica. El nombre puede usarse subsecuentemente en un comando DECLARE

HANDLER.

Además de valores SQLSTATE , los códigos de error MySQL se soportan.

DECLARE handlers

Este comando especifica handlers que pueden tratar una o varias condiciones. Si una de estas condiciones ocurre, el comando especificado se ejecuta.

Para un handler CONTINUE , continúa la rutina actual tras la ejecución del comando del handler.

Para un handler EXIT , termina la ejecución del comando compuesto BEGIN…END actual. El handler de tipo UNDO todavía no se soporta.

SQLWARNING es una abreviación para todos los códigos SQLSTATE que comienzan con 01.

NOT FOUND es una abreviación para todos los códigos SQLSTATE que comienzan con 02.

SQLEXCEPTION es una abreviación para todos los códigos SQLSTATE no tratados por SQLWARNING o NOT FOUND.

Además de los valores SQLSTATE , los códigos de error MySQL se soportan.

Por ejemplo:

http://aby17ekbalam.blog.com/files/2010/05/a3.png


Tenga en cuenta que @x es 3, lo que muestra que MySQL se ha ejecutado al final del procedimiento.

Si la línea DECLARE CONTINUE HANDLER FOR SQLSTATE ’23000′ SET @x2 = 1; no está presente, MySQL habría tomado la ruta por defecto (EXIT) tras el segundo INSERT fallido debido a la restricción PRIMARY KEY , y SELECT @x habría retornado 2.

Cursores

Se soportan cursores simples dentro de procedimientos y funciones almacenadas. La sintaxis es la de SQL empotrado. Los cursores no son sensibles, son de sólo lectura, y no permiten scrolling. No sensible significa que el servidor puede o no hacer una copia de su tabla de resultados.

Los cursores deben declararse antes de declarar los handlers, y las variables y condiciones deben declararse antes de declarar cursores o handlers.

Por ejemplo:


Declarar cursores

Este comando declara un cursor. Pueden definirse varios cursores en una rutina, pero cada cursor en un bloque debe tener un nombre único.

El comando SELECT no puede tener una cláusula INTO.

Sentencia OPEN del cursor

Este comando abre un cursor declarado préviamente.

Sentencia de cursor FETCH

Este comando trata el siguiente registro (si existe) usando el cursor abierto especificado, y avanza el puntero del cursor

Sentencia de cursor CLOSE

Este comando cierra un cursor abierto préviamente.






Si no se cierra explícitamente, un cursor se cierra al final del comando compuesto en que se declara.

Constructores de control de flujo

Los constructores IF, CASE, LOOP, WHILE, ITERATE, y LEAVE están completamente implementados.

Estos constructores pueden contener un comando simple, o un bloque de comandos usando el comando compuesto BEGIN … END. Los constructores pueden estar anidados.

Los bucles FOR no están soportados.

Sentencia IF

IF implementa un constructor condicional básico. Si search_condition se evalúa a cierto, el comando SQL correspondiente listado se ejectua. Si no coincide ninguna search_condition se ejecuta el comando listado en la cláusula ELSE. statement_list puede consistir en varios comandos.

Tenga en cuenta que también hay una función IF(), que difiere del commando IF descrito aquí.

La sentencia CASE

El comando CASE para procedimientos almacenados implementa un constructor condicional complejo.



Si una search_condition se evalúa a cierto, el comando SQL correspondiente se ejecuta.

Si no coincide ninguna condición de búsqueda, el comando en la cláusula ELSE se ejecuta.

Nota: La sitaxis de un comando CASE mostrado aquí para uso dentro de procedimientos almacenados difiere ligeramente de la expresión CASE SQL descrita. El comando CASE no puede tener una cláusula ELSE NULL y termina con END CASE en lugar de END.

Sentencia LOOP

LOOP implementa un constructor de bucle simple que permite ejecución repetida de comandos particulares. El comando dentro del bucle se repite hasta que acaba el bucle, usualmente con un comando LEAVE. Un comando LOOP puede etiquetarse. end_label no puede darse hasta que esté presente begin_label, y si ambos lo están, deben ser el mismo.

Sentencia LEAVE

Este comando se usa para abandonar cualquier control de flujo etiquetado. Puede usarse con BEGIN… END o bucles.

La setencia ITERATE

ITERATE sólo puede aparecer en comandos LOOP, REPEAT, y WHILE . ITERATE significa “vuelve a hacer el bucle.”

Por ejemplo:




Sentencia REPEAT

El comando/s dentro de un comando REPEAT se repite hasta que la condición search_condition es cierta.

Un comando REPEAT puede etiquetarse. end_label no puede darse a no ser que begin_label esté presente, y si lo están, deben ser el mismo.

Por ejemplo:

Sentencia WHILE





Triggers

Un Trigger es una porción de código que se “dispara” al ocurrir un evento, es decir que sejecuta cuando se cumple una condición establecida al realizar una operación de inserción (INSERT), actualización (UPDATE) o borrado (DELETE).

Son usados para mejorar la administración de la Base de datos, sin necesidad de contar con el usuario para que ejecute una sentencia de SQL. Además, pueden generar valores de columnas, prevenir errores de datos, sincronizar tablas, modificar valores de una vista, etc.

Permiten implementar programas basados en paradigma lógico (sistemas expertos, deducción).

Suelen ser implementados para realizar tareas relacionadas con cambios en las tablas; como auditorías, búsqueda de límites de los valores, o establecimiento de valores por omisión en columnas.

Relación-Diferencia con los Stored Procedure:

Los eventos que tienen origen en la base de datos llaman de manera implícita al trigger, en tanto que son aplicaciones cliente las que inician de manera explícita a los procedimientos almacenados.

Las implementaciones de servidor de los triggers son muy pocos estándares; más bien son específicas de cada fabricante.

La estructura básica de un trigger es:

Llamada de activación: es la sentencia que permite “disparar” el código a ejecutar.

Restricción: es la condición necesaria para ejecutar el código. Esta restricción puede ser de tipo condicional o de tipo nulidad.

Acción a ejecutar: es la secuencia de instrucciones a ejecutar una vez que se han cumplido las condiciones iníciales.

Existen dos tipos de triggers según la cantidad de ejecuciones que realizan:

õ Row Triggers (o Triggers de fila): son aquellos que se ejecutarán n-veces si se llama n veces desde la tabla asociada al trigger

õ Statement Triggers (o Triggers de secuencia): son aquellos que, sin importar la cantidad de veces que se cumpla con la condición, su ejecución es única.

Pueden ser de sesión y almacenados.

Diferencias entre motores:

õ Sybase: Soporta sólo un trigger por operación de inserción, actualización o eliminación.

õ SQL Server de Microsoft: Soporta un máximo de 3 triggers por tabla. Cada uno de ellos puede llamar hasta 16 procedimientos almacenados.

õ Ingress: Soporta varios triggers pero su ejecución no es determinística.

õ Oracle: soporta hasta 12 triggers por tabla: lo hace permitiendo especificar lo siguiente por cada comando de operación: se dispara un trigger previo antes de que se ejecute el comando de SQL y otro posterior después de la ejecución. Además, Oracle permite indicar el número de veces que se dispara un trigger.

õ Informix: soporta triggers previos y posteriores, y más de uno por operación; usa el número de la columna para determinar la secuencia de ejecución de los triggers.

õ DB2/UDB: soporta varios triggers por cada comando de operación, en una tabla. DB2 ejecuta los triggers en el orden en que fueron creados. También soporta un tipo especial de gatillo llamado de “alerta”, el cual tiene la capacidad de informar a una aplicación externa del cambio de condición de la base de datos.

õ MySql: No soportan sentencias que hacen commits o rollbacks explícitos o implícitos, ni sentencias que devuelvan un resultado. Esto incluye sentencias SELECT que no tienen una cláusula INTO y la sentencia SHOW. Una función puede procesar un resultado tanto con SELECT … INTO como con el uso de un cursor y de la sentencia FETCH.

Los Errores de integridad referencial

La integridad referencial forzada con triggers no es estándar, es propensa a errores y difícil de implementar y mantener. Los triggers exigen esfuerzos de programación para implementar la integridad referencial; la integridad referencial mediante declaraciones no requiere tales esfuerzos. Como un servidor no tiene forma de saber que está usándose un trigger para la integridad referencial no puede hacer nada para optimizarlo.

Por ejemplo, una transacción que agrega 100 registros nuevos a la tabla de órdenes de compra y que tiene forzada la integridad referencial a la tabla de proveedores a través de un trigger, ocasionará que el trigger se ejecute 100 veces a fin de revisar el mismo valor de la clave cada vez; esa ejecución es impostergable.

En contraste, la implementación de integridad referencial mediante declaraciones en el servidor, revisaría ese valor sólo una vez para toda la operación. La integridad referencial mediante declaraciones ofrece mejor documentación y claridad utilizando instrucciones de

SQL de DDL estándar basadas en el catálogo.

Disparadores en Mysql

Disparadores (triggers)

Un disparador es un objeto con nombre dentro de una base de datos el cual se asocia con una tabla y se activa cuando ocurre en ésta un evento en particular. Por ejemplo, las siguientes sentencias crean una tabla y un disparador para sentencias INSERT dentro de la tabla. El disparador suma los valores insertados en una de las columnas de la tabla:

Este capítulo describe la sintaxis para crear y eliminar disparadores, y muestra algunos ejemplos de cómo utilizarlos.

Sintaxis de CREATE TRIGGER

Un disparador es un objeto con nombre en una base de datos que se asocia con una tabla, y se activa cuando ocurre un evento en particular para esa tabla.

El disparador queda asociado a la tabla nombre_tabla. Esta debe ser una tabla permanente, no puede ser una tabla TEMPORARY ni una vista. momento_disp es el momento en que el disparador entra en acción. Puede ser BEFORE (antes) o AFTER (despues), para indicar que el disparador se ejecute antes o después que la sentencia que lo activa.

evento_disp indica la clase de sentencia que activa al disparador. Puede ser INSERT, UPDATE, o DELETE. Por ejemplo, un disparador BEFORE para sentencias INSERT podría utilizarse para validar los valores a insertar.

No puede haber dos disparadores en una misma tabla que correspondan al mismo momento y sentencia.

Por ejemplo, no se pueden tener dos disparadores BEFORE UPDATE. Pero sí es posible tener los disparadores BEFORE UPDATE y BEFORE INSERT o BEFORE UPDATE y AFTER UPDATE.

sentencia_disp es la sentencia que se ejecuta cuando se activa el disparador. Si se desean ejecutar múltiples sentencias, deben colocarse entre BEGIN … END, el constructor de sentencias compuestas. Esto además posibilita emplear las mismas sentencias permitidas en rutinas almacenadas.



Note: Antes de MySQL 5.0.10, los disparadores no podían contener referencias directas a tablas por su nombre. A partir de MySQL 5.0.10, se pueden escribir disparadores como el llamado testref, que se muestra en este ejemplo:

Si en la tabla test1 se insertan los siguientes valores:

Entonces los datos en las 4 tablas quedarán así:




Las columnas de la tabla asociada con el disparador pueden referenciarse empleando los alias OLD y NEW. OLD.nombre_col hace referencia a una columna de una fila existente, antes de ser actualizada o borrada. NEW.nombre_col hace referencia a una columna en una nueva fila a punto de ser insertada, o en una fila existente luego de que fue actualizada.

El uso de SET NEW.nombre_col = valor necesita que se tenga el privilegio UPDATE sobre la columna. El uso de SET nombre_var = NEW.nombre_col necesita el privilegio SELECT sobre la columna.

Nota: Actualmente, los disparadores no son activados por acciones llevadas a cabo en cascada por las restricciones de claves extranjeras. Esta limitación se subsanará tan pronto como sea posible.

La sentencia CREATE TRIGGER necesita el privilegio SUPER. Esto se agregó en MySQL 5.0.2.

Sintaxis de DROP TRIGGER

Elimina un disparador. El nombre de esquema es opcional. Si el esquema se omite, el disparador se elimina en el esquema actual.

Nota: cuando se actualice desde una versión anterior de MySQL 5 a MySQL 5.0.10 o superior, se deben eliminar todos los disparadores antes de actualizar y volver a crearlos después, o DROP TRIGGER no funcionará luego de la actualización.



La sentencia DROP TRIGGER necesita que se posea el privilegio SUPER, que se introdujera en MySQL 5.0.2.

Utilización de disparadores

El soporte para disparadores es básico, por lo tanto hay ciertas limitaciones en lo que puede hacerse con ellos. Esta sección trata sobre el uso de los disparadores y las limitaciones vigentes.

Un disparador es un objeto de base de datos con nombre que se asocia a una tabla, y se activa cuando ocurre un evento en particular para la tabla. Algunos usos para los disparadores es verificar valores a ser insertados o llevar a cabo cálculos sobre valores involucrados en una actualización.

Un disparador se asocia con una tabla y se define para que se active al ocurrir una sentencia INSERT, DELETE, o UPDATE sobre dicha tabla. Puede también establecerse que se active antes o después de la sentencia en cuestión.

Por ejemplo, se puede tener un disparador que se active antes de que un registro sea borrado, o después de que sea actualizado.

Para crear o eliminar un disparador, se emplean las sentencias CREATE TRIGGER y DROP TRIGGER.

Este es un ejemplo sencillo que asocia un disparador con una tabla para cuando reciba sentencias INSERT. Actúa como un acumulador que suma los valores insertados en una de las columnas de la tabla.

La siguiente sentencia crea la tabla y un disparador asociado a ella:

La sentencia CREATE TRIGGER crea un disparador llamado ins_sum que se asocia con la tabla account. También se incluyen cláusulas que especifican el momento de activación, el evento activador, y qué hacer luego de la activación:

La palabra clave BEFORE indica el momento de acción del disparador. En este caso, el disparador debería activarse antes de que cada registro se inserte en la tabla. La otra palabra clave posible aqui es AFTER.

La plabra clave INSERT indica el evento que activará al disparador. En el ejemplo, la sentencia INSERT causará la activación. También pueden crearse disparadores para sentencias DELETE y UPDATE.


La sentencia siguiente, FOR EACH ROW, define lo que se ejecutará cada vez que el disparador se active, lo cual ocurre una vez por cada fila afectada por la sentencia activadora. En el ejemplo, la sentencia activada es un sencillo SET que acumula los valores insertados en la columna amount. La sentencia se refiere a la columna como NEW.amount, lo que significa “el valor de la columna amount que será insertado en el nuevo registro.”

Para utilizar el disparador, se debe establecer el valor de la variable acumulador a cero, ejecutar una sentencia INSERT, y ver qué valor presenta luego la variable.

En este caso, el valor de @sum luego de haber ejecutado la sentencia INSERT es 14.98 + 1937.50 – 100, o 1852.48.

Para eliminar el disparador, se emplea una sentencia DROP TRIGGER. El nombre del disparador debe incluir el nombre de la tabla:

Debido a que un disparador está asociado con una tabla en particular, no se pueden tener múltiples disparadores con el mismo nombre dentro de una tabla. También se debería tener en cuenta que el espacio de nombres de los disparadores puede cambiar en el futuro de un nivel de tabla a un nivel de base de datos, es decir, los nombres de disparadores ya no sólo deberían ser únicos para cada tabla sino para toda la base de datos. Para una mejor compatibilidad con desarrollos futuros, se debe intentar emplear nombres de disparadores que no se repitan dentro de la base de datos.

Adicionalmente al requisito de nombres únicos de disparador en cada tabla, hay otras limitaciones en los tipos de disparadores que pueden crearse. En particular, no se pueden tener dos disparadores para una misma tabla que sean activados en el mismo momento y por el mismo evento. Por ejemplo, no se pueden definir dos BEFORE INSERT o dos AFTER UPDATE en una misma tabla. Es improbable que esta sea una gran limitación, porque es posible definir un disparador que ejecute múltiples sentencias empleando el constructor de sentencias compuestas BEGIN … END luego de FOR EACH ROW. (Más adelante en esta sección puede verse un ejemplo).

También hay limitaciones sobre lo que puede aparecer dentro de la sentencia que el disparador ejecutará al activarse:



El disparador no puede referirse a tablas directamente por su nombre, incluyendo la misma tabla a la que está asociado. Sin embargo, se pueden emplear las palabras clave OLD y NEW. OLD se refiere a un registro existente que va a borrarse o que va a actualizarse antes de que esto ocurra. NEW se refiere a un registro nuevo que se insertará o a un registro modificado luego de que ocurre la modificación.

El disparador no puede invocar procedimientos almacenados utilizando la sentencia CALL. (Esto significa, por ejemplo, que no se puede utilizar un procedimiento almacenado para eludir la prohibición de referirse a tablas por su nombre).

El disparador no puede utilizar sentencias que inicien o finalicen una transacción, tal como START TRANSACTION, COMMIT, o ROLLBACK.

Las palabras clave OLD y NEW permiten acceder a columnas en los registros afectados por un disparador. (OLD y NEW no son sensibles a mayúsculas). En un disparador para INSERT, solamente puede utilizarse NEW.nom_col; ya que no hay una versión anterior del registro. En un disparador para DELETE sólo puede emplearse OLD.nom_col, porque no hay un nuevo registro. En un disparador para UPDATE se puede emplear OLD.nom_col para referirse a las columnas de un registro antes de que sea actualizado, y NEW.nom_col para referirse a las columnas del registro luego de actualizarlo.

Una columna precedida por OLD es de sólo lectura. Es posible hacer referencia a ella pero no modificarla.

Una columna precedida por NEW puede ser referenciada si se tiene el privilegio SELECT sobre ella. En un disparador BEFORE, también es posible cambiar su valor con SET NEW.nombre_ col = valor si se tiene el privilegio de UPDATE sobre ella. Esto significa que un disparador puede usarse para modificar los valores antes que se inserten en un nuevo registro o se empleen para actualizar uno existente.

En un disparador BEFORE, el valor de NEW para una columna AUTO_INCREMENT es 0, no el número secuencial que se generará en forma automática cuando el registro sea realmente insertado.

Podría parecer más fácil definir una rutina almacenada e invocarla desde el disparador utilizando una simple sentencia CALL. Esto sería ventajoso también si se deseara invocar la misma rutina desde distintos disparadores. Sin embargo, una limitación de los disparadores es que no pueden utilizar CALL. Se debe escribir la sentencia compuesta en cada CREATE TRIGGER donde se la desee emplear.


MySQL gestiona los errores ocurridos durante la ejecución de disparadores de esta manera:

Si lo que falla es un disparador BEFORE, no se ejecuta la operación en el correspondiente registro.

Un disparador AFTER se ejecuta solamente si el disparador BEFORE (de existir) y la operación se ejecutaron exitosamente.

Un error durante la ejecución de un disparador BEFORE o AFTER deriva en la falla de toda la sentencia que provocó la invocación del disparador.

En tablas transaccionales, la falla de un disparador (y por lo tanto de toda la sentencia) debería causar la cancelación (rollback) de todos los cambios realizados por esa sentencia. En tablas no transaccionales, cualquier cambio realizado antes del error no se ve afectado.


Tipos de datos (fechas y horas) (Reporte de práctica n° 16)


Una empresa almacena los datos de sus empleados en una tabla “empleados”.

1. Elimine la tabla, si existe: drop table if exists empleados; 2. Cree la tabla eligiendo el tipo de dato adecuado para cada campo:

create table empleados(nombre varchar(20), documento char(8), sexo char(1), domicilio varchar(30), fechaingreso date);

1. Ingrese algunos registros:

insert into empleados values(‘Juan Perez’,’22333444′,’m',’Colon 123′,’1990-10-08′), (‘Ana Acosta’,’23333444′,’f',’Caseros 987′,’1995-12-18′), (‘Lucas Duarte’,’25333444′,’m',’Sucre 235′,’2005-05-15′), (‘Pamela Gonzalez’,’26333444′,’f',’Sarmiento 873′,’1999-02-12′), (‘Marcos Juarez’,’30333444′,’m',’Rivadavia 801′,’2002-09-22′);

1. Seleccione todos los datos de los empleados que ingresaron a la empresa antes del 2000: select * from empleados where fechaingreso<’2000′;

2. Muestre el nombre y la fecha de ingreso de los empleados de sexo masculino: select nombre,fechaingreso from empleados where sexo=’m';

3. Modifique la fecha de ingreso del empleado con documento “22333444″ a “1990-10-18″: update empleados set fechaingreso=’1990-10-18′ where documento=’22333444′;

4. Ingrese un empleado con valor para “fechaingreso” en la cual coloque 2 digitos correspondientes al año: insert into empleados values(‘Susana Duarte’,’30123456′,’f',’Sucre 1234′,’99-02-12′);

5. ngrese un empleado colocando sólo un dígito en la parte de la fecha correspondiente al mes y día: insert into empleados values(‘Daniel Herrero’,’30000001′,’m',null,’1980-2-03′);

6. Ingrese una fecha de ingreso sin separadores: insert into empleados values(‘Ana Juarez’,’31123123′,’f',null,’19900306′);

10. Ingrese un valor de tipo fecha y hora: insert into empleados values(‘Juan Mores’,’32222333′,’m',null,’1990-03-06 10:15′); Sólo guarda la parte de la fecha.

11. Ingrese un valor que MySQL no reconozca como fecha:

12. insert into empleados values(‘Hector Perez’,’34444555′,’m',null,’1990036′); Almacenará ceros.





Tipos de datos (numéricos) (Reporte de práctica n°15)


1. A. El departamento de Meteorología de una ciudad tiene almacenados en una tabla las estadísticas de temperatura y precipitaciones de varias ciudades del mundo. La tabla tiene registrados los siguientes datos:

1. Elimine la tabla “estadisticas”. 2. Cree la tabla eligiendo el tipo de dato adecuado para almacenar los datos descriptos

arriba:

- ciudad y país: cadena de caracteres,

- temperaturas (máxima y mínima): entero desde -20 hasta 40 aprox.

- precipitaciones media anual: desde 0 a 2000 aprox.


Tipos de datos (Reporte de práctica n° 14)





Una empresa almacena los datos de sus clientes en una tabla llamada “clientes”.

1. Elimine la tabla “clientes” si existe: drop table if exists clientes; 2. Créela con los siguientes campos y clave: create table clientes (documento char(8),

apellido varchar(20), nombre varchar(20), domicilio varchar(30),mtelefono varchar (11), primary key(documento));

3. Analice la definición de los campos. Se utiliza char(8) para el documento porque siempre constará de 8 caracteres. Para el número telefónico se usar “varchar” y no un tipo numérico porque si bien es un número, con él no se realizarán operaciones matemáticas.

4. Ingrese algunos registros:

insert into clientes (documento,apellido,nombre,domicilio,telefono) values(’2233344′, ‘Perez’,'Juan’,'Sarmiento 980′,’4342345′), (’2333344′,’Perez’,'Ana’,'Colon 234′), (’2433344′,’Garcia’,'Luis’,'Avellaneda 1454′,’4558877′), (’2533344′,’Juarez’,'Ana’,'Urquiza 444′,’4789900′);

1. Seleccione todos los clientes de apellido ‘Perez’. 2. seleccione el apellido, domicilio y teléfono de todas las ‘Ana’.




Valores null. (Reporte de prácticas n°12)


Trabaje con la tabla que almacena los datos sobre películas, llamada “peliculas”.

1. Elimine la tabla. 2. Créela con la siguiente estructura:

-codigo (entero, autoincremento),

-titulo (cadena de 30, not null),

-actor (cadena de 20),

-duracion (entero),

-clave primaria (codigo).

1. Visualice la estructura de la tabla. 2. Ingrese los siguientes registros:

insert into peliculas (titulo,actor,duracion)values(‘Mision imposible’,'Tom Cruise’,120), (‘Harry Potter y la piedra filosofal’,'Daniel R.’,180), (‘Harry Potter y la camara secreta’,'Daniel R.’,190), (‘Mision imposible 2′,’Tom Cruise’,150), (‘Titanic’,'L. Di Caprio’,220), (‘Mujer bonita’,'R. Gere-J. Roberts’,200);

1. Recupere todos los registros para verificar la carga automática de los códigos. 2. Ingrese un registro con valor nulo para el campo clave primaria: 3. insert into peliculas (codigo,titulo,actor,duracion)values(null,’Elsa y Fred’,'China

Zorrilla’,90);

Verifique que acepta el registro pero pasa por alto el dato ingresado para el código colocando en su lugar el valor siguiente de la secuencia.

1. Intente ingresar un registro con valor nulo para el campo “titulo”. Verifique que no realiza la acción. insert into peliculas(titulo,actor,duracion)values(null,’Tom Cruise’,120);


2. Ingrese un registro con cadenas vacías para los campos varchar y valor 0 para los campos numéricos: insert into peliculas (codigo,titulo,actor,duracion)values(0,”,”,0); Visualice el registro para ver cómo almacenó MySQL el registro ingresado anteriormente.

10. Coloque 120 en la duración de la película cuyo valor de duración sea nulo (1 registro actualizado): update peliculas set duracion=120 where duracion is null;

11. Coloque ‘Desconocido’ en el campo “actor” en los registros que tengan valor nulo en dicho campo (1 registro afectado): update peliculas set actor=’Desconocido’where actor is null;

12. Muestre todos los registros. Note que el cambio anterior no afectó al registro con valor nulo en el campo “actor”.

13. Coloque ‘Desconocido’ en el campo “actor” en los registros que tengan cadena vacía en dicho campo (1 registro afectado): update peliculas set actor=’Desconocido’where actor=”;

14. Elimine los registros cuyo título sea una cadena vacía: delete from peliculas where titulo=”;




Comando truncate table. (Reporte de práctica n° 11)


Un videoclub almacena información sobre sus películas en una tabla llamada “peliculas”.

1. Elimine la tabla si existe. 2. Créela con la siguiente estructura:





-codigo (entero), autoincremento,

-titulo (cadena de 30),

-actor (cadena de 20),

-duracion (entero),

-clave primaria: codigo.

1. Ingrese los siguientes registros:

insert into peliculas (titulo,actor,duracion) values(‘Mision imposible’,'Tom Cruise’,120), (‘Harry Potter y la piedra filosofal’,'xxx’,180), (‘Harry Potter y la camara secreta’,'xxx’,190), (‘Mision imposible 2′,’Tom Cruise’,120), (‘La vida es bella’,'zzz’,220);

1. Seleccione todos los registros y verifique la carga automática de los códigos. 2. Elimine todos los registros: delete from peliculas; 3. Ingrese el siguiente registro, sin valor para la clave primaria: insert into peliculas

(titulo,actor,duracion) values(‘Mujer bonita’,'Richard Gere’,120); 4. Vea los registros para verificar que al generar el valor para “codigo” continuó la

secuencia: select *from peliculas; 5. Elimine todos los registros vaciando la tabla: truncate table peliculas; 6. Ingrese el siguiente registro: insert into peliculas (titulo,actor,duracion)values(‘Elsa

y Fred’,'China Zorrilla’,90);

10. Muestre el registro ingresado para verificar que inició la secuencia nuevamente para el campo “codigo”: select * from peliculas;



CONEXIÓN DE BASE DE DATOS CON JAVA

Documents

Transcript of CONEXIÓN DE BASE DE DATOS CON JAVA