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 filas
o 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:

ORACLE
MYSQL
POSTGRESS
DB2
INTERBASE
SQLSERVER
INFORMIX

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++;
}
?>