jueves, 9 de abril de 2009

Manual de PHP 74. MySQL: Añadir datos mediante formularios

Continuando con los manuales de PHP, en esta entrada describo cómo añadir datos a tu base de datos desde un formulario HTML.





Creación del formulario

El caso más frecuente -casi el único- es que los registros de una tabla se añadan utilizando un formulario y enviando desde él los datos a un script PHP que ejecute la opción de añadir. Si no recuerdas el funcionamiento de este método, pulsa aquí



En el ejemplo hemos desarrollado un formulario para añadir registros a la tabla demo4 con las siguientes peculiaridades:

  • Para los campos DNI, nombre y apellidos hemos utilizado input tipo texto y hemos recogido mediante la opción name cada uno de los campos en una variable independiente.
  • Para los campos Fecha de nacimiento y hora de nacimiento hemos utilizado tres opciones select en cada una de ellas.
    La finalidad de estas opciones no es otra que impedir la introducción de fechas no válidas (en realidad no lo impedimos totalmente ya que, tal como está confeccionado, podría introducirse 31 de febrero, o 31 de abril). Ese aspecto es mejorable, pero para hacerlo –desde el propio formulario– tendríamos de recurrir a un lenguaje del lado del cliente (JavaScrpt por ejemplo).
  • Los valores de esos tres campos (tanto en fecha como en hora) los recogemos en variables que son elementos de dos array escalares.
  • El campo sexo la recogemos en input tipo radio y les asignamos valores M ó F que coinciden con los valores del campo ENUM de la tabla.
  • Con el campo Fumador -opción Fumador/No fumador - hacemos exactamente lo mismo, pero asignándoles valores 1 o 0 ya que el formulario no permite la opción NULL ó cadena vacia.
    En el script posterior será cuando modifiquemos los valores de esas variables.
  • Para el campo Idiomas utilizamos una opción select de tipo múltiple y para los values un pequeño truco que describimos aquí más adelante.
Pues bien, aquí tienes, código fuente del formulario que hemos diseñado:


<html>

<head>

<title>Formulario para añadir datos a la tabla demo4</title>

</head>

<body>

<center><h2>Tabla «demo4»<br>Formulario de altas<h2></center>



<!-- creamos un formulario en el que recogeremos los valores

a añadir a la base de datos demo4

utilizaremos los mismos nombres de variables que en aquel

- por razones de comodidad- anteponiendoles p_ //-->



<form name="altas" method="POST" action="ejemplo173.php">

<table bgcolor="#E9FFFF" align=center border=2>



<td align="right">Escribe tu D.N.I.: </td>

<td align="left"> <input type="text" name="p_v1" value="" size=8></td><tr>

<td align="right">Nombre....: </td>

<td align="left"> <input type="text" name="p_v2" value="" size=20></td><tr>

<td align="right">Primer apellido....: </td>

<td align="left"> <input type="text" name="p_v3" value="" size=15></td><tr>

<td align="right">Segundo apellido...: </td>

<td align="left"> <input type="text" name="p_v4" value="" size=15></td><tr>

<td align="right">Fecha de nacimiento: </td>



<!-- para evitar fechas de nacimiento incorrectas

utilizamos la opción select para asignarles valores

y recogemos e un array de indices 0, 1 y 2

los valores respectivos de año, mes y día

con el ánimo de mantener la misma secuencia

con la que MySQL registrará estos datos //-->





<td align="left"> <select name="p_v5[2]">

<!-- insertamos un script PHP que nos genere autmaticamente las options con valores entre

1 y 31 (se trata del campo dias //-->



<? for ($i=1;$i<32;$i++){

echo "<option>$i</option>";

}

?>

</select> de



<!-- repetimos un bucle como el anterior las options de mes

esta vez entre 1 y 12 (se trata del campo dias //-->



<select name="p_v5[1]">

<? for ($i=1;$i<13;$i++){

echo "<option>$i</option>";

}

?>

</select> de



<!-- ahora el bucle para años, tratándose de fechas de nacimiento

pongámoslas en el intervalo 1935 - 2003 //-->



<select name="p_v5[0]">

<? for ($i=1935;$i<2004;$i++){

echo "<option>$i</option>";

}

?>



<!-- el sexo lo recogemos mediante una una opcion

tipo radio y le asignamos cheked al valor M

para obligar a que tenga el mismo valor

El unico detalle relevante es que el name ha de ser el mismo

en ambos botones de opcion //-->



</select></td><tr>

<td align="right">Sexo...:</td>

<td align="left"> <input type="radio" name="p_v6" value="M" checked > Masculino <input type="radio" name="p_v6" value="F" > Femenino </td><tr>

<td align="right">Hora de nacimiento: </td>





<!-- para insertar la hora de nacimiento utilizamos la misma

estrategia que para la fecha de nacimiento

utilizando un array como variable y asignando

los indices 0, 1 y 2 para

horas, minutos y segundos respectivamente //-->



<td align="left"> <select name="p_v7[0]">

<? for ($i=0;$i<24;$i++){

echo "<option>$i</option>";

}

?>



</select> h

<select name="p_v7[1]">

<? for ($i=0;$i<60;$i++){

echo "<option>$i</option>";

}

?>

</select> m

<select name="p_v7[2]">

<? for ($i=0;$i<60;$i++){

echo "<option>$i</option>";

}

?>

</select> s</td><tr>



<!-- volvemos a utilizar la opción radio para asignar valor 1 al caso de fumador

valor 0 en el caso de no fumador y recogemos el resultado

en la variable p_v8 //-->



<td align="right">Fumador:</td>

<td align="left"> <input type="radio" name="p_v8" value="1" checked > Si <input type="radio" name="p_v8" value="0" > No </td><tr>



<!-- la opción idiomas la activamos mediante un SELECT MULTIPLE

que permite visualizar las OPCIONES DE IDIOMA

POR EL MISMO ORDEN EN QUE FUERON DEFINIDAS

EN LA OPCION SET DE LA BASE DE DATOS

A cada una de las opciones les asignamos como valor

una POTENCIA DE DOS empezando por

2 elevado 0, 2 elevado 1, 2 elevado 2, etc.

la finalidad de esta estrategia es permitir

que en el formulario de ALTAS

se puedan sumar estos valores y que esa suma

se el valor decimal equivalente al valor binario

de las opciones seleccionadas

El array p_v9 recogerá con indices correlativos

a partir de 0, unicamente los valores de

AQUELLAS OPCIONES QUE HAN SIDO SELECCIONADAS //-->







<td align="right">Habla:<br>

(<i>Si habla varios seleccionarlos<br>

pulsando con el mouse encima de <br>

cada uno de ellos con la tecla<br>

<b>Ctrl</b> presionada</i>)</td>

<td align="left"> <SELECT MULTIPLE name=p_v9[] SIZE=6>

<option value=1>Castellano</option>

<option value=2>Francés</option>

<option value=4>Inglés</option>

<option value=8>Alemán</option>

<option value=16>Búlgaro</option>

<option value=32>Chino</option>

</select>

</td><tr>



<!--colocamos los botones de enviar y borrar //-->





<td align=center><input type=submit value="Enviar"></td>

<td align=center><input type=reset value="Borrar"></td>

</form>

</table>

</body>

</html>




Añadir nuevo registro con datos del formulario

Como recordarás, cuando se envía el contenido de un formulario mediante el method=POST y se indica como action un fichero PHP los valores enviados son recogidos en este último fichero en variables de PHP que tienen como nombre $_POST['var'] –o $HTTP_POST_VARS['var']– donde cada una de los índices asociativos de los array (var) coinciden con los name de los diferentes campos del formulario.

A partir de ahí, bastaría con depurar los valores recibos, recoger en variables los valores depurados e incluirlos en la sentencia MySQL INSERT -la hemos visto en la página anterior- para añadirlos a la tabla correspondiente. Aquí tienes –comentado– el script:


<?

# recogemos en una variable el nombre de BASE DE DATOS

$base="ejemplos";



# recogemos en una variable el nombre de la TABLA

$tabla="demo4";



# recoger y adaptar las variables pasadas desde el formulario

# ni el DNI ni los nombres y apellidos necesitan ninguna modificacion

# por eso los pasamos a la variable intermedia directamente

/* estas variables intermedias podrían evitarse. El hecho de usarlas

obedece unicamente a un intento de mayor claridad en la interpretación

de este codigo fuente */

$v1=$_POST['p_v1'];

$v2=$_POST['p_v2'];

$v3=$_POST['p_v3'];

$v4=$_POST['p_v4'];



/* Leemos el array pv__5 y lo recogemos

en un array escalar de indices autonumericos

(nacimiento) teniendo en cuenta que el orde sería

dia, mes y año, ya que así lo hemos insertado

en los indices del formulario */

foreach ($_POST['p_v5'] as $valor){

$nacimiento[]=$valor;

}



/* creamos la variable fecha de nacimiento

ENCADENANDO el array anterior

FIJATE QUE LO HACEMOS EN ORDEN INVERSO

PORQUE MySQL REQUIERE FECHAS CON FORMATO

AÑO-MES-DIA (AAAA-MM-DD) */

$v5=$nacimiento[2]."-".$nacimiento[1]."-".$nacimiento[0];



# la variable Sexo la recogemos sin modificaciones

# ya que desde el formulario solo recibimos

# valor M ó valor F

$v6=$_POST['p_v6'];



/* Leemos el array pv__5 y lo recogemos

en un array escalar (hora) de indices autonumericos

teniendo en cuenta que el orde sería

dia, mes y año, ya que así lo hemos insertado

en los indices del formulario */

foreach ($_POST['p_v7'] as $valor){

$hora[]=$valor;

}



/* encadenamos los elementos del array hora en formato válido

MySQL, es decir: hora:minutos:segundos (hh:mm:ss) */

$v7=$hora[0].":".$hora[1].":".$hora[2];



# la variable $p_v8 puede contener valores

# 0 (no fumador) ó 1 (si fumador)

# con este bucle asignamos NULL para el primero de los casos

# o CADENA VACIA para el segundo

# ¡¡Atención......

# fijate como pasamos la cadena vacia

# y fijate que en el INSERT no ponemos la variable $v8 entre comillas

# es la excepción para el tipo de variable CHAR(O)

# LA UNICA QUE NO PASAMOS ENTRECOMILLADA

if ($_POST['p_v8']==0) {

$v8='"\n"';

}else{

$v8='""';

}



# el truco de asignar en el formulario valores 1,2,4,8,16,32 a las opciones de idioma

# nos permite sumarlos aquí para obtener el valor conjunto

# aqui se suman todos los valores de la matriz pasada desde el formulario

foreach($_POST['p_v9'] as $valor) {

$v9+=$valor;

};



# establecemos la conexion con el servidor

$c=mysql_connect("localhost","pepe","pepa");



#asiganamos la conexión a una base de datos determinada

mysql_select_db($base,$c);



# AÑADIMOS EL NUEVO REGISTRO

/* CUIDADO.....

SOLO LAS VARIABLES NUMERICAS VAN SIN COMILLAS AL INSERTAR LOS VALOES

OBSERVA EN VALUES QUE LAS VARIABLES NO NUMERICAS SE INSERTAN

ENTRE COMILLAS..... */

mysql_query("INSERT $tabla (DNI,Nombre,Apellido1,Apellido2, Nacimiento,Sexo,Hora,Fumador,Idiomas) VALUES ('$v1','$v2','$v3','$v4','$v5','$v6','$v7',$v8,'$v9')",$c);



#comprobamos el resultado de la insercion

# el error CERO significa NO ERROR

# el error 1062 significa Clave duplicada

# en otros errores forzamos a que nos ponga el número de error

# y el significado de ese error (aunque sea en ingles)....

if (mysql_errno($c)==0){echo "<h2>Registro AÑADIDO</b></H2>";

}else{

if (mysql_errno($c)==1062){echo "<h2>No ha podido añadirse el registro<br>Ya existe un campo con este DNI</h2>";

}else{

$numerror=mysql_errno($c);

$descrerror=mysql_error($c);

echo "Se ha producido un error nº $numerror que corresponde a: $descrerror <br>";

}

}



# cerramos la conexion

mysql_close();



?>




En realidad, tal como habrás podido ver en el código fuente, la depuración ha sido la siguiente:
  • Hemos creado un valor de fecha y hora en formatos MySQL válidos de la forma que describimos un poco más arriba.
  • Hemos sumado todos los valores numéricos recibidos en el array obtenido del SELECT MULTIPLE y hemos asignado el resultado a la variable depurada que recoge el valor a escribir en el campo Idiomas. La justificación de esa suma la tienes al final de la entrada.
  • La variable Fumador es la que tiene un poquito más de complicación. Veámosla con calma:
    Los valores que recibimos desde formulario son 1 o 0 y hemos de transformarlos en una cadena vacía o en NULL. Hemos insertado un operador condicional (un if... else) para convertir eso valores en: $var="'\N'" (comilla doble, comilla simple, barra invertida, N, comilla simple y comilla doble) ó $var="''" (comillas dobles, dos comillas simples y unas comillas dobles)
  • Asignados los nuevos valores tenemos que recurrir a un pequeño truco. Venimos repitiendo que en la sentencia INSERT los nombres de las variables no numéricas que contienen los values hay que escribirlos dentro de comillas simples, pero en el caso de un campo tipo CHAR(0) hemos de hacer una excepción que sería no poner esas comillas al nombre de la variable. Al hacerlo así, se escribirían como valores –en la sentencia de inserción– uno de estos: ='\N' o =' ' (los valores de la variable) que al contener comillas ya son interpretados por MySQL como una cadena.


Los valores de SELECT MULTIPLE

La opción SELECT MULTIPLE dentro de un form típico de HTML permite elegir ninguno, uno o varios de los elementos de la lista.

Basta con pulsar con el ratón sobre cada uno de los valores elegidos manteniendo pulsada la tecla Ctrl, es decir, puro Windows.

Para recoger los valores de esa opción se define -dentro de la etiqueta SELECT- un name tipo array. Bastaría con escribir:

<SELECT MULTIPLE

name=var[] SIZE=6>


Como ves, var es el nombre de la variable (esta vez sin $ delante, recuerda que no estamos en PHP sino en puro HTML) y va seguido de [] precisamente para indicar que es un array.

Lo de SIZE=6 no es otra cosa que el parámetro que indica cuántos elementos de la lista de opciones queremos que se visualicen simultáneamente en la página.

El truco está en los values de cada option dentro de ese select

Los hemos escrito así:


<option value=1>Castellano

<option value=2>Francés

<option value=4>Inglés

<option value=8>Alemán

<option value=16>Búlgaro

<option value=32>Chino




Fíjate que hemos mantenido exactamente el mismo orden en el que han sido definidos en el campo SET de la tabla.

Y fíjate también en los valores: 1, 2, 4, 8, 16 y 32 que son precisamente las potencias de 2:

20, 21, 22, 23, 24, 25, y 26

Al ir seleccionando valores, van añadiéndose al array. Por ejemplo. Si seleccionamos Francés y Búlgaro el array sería este: var[0]=2, var[1]=16

Si sumamos esos valores (2 + 16) el resultado sería 18, y al convertir a binario este valor, resultará:

010010

que es como decirle a MySQL (mirando la cadena de derecha a izquierda, ¿lo recuerdas?) que incluya los valores segundo (Francés) y quinto (Búlgaro) del SELECT MULTIPLE que corresponden a las posiciones en las que la cadena binaria contiene un uno.





Fuente:



miércoles, 8 de abril de 2009

Acer AspireRevo



Si hace unos días escribía una entrada sobre equipos que podrían tener un lugar en el salón de nuestras casas, hoy os copio una entrada publicada en engadget sobre la presentación del primer equipo con gráficos NVIDIA Ion que allí os comentaba:

Acer acaba de anunciar el AspireRevo, el primer mini-ordenador de escritorio con gráficos NVIDIA Ion, es decir, puede reproducir contenido 1080p y DirectX 10. En su interior incluye un procesador Intel Atom 230 de 1,6GHz, 4GB de RAM, disco duro de 250GB, lector de tarjetas 4-en-1, salidas HDMI y VGA, Ethernet gigabit, seis puertos USB 2.0, entrada y salida de audio, y Windows Vista Home Premium/Basic como sistema operativo. El tamaño de este diminuto ordenador es de sólo 18x18x3 cm, y aunque todavía no hay información sobre el precio o la fecha de lanzamiento, se dice que estará disponible este segundo trimestre del 2009

Manual de PHP 73. MySQL: Añadir registros e índices

Manejando índices

Es muy frecuente la utilización de índices en las bases de datos. Pero... ¿qué son los índices? ¿para qué sirven?.

Si nos planteamos cuál es la utilidad del índice de un libro la respuesta sería:
  • Facilitar la búsqueda de datos
  • Agilizar esa búsqueda
La utilidad de los índices en la bases de datos es la misma.


Tipos de índices

Si seguimos con el ejemplo del libro veremos que caben las posibilidades de que tenga:
  • Un solo índice
  • Varios índices
Algunos libros sólo contienen un indice de contenidos. Sin embargo, es frecuente que también dispongan de otros, tales como: índices analíticos, índices onomásticos, etcétera.

Cuando existe un solo índice es obvio que puede decirse de él que es único y cuando existen varios podemos decir que el índice de contenidos es el índice principal y los demás son índices sin más o índices auxiliares.

Coincidirás con nosotros en que en el Índice de contenidos de un libro de texto sólo existe una referencia al Tema XIII en la que puede decir: Tema XIII página 314.

También coincidirás en que si en ese índice, además de lo anterior, dijera: Tema XIII página 714 nos encontraríamos en una situación confusa que nos obligaría a preguntarnos: ¿donde está el Tema XIII? ¿En la página 314? ¿En la 714? ¿En ambas?.

Es por eso que las tablas de las bases de datos no admiten nunca valores duplicados ni en los índices únicos ni tampoco en los índices principales.

Los índices auxiliares tienen un comportamiento distinto. El índice onomástico de un libro puede hacer referencia a varias páginas y puede tener duplicados.

Por ejemplo: en un manual de Word puede existir un índice onomástico en el que se asocie la palabra macros con las páginas 37, 234 y 832 siempre que en esas páginas existan contenidos que aludan a la palabra macro.

Es por eso que las tablas de las bases de datos también admiten duplicados cuando se trata de índices auxiliares.

Sintaxis de la definición de índices MySQL

Tanto al crear una tabla como al modificarla se pueden añadir índices de la misma forma que también se pueden insertar campos.

La sintaxis (dentro de la sentencia MySQL que crea o modifica una tabla) es la siguiente:

PRIMARY KEY(campo)

donde campo es el nombre del campo que se establece como índice principal de la tabla.

El nombre del campo no va entrecomillado y PRIMARY KEY (campo) se añade dentro de la sentencia CREATE como si se tratara de un campo más, delimitado por comas, salvo que estuviera al final de la sentencia CREATE, en cuyo caso se omitiría la coma final.

En el código fuente de la creación de la tabla que encontrarás al final de la entrada puedes ver un ejemplo práctico de la sintaxis.

Solo puede definirse un índice primario por tabla y el campo utilizado ha de ser un campo no nulo.

UNIQUE nombre (campo)

Similar a PRIMARY KEY, en cuanto a que no admite valores duplicados, pero con dos diferencias importantes.
UNIQUE permite la creación de más de un índice de este tipo por tabla y además no requiere que los campos sobre los que se define sean no nulos.

INDEX nombre (campo)

Con esta sintaxis se crea un índice secundario que debe tener un nombre (la posibilidad de que existan varios obliga a identificarlos de esta forma) y -como en los casos anteriores- el campo que va a ser utilizado como índice.

INDEX nombre (campo(n))

Es un caso particular del anterior utilizable sólo en el caso de que el campo índice sea tipo CHAR y VARCHAR que permite indexar por los n primeros caracteres de esas cadenas.

El valor de n ha de ser:

n <= 256

dado que el tamaño máximo de un índice está limitado en MySQL a 256 bytes.

Otra limitación de MySQL es el número máximo de índices de una tabla que no puede ser mayor de dieciséis.

Los errores MySQL

PHP dispone de dos funciones que nos permiten detectar si una sentencia MySQL se ha ejecutado correctamente o si se ha producido algún error.

Son las siguientes:

mysql_errno($enl)

Indica el número de error que se ha producido en la transacción MySQL realizada a través del identificador de enlace $enl.

Cuando el número de error es CERO significa que no se ha producido error.

Otros valores bastante usuales son los siguientes:


Error número 1050

Indica que hemos tratado de crear una tabla ya existente.

Error número 1062

Indica que hemos tratado de introducir un valor con clave duplicada. Aparecerá cuando tratemos de introducir un valor ya existente en un campo con índice único o principal.

mysql_error($enl)

Devuelve la descripción del error. Cuando el número de error es CERO devuelve una cadena vacía.

Resulta de muchísima utilidad para depurar scripts.

Añadir registros a una tabla

Las sentencias MySQL que permiten añadir registros a una tabla son las siguientes:

INSERT tabla (campo1,campo2,..) VALUES (valor1,valor2,..)

Vamos a desarrollar un ejemplo completo de creación de una tabla e inserción de registros utilizando diversos métodos. Para ello seguiremos el siguiente proceso:

1.- Creación de la tabla

Empezaremos creando una tabla a la que llamaremos demo4 y que contendrá los siguientes campos:
  • Contador, que será de tipo TINYINT(8) (número entero con un máximo de 8 dígitos) que contenga solo valores positivos, que se rellene automáticamente con ceros por la izquierda y que se autoincremente cada vez que añadimos un registro.
  • DNI, destinado a recoger valores de números de DNI y que debe poder contener un máximo de ocho caracteres.
    Lo definiremos de tipo CHAR porque sus valores, pese a ser numéricos, nunca van a requerir ningún tratamiento aritmético.
  • Nombre, Apellido1 y Apellido2 serán tres campos tipo VHAR de tamaños máximos respectivos de 20, 15 y 15 caracteres.
    Su finalidad la evidencian los nombres de campo. Les asignaremos el flag NOT NULL aunque no sea totalmente correcto dado que existen países en los que se utiliza un solo apellido.
  • Nacimiento será un campo tipo DATE al que asignaremos como valor por defecto el de 1970-12-21. Recuerda que MySQL trata las fechas en ese orden (año-mes-dia) y que admite como separadores tanto - como / por lo que son válidas entradas con cualquiera de estos formatos: 1970-12-21 ó 1970/12/21, aunque esta segunda es convertida automaticamente al primer formato por MySQL.
  • Hora será un campo tipo TIME al que asignaremos como valor por defecto el de 00:00:00. Recuerda que MySQL trata las horas en ese orden (hh:mm:ss) y que sólo admite como separador :.
    Este campo está destinado a recoger la hora de nacimiento que aunque no tiene demasiado sentido es una buena excusa para introducir este tipo de campo.
  • Sexo será un campo tipo ENUM que tendrá dos opciones: M (masculino) y F(femenino) y al que asignaremos M como valor por defecto.
  • Fumador será un campo tipo CHAR(0) que por su estructura -cadena de longitud cero- tendrá dos únicas opciones de valor: NULL ó "", que, como veremos, son valores distintos para MySQL
  • Idiomas será un campo tipo SET definido para los valores: Castellano, Francés, Inglés, Alemán, Búlgaro y Chino y que podrá contener, como ocurre con los campos de este tipo, ninguno, uno o varios de los valores de la lista.
  • Índice primario será tratado como tal el campo DNI ya que se trata de un valor único para cada persona y que, como tal, no puede tener duplicados
  • Índices auxiliares. Para ejemplificar su tratamiento consideraremos el campo Contador como índice secundario.
El código fuente del fichero que genera esta tabla puedes verlo aquí debajo

<?

$base="ejemplos";

#definimos otra variable con el NOMBRE QUE QUEREMOS DAR A LA TABLA


$tabla="demo4";


# establecemos la conexión con el servidor


$c=mysql_connect ("localhost","pepe","pepa");


#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS CREAR LA TABLA


mysql_select_db ($base, $c);

# creamos la cada con la sentencia de inserción de los campos

$crear="CREATE TABLE $tabla (";

# definimos como autoincremental el campo contador

# de esta forma irá tomando valores automaticamente

# este tipo de campo va a requerir que lo definamos como campo INDICE

$crear.="Contador TINYINT(8) UNSIGNED ZEROFILL NOT NULL AUTO_INCREMENT,";

$crear.="DNI CHAR(8) NOT NULL, ";

$crear.="Nombre VARCHAR (20) NOT NULL, ";

$crear.="Apellido1 VARCHAR (15) not null, ";

$crear.="Apellido2 VARCHAR (15) not null, ";

# insertamos un valor por defecto en la fecha de nacimiento

$crear.="Nacimiento DATE DEFAULT '1970-12-21', ";

$crear.="Hora TIME DEFAULT '00:00:00', ";

# insertamos un campo tipo Enum

$crear.="Sexo Enum('M','F') DEFAULT 'M' not null, ";

$crear.="Fumador CHAR(0) , ";

$crear.="Idiomas SET(' Castellano',' Francés','Inglés',' Alemán',' Búlgaro',' Chino'), ";

# ahor insertamos el indice principal que evitará que se puedan repetirse

# los numeros de DNI

$crear.=" PRIMARY KEY(DNI), ";

# el indice asociado al contador

# que por su caracter autonumerico es inevitable

$crear.=" UNIQUE auto (Contador)";

$crear.=")";

#Creamos la cadena, comprobamos si esa instrucción devuelve

# VERDADERO o FALSO

# y dependiendo de ellos insertamos el mensaje de exito o fracaso



if(mysql_query ($crear ,$c)) {

echo "<h2> Tabla $tabla creada con EXITO </h2><br>";

}else{

echo "<h2> La tabla $tabla NO HA PODIDO CREARSE ";

# echo mysql_error ($c)."<br>";

$numerror=mysql_errno ($c);

if ($numerror==1050){echo "porque YA EXISTE</h2>";}

};

# cerramos la conexión... y listo...

mysql_close($c);

?>




Crear tabla demo4

2.1.- Añadir un registro

Cuando se añade un registro en una tabla los valores pueden añadirse en la propia sentencia MySQL o ser recogidos de los valores de variables PHP previamente definidas.

En este ejemplo tienes el código fuente del primero de los casos, en el que se añade a la tabla anterior un registro cuyos valores son:

DNI Nombre Apellido1 Apellido2 Nacimiento Sexo Hora Fumador Idiomas
1234 Lupicinio Servidor Servido 1954-11-23 M 16:24:52 NULL 3

Código fuente:


<?

# recogemos en una variable el nombre de BASE DE DATOS

$base="ejemplos";



# recogemos en una variable el nombre de la TABLA

$tabla="demo4";



# establecemos la conexion con el servidor

$conexion=mysql_connect("localhost","pepe","pepa");



#asiganamos la conexión a una base de datos determinada

mysql_select_db($base,$conexion);



# AÑADIMOS EL NUEVO REGISTRO

$v10='""';

mysql_query("INSERT $tabla (DNI,Nombre,Apellido1,Apellido2, Nacimiento,Sexo,Hora,Fumador,Idiomas) VALUES ('1234','Lupicinio','Servidor','Servido','1954-11-23','M','16:24:52',NULL,3)",$conexion);



#comprobamos el resultado de la insercion

# el error CERO significa NO ERROR

# el error 1062 significa Clave duplicada

# en otros errores forzamos a que nos ponga el número de error

# y el significado de ese error (aunque sea en ingles)....

if (mysql_errno($conexion)==0){echo "<h2>Registro AÑADIDO</b></H2>";

}else{

if (mysql_errno($conexion)==1062){echo "<h2>No ha podido añadirse el registro<br>Ya existe un campo con este DNI</h2>";

}else{

$numerror=mysql_errno($conexion);

$descrerror=mysql_error($conexion);

echo "Se ha producido un error nº $numerror que corresponde a: $descrerror <br>";

}

}

# cerramos la conexion

mysql_close();

?>



Añadir regitro

Presta atención a los siguientes aspectos:
  • En la sentencia no se alude al campo Contador. La razón es que se trata un campo AUTOINCREMENTAL y en ese tipo de campos los valores de los registros se escriben automáticamente cada vez que se añade uno nuevo.
  • El registro no se añadiría si el valor de DNI coincidiera con otra ya existente en la tabla. Recuerda que habíamos definido ese campo como índice primario.
    Si no hubiéramos incluido el aviso de error no tendríamos ninguna referencia sobre el éxito de la inserción y no detectaríamos el problema de duplicidad. Sencillamente ocurriría que el registro no se añadiría pero no nos enteraríamos de tal circunstancia.
  • Si en los valores de nombre y apellidos hubiéramos insertado textos más largos del tamaño establecido para ellos al crear la tabla, las cadenas se recortarían y sólo se añadirían -de izquierda a derecha- los n primeros caracteres de la cadena.
  • Si en la fecha de nacimiento hubiéramos introducido una cadena vacía nos habría puesto el valor por defecto, pero si hubiéramos introducido un valor no válido nos habría escrito 0000-00-00.
    Serían valores no válidos en este caso:
    • Los que tuvieran como valor de mes alguno no perteneciente al intervalo [1,12].
    • Los que tuvieran como valor de día un valor no válido en concordancia con el mes y el año. Admitiría 29 en un mes de febrero sólo en el caso de que el año fuera bisiesto.
    • Cuando la secuencia no coincidiera con esta AAAA-MM-DD.
    • Cuando los separadores no fueran (-) o (/)
  • En el campo Sexo si hubiéramos introducido una cadena vacía nos habría puesto M (valor por defecto) pero si hubiéramos intentado introducir un valor que no fuera M ni F nos habría insertado una cadena vacía.
  • El campo hora se comportaría de idéntica forma al de fecha salvo que aquí la secuencia es: hh:mm:ss, que la hora debe pertenecer al intervalo [0,23], los minutos y los segundos a [0,59] y que el único separador válido en este caso es (:).
  • El campo Fumador requiere particular atención ya que se trata de un campo CHAR(0) que sólo admite dos valores: NULL o cadena vacía, que como recordarás son distintos para MySQL.
    • Para introducir el valor NULL -utilizando el procedimiento de inserción de este ejemplo- tienes dos posibilidades, o escribir NULL sin ponerlo entre comillas -tal como lo he hecho en el ejemplo o escribir '\n' que como ves, es el carácter especial \n esta vez colocado entre comillas.
    • Para introducir una cadena vacía en este campo bastaría con que pusieramos '' (¡ojo no es una comilla doble es la comilla sencilla (') repetida dos veces!
      Date cuenta de que si pusiéramos comillas dobles tendríamos un error ya que hay unas comillas dobles delante del INSERT que se cierran al final de la sentencia MySQL y que no podemos volver a escribirlas entre ambas para evitar un falso cierre de la cadena que contienen.

  • En este caso el valor del campo Idiomas puede contener valores decimales comprendidos entre 0 y 64 o entre sus equivalentes binarios que son 0 y 111111.
    El valor 64 lo justifica el hecho de que son seis los elementos que puede contener el campo (hemos definido: Castellano, Francés, Inglés, Alemán, Búlgaro y Chino que son seis y que el caso de insertarlos todos requeriría el número binario 111111, cuyo valor decimal es precisamente 64.
    El valor 3 significa lo mismo que su equivalente binario (11) o mejor (000011) lo cual quiere decir que, como el primer carácter de la derecha es uno el campo toma el primer elemento de la lista (Castellano), como el segundo (de derecha a izquierda) también es uno tomará también el segundo elemento de la lista (Francés) y por ser cero todos los demás no tomará ningún otro valor de la lista, con lo que la cadena resultante sería en este caso Castellano, Francés.
  • Fíjate también en que el valor 3 no lo hemos puesto entre comillas porque se trata de una expresión decimal. ¿Qué ocurría si hubiera puesto 11? ¿Lo habría interpretado como once (decimal) o como tres (binario)?.
    La solución es simple: '11' (entre comillas) sería interpretado como binario, sin comillas como decimal.
  • No es necesario introducir valores en todos los campos, es decir, que la lista de campos de la sentencia INSERT puede no contenerlos a todos.
  • No es necesario escribir el nombre de los campos en el mismo orden en el que fueron creados pero si es imprescindible que campos y valores estén escritos en la sentencia INSERT exactamente en el mismo orden y también que en esa sentencia el número de campos y el número de valores sea el mismo.
  • Recuerda que los values tipo numérico no se incluyen entre comillas, mientras que los no numéricos tienen que estar contenidos entre comillas incluso en el caso de no se inserten directamente sino a través de una variable PHP.

2.2- Añadir un registro a partir de datos contenidos en variables

También es posible añadir registros a partir de valores contenidos en variables PHP. Esta opción es, sin ninguna duda, la más utilizada ya que lo habitual será escribir el contenido a añadir en un form y después -a través del method (POST o GET)- pasar al script de inserción esos valores como variables PHP.

Aquí tienes el código fuente de un ejemplo con la tabla anterior:


<?

# recogemos en una variable el nombre de BASE DE DATOS

$base="ejemplos";



# recogemos en una variable el nombre de la TABLA

$tabla="demo4";



# recogemos en variables los valores que vamos a asignar a cada campo

$v1="9876545";

$v2="Gonzalo";

$v3="Fernández";

$v4="del Campo";

$v5="1957/11/21";

$v6="M";

$v7=date("h:i:s");

$v8="\n";

$v9=7;



# establecemos la conexion con el servidor

$c=mysql_connect("localhost","pepe","pepa");



#asiganamos la conexión a una base de datos determinada

mysql_select_db($base,$c);



# AÑADIMOS EL NUEVO REGISTRO

#####################################################################

# ¡¡MUCHO CUIDADO CON LOS VALUES!! #

# OBSERVA QUE AUNQUE SON VARIABLES VAN ENTRE COMILLAS #

# salvo el caso de $v9 que es un NUMERO #

# ESTE DETALLE ES SUMAMENTE IMPORTE #

#####################################################################



mysql_query("INSERT $tabla (DNI,Nombre,Apellido1,Apellido2, Nacimiento,Sexo,Hora,Fumador,Idiomas) VALUES ('$v1','$v2','$v3','$v4','$v5','$v6','$v7','$v8',$v9)",$c);



#comprobamos el resultado de la insercion

# el error CERO significa NO ERROR

# el error 1062 significa Clave duplicada

# en otros errores forzamos a que nos ponga el número de error

# y el significado de ese error (aunque sea en ingles)....



if (mysql_errno($c)==0){echo "<h2>Registro AÑADIDO</b></H2>";

}else{

if (mysql_errno($c)==1062){echo "<h2>No ha podido añadirse el registro<br>Ya existe un campo con este DNI</h2>";

}else{

$numerror=mysql_errno($c);

$descrerror=mysql_error($c);

echo "Se ha producido un error nº $numerror que corresponde a: $descrerror <br>";

}

}



# cerramos la conexion

mysql_close();

?>









Añadir regitro

Quizá te resulten de alguna utilidad estos comentarios
  • Observa en el código fuente que al insertar las variables en los VALUES de la sentencia MySQL ponemos cuando se trata de valores tipo cadena '$variable' (el nombre de la variable entre comillas) y cuando se trata de valores númericos sin comillas.
  • Si quieres introducir el valor NULL en un campo tipo VAR(0) define la variable así: $var="\n" y si quieres introducir una cadena vacía defínela de este otro modo:$var="''" -comillas dobles (") seguidas de dos comillas sencillas (') y para terminar otras comillas dobles (").

3.- Variantes de la sentencia INSERT

La sentencia INSERT cuya sintaxis se indica más arriba como:

INSERT tabla (campo1,campo2,..) VALUES (valor1,valor2,..)

permite algunos modificadores opciones tales como:
INSERT [LOW_PRIORITY | DELAYED] [IGNORE] tabla (campo1,..) VALUES (valor1,..)

de ellos LOW_PRIORITY y DELAYED son incompatibles por lo que solo cabe uno u otro pero ambos a la vez.

Veamos su utilidad. La inserción de registros y la lectura de una tabla son procesos incompatibles, pero cabe la posibilidad de que se intenten ejecutar simultáneamente. No olvides que estamos en Internet y es perfectamente posible que desde dos ordenadores distintos, dos personas distintas estén accediendo a la misma tabla simultáneamente y que uno de los accesos sea de escritura, es decir: añadir, modificar o borrar campos en la tabla

¿Quién tiene preferencia de paso? ¿Quien tiene que esperar?. Si la opción LOW_PRIORITY está activada, el proceso de escritura esperará a que terminen los procesos de lectura activos pero se si está activa la opción DELAYED el proceso de lectura se interrumpirá automáticamente para ceder el paso al de escritura.

Respecto a la opción IGNORE tiene utilidad cuando se trata de realizar una secuencia de inserciones. Si no está activa en el momento en el que aparezca una clave duplicada se interrumpirá el proceso de inserción, por el contrario, si estuviera activa el proceso de inserción continuará con los siguientes registros de la secuencia, aunque -como es lógico- seguirán sin insertarse los registros con clave duplicada.

4.- Tablas para pruebas

Aquí tienes comentado un script que permite agregar aleatoriamente y de forma automática registros a la tabla demo4.

Dado que en las páginas siguientes trataremos de consultas va a resultarnos muy cómodo poder rellenarlas de forma automática.


<?

# recogemos en una variable el nombre de BASE DE DATOS



$base="ejemplos";



# recogemos en una variable el nombre de la TABLA



$tabla="demo4";



#creamos un array con DIEZ NOMBRES



$nombres=array("Fernando","Generosa","Gonzalo","Servanda","Dorotea","Filiberto","Tiburcio","Lupicinia");

$nombres[]="Telesfora";$nombres[]="Ambrosio";



#creamos un array con DIEZ PRIMEROS APELLIDOS



$ape1=array("Alonso","Fernández","Alvarez","Domínguez","García","Rodríguez","Iglesias","Cano");

$ape1[]="Barcena";$ape1[]="López";



#creamos un array con DIEZ SEGUNDOS APELLIDOS



$ape2=array("del Rio","del Campo","del Valle","del Monte","de Loriana","de Nora","de Aviles","de Blimea");

$ape2[]="de Grado";$ape2[]="de las Asturias";



#creamos una variable contador inicializada a cero

$i=0;



# establecemos la conexion con el servidor

$c=mysql_connect("localhost","pepe","pepa");



#asiganamos la conexión a una base de datos determinada



mysql_select_db($base,$c);





#creamos un bucle definiendo el número de registros que queremos añadir

# en este caso 10



while($i<100){

#generamos numeros aleatorios

#introducimos la semilla del generados



mt_srand((double)microtime()*1000000);

# generamos un numero de DNI aleatoriamente



$v1=mt_rand(1,99999999);





# elegimos aleatoriamente uno de los 10 nombres del array

# elegimos el valor entre 0 y 9 porque los indices empiezan en CERO



$v2=$nombres[mt_rand(0,9)];



# elegimos aleatoriamente uno de los 10 primeros apellidos del array





$v3=$ape1[mt_rand(0,9)];





# elegimos aleatoriamente uno de los 10 primeros apellidos del array



$v4=$ape2[mt_rand(0,9)];





# elegimos una fecha aleatoria entee 1-1-1970 (comienzo del tiempo UNIX)

# y 462837600 que corresponde al 1 de Setiembre de 1984

# en ese intervalo estará la fecha generada aleatoriamente

# tomada con formato MySQL año-mes-dia (AAAA-MM-DD)



$v5=date("Y-m-d",mt_rand(0,462837600));



#trateremos de buscar una coherencia aproximada

# a los nombres y sexos de la lista aleatoria

# si el nombre acaba en "a" asignaremos sexo femenino (F)

# si acaba en "o" masculino (M)



$v6=substr($v2,-1);



if ($v6=="a"){

$v6="F";

}else{

$v6="M";

}



# extraemos de la fecha aleatoria anterior la hora



$v7=date("h:i:s",mt_rand(0,462837600));







# como el valor del campo fumador es tipo CHAR(0) solo admite

# como valores NULL ó ""

# lo generamos así:



$v8=mt_rand(0,1);



if ($v8==0){

$v8="\N";

}else{

$v8="''";

}







# dado que tenemos en el campo SET SEIS POSIBLES OPCIONES

# elegimos aleatoriamente un numero entre y 0 y 64

# que son los equivalentes binarios de 000000 y 111111





$v9=mt_rand(0,64);



# AÑADIMOS EL NUEVO REGISTRO



mysql_query("INSERT $tabla (DNI,Nombre,Apellido1,Apellido2, Nacimiento,Sexo,Hora,Fumador,Idiomas) VALUES ('$v1','$v2','$v3','$v4','$v5','$v6','$v7',$v8,'$v9')",$c);



########################################################

# UNA FUNCIÓN MUY INTERESANTE........

# mysql_afected_rows($c) devuelve el número

# de registros afectados por la ultima llamada

# a una INSERCION, MODIFICACION O BORRADO

# DE REGISTROS A TRAVÉS DE mysql_query

# Aquí, dado que tenemos un bucle para la inserción

# vamos acumulando sus valores en un contador

############################################################





$registros_anadidos += mysql_affected_rows($c);





#comprobamos el resultado de la insercion

# el error CERO significa NO ERROR

# el error 1062 significa Clave duplicada

# en otros errores forzamos a que nos ponga el número de error

# y el significado de ese error (aunque sea en ingles)....







if (mysql_errno($c)==0){$i++;



}

#cerramos el bucle while del principio

}







# cerramos la conexion

print "Se han añadido: ".$registros_anadidos ." registros";



mysql_close();



?>












Insertar datos demo4





Fuente:

martes, 7 de abril de 2009

Manual de PHP 72. MySQL: Ver y modificar estructuras

Visualizar la estructura de una tabla

Es posible visualizar la estructura de una tabla de dos maneras: utilizando nuevas funciones de PHP, o aplicando nuevas sentencias MySQL con las funciones ya conocidas.

Lectura de resultados de sentencias MySQL

La sentencia SHOW FIELDS – como prácticamente ocurre con todas las sentencias MySQL– no devuelve los resultados en formato legible.

Los resultados devueltos por estas sentencias requieren ser convertidos a un formato que sea interpretable por PHP.

Esa traducción se realiza de la siguiente forma:

El resultado devuelto por MySQL a través de una llamada mysql_query() es recogido en una variable, de la forma siguiente:

$r=mysql_query(sent, $c)

El resultado recogido en la variable $r, está estructurado en líneas y la función:

$t =mysql_fetch_row ($r)

recoge en una variable ($t) el contenido de la primera línea y coloca su puntero interno al comienzo de la línea siguiente. Por esta razón la lectura completa del contenido de la variable $r requiere llamadas sucesivas a mysql_fetch_row hasta que haya sido leída la última línea del resultado de la llamada a MySQL.

La variable $t tiene estructura de array escalar siendo cero el primero de sus índices.

Cuando el puntero interno de mysql_fetch_row() alcance el final de la última línea del resultado devolverá FALSE.

Por esa razón, la visualización de los resultados de una sentencia MySQL suele requerir dos bucles. Este es el esquema de la lectura:

$r=mysql_query(inst,$c);
while($t=mysql_fech_row($r){
foreach ($t as $valor){
print $valor;
}

}


o también

while($t=mysql_fech_row($r){
$g[]=$t;
}


con lo que estaríamos creando un array bidimensional con el contenido de los resultados de cada línea.

En este caso el primer índice del array $g seguiría las normas de creación de arrays y se iría autoincrementando en cada ciclo del bucle while.

El ejemplo final tiene desarrollados ambos métodos.

Existe una función alternativa que mejora las prestaciones de la anterior. Se trata de:

$t =mysql_fetch_array($r)

es idéntica en cuanto a su funcionamiento y, además, añade una nueva posibilidad ya que los arrays que devuelve pueden ser leídos como escalares y también como asociativos. En este último caso incorporan como índice el nombre del campo de la tabla del que se han extraído cada resultado.

Respecto a la forma en la que sea asignan los índices a los array obtenidos mediante consultas a tablas, puedes verla en este enlace.

Otras funciones informativas

mysql_num_fields ($res)

Está función -en la que $res es el identificador de resultado - devuelve el número de campos de la tabla.

mysql_num_rows ($res)

Devuelve el número de registros que contiene la tabla. Si la tabla no contiene datos devolverá CERO.

mysql_field_table($res, 0)

Devuelve el nombre de la tabla. Observa que se pasa con índice 0 ya que esta información parece ser la primera que aparece en la tabla.

mysql_field_type($res, $i)

Nos devuelve el tipo de campo correspondiente a la posición en la tabla señalada por el índice $i. Dado que la información de primer campo está en el índice 0, el último valor válido de $i será igual al número de campos menos uno.

mysql_field_flags($res, $i)

Nos devuelve los flags del campo correspondientes a la posición en la tabla señalada por el índice $i. Se comporta igual que la anterior en lo relativo a los índices.

mysql_field_len($res, $i)

Nos devuelve la longitud del campo correspondiente a la posición en la tabla señalada por el índice $i. Igual que las anteriores en lo relativo a los índices.

mysql_field_name($res, $i)

Nos devuelve el nombre del campo correspondiente a la posición en la tabla señalada por el índice $i. En lo relativo a los índices su comportamiento es idéntico a las anteriores.

Liberando memoria

Si queremos liberar la parte de la memoria que contiene un identificador de resultado bastará con que insertemos la siguiente instrucción:

mysql_free_result($res)

Este proceso debe ser posterior a la visualización de los datos.


Ver la estructura de una tabla utilizando MySQL


La sentencia MySQL que permiten visualizar la estructura de una tabla es la siguiente:


SHOW FIELDS from nombre de la tabla



<?
# asignamos a una variable el nombre de la base de datos
$base="ejemplos";
# esta otra recoge el nombre de la tabla
$tabla="ejemplo1";
# establecemos la conexión con el servidor
$c=mysql_connect ("localhost","pepe","pepa");
# seleccionamos la base de datos
mysql_select_db ($base, $c);

#ejecutamos mysql_query llamando a la sentencia
# SHOW FIELDS

$resultado=mysql_query( "SHOW FIELDS from $tabla",$c);

# determinamos el número campos de la tabla

$numero=mysql_num_rows($resultado);

# Presentamos ese valor númerico

print "La tabla tiene $numero campos&ltbr>";

# ejecutamos los bucles que comentamos al margen
while($v=mysql_fetch_row ($resultado)){
foreach($v as $valor) {
echo $valor,"<br>";
}

}



#####################################################################
# REPETIMOS LA CONSULTA ANTERIOR USANDO AHORA LA #
# función mysql_fecth_array #
#####################################################################

#tenemos que VOLVER a EJECUTAR LA SENTENCIA MySQL
# porque el puntero está AL FINAL de la ultima línea
# de los resultados

$resultado=mysql_query( "SHOW FIELDS from $tabla",$c);

print("<BR> Los resultados con mysql_fech_array<br>");


while($v=mysql_fetch_array($resultado)){
foreach($v as $clave=>$valor) {
print ("El indice es: ".$clave." y el valor es: ".$valor."<br>");
}

}


################### la tercera posibilidad comentada
####################################################

$resultado=mysql_query( "SHOW FIELDS from $tabla",$c);
# intentaremos explicar este doble bucle con calma
/* En los procesos anteriores a cada paso del bucle
foreach leiamos un array, lo imprimiamos y sustituiamos
ese array por uno nuevo

Ahora trataremos de recoger todos esos resultados en array
para ello usamos un array bidimensional que renueva
el primer indice en cada ciclo del bucle while
de ahi que pongamos el $contador para asignarle
el primer indice
Los segundos indices serán los valores de los indices
del array $v que recogemos de la petición MySQL
pero mysql_fetch_array genera dos indices para
cada uno de los valores, uno numerico y otro asociativo
asi que filtramos y si el indice es numérico
guardamos en el array llamado numerico
y si no lo es guardamos el llamado asociativo
Tendremos separados en dos array ambos resultados
¿Complicado... ? Es cuestión de analizar con calma */

# pongamos el contador a cero para asegurar
# no hay variables anteriores con el mismo nombre
# y valores distintos

$contador=0;

while($v=mysql_fetch_array($resultado)){
foreach ($v as $indice1=>$valor1){
if(is_int($indice1)){
$numerica[$contador][$indice1]=$valor1;
}else{
$asociativa[$contador][$indice1]=$valor1;
}

}

$contador++;
}

/* vamos a leer los array resultantes
empecemos por el numerico que al tener
dos indices requiere dos foreach anidados
el valor del primero será un array
que extraemos en el segundo */

foreach($numerica as $i=>$valor){
foreach ($valor as $j=>$contenido){
print ("numerico[".$i."][".$j."]=".$contenido."<br>");
}

}


foreach($asociativa as $i=>$valor){
foreach ($valor as $j=>$contenido){
print ("asociativo[".$i."][".$j."]=".$contenido."<br>");
}

}



# liberamos memoria borrando de ella el resultado

mysql_free_result ($resultado);

# cerramos la conexion con el servidor

mysql_close($c);
?>



Borrar una tabla


Las sentencias MySQL que permite borrar una tabla son las siguientes:

DROP TABLE IF EXISTS from nombre de la tabla


DROP TABLE from nombre de la tabla

la diferencia entre ambas radica en que usando la primera no se generaría ningún error en el caso de que tratáramos de borrar una tabla inexistente.


Aquí tienes el código fuente de un ejemplo:


<?

# insertamos un nombre de tabla imaginaria para evitar riesgos de ejecución
$base="ejemplos";
$tabla="prueba1";

$borrar="DROP TABLE ";
$borrar .=$tabla;
$conexion=mysql_connect ("localhost","pepe","pepa");
mysql_select_db ($base, $conexion);

if(mysql_query ($borrar ,$conexion)) {
echo "<h2> Tabla $tabla borrada con EXITO</h2><br>";
}else{
echo "<h2> La tabla $tabla NO HA PODIDO BORRARSE</h2><br>";
};

mysql_close($conexion);
?>








Borrar uno de los campos de una tabla


La sentencia MySQL que permite borrar uno de los campos de una tabla es la siguiente:


ALTER TABLE nombre de la tabla DROP nombre deL campo


Es posible modificar la estructura de una tabla -en este caso borrar un campo- siguiendo un procedimiento similar a los anteriores.

La única diferencia estriba en utilizar la sentencia MySQL adecuada.

Resulta obvio que el campo debe existir para que pueda ser borrado y si no existiera, es obvio también que se produciría un error.

Aquí tienes el código fuente de un script que borra uno de los campos de una tabla.

<?
# nombre de la base de datos
$base="ejemplos";

# nombre de la tabla en la que pretendemos borrar el campo
$tabla="tabla1";

# nombre del campo a borrar
$campo="num1";

# definicion de una variable que contiene la sentencia MySQL
# de borrado
$borrar="ALTER TABLE ";
$borrar.=$tabla;
$borrar.=" DROP $campo";

$conexion=mysql_connect ("localhost","pepe","pepa");

mysql_select_db ($base, $conexion);

if(mysql_query ($borrar ,$conexion)) {
echo "<h2> A la tabla $tabla se le ha BORRADO el campo $campo</h2><br>";
}else{
echo "<h2> No ha podido BORRAR</h2><br>";
};

mysql_close($conexion);
?>

Añadir un nuevo campo a una tabla


Las sentencia MySQL que permite añadir un nuevo campo a una tabla es la siguiente:

ALTER TABLE nombre de la tabla ADD nombre del campo tipo [flags]

El procedimiento es similar a los casos anteriores utilizando esta nueva sentencia MySQL.

La sintaxis es similar a la de la creación de tablas: el nombre del campo debe ir seguido del tipo sin otra separación que el espacio

Aquí tienes el código fuente de un script que añade uno de los campos de una tabla.

<?
$base="ejemplos";
$tabla="tabla1";

$anadir="ALTER TABLE ";
$anadir.=$tabla;
$anadir.=" ADD nuevocampo TINYINT(12) ";

$conexion=mysql_connect ("localhost","pepe","pepa");
mysql_select_db ($base, $conexion);

if(mysql_query ($anadir ,$conexion)) {
echo "<h2> A la tabla $tabla se le ha añadido un campo</h2><br>";
}else{
echo "<h2> No ha podido añadir</h2><br>";
};

mysql_close($conexion);
?>






Fuente:


lunes, 6 de abril de 2009

Manual de PHP 71.MySQL: Creación de tablas

Creación de tablas

Las tablas son elementos de las base de datos. Por esa razón nos resultará imposible crear una tabla sin tener creada y seleccionada una base de datos.

Es por eso que para la creación de una tabla se necesitan los siguientes requisitos:

– Tener abierta una conexión con el servidor MySQL.

– Tener seleccionada una base de datos.

Conexión con el servidor

La hemos comentado en la página anterior, recuerda que requería la función:

$c=mysql_connect(h, u, p)

Esa conexión ha de ser establecida antes de cualquier otra intervención relacionada con accesos a bases de datos y tablas.

Selección de la base de datos

Dado que podemos manejar bases de datos distintas –en este curso usaremos ejemplos y practicas– es preciso decir a MySQL con qué base queremos trabajar.

mysql_select_db("n", $c);

donde n es el nombre de la base de datos (puede ser una cadena entrecomillada o el nombre de una variable previa que contenga ese nombre). En este último caso, como es habitual, el nombre de la variable no llevaría comillas.

El segundo parámetro $c es el identificador de conexión. Es decir, la variable creada al establecer la conexión con MySQL.

Este valor debe insertarse siempre. La razón es que MySQL permite mantener abiertas, de forma simultánea, varias conexiones (podríamos manejar más de un servidor de bases de datos) y en esas condiciones sería necesaria una conexión distinta para cada servidor.

Creación de una tabla

En todas las transacciones PHP–MySQL habremos de utilizar instrucciones de ambos lenguajes.
La forma habitual –hay algunas excepciones– en la que PHP se comunica con MySQL es la función:

mysql_query("sent", $c);

donde la cadena sent contiene las instrucciones propias de MySQL –las comentamos a continuación– y $c sigue siendo la variable que contiene el identificador de conexión.

La sintaxis de las sentencias MySQL que crean tablas son las siguientes:

Crear una tabla MySQL

La creación de tablas MySQL requiere una de estas dos sentencias:

CREATE TABLE IF NOT EXISTS tabla (campo1, campo2,... )

CREATE TABLE tabla (campo1, campo2,... )

La única diferencia entre ambas opciones es que la segunda daría un error si tratáramos de crear una tabla preexistente (deberíamos recurrir al procedimiento que hemos visto cuando creábamos bases de datos) mientras que la primera no da ese mensaje de error.

Aunque no lo hemos indicado, CREATE DATABASE también permite esta sintaxis alternativa.

Definición de campos en una tabla MySQL

Cada uno de los campos que vayamos a crear en una tabla requiere una definición que debe contener lo siguiente:

– nombre del campo
Es una palabra cualquiera –distinta para campo de la tabla y que normalmente suele elegirse aludiendo al contenido. Por ejemplo, fec_nac, nom_perro, etcétera.

No va entre comillas nunca y MySQL diferencia mayúsculas/minúsculas.

Para utilizar como nombres de campo palabras reservadas –por ejemplo, create– del lenguaje MySQL debemos escribirla entre ` `. Observa que no son comillas sino acentos graves. Lo más aconsejable es evitar esta situación.

– tipo y dimensiones
Los tipos de campos –los hemos visto en la página anterior– tienen que ajustarse a uno de los soportados por MYSQL. Se escriben a continuación del nombre sin otra separación que un espacio y requieren la sintaxis –estricta– correspondiente a cada tipo.

– flags del campo ( son opcionales) Puede utilizarse cualquiera de los permitidos para cada tipo de campo –puedes verlos encerrados entre corchetes– al lado de cada tipo de campo.



DIMENSIONES

Cuando se establezca una dimensión como parámetro opcional de un campo deben tenerse en cuenta algunos detalles.

Si en un campo numérico introdujéramos valores que exceden los límites su valor no se registraría en la tabla sino el valor del límite más próximo correspondiente a ese tipo de campo.

Supongamos un campo tipo TINYINT que permite valores comprendidos entre -128 y 127. Si asignáramos en uno de sus registros un valor igual a 234 se escribiría en la tabla 127 (el límite superior) y si ponemos -834 escribiría el límite inferior, es decir, -128.

En caso de cadenas, si el valor introducido sobrepasara la longitud máxima permitida, la cadena sería recortada y únicamente se registraría el número máximo de caracteres permitidos.

Consideraciones sobre IF NOT EXISTS

Esta variante de CREATE –aplicable tanto en tablas como en bases de datos– tiene la ventaja de no dar mensajes de error en caso de intentar crear una tabla –o base– ya existente, pero puede darnos algún sobresalto porque no advierte que la tabla no ha sido creada y puede darnos la sensación de que puede haber reescrito una tabla anterior.

Si pulsas reiteradamente en el enlace Crear tabla ejemplo1 comprobarás que no aparece ningún mensaje de error.


Ejemplo de creación de una tabla

<?
/* nos conectamos con el servidor
recogiendo en $c el identificador de conexión */
$c=mysql_connect ("localhost","pepe","pepa") or die ("Imposible conectar");
# seleccionamos una base de datos existente
# de lo contrario nos daría un error
# pondremos como nombre ejemplos nuestra base de datos
# creada en la página anterior y usaremos $c
# importante no olvidarlo
mysql_select_db ("ejemplos", $c);
/* ahora ya estamos en condiciones de crear la tabla
podríamos escribir ya la instrucción mysql_query y meter
detro la sentencia MySQL pero, por razones de comodidad
crearemos antes una variable que recoja toda la sentencia
y será luego cuando la ejecutemos.
Definiremos una varable llamada $crear e iremos añadiendo cosas */
# la primera parte de la instrucción es esta (espacio final incluido
$crear="CREATE TABLE IF NOT EXISTS ";
# añadiremos el nombre de la tabla que será ejemplo1
# fijate en el punto (concatenador de cadenas) que permite
# ir añadiendo a la cadena anterior
$crear .="ejemplo1 ";
#ahora pongamos el paréntesis (con un espacio delante)
#aunque el espacio también podría detrás de ejemplo1
$crear .="( ";
# insertemos el primer campo y llamemoslo num1
# hagamoslo de tipo TINYINT sin otras especificamos
# sabiendo que solo permitira valores numéricos
# comprendidos entre -128 y 127
$crear .="num1 TINYINT , ";
# LOS CAMPOS SE SEPARAN CON COMAS por eso
# la hemos incluido al final de la instrucción anterior

# ahora num2 del mismo tipo con dimensión 3 y el flag UNSIGNED
# Y ZEROFILL que: cambiará los límites de valores
# al intervalo 0 - 255, y rellenará con ceros por la izquierda
# en el caso de que el número de cifras significativas
# sea menor de 3.
# Fijate que los flags van separado unicamente por espacios
$crear .="num2 TINYINT (3) UNSIGNED ZEROFILL, ";
# en num3 identico al anterior añadiremos un valor por defecto
# de manera que cuando se añadan registros a la tabla
# se escriba automaticamente ese valor 13 en el caso
# de que no le asignemos ninguno a ese campo
# por ser numérico 13 no va entre comillas
$crear .="num3 TINYINT (7) UNSIGNED ZEROFILL DEFAULT 13, ";
# ahora un número decimal num4 tipo REAL con 8 digitos en total
# de los cuales tres serán decimales y también rellenaremos con ceros
# Pondremos como valor por defecto 3.14
$crear .="num4 REAL (8,3) ZEROFILL DEFAULT 3.14, ";
# añadamos una fecha
$crear .="fecha DATE, ";
/* una cadena con un limite de 32 carácter con BINARY
para que diferencie Pepe de PEPE */
$crear .="cadena VARCHAR(32) BINARY, ";
/* un ultimo campo –opcion– del tipo ENUM que solo admita
como valores SI, NO, QUIZA
fijate en las comillas y en el parentesis
¡¡cuidado...!! aqui no ponemos coma al final
es el último campo que vamos a insertar y no necesita
ser separado. Si la pones dará un ERROR */
$crear .="opcion ENUM('Si','No','Quiza') ";
# solo nos falta añadir el paréntesis conteniendo toda la instrucción
$crear .=")";
/* tenemos completa la sentencia MYSQL
solo falta ejecutarla mediante mysql_query
ya que la conexión está abierta
y la base de datos ya está seleccionada */

/* pongamos un condicional de comprobación */
if(mysql_query($crear,$c)){
print "Se ha creado la base de datos<br>";
print "La sentencia MySQL podríamos haberla escrito asi:<br>";
print "mysql_query("."\"".$crear."\" , $c);";

}else{
print "Se ha producido un error al crear la tabla";
}

?>

Crear tabla ejemplo1





Fuente:


viernes, 3 de abril de 2009

Nintendo DSi y Acekard 2i



Hoy se pueden encontrar ya a la venta en España unidades de la Nintendo DSi. Cuando se anunció su comercialización una de las pretendidas mejoras era que no se podría continuar jugando a juegos no originales, pero en realidad ya se puede encontrar un cartucho, el Acekard 2i, que según anuncian en algunas páginas, permitiría la ejecución de ROMs almacenadas previamente.

Para rematarla, en algunos lugares ya se puede encontrar a la venta un "pack" que incluye la nueva consola y el cartucho para la ejecución de aplicaciones "creadas por nosotros mismos" tal y como podéis ver en la imagen que abre el artículo.

Relacionado con esto y para los que estéis planteándoos comprar una nueva consola portátil os copio el siguiente texto cuyo enlace original como siempre podréis encontrar al final de la página:

Acekard ha anunciado el lanzamiento de un nuevo cartucho flash compatible con todos los modelos de NDS, incluida la última DSi.

El Acekard 2i permite cargar software casero y copias de seguridad a través de su slot MicroSD, pero de momento no tiene acceso al slot de la consola ni al resto de sus nuevas funciones (cámaras de fotos, etc.).

El Acekard 2.1 tiene compatibilidad completa con ROMs y homebrew, trucos de Action Replay, soporte para memorias MicroSDHC y menor consumo eléctrico que anteriores modelos, ente otras características que podéis leer en el análisis, además de sus ventajas y desventajas frente al resto de cartuchos.


Enlaces:

Análisis del Acekard 2.1: http://www.elotrolado.net/noticia_analisis-flashcart-acekard-2-1-para-nds_15314

Venta Nintendo DSi y Acekard 2.1: http://www.todoconsolas.com/product_info.php?cPath=114_160&products_id=3036

Equipos de salón


Allá por agosto comentaba que por primera vez comenzaban a aparecer equipos que cualquiera podríamos incorporar al salón de nuestras casas.

La primera condición para que esto sea cierto pasa, sin duda, por la miniaturización de los dispositivos. A ello ha contribuido el procesador Atom de Intel, que una vez más, ha visto el peligro que podría suponer el Nano de Via y se ha puesto las pilas para incluso comercializarlo con tanta rapidez que se ha comido el mercado de netbooks con su procesador.

Otro factor a tener en cuenta es el consumo energético de estos aparatos. Probablemente estarán encendidos mucho tiempo, pensemos en la comodidad de ver los vídeos almacenados en nuestro ordenador o los que nos hemos bajado con nuestro software P2P, Youtube,...

Como factor final para los candidatos deberíamos pedir la mínima emisión de ruido si no queremos escuchar de manera permanente un ventilador gigante silbando al lado de nuestra TV. Todo ello hace que estos productos basados en Atom o Nano sean ideales para esta tarea.

Lo cierto es que estos días ando metido en varios cursos y no tengo mucho tiempo para escribir algo que no sean manuales, boletines de respuesta, ejercicios y más manuales pero el ion de NVidia y el Asus Eeebox 208 me parecen dos muy buenos candidatos para ser incorporados al salón de cualquier casa.




El Asus Eeebox 208 no es mas que un adelanto -léase despiste- de la compañía, que a los pocos días de haber puesto a la venta su modelo 206 filtraba en su propia página web y por unas horas, las características del que sería su siguiente modelo , el 208 y cuyas características básicas son: procesador Intel Atom 330 con doble núcleo y una tarjeta gráfica ATI Radeon HD4350 con 256 MB, puerto HDMI y una batería interna para que puedas usarlo a ratos sin tenerlo que conectar a la red eléctrica, en cuanto al disco duro ofrecerán versiones de 160, 250 y 320 GB, incluyendo cuatro USB y un HDMI .



Por otra parte, aunque esta vez de un modo oficial, NVidia también ha anunciado su propia plataforma llamada ION que básicamente es un netbook que delegará sus prestaciones para gráficos y visualización en una GeForce 9400M y que podéis ver en la imagen de cabecera de este artículo. Lo que lo diferencia de otros productos es que finalmente parece que se ofrecerá tanto con el procesador Atom como con el Nano y que ofrecerá velocidades para aplicaciones gráficas entre 5 y 10 veces superiores en rendimiento a los productos actuales. Mucho me temo que a estas alturas el rendimiento del procesador Intel superará al de Via en prestaciones.

Como todo anuncio precipitado, increiblemente en el mercado informático se están anunciando como comerciales productos que aún están en desarrollo y cuyas especificaciones, por tanto, es imposible conocer, parece que los consumos del producto de NVidia aún difieren bastante de lo que debería ser un producto de este tipo por, según palabras de la compañía, no estar todavía optimizado. Viendo la caja de la imagen y el ventilador, espero que también optimicen el tema de los ruidos, porque pocas cosas hay más molestas que oir un diálogo con el sonido zumbante del ventilador de la gráfica a toda pastilla.