el lenguaje sql
DESCRIPTION
Manual de reseña rápida de SQLTRANSCRIPT
EL LENGUAJE SQL
SQL es un lenguaje de consultas (query) que dispone de un número muy reducido de ordenes pero muy potentes.
Como este es el lenguaje que vamos a utilizar a partir de ahora para trabajar en nuestras tablas, vamos a recordar las ordenes básicas.
CREATE DATABASE
Esta orden nos permite crear una base de datos SQL.
Una base de datos (como ya hemos dicho) es un contenedor que agrupa todos los objetos relacionados con ella, tales como tablas, índices, relaciones, procedimientos almacenados etc.
CREATE DATABASE [IF NOT EXISTS] nombre_de_base_de_datos
Esta orden SQL crea una base de datos con el nombre: nombre_de_base_de_datos si la base de datos ya existe y no se indica [IF NOT EXISTS] se produce un error.
En Mysql las bases de datos se crean como subdirectorios o carpetas que contienen las tablas de dicha base de datos.
CREATE TABLE
Esta orden permite crear una tabla vacía con su estructura (nombres de campos, tipos, índices etc.).
Devuelve un error si ya existe la tabla.
Si la tabla es creada Mysql genera tres ficheros:
Nombre_de_tabla.frm, que es el fichero de definición.
Nombre_de_tabla.MYD, que es el fichero que contiene los datos.
Nombre_de_tabla .MYI, fichero índice.
Un tipo especial es el AUTO_INCREMENT, si un campo INT es AUTO_INCREMENT, cuando se inserta un nuevo registro el Motor de Base de Datos le asigna, automáticamente, el valor anterior mas uno (permite definir el valor del incremento, el valor inicial y final etc.)esto evita parte del trabajo al equipo cliente y evita trafico de red, haciendo el sistema mas rápido y eficiente.
Una tabla solo puede tener un campo AUTO_INCREMENT y sus valores no pueden ser negativos (y si exceden el valor máximo se reinicia a 1).
KEY (clave) es sinónimo de ÍNDICE (INDEX).
Una clave única solo puede tener valores distintos, si intentamos introducir valores repetidos en un campo de clave única da un error.
Una clave primaria (PRIMARY KEY)es una clave única con la restricción de que todas las columnas deben estar definidas como NOT NULL
Una tabla solo puede tener una clave primaria pero puede estar constituida por un índice de múltiples campos.
Su forma general es la siguiente:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS]nombre_de_tabla[definición,...)][opciones_de_tabla] [orden_select]
definición: nombre_de_campo tipo [NOT NULL | NULL] [DEFAULT default_valor] [AUTO_INCREMENT] [PRIMARY KEY] or PRIMARY KEY (nombre_campo_índice,...) ó KEY [nombre_índice] (nombre_campo_índice,...) ó INDEX [nombre_índice] (nombre_campo_índice,...) ó UNIQUE [INDEX] [nombre_índice] (nombre_campo_índice,...) ó [CONSTRAINT symbol] FOREIGN KEY nombre_índice (nombre_campo_índice,...) [reference_definition] ó CHECK (expr)
tipos de campos:
TINYINT[(longitud)] [UNSIGNED] [ZEROFILL] ó SMALLINT[(longitud)] [UNSIGNED] [ZEROFILL] ó MEDIUMINT[(longitud)] [UNSIGNED] [ZEROFILL] ó INT[(longitud)] [UNSIGNED] [ZEROFILL] ó INTEGER[(longitud)] [UNSIGNED] [ZEROFILL] ó BIGINT[(longitud)] [UNSIGNED] [ZEROFILL] ó REAL[(longitud,decimales)] [UNSIGNED] [ZEROFILL] ó DOUBLE[(longitud,decimales)] [UNSIGNED] [ZEROFILL] ó FLOAT[(longitud,decimales)] [UNSIGNED] [ZEROFILL] ó DECIMAL(longitud,decimales) [UNSIGNED] [ZEROFILL] ó NUMERIC(longitud,decimales) [UNSIGNED] [ZEROFILL] ó CHAR(longitud) [BINARY] ó VARCHAR(longitud) [BINARY] ó DATE ó TIME ó TIMESTAMP ó DATETIME ó TINYBLOB ó BLOB ó MEDIUMBLOB ó LONGBLOB ó TINYTEXT ó TEXT ó MEDIUMTEXT ó LONGTEXT ó ENUM(valor1,valor2,valor3,...)
ó SET(valor1,valor2,valor3,...)
nombre_campo_índice: nombre_de_campo [(longitud)]
definición_referencia:
REFERENCES nombre_tabla [(nombre_campo_índice,...)] [MATCH FULL | MATCH PARTIAL] [ON DELETE reference_option] [ON UPDATE reference_option]
opcion_referencia:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT
opciones_de_tabla:
TYPE = {ISAM | MYISAM | HEAP} o AUTO_INCREMENT = # o AVG_ROW_LONGITUD = # o CHECKSUM = {0 | 1} o COMMENT = "string" o MAX_FILAS = # o MIN_FILAS = # o PACK_KEYS = {0 | 1} o PASSWORD = "string" o DELAY_KEY_WRITE = {0 | 1} ó ROW_FORMAT= { default | dynamic | static | compressed } o RAID_TYPE= {1 | STRIPED | RAID0 } RAID_CHUNKS=# RAID_CHUNKSIZE=#;
orden_select:
CREATE INDEX
Esta orden permite crear un índice a partir de un campo o una combinación de ellos.
En Mysql se puede crear con la siguiente orden alter table.
ALTER TABLE
Esta orden de SQL nos permite modificar los atributos de las tablas (campos, nombre de tabla, índices etc.), y tiene como forma general la siguiente:
ALTER [IGNORE] TABLE nombre_tabla modificacion [, modificacion ...]
Donde modificación puede ser:
ADD [COLUMN] definición_creacion [FIRST | AFTER nombre_campo ] ó ADD [COLUMN] (definición_creacion, definición_creacion,...) ó ADD INDEX [nombre_índice] (nombre_campo_índice,...) ó ADD PRIMARY KEY (nombre_campo_índice,...) ó ADD UNIQUE [nombre_índice] (nombre_campo_índice,...) ó ALTER [COLUMN] nombre_campo {SET DEFAULT literal | DROP DEFAULT} ó CHANGE [COLUMN] nombre_campo_viejo definición_creacion
ó MODIFY [COLUMN] definición_creacion ó DROP [COLUMN] nombre_campo ó DROP PRIMARY KEY ó DROP INDEX nombre_índice ó RENAME [AS] new_ nombre_tabla ó tabla_optiones
ALTER TABLE nos permite modificar la estructura de una tabla existente, podemos añadir o borrar campos,crear o borrar índices o renombrar o borrar la propia tabla.
ALTER TABLE hace una copia temporal de la tabla original la modificación se realiza sobre la copia, la tabla original se borra y se renombra la nueva.
Mientras ALTER TABLE se ejecuta la tabla original todavía puede ser leida por otros clientes .
La palabra COLUMN es opcional y se puede omitir.
Si utilizamos ALTER TABLE nombre_tabla RENAME AS nuevo_nombre sin mas opciones, MySQL simplemente renombra la tabla sin crear el fichero temporal.
DROP COLUMN borra un campo y lo elimina de cualquier índice en el cual intervenga, si el índice es creado por la columna borrada, borra también el índice. Ejemplos:
Creamos la tabla t1 con los campos a y b:
CREATE TABLE t1 (a INTEGER,b CHAR(10));
Cambiamos el nombre a t2
ALTER TABLE t1 RENAME t2;
Para cambiar el tipo del campo a de INTEGER a TINYINT NOT NULL (dejando el mismo nombre), y cambiar el campo b de CHAR(10)a CHAR(20)cambiando el nombre de b a c: ALTER TABLE t2 MODIFY a TINYINT NOT NULL, CHANGE b c CHAR(20);
Para añadir un campo TIMESTAMP llamado d hacemos : ALTER TABLE t2 ADD d TIMESTAMP;
Para añadir un índice por el campo d, y hacer el campo a la clave primaria: ALTER TABLE t2 ADD INDEX (d), ADD PRIMARY KEY (a);
Para borrar el campo c haremos:
ALTER TABLE t2 DROP COLUMN c;
Para añadir un campo AUTO_INCREMENT entero llamado c:
ALTER TABLE t2 ADD c INT UNSIGNED NOT NULL AUTO_INCREMENT,ADD INDEX (c);
Indexamos c, porque el campo AUTO_INCREMENT debe estar indexado, y también hay que declarar c como NOT NULL, porque los campos indexados no pueden ser NULL.
Cuando añadimos un campo AUTO_INCREMENT los valores del campo son llenados por una secuencia de números automáticamente.
DROP DATABASE
Esta orden borra una base de datos y todo su contenido, tiene la siguiente forma.
DROP DATABASE [IF EXISTS] nombre_de_base_de_datos
Esta orden borra la base de datos nombre_de_base_de_datos y todas las tablas que contiene, por tanto, hay que tener mucho cuidado con este comando.
En caso de que nombre_de_base_de_datos no exista la orden devuelve un error (si no se ha indicado IF EXIST)
DROP TABLE
Del mismo modo que la anterior, esta órden borrará una tabla con todo su contenido, es preciso utilizarla, por tanto, también con mucho cuidado.
SELECT
Esta será la orden mas utilizada en sql porque es la que nos permitirá leer conjuntos de información de una tabla.
Su forma es:
SELECT campos FROM tabla WHERE condicion_de_busqueda
Ejemplos:
SELECT * FROM clientes
Esta órden nos devolverá todos los registros de la tabla clientes.
¡Cuidado ! si la tabla clientes tiene pocos registros se ejecutará en décimas de o centésimas de segundo pero si tiene miles de registros y la consulta es por Internet puede ser que tengamos que esperar 10 o 15 minutos para tener los resultados.
SELECT código, articulo, precio FROM productos
Esta orden nos devolverá el contenido de los campos código, articulo y precio de todos los registros de la tabla productos.
SELECT código, articulo FROM productos WHERE precio>2000
Esta órden nos devolverá el contenido de los campos código y articulo de todos los registros de la tabla productos cuyo precio sea superior a 2000.
SELECT * FROM clientes WHERE poblacion="BILBAO" ORDER BY nombre
En este caso SELECT nos devolverá el contenido de todos los campos de clientes de BILBAO además ordenados por su nombre.
SELECT tiene la siguiente forma general:
SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT] [HIGH_PRIORITY] [DISTINCT | DISTINCTROW | ALL] expresion de consulta,... [INTO {OUTFILE | DUMPFILE} 'nombre_fichero' opciones_exportacion] [FROM table_references [WHERE condicion] [GROUP BY {entero_sin_signo | nombre_campo| formula}] [HAVING condicion] [ORDER BY {entero_sin_signo | nombre_campo| formula} [ASC | DESC] ,...] [LIMIT [desplazamiento,]filas] [PROCEDURE nombre_proc] ]
SELECT, en general, se utiliza para encontrar registros desde una o mas tablas aunque también se puede usar para realizar cálculos sin relación con ninguna tabla.
Ejemplos:
SELECT 1 + 1;
devuelve: 2
Todas las palabras clave deben usarse en el orden exacto que se indica arriba, por ejemplo: la cláusula HAVING debe estar Después de GROUP BY y antes que ORDER BY.
Se puede usar un alias utilizando la cláusula AS el cual se puede utilizar en lugar del nombre de la tabla o del campo en ORDER BY o HAVING .
SELECT concat(apellido,', ',nombre) AS nom from clientes ORDER BY nom;
Aquí nom es el alias de la combinación de dos campos: apellido y nombre.
La partícula FROM tabla indica la tabla de las cuales extrae la información que nos devuelve SELECT.
Los campos se pueden nombrar como nombre_tabla.nombre_campo.
Para ordenar los resultados utilizamos la cláusula ORDER BY seguida de la condición de orden.
Para agrupar los registros según un criterio utilizamos GROUP BY condicion_agrupamiento.
SELECT colegio, region, nombre FROM educacion ORDER BY región, nombre;SELECT colegio, region AS r, nombre AS n FROM educacion ORDER BY r, n;SELECT colegio, region,nombre FROM educacion ORDER BY 2, 3;
Para ordenar en orden inverso añadiremos la cláusula DESC (descendiente)al nombre del campo que sigue a ORDER BY, por defecto el orden es ascendente aunque también se puede utilizar la palabra clave ASC.
HAVING puede referirse a cualquier campo o alias utilizado en la
select, se aplica la ultima, no deberíamos utilizar condiciones que se puedan utilizar con WHERE .
Por ejemplo, no deberíamos utilizar:
FROM nombre_campo FROM nombre_tabla HAVING nombre_campo> 0;
Si no esto:
SELECT nombre_campo FROM nombre_tabla WHERE nombre_campo> 0;
Podemos usar la cláusula LIMIT para limitar el número de filas devueltas por SELECT.
LIMIT puede tener uno o dos argumentos, en este ultimo caso, el primero indica el desplazamiento de la primera fila devuelta el segundo, el máximo número de filas a devolver.
El desplazamiento de la fila inicial es 0 (no 1).
FROM * FROM tabla LIMIT 5,10; # encuentra filas de 6 a 15.
Si se dá un solo argumento, este indica el máximo número de filas a devolver.
FROM * FROM table LIMIT 5; # devuelve la primeras 5 filaso sea, LIMIT n es equivalente a LIMIT 0,n.
SELECT ... INTO OUTFILE 'nombre_fichero' escribe los registros seleccionados por SELECT a un fichero que se crea en el servidor y que no puede existir previamente para evitar destruir ficheros como `/etc/passwd' (fichero de claves de acceso en Linux) con las consecuencias nefastas que esto produciría.
SELECT ... INTO OUTFILE es el complemento de LOAD DATA INFILE.
La sintaxis para las opciones_exportacion consiste en los mismos FIELDS y LINES que se usan con LOAD DATA INFILE
INSERT INTO
Esta orden nos permite insertar registros nuevos en una tabla, se indican los nombres de los campos a escribir entre paréntesis y los valores de dichos campos de la misma forma como se indica a continuación.
Su forma es:
INSERT INTO tabla (CAMPOS)VALUES (VALOR_DE_CAMPO)
Ejemplo:
INSERT INTO clientes (código,nombre,direccion)VALUES("0001","FIFI","POZA 22")
Esta orden inserta un registro nuevo en la tabla de clientes y rellena los campos: código, nombre y dirección con los valores respectivos : "0001","FIFI" y "POZA 22".
Su forma general es la siguiente:
INSERT [LOW_PRIORITY | DELAYED] [IGNORE]
[INTO] nombre_tabla [(nombre_campo,...)] VALUES (expression,...),(...),...
ó INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] nombre_tabla [(nombre_campo,...)] SELECT ...ó INSERT [LOW_PRIORITY | DELAYED] [IGNORE] [INTO] nombre_tabla SET nombre_campo=expression, nombre_campo=expression, ...
La forma INSERT ... SELECT inserta en una tabla registros seleccionados desde otra u otras tablas.
nombre_tabla es la tabla en la que se insertan los registros, la lista de campos o la cláusula SET indica los valores que corresponden a cada campo.
Si no se indica la lista de campos hay que dar valores a todos en la lista de VALUES()o bien mediante una SELECT.
Si no conocemos el orden de los campos en la tabla podemos usar DESCRIBE nombre_tabla para descubrirlo.
Podemos usar una expresión para el valor a insertar como por ejemplo:
INSERT INTO nombre_tabla (col1,col2) VALUES(15,col1*2);
Pero esto no:
INSERT INTO nombre_tabla (col1,col2) VALUES(col2*2,15);
Porque cuando va a sustituir col1 , col2 aún no ha tomado valor.
Si indicamos LOW_PRIORITY la ejecución de INSERT se retrasará hasta que ningun cliente este leyendo registros desde la tabla, si no se indica, el cliente espera hasta que se complete la orden INSERT (lo cual puede suponer bastante tiempo si la tabla es muy grande).
Sin embargo INSERT DELAYED permite que el cliente procese una vez.
Los campos AUTO_INCREMENT trabajan como siempre
La opción DELAYED para la orden INSERT es una opción especifica de MySQL que es muy usada cuando el cliente no puede esperar a que el INSERT se complete.
Una ventaja interesante de INSERT DELAYED es que cuando acceden muchos clientes de modo concurrente sus registros se escriben en un bloque ,lo cual es mucho más rápido que hacer inserciones separadas.
UPDATE
Esta orden de SQL nos permite modificar el contenido de uno o varios registros de una tabla.
Ejemplo:
UPDATE clientes SET nombre="SISI",direccion="G. VIA 33" WHERE nombre="MIMI"
Esta orden cambiará el nombre de los clientes que se llamen MIMI por SISI y su direccion por G. VIA 33.
Su forma general es la siguiente:
UPDATE [LOW_PRIORITY] [IGNORE] nombre_tabla SET nombre_campo1=expr1,nombre_campo2=expr2,... [WHERE condicion] [LIMIT #]
UPDATE actualiza los registros de una tabla existente con valores nuevos.
La cláusula SET dice qué campos se modifican y los nuevos valores que toman.
La cláusula WHERE ,si existe, indica que registros deben modificarse, si no se indica cambian todos los registros de la tabla.
Si se especifica LOW_PRIORITY,la ejecución de UPDATE se retrasa hasta que ningún cliente este leyendo la tabla.
Si se accede a un nombre_campo en una expresión, UPDATE usa el valor actual de dicho campo por ejemplo, la siguiente orden pone el campo edad (de todos los registros) a su valor actual mas 1:
UPDATE personal SET edad=edad+1;
Las asignaciones de UPDATE se evalúan de izquierda a derecha.
Por ejemplo, la siguiente orden duplica el campo edad y le suma 1.
UPDATE personal SET edad=edad*2,edad=edad+1;
UPDATE devuelve el número de filas que ha cambiado.
DELETE
Esta orden de SQL nos permite borrar un registro o varios de una tabla.
DELETE FROM clientes WHERE poblacion="BIBAO"
Esta orden borrará de la tabla clientes todos los registros de clientes de BILBAO.
No hay que decir que esta orden es preciso utilizarla con mucho cuidado (entre otros riesgos, si no se indica la cláusula WHERE borrará toda la tabla ).
Su forma general es la que sigue:
DELETE [LOW_PRIORITY] FROM nombre_tabla [WHERE condicion] [LIMIT filas]
DELETE borra filas de nombre_tabla que satisfacen la condición de búsqueda dada por condición, y devuelve el número de registros borrados .
Si queremos saber cuantos registros se han borrado de la tabla (cuando se borra entera ) y a cambio de sufrir una ralentización del proceso, podemos hacer:
DELETE FROM nombre_tabla WHERE 1>0;
Esto es mucho más lento que DELETE FROM nombre_tabla sin clausula WHERE porque borra las filas una a una.
Si indicamos LOW_PRIORITY, la ejecución de DELETE se retrasa hasta que no haya más clientes leyendo la tabla.
Con LIMIT le podemos decir a DELETE el máximo número de filas a borrar antes de que el control vuelva al cliente esto se puede utilizar para asegurar que el borrado no exige demasiado tiempo, podemos repetir la ejecución de DELETE hasta que el borrado sea el deseado.
CONEXIONES
Para acceder a una base de datos es necesario establecer antes una conexión.
Para establecer una conexión es necesario enviar el nombre del servidor, el nombre de la base de datos a la que deseamos acceder, el usuario y su clave (password)E
Cuando se realiza una conexión, el servidor reserva una zona de memoria donde guarda toda la información del usuario que está accediendo lo cual consume recursos del servidor que se liberan cuando se cierra la conexión (la cierra el usuario o el propio servidor cuando detecta que lleva un tiempo sin actividad).
Las conexiones con la base de datos pueden ser de dos tipos: persistentes y no persistentes.
En las conexiones persistentes el servidor "recuerda " si el usuario ya ha accedido antes y no abre , en este caso, una nueva conexión con el consiguiente ahorro de recursos.
Una vez terminado el proceso debe cerrarse la conexión (para evitar agotar los recursos del servidor).
CAPITULO 27
FUNCIÓNES DE PHP PARA ACCESO A BASES DE DATOS
Php dispone de una gran cantidad de funciones de acceso a diferentes motores de bases de datos (tanto comerciales como de software libre ).
Tales como:
ORACLEMYSQLPOSTGRESSDB2INTERBASESQLSERVERINFORMIX
FUNCIÓNES DE PHP PARA ACCESO A BASES DE DATOS MySQL
Aquí nos vamos a preocupar de aprender a utilizar la base de datos de software libre más utilizada en todos los sites del mundo, por su robustez y velocidad de acceso: Mysql.
Mysql soporta el estándar SQL (ANSI), y además está disponible para distintas plataformas, incluido WindowsXX Linux y Unix.
Php dispone de una gran cantidad de funciones para la utilización y acceso a bases de datos Mysql las cuales vamos a describir a continuación para utilizarlas en ejemplos prácticos después.
Todas las funciones comienzan por el prefijo mysql_ .
FUNCIÓN mysql_affected_rows()
Esta función nos devuelve el número de filas de la tabla a las que afecta la última orden SELECT, UPDATE o DELETE y en el servidor con el que estamos conectados (el cual estará definido por el identificador de conexión recogido con la función de conexión que se explica luego).
Si no se indica un identificador de conexión, se supone que la conexión es la última abierta.
Esta orden es más conveniente en las que modifican archivos (UPDATE ,DELETE) que para las instrucciones SELECT.
Para saber el número de filas devuelto por una SELECT, se usa la función mysql_num_rows.
FUNCIÓN mysql_close
Su forma es : mysql_close (id_conexion)
Utilizamos esta función para cerrar una conexión al servidor y devuelve TRUE si se ha cerrado correctamente y FALSE en caso de error.
Mysql_close cierra la conexión a la base de datos Mysql correspondiente al identificador de conexión que le damos entre paréntesis.
Si no se indica un identificador de conexión, supone que se trata de la última conexión abierta.
Esta función no es normalmente necesaria en conexiones no persistentes (abiertas con mysl_connect) ya que ésta se cierra automáticamente al final de la ejecución del script o página.
La función mysql_close no cierra una conexión persistente(abierta con mysql_pconnect()).
FUNCIÓN mysql_connect()
Esta será la primera función a ejecutar en un acceso a bases de datos remotas ya que es la que nos permite crear una conexión con el servidor.
Tiene la siguiente forma:
mysql_connect(servidor,usuario,password)
Devuelve un identificador de conexión, o FALSE en caso de error.
sql_connect establece una conexión a un servidor de MySQL.
Todos los parámetros son optativos, y si no se indican, los valores por defecto son (' el localhost', nombre del usuario que posee el proceso del servidor, la contraseña vacía).
La cadena servidor también puede incluir un número del puerto, "servidor:puerto".
En caso de realizar una segunda llamada a mysql_connect con los mismos argumentos, no se establecerá ninguna nueva conexión, sino que se devolverá el identificador de conexión de la ya existente.
La conexión al servidor se cerrará en cuanto la ejecución del script acabe, a menos que la cerremos antes con la función mysql_close().
Ejemplo:
$con = mysql_connect("localhost", "nobody"); // abre una conexión no persistente
Esto nos conecta al servidor localhost con el usuario nobody y sin password.
FUNCIÓN mysql_create_db()
La función mysql_create_db intenta crear una nueva base de datos en el servidor cuyo identificador de conexión está indicado dentro del paréntesis como parámetro.
FUNCIÓN mysql_data_seek()
Devuelve: TRUE si todo ha ido bien, y FALSE en caso de error.
La función mysql_data_seek mueve el puntero que indica la fila actual al número de fila de la consulta que indica el identificador.
La próxima llamada al mysql_fetch_row o mysql_fetch_array devolvería esa fila.
FUNCIÓN mysql_dbname()
Esta función nos permite obtener nombres de bases de datos alojadas en el servidor.
Anteriormente se habrá ejecutado la orden mysql_list_dbs que nos devuelve la lista de bases de datos del servidor con el que se ha conectado, mysql_dbname devuelve el nombre de la base de datos situada en la posición i de dicha lista.
Podemos usar la función mysql_num_filas para determinar cuántos nombres de bases de datos están disponibles.
FUNCIÓN mysql_db_query()
Devuelve: un identificador de conexión, o FALSE en caso de error.
Esta función ejecuta una consulta en una base de datos.
Si el dentificador no se indica dentro del paréntesis, la función intenta encontrar una conexión abierta con el servidor.
Si no encuentra una conexión, intentará crear una (es similar a mysql_connect( ) sin argumentos).
FUNCIÓN mysql_drop_db()
Elimina una base de datos del servidor cuyo identificador de conexión se da como parámetro.
Devuelve: TRUE si todo ha ido bien, y FALSE en caso de error.
FUNCIÓN mysql_errno()
Devuelve el número de error correspondiente a la última operación realizada si ha fallado.
FUNCIÓN mysql_error()
Devuelve el mensaje de error producido en la última operación realizada por la base de datos si ha sido fallida.
Ejemplo:
<?php
mysql_connect("servidor_inexistente"); // este servidor no existe echo mysql_errno().": ".mysql_error()."<BR>"; //visualiza este error mysql_select_db("noexistentedb"); echo mysql_errno("noexistentedb"); //visualiza este error
echo mysql_errno().": ".mysql_error()."<BR>"; $conn = mysql_query("SELECT * FROM noexistentetabla"); echo mysql_errno().": ".mysql_error()."<BR>"; //visualiza este error
?>
FUNCIÓN mysql_fetch_array()
Devuelve una matriz con la información correspondiente al resultado de una consulta definido por su identificador o 'false' si ya no hay más filas.
Es una versión extendida de mysql_fetch_row ( ).
Además de almacenar los datos utilizando índices numéricos de la matriz, también lo hace mediante índices asociativos, utilizando los nombres de los campos como claves.
Si dos o más columnas del resultado tienen el mismo nombre de campo, la última es la que tiene preferencia.
Para acceder a las demás filas es necesario utilizar el índice numérico o un alias del campo:
El alias de un campo se puede definir así:
select t1.f1 as alias1 t2.f1 as alias2 from t1, t2
Esta función no es más lenta que 'mysql_fetch_row( )'.
Ejemplo de mysql_fetch_array()
<?php mysql_connect($host,$user,$password); $result = mysql_db_query("database","select * from clientes"); while($row = mysql_fetch_array($result)) { echo $row["user_id"]; echo $row["nombre"]; } mysql_free_result($result); ?>
FUNCIÓN mysql_fetch_field()
mysql_fetch_field(resultado, desplazamiento );
Devuelve un objeto que contiene la información de los campos que componen un resultado de una consulta.
Si no se indica 'desplazamiento', nos da información sobre el siguiente campo que todavía no ha sido devuelto.
El objeto devuelto tiene las siguientes propiedades:
name - nombre del campo table - nombre de la tabla a la que pertenece el campo max_longitud - longitud máxima que puede tomar el campo not_null - 1 si el campo no puede tomar valores nulos primary_key - 1 si el campo es una clave principal (primary key) unique_key - 1 si el campo tiene restricción de unicidad multiple_key - 1 si el campo no tiene restricción de unicidad numeric - 1 si el campo es numérico blob - 1 si el campo es BLOB type - tipo de dato (del campo) unsigned - 1 si el campo es 'unsigned' zerofill - 1 si el campo es rellenado con ceros
FUNCIÓN mysql_fetch_lengths()
Su forma es: mysql_fetch_lengths(resultado);
Devuelve: una tabla o FALSE si hay un error.
mysql_fetch_lengths almacena en una matriz las longitudes de cada campo de una consulta realizada con mysql_fetch_row o mysql_fetch_array.
FUNCIÓN mysql_fetch_object()
Tiene la siguiente forma: mysql_fetch_object(resultado);
Devuelve: un objeto o FALSE en caso de error.
Esta función es similar a mysql_fetch_array, solo que los resultados de una consulta, en lugar de una tabla, los devuelve como un objeto.
En este caso, solo se puede acceder a los datos a través de los nombres de sus campos.
La velocidad de ejecución es idéntica a la de mysql_fetch_array().
Como ya sabemos, para referenciar el valor de un campo debemos utilizar el operador típico de los objetos (->).
FUNCIÓN mysql_fetch_row()
Esta función devuelve una matriz (o false si hay error) y su forma es:
mysql_fetch_row(int result);
Nos da una tabla con los valores de los campos de la fila actual de la consulta, la que indica (result) , y mueve el puntero interno que marca la fila actual a la siguiente fila, si no hay mas filas devuelve FALSE.
El índice de la tabla comienza en 0.
FUNCIÓN mysql_field_name()
Su forma es:
mysql_field_name(string result, int i);
Esta función nos devuelve el nombre del campo indicado por el parámetro i.
FUNCIÓN mysql_field_seek()
Tiene la siguiente forma:
mysql_field_seek(resultado,desplazamiento);
El resultado de esta función es mover el puntero del campo actual hacia adelante las posiciones indicadas por 'desplazamiento'.
FUNCIÓN mysql_field_table()
Su forma es:mysql_field_table(resultado, desplazamiento);
Devuelve el nombre de la tabla que almacena el campo especificado por el índice ('desplazamiento' ).
FUNCIÓN mysql_field_type()
mysql_field_type(string result, int field_desplazamiento);
Devuelve el tipo del campo del índice especificado.
FUNCIÓN mysql_field_flags()
mysql_field_flags(string result, int field_desplazamiento);
Devuelve una cadena con los indicadores (flags) del campo expresado como una cadena de texto en la que cada indicador se corresponde con una palabra, y éstas van separadas mediante un espacio simple.
Se puede analizar la cadena utilizando explode( )
Los indicadores son:
"not_null", "primary_key", "unique_key", "multiple_key", "blob", "unsigned", "zerofill", "binary", "enum", "auto_increment", "timestamp".
FUNCIÓN mysql_field_len()
Esta función tiene la forma:
mysql_field_len(string result, int field_desplazamiento);
Devuelve la longitud del campo indicado entre parentesis.
FUNCIÓN mysql_free_result()
Su forma es la siguiente:
mysql_free_result(int result);
Esta función solo debería ser utilizada si la cantidad de memoria requerida para almacenar el resultado de una consulta es muy grande.
Cuando se ejecuta esta función, toda la memoria asociada al resultado se libera.
FUNCIÓN mysql_insert_id()
int mysql_insert_id();
Esta función devuelve el ID (código) generado para los campos autoincrementales (AUTO_INCREMENT).
El ID devuelto es el correspondiente al de la última operación INSERT.
FUNCIÓN mysql_list_fields()
Esta función tiene la forma siguiente:
mysql_list_fields(string database, string tablename);
Devuelve información sobre la tabla cuyo nombre es el segundo parámetro.
El valor resultante puede ser utilizado con mysql_field_flags(), mysql_field_len(), mysql_field_name(),y mysql_field_type().
El identificador que devuelve es un entero positivo o '-1' en caso de error.
El texto que describe el error se encuentra en $phperrmsg.
FUNCIÓN mysql_list_dbs()
int mysql_list_dbs();
Devuelve un puntero que contiene las bases de datos disponibles para el servidor actual.
Esta función se utiliza junto con la función mysql_dbname( ) como ya se ha explicado para obtener los nombres de bases de datos ubicadas en el servidor.
FUNCIÓN mysql_list_tables()
Esta función nos permite obtener una lista de tablas contenidas en una base de datos del servidor con el cual hemos realizado una conexión.
Su forma es la siguiente:
mysql_list_tables(basedatos, identificador_conexion);
Devuelve un identificador, el cual podemos utilizar con la función mysql_tablename para extraer el nombre de las tablas de la base de datos indicada en el primer parámetro.
FUNCIÓN mysql_num_fields()
Su forma es la siguiente:
mysql_num_fields(int result);
La función mysql_num_fields devuelve el número de campos de una consulta.
FUNCIÓN mysql_num_rows()
int mysql_num_rows($result);
Devuelve el número de filas del resultado de una consulta.
FUNCIÓN mysql_pconnect()
mysql_pconnect(nombre_servidor,nombre_usuario, password);
Devuelve un identificador de conexión persistente o 'false' en caso de error.
Las diferencias con respecto a mysql_connect( ) son:
Primero: esta función intenta encontrar una conexión persistente que ya esté abierta con la misma máquina, usuario y password.
Si es encontrada, devuelve el identificador de la misma, en lugar de crear una nueva conexión.
Segundo, la conexión al servidor SQL no será cerrada cuando finalice la ejecución del script, sino que permanece abierta para un uso posterior.
La función mysql_close no cierra una conexión abierta con mysql_pconnect.
Las conexiones abiertas con esta función se llaman "persistentes".
Ejemplo:
$con = mysql_pconnect("localhost", "nobody","123"); // abre una conexión persistente
En $con nos devolverá (si tiene éxito) el identificador de una conexión persistente al servidor localhost con el usuario nobody y password 123 .
FUNCIÓN mysql_query()
Su forma es la siguiente:
mysql_query(consultaSQL,identif._conexion );
Ejecuta una consulta a la base de datos activa en el servidor relacionado con el identificador de conexión.
Si este identificador se ignora, se utiliza la última conexión abierta.
Si no hay conexiones abiertas la función intenta establecer una.
Esta función devuelve TRUE o FALSE para indicar si las operaciones UPDATE, INSERT o DELETE han tenido éxito.
Para la operación SELECT devuelve un nuevo identificador de resultado.
FUNCIÓN mysql_result()
Su forma es la siguiente:
mysql_result(int result, int row, mixed campo);
Devuelve el contenido de la celda de un resultado.
El argumento 'campo' puede ser un índice o el nombre del campo correspondiente o bien el nombre del campo de la forma: tabla.campo.
Si la columna tiene un alias ('select código as codcli from clientes...') se utiliza el alias en lugar del nombre del campo.
En lugar de esta función es preferible usar mysql_fetch_row(), mysql_fetch_array(), y mysql_fetch_object(), con las que obtendremos mejor rendimiento.
Ejemplo:
$result = mysql_query("SELECT * FROM agenda", $con); //hace una consulta a la tabla "agenda"
En $resul están todos los registros de la tabla agenda que debe pertenecer a la base de datos seleccionada previamente y que esta en la conexión $con.
FUNCIÓN mysql_select_db()
Su forma es la siguiente:
mysql_select_db(nombre_basededatos,ident._conexion )
Devuelve: true si tiene éxito o false en caso de error.
Establece la base de datos activa en el servidor. Si no se establece identificador de conexión se utiliza la última conexión abierta.
Si no hay conexiones abiertas o activas, la función intenta establecer una.
A partir de la llamada a mysql_select_db las llamadas a mysql_query( ) actúan sobre la nueva base de datos activa.
Ejemplo:
mysql_select_db("mydb", $con); //selecciona la base de datos "mydb" utilizando la conexión $con
Selecciona la base de datos mydb alojada en el servidor con el cual hemos conectado mediante el identificador de conexión $con.
FUNCIÓN mysql_tablename()
mysql_tablename(int result, int i);
Toma como argumento un puntero devuelto por la función mysql_list_tables( ) y devuelve el nombre de la tabla situada en la posición del índice i.
Podemos usar la función mysql_num_filas( )para definir el número de tablas.
Ejemplo:
<?php mysql_connect ("localhost:3306"); $result = mysql_list_tables ("basededatos"); $i = 0; while ($i < mysql_num_filas ($result)) { $tb_nombre[$i] = mysql_tablename ($result, $i); echo $tb_nombre[$i] . "<BR>"; $i++; } ?>