sábado, 25 de abril de 2009

Manual de PHP 76. MySQL: Modificar Registros.

Sintaxis MySQL de modificación de registros

Las sentencias MySQL que permiten la modificación de registros en las tablas pueden incluir algunas de las siguientes cláusulas que, al igual que ocurría en casos anteriores, pueden tener categoría de obligatorias u opcionales.

El orden en que deben estar indicadas ha de seguir la misma secuencia en la que están descritas aquí.

(PULSE EN EL ENLACE LEER MAS PARA LEER EL CONTENIDO COMPLETO DEL ARTÍCULO)

UPDATE

Tiene carácter obligatorio, debe ser la primera palabra de la sentencia e indica a MySQL que vamos realizar una modificación.


[LOW_PRIORITY]

Es opcional e indica a MySQL espere a que se terminen de hacer las consultas que en ese momento pudiera haber en proceso antes realizar la actualización.

[IGNORE]

Es opcional. Cuando se incluye en una sentencia el proceso de actualización no se interrumpe si aparece un conflicto de clave duplicada en uno de los registros en proceso. Simplemente ignora ese registro y continúa con los siguientes

Si no se incluye, el proceso de modificación se interrumpe en el momento en que encuentre un conflicto de clave duplicada.

Tanto con ignore como sin esa cláusula, en el caso de duplicidad de clave NUNCA se efectúan las modificaciones.

tabla

Es obligatoria y contiene el nombre de la tabla que pretendemos modificar.

SET

Tiene carácter obligatorio y debe estar delante de las definiciones de campo y valor.

campo1 = valor1

Es obligatoria al menos una definición. Indica el nombre del campo a modificar (campo1) y el valor que se asignará a ese campo.

Si se pretende modificar más de un campo se repetirá esta definición tantas veces como sea necesario, separando cada una de ellas por una coma.

WHERE

Es un campo opcional y su comportamiento es idéntico a señalado al mencionar el proceso de consultas.

ORDER BY

Tiene idéntica funcionalidad a la descrita al referirnos a consultas


Modificar un campo en todos los registros de una tabla

La sentencia MySQL, que permite modificar uno o varios campos en todos los registros de una tabla, es la siguiente:

UPDATE tabla SET campo1=valor1, campo2=valor2

¡Cuidado con esta sentencia!. Hay que tener muy presente que con esta sentencia -en la que no aparece WHERE- se modificarán TODOS LOS REGISTROS DE LA TABLA y por lo tanto los campos modificados tendrán el mismo valor en todos los registros.

Algunas consideraciones sobre la sintaxis

Siempre que manejes PHP y MySQL debes tener muy presente lo siguiente:

  • MySQL requiere SIEMPRE que los valores tipo cadena que incluyen campos de fecha vayan entre comillas. Por el contrario, los numéricos no deben llevar comillas.
  • Presta mucha atención a esto cuando escribas los valores directamente en la sentencia MySQL
  • Cuando pases valores desde una variable PHP debes tener muy en cuenta las consideraciones anteriores y si el contenido de la variable es una cadena que va a ser tratada como tal por MySQL tienes dos opciones para evitar el error:

    • Definir la variable así: $variable ="'valor'" (comillas dobles, comilla simple al principio y comilla simple, comilla doble al final) y poner en la sentencia MySQL el nombre de la variable sin entrecomillar, o
    • Definir la variable PHP así: $variable ="valor" y al escribir el nombre de esa variable en la sentencia MySQL escribirlo entre comillas sencillas, es decir, así: '$variable'

  • No pienses que es caprichoso el orden que hemos puesto en las comillas. Recuerda que al llamar a la sentencia MySQL, el contenido de la sentencia va entre comillas (que por costumbre son comillas dobles, por esa razón todo entrecomillado que vaya dentro de esa sentencia ha de usar comillas simples para evitar un error seguro).

    De ahí que al definir una variable PHP en la forma $variable ="'valor'" las comillas dobles exteriores indican a PHP que se trata de una cadena, por lo que, al pasar la variable a MySQL éste recibirá el contenido de la cadena que es, logicamente: 'valor' y en este caso las comillas forman parte del valor, razón por el que no es necesario escribir -en la sentencia MySQL- el nombre de la variable entrecomillado.

En este primer ejemplo, hemos incluido una actualización de tablas que pondrá puntuación 7 en la primera de las pruebas a todos los aspirantes a astronautas de nuestro ejemplo.

Es un caso de actualización sin la condición WHERE y tiene el código comentado.


<?

$base="ejemplos";

# establecemos la conexión con el servidor

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



#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR

mysql_select_db ($base, $c);



# establecemos el nombre de la tabla en una variable

$tabla="demodat1";



# asignamos el valor a escribir en todos los registros a una varibale

$valor=7;



# hacemos la llamada a MySQL mediante la función mysql_query

# y le decimos que UPDATE (modifique) la tabla

# y que lo haga (SET) en el campo Puntos

# poniendo el valor que en este caso es 7

$resultado=mysql_query("UPDATE $tabla SET Puntos=$valor",$c);



# cerramos la conexión con la base de datos

mysql_close($c);



# escribimos un mensaje para que nos avise del final de proceso de actualización

echo "<h2>Proceso de actualización terminado</h2>";



# cerramo el script PHP

?>



<!--

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

# AHORA YA ESTAMOS EN HTML (hemos cerrado el script PHP con ?> #

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



escribimos esta script de JAVASCRIPT

para que el navegador cargue en la ventana actual

la página que nos permite visualizar el contenido

de las tablas y que es un ejemplo que hemos desarrollado

en la página anterior.

Como observarás esta llamada no la hacemos desde PHP

sino desde JavaScript, la razón es simple:

PHP se ejecuta en el servidor SIEMPRE

JavaScript se ejecuta siempre el el cliente (navegador del usuario)

y lo que pretendemos ahora es que el navegador del usuario

cargue la página indicada -->







<script language="JavaScript">

window.self.location="ejemplo196.php";

</script>



Selección y modificación de un solo registro

Es una de las opciones más habituales. Es el caso en el que –mediante un formulario– asignamos una condición a WHERE y simultáneamente asignamos los nuevos valor del campo o campos elegidos. Requiere la siguiente sintaxis:

UPDATE tabla SET campo1=valor1, campo2=valor2 WHERE condición

La condición es fundamental en esta opción y normalmente aludirá a un campo índice (clave principal o única), de modo que sea un solo registro el que cumpla la condición. Podría ser el caso, en nuestro ejemplo, del campo DNI que por su unicidad garantizaría que la modificación solamente va a afectar a uno solo de los registros.

El ejemplo siguiente nos permitirá hacer modificaciones de este tipo en la tabla deomodat2. Observa el código fuente y verás que mediante un simple recurso JavaScript, el script que realiza la modificación nos reenvía al formulario con un mensaje de confirmación de la modificación.

El formulario:

<html>

<head><title>Formulario de modificaciones</title></head>

<body>

<h2><center>MODIFICACION DE PUNTUACIONES<BR> DE LA PRUEBA Nº 2



<!-- Caundo la variable $avisa recoge el mensaje creado en

el script que actualiza la base de datos, la imprimimos

con esta etiqueta PHP -->



<? echo $_GET['avisa']; ?>



</H2></CENTER>

<FORM name="modificar" method="GET" action="ejemplo199.php">



<table align=center border=2>

<td>Escriba el DNI de la persona a calificar..:</td>

<td><input type="text" name="Penitente" value=""></td><tr>

<td>Escriba aquí la calificación..:</td>

<td><input type="text" name="Calificacion" value=""></td><tr>

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

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

</form>

</table>

<br><BR>

<H3><CENTER>Tenga en cuenta que la calificación requiere<br>un número de DNI existente en la base de datos</center></h3>

</body>

</html>


El Script:

<?

#recogemos del formulario las variables Calificacion y Penitente

# en variables automaticas de PHP que serán $Calificacion y $Penitente

# atención a Mayusculas/Minusculas en nombres de variables

# recuerda que para PHP son DISTINTAS

$Calificacion=$_GET['Calificacion'];

$Penitente=$_GET['Penitente'];

$base="ejemplos";



# establecemos la conexión con el servidor

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



#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR

mysql_select_db ($base, $c);



# establecemos el nombre de la tabla en una variable

$tabla="demodat2";



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

# COMPROBACION DE LA EXISTENCIA DE UN REGISTRO CON ESE D.N.I. #

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



# Es una operación necesaria para advertir al usuario de la correcta realización

# del proceso de modificación.

# Si introducimos un DNI inexistente la función UPDATE no DARA MENSAJE DE ERROR

# aunque evidentemente NO LO ACTUALIZARA tampoco

#

# Para hacer esa comprobación tenemos múltiples opciones una de ellas sería

# contar los registros en los que el DNI es igual al valor recibido en la variable

# $Penitente

# Si existiera el DNI devolvería UNO en el índice CERO DEL ARRAY

# recuerda que los indices de ese array se corresponden con el orden

# en el que han sido insertados los campos en la opcion SELECT

# en este caso solo ponemos uno... COUNT(DNI) por lo que el índice del array

# ha de ser el primero de los posibles que como sabes es CERO

$resultado=mysql_query("SELECT DNI FROM $tabla WHERE (DNI=$Penitente)",$c);

$comprueba=mysql_num_rows($resultado);



#HACEMOS LA COMPROBACION

# y en caso de inexistencia del recogemos en una variable ($Avisar)

# la cadena del mensaje de inexistencia

# en otro caso (cuando el DNI existe) hacemos que ese mensaje sea la cadena vacia

if($comprueba==0) {$avisar="<h2>No existe nadie con DNI ".$Penitente. " en la base de datos<br>Su Modificacion anterior no ha sido procesada</h2>";

}else{

$avisar="<BR>Calificación registrada<BR>";

}



# hacemos la llamada a MySQL mediante la función mysql_query

# y le decimos que UPDATE (modifique) la tabla

# y que lo haga (SET) en el campo Puntos

# poniendo el valor que en este caso $Calificacion

# si el DNI existe en la base de datos actualizará el valor

# y si no existe no pasa nada... ya tenemos el mensaje de error

# que nos aparecerá en la página formulario

$resultado=mysql_query("UPDATE $tabla SET Puntos=$Calificacion WHERE (DNI=$Penitente)",$c);



#colocamos la opcion de mensaje de error por si se produce alguna incidencia

if (mysql_errno($c)==0){echo " ";

}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 conexión con la base de datos

mysql_close($c);



# escribimos un mensaje para que nos avise del final de proceso de actualización



#insertamos el script de Java que nos devolverá al formulario



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

#fijate como pasamos el valor del mensaje de aviso #

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

# para pasar valores a PHP hay la opcion de añadir a la direccion

# URL del script el simbolo de cerrar interrogacion

# seguido del nombre de la variable con la que será transferido

# el signo igual y el valor de la variable

#

# si quieres pasar mas de una variable la sintaxis sería

# http://loquesea.php?variable1=valor1&variable2=valor2&variable3=valor3

?>



<script language='JavaScript'>

<? echo "window.self.location='ejemplo198.php?avisa=$avisar'" ?>

</script>




Modificación simúltanea de un campo en cualquiera de los registros

Aquí tienes un ejemplo que permite visualizar el valor actual de todas las puntuaciones de la prueba 2 de los astronautas así como sus nombres y apellidos y DNI y en la cual se pueden modificar ninguno, uno, varios o todos los valores y posteriormente actualizarlos todos con los nuevos valores.

El formulario:

<html>

<head>

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

</head>

<body>



<?



# definimos una variable con el NOMBRE DE LA BASE DE DATOS





$base="ejemplos";



# establecemos la conexión con el servidor



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



#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR



mysql_select_db ($base, $conexion);





#creamos una consulta de las bases de datos demo4 y demodat2

# esta segunda es la tabla de puntuaciones de la segunda prueba

# seleccionamos los campos DNI de ambas tablas

# y nombre y apellidos de la primera

# establecemos como condicion la IGUALDAD DE LOS DNI en ambas BASES











$resultado=mysql_query("SELECT demo4.DNI,demo4.Nombre,demo4.Apellido1, demo4.Apellido2 ,demodat2.Puntos FROM demo4, demodat2 WHERE (demo4.DNI=demodat2.DNI) ",$conexion);



# presentamos la salida en forma de tabla HTML



# estos son los encabezados





echo "<table align=center border=2 bgcolor='#F0FFFF'>";

echo "<td colspan=5 align=center>Para modificar escribe en la casilla correspondiente</td><tr>";

echo "<td colspan=4 align=center>Datos del aspirante</td>";

echo "<td align=center>Puntuación</td><tr>";





#escribimos la etiqueta de apertura de un formulario como method=post

# como action ponemos la direccion de la página que realizará las actualizaciones

# en este caso sera ejemplo201.php



echo "<form name='modificar' method=\"POST\" action='ejemplo201.php'>";



while($salida = mysql_fetch_array($resultado)){



# escribimos un bucle que nos lea desde el indice 0 hasta el indice 6

# de la matriz de salida ya que los indices 0,1,2,3,4...

# se corresponden con el número de orden tal como fueron establecidos

# los campos en la opción SELECT: 0 es el indice del primero

# 1 el de segundo, 2 el del tercero, etc. etc.



for ($i=0;$i<5;$i++){



# establecemos un condicion que escriba una tabla normal SALVO

# cuando $i=4 que es el valor actual de la puntuación

# cuando eso ocurre pedimos que escriba en la celda de la tabla

# un campo de formulario TIPO TEXTO cuyo NOMBRE SEA UNA MATRIZ

# aqui la hemos llamado ident

# cuyos indices sean los DNI de los personajes de la tabla

# recuerda que la $Salida[0] contiene siempre el primer elemento

# definido en la opcion SELECT y que en este caso es el DNI

# PEDIMOS QUE ESE CAMPO DEL FORM tenga por valor EL VALOR ACTUAL DE LA PUNTUACION

# existente en la base de DATOS





if($i!=4){



echo "<td>",$salida[$i],"</td>";

}else{

echo "<td><input type=text size=8 name=ident[$salida[0]] value=$salida[4]></td><tr>";

}



#cerramos el bucle for



}





# CERRAMOS EL BUCLE WHILE



}



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



mysql_close($conexion)



# SALIMOS DE PHP y ponemos los botones de borrar /enviar desde HTML



?>



<td colspan=5 align=center><br><input type=submit value='Modificar'> <input type=reset value='Borrar'>



<!-- CERRAMOS EL FORMULARIO Y LA TABLA -->



</form></table>



<!-- LOS CAMPOS DEL FORMULARIO PUEDEN MODIFICARSE DESDE EL TECLADO

Y RECOGERAN LAS MODIFICACIONES EN EL ARRAY iden que como recuerdas

TENIA POR INDICE EL Nº DE DNI

AL PULSAR EN ENVIAR ESE ARRAY ES PASADO A ejemplo133.php

QUE REALIZA LA ACTUALIZACION DE LA TABLA -->

</body>

</html>








El Script:


<?



$base="ejemplos";



# establecemos la conexión con el servidor



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



#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR



mysql_select_db ($base, $conexion);





# escribimos un bucle que nos lea la matriz pasada desde el formulario

# de modificación de datos

# el indice de esa matriz sera el DNI (fijate en el codigo fuente del formulario)

# y el valor asociado la puntuación tecleada en el formulario

# que será el valor con el que se modificará la tabla



# la instruccion WHERE obliga a que cada valor se asigne en la tabla

# al registro cuyo DNI coincide con el indice de la matria transferida desde el formulario



foreach ($_POST['ident'] as $indice=>$valor){



$resultado=mysql_query("UPDATE demodat2 SET Puntos=$valor WHERE DNI=$indice ",$conexion);





}



#cerramos la conexion



mysql_close($conexion);





# cerramos la etiqueta PHP y desde HTML llamamos a la página que visualiza los valores

# si todo ha ido bien :-) los campos apareceran actualizados



?>



<script language="JavaScript">



window.self.location="ejemplo200.php";



</script>






Fuente:



domingo, 19 de abril de 2009

Cumpleaños


Hoy hace una año que comencé este blog con una "declaración de intenciones" -visible en la parte superior izquierda de la pantalla- que sigue exactamente igual de vigente en estos momentos.

Cuando escribí mi primera entrada lo único que pretendía y sigo intentando, es mostrar aquellas tendencias en informática que me parecen significativas y relevantes por cuestiones que difieren de rendimientos y, por encima de todo ir incorporando ayudas y manuales que después pueda incorporar a mis clases o a mi labor como informático.

Lo que si puedo asegurar es que desde entonces he aprendido mucho, sobre todo en lo referente a blogs, publicaciones electrónicas,...pero sobre todo he pasado muchas horas elaborando manuales -buena parte de los cuales, en cualquier caso, son reelaboraciones de manuales libres de internet o de cursos a los que he asistido con licencia creative common-.

A pesar de ello me ha ayudado, sin duda, a ser mucho mas organizado y a organizar la información -esta página se ha convertido para mi en ese pen drive que me puedo olvidar porque sólo tengo que conectarme a Internet para recuperar la información- y me ha dado unas cuantas sorpresas. La primera de ella es que estas páginas se han descargado más de 200.000 veces y ha tenido más de 123.000 visitas únicas en un año; cuando comencé esperaba tener la visita de mis alumnos,... y sólo cuando usásemos la documentación en clases. Por citar otra que me sorprendió gratamente, de hecho no fui consciente de ello hasta bastante despues de haber sucedido, fue la reseña de este blog publicada en el ciberpaís.

En fin que muchas gracias a todos los que se han pasado por aquí y a los que me visitarán aunque nunca leerán esta entrada, y muchas gracias a todos los que os habéis leído todo este rollo con el que quería celebrar el llevar un año con apartamento de alquiler en Internet, y ya puestos poder publicar una imagen de mi blog en una entrada.

Tecnoloxiaxa



lunes, 13 de abril de 2009

Agregar Nube de Etiquetas en blogger


Probablemente te pase como a mi, que has ido añadiendo etiquetas a tus entradas y la lista se ha hecho inmensa, o simplemente deseas mostrarla de un modo más atractivo.

Una manera de solucionarlo es crear una nube de etiquetas - ( Tag Cloud ) - en la que las etiquetas se muestran con un tamaño menor o mayor dependiendo de la frecuencia con la que aparezcan -el número de post creados con dicha etiqueta-. Además en el que podéis ver en esta página se puede configurar, de modo muy sencillo para que muestre o no el número de veces en que aparece.

Puedes ver cómo añadir una nube de etiquetas a tu blog de blogger (blogspot) pulsando en el enlace leer mas - que es una traducción del enlace del final de la página.-

Lo primero que has de hacer es bajarte la plantilla y guardarla por si tienes algún problema y así poder restaurar tu plantilla original.

Código:




<b:widget id='TagCloud' locked='false' title='Tags' type='Label'>
<b:includable id='main'>
<b:if cond='data:title'>
<h2><data:title/></h2>
</b:if>
<div class='widget-content' style='text-align: justify;'>
<script type="text/javascript">
/*
Simple Blogger Tag Cloud Widget
by Raymond May Jr.
http://www.compender.com
Released to the Public Domain
*/

//Variables:
var max = 150; //max css size (in percent)
var min = 50; //min css size (...)
var showCount = 1; // show counts? 1 for yes
var minCount = 1; // what is the minimum count for a Tag to be shown? 1 for all.

//Begin code:
var range = max - min;

//Build label Array
var labels = new Array();
<b:loop values='data:labels' var='label'>
labels.push("<data:label.name/>");
</b:loop>
//URLs
var urls = new Array();
<b:loop values='data:labels' var='label'>
urls.push("<data:label.url/>");
</b:loop>

//Counts
var counts = new Array();
<b:loop values='data:labels' var='label'>
counts.push("<data:label.count/>");
</b:loop>

//Number sort funtion (high to low)
function sortNumber(a, b)
{
return b - a;
}

//Make an independant copy of counts for sorting
var sorted = counts.slice();

//Find the largest tag count
var most = sorted.sort(sortNumber)[0];
//Begin HTML output
for (x in labels)
{
if(x != "peek" && x != "forEach" && counts[x] >= minCount)
{
//Calculate textSize
var textSize = min + Math.floor((counts[x]/most) * range);
//Show counts?
if(showCount == 1)
{
var count = "(" + counts[x] + ")";
}else{
var count = "";
}
//Output
document.write("<span style='font-size:" + textSize + "%'><a href='" + urls[x] + "'>" + labels[x] + count + "</a></span> " );
}
}
</script>
</div>
</b:includable>
</b:widget>





Instalación:

Si ya tienes instalado en la página un elemento de tipo Etiqueta (Label) puedes saltar al paso 2


Paso 1:
Instala un elemento de tipo etiqueta: menú Diseño--> Elementos de la página --> Añadir un gadget en la columna que desees.

Busca el elemento Etiqueta y pulsa en "Añadir al blog"


Paso 2:
Reemplaza el código del widget Etiqueta que acabas de añadir por el código personalizado que tienes más arriba.

Para ello, primero navega por tu plantilla y pulsa expandir plantillas de artilugios


Busca el elemento widget Etiqueta (label) que acabas de añadir -debería ser algo similar al siguiente texto:

<b:widget id='Label1' locked='false' title='Tags' type='Label'>

aunque el id y el título podrían ser diferentes, por lo que mejor emplea la herramienta de búsqueda de tu navegador y buscatype='Label'.

Borra la etiqueta Label desde el inicio al final (debes borrar ambas también) que aparecerá marcado como

</b:widget>

y reemplaza todo lo seleccionado con el texto del código que hemos creado al principio.

Fuente:
http://www.compender.com/2007/12/simple-tag-cloud.html


Añadir "Leer más" o read more en Blogger

La página principal de tu blog generalmente muestra todo el contenido de cada unos de tus posts. Si estos son mayores a 2 párrafos, tus visitantes se verán en dificultades para encontrar rápidamente algún tema de interés para ellos dado que van a necesitar desplazarse hacia abajo en la página. Aquí es donde los post con resúmenes expandibles ayudaban en el viejo blogger.Este hack sirve al mismo propósito para el nuevo blogger y aún hace algunas cosas más!

Esto es, la página principal sólo mostrará los resúmenes de los posts y cuando den click en "leer más", el post completo aparecerá en la página principal (vista Peekabo)!!


He recibido algunas solicitudes para crear dicho hack y me las he arreglado para echarlo a andar. Más tarde, Hans lo mejoró agregando un enlace para "Mostrar Resumen" con el cual se puede colapsar nuevamente un post expandido para mostrar sólo el resumen. Juntos, también hicimos que el enlace "Leer Más" se mostrara únicamente para aquellos posts que tienen resumen. Este es un hack fantástico, pero necesitas tener cuidado al modificar tu template. Si no estás familiarizado con HTML, recomiendo de sobremanera que obtengas ayuda de alguien que lo conozca mientras aplicas este hack. Aquí están los pasos a seguir.


Paso 0.

¡IMPORTANTE!

Descarga y graba tu plantilla (template), de modo que puedas volver atrás si tienes algún problema con este truco.

Paso 1.


Encuentra la etiqueta </head> en tu template y agrega todo el código que se muestra a continuación antes de ella.


<b:if cond='data:blog.pageType != "item"'>
<script type="text/javascript">

var fade = false;
function showFull(id) {
var post = document.getElementById(id);
var spans = post.getElementsByTagName('span');
for (var i = 0; i &lt; spans.length; i++) {
if (spans[i].id == "fullpost") {
if (fade) {
spans[i].style.background = peekaboo_bgcolor;
Effect.Appear(spans[i]);
} else spans[i].style.display = 'inline';
}
if (spans[i].id == "showlink")
spans[i].style.display = 'none';
if (spans[i].id == "hidelink")
spans[i].style.display = 'inline';
}
}


function hideFull(id) {
var post = document.getElementById(id);
var spans = post.getElementsByTagName('span');
for (var i = 0; i &lt; spans.length; i++) {
if (spans[i].id == "fullpost") {
if (fade) {
spans[i].style.background = peekaboo_bgcolor;
Effect.Fade(spans[i]);
} else spans[i].style.display = 'none';
}
if (spans[i].id == "showlink")
spans[i].style.display = 'inline';
if (spans[i].id == "hidelink")
spans[i].style.display = 'none';
}
post.scrollIntoView(true);
}

function checkFull(id) {
var post = document.getElementById(id);
var spans = post.getElementsByTagName('span');
var found = 0;
for (var i = 0; i &lt; spans.length; i++) {
if (spans[i].id == "fullpost") {
spans[i].style.display = 'none';
found = 1;
}
if ((spans[i].id == "showlink") &amp;&amp; (found == 0))
spans[i].style.display = 'none';
}
}

</script>
<style>
#fullpost {
display:none;
}
</style>
</b:if>




Paso 2.
Encuentra el includable llamado 'post' y copia y pega los cambios mostrados en rojo de lo que se muestra a continuación (Debes tener mucho cuidado para evitar errores. Date cuenta que la palabra "uncustomized-post-template" puede no aparecer en tu template, pero no hay problema por ello y tampoco debes añadirla):

<b:includable id='post' var='post'>
<div class='post uncustomized-post-template' expr:id='"post-" + data:post.id'>
<a expr:name='data:post.id'/>
<b:if cond='data:post.title'>
<h3 class='post-title'>
<b:if cond='data:post.url'>
<a expr:href='data:post.url'><data:post.title/></a>
<b:else/>
<data:post.title/>
</b:if>
</h3>
</b:if>
<div class='post-header-line-1'/>
<div class='post-body'>
<b:if cond='data:blog.pageType == "item"'>
<p><data:post.body/></p>

<b:else/>
<style>#fullpost {display:none;}</style>
<p><data:post.body/></p>
<span id='showlink'>
<p><a href='javascript:void(0);' expr:onclick='"javascript:showFull(\"post-" + data:post.id + "\");"'>Leer Más...</a></p>
</span>
<span id='hidelink' style='display:none'>
<p><a href='javascript:void(0);' expr:onclick='"javascript:hideFull(\"post-" + data:post.id + "\");"'>Sólo Sumario...</a></p>
</span>
<script type='text/javascript'>
checkFull("post-" + "<data:post.id/>");
</script>
</b:if>
<div style='clear: both;'/> <!-- clear for photos floats -->
</div>




Para encontrar el Includable, puedes hacer una búsqueda por el término id="post". Si no te es posible encontrarlo, posiblemente no hayas expandido el template. Selecciona el checkbox con la etiqueta "Expand Widget Templates", que se encuentra justo encima del código del template, para expandir éste y mostrar más código.

N. de Tr. Para poder encontrar el Includable en el template será necesario pulsar el checkbox con la leyenda Expand Widget Templates como se aprecia en la imagen. La ubicación dependerá de la plantilla que hayamos seleccionado para nuestro blog. La advertencia aplica para el caso mostrado en la imagen, lo que aplica es simplemente agregar lo que está en rojo e ignorar los códigos previos, que podrán variar de acuerdo a la plantilla de nuestro blog. De acuerdo a nuestras preferencias, podemos también cambiar las leyendas Read More y Summary Only para que indiquen lo que al gusto de cada quien convenga.


Paso 3

Selecciona la pestaña Settings->Formatting (Cofiguración/Formato), hecho lo cual encontrarás en la parte inferior un cuadro de texto para que especifíques el "Post Template" (Plantilla de entrada). Copia y pega estas líneas a dicho cuadro de texto y guarda la configuración. (Por favor NO las teclees tu mismo dado que pudiera se que se introduzcan algunos espacios que causen que la funcionalidad se pierda).


Escribe tu resumen aquí.

<span id="fullpost">

Escribe el resto de tu post aquí.

</span>



Ahora cada vez que crees un nuevo post, se te va a indicar claramente dónde debes escribir el resumen y dónde agregar el resto del post. Es importante asegurarse de que la etiqueta </span> mostrada arriba se encuentra al final de tu post. Para asegurar esto, utiliza la pestaña "Edit HTML" (Edición de HTML) en lugar de la pestaña "Compose" (Redactar) cuando escribar tu post. Después de teclearlo, puedes regresar al modo "Redactar" y modificar la tipografía y colores. Cabe mencionar que también puedes dividir algunos (o todos) tus posts anteriores para que tengan un resumen, para lo cual tendrás que editarlos. El enlace "Leer más" aparecerá sólo para aquéllos posts que se hayan dividido de esta manera.

N. de Tr. Se agregó imagen para mostrar dónde se debe realizar el cambio.

Esto es lo que Ramani pide a cambio:

Si estás visitando mi blog por primera vez, no te pierdas de otras cosas interesantes que ofrezco:

  • Un blog de tipo Digg para compartir y promver tu blog - bvibes.com
  • Un template bastante rápido basado en AJAX - Neo

Notas Importantes:

  • Nota 1: Por favor no olvides agrear una liga a Hackosphere en tu sidebar. Eso es la única cosa que espero a cambio :)
  • Nota 2: Si quisieras incorporar algunos efectos especiales de aparecer/desaparecer para este hack, lo puedes tener incorporando unos cuantos cambios descritos en este otro post.
  • Nota 3. Si quisieras que la liga "Leer más" te llevara a la página del post en ligar de expandirlo en la página principal, utiliza este otro hack.
  • Nota 4. Si seleccionas la liga "Entradas anteriores", la liga "Leer más" pudiera aparecer aún para aquellos posts para los cuales no se ha incorporado el hack. Este es un problema conocido aún sin solución.


Escrito originalmente por Ramani, en su blog Hackosphere.

Traducido por: Amox con pequeñas modificaciones.

El ejemplo de su uso en el blog lo pueden ver aquí.




Manual de PHP 75. MySQL. Consultas en tablas.

Sintaxis MySQL de selección de registros


Las sentencias de selección de registros requieren utilizar -entre otras- palabras clave como las que enumeramos a continuación.

Observa que hay dos tipos: obligatorias y opcionales, y que algunas de las palabras clave son alternativas y por lo tanto, incompatibles en una misma sentencia.

El uso de estas palabras clave requiere que sean insertadas en un determinado orden tal y como se enumera aquí debajo.

Si alteráramos ese orden (p. ejemplo: colocando GROUP BY antes de WHERE) nos daría un error y no se ejecutaría la sentencia.




SELECT

Es la primera palabra de la sentencia de búsqueda y tiene carácter obligatorio.

[STRAIGHT_JOIN]

Es una palabra clave de uso opcional (la marcamos con corchetes para indicar su condición de opcional) que fuerza al optimizador MySQL a organizar las tablas en el mismo orden en el que han sido especificados los campos en la cláusula FORM.

Sirve para mejorar -en casos muy concretos- la velocidad de gestión de tablas de gran tamaño.

[SQL_BIG_RESULT]

Es una cláusula opcional que se usa para indicar al optimizador que el resultado va a tener una gran cantidad de registros.

En ese caso, MySQL utilizará tablas temporales cuando sea necesario para optimizar la velocidad de gestión de la información.

Esta cláusula también puede ser utilizada dentro de GROUP BY.

[SQL_BUFFER_RESULT]

Es opcional y su finalidad es la de forzar a MySQL a tratar el resultado en un fichero temporal.

Ese tratamiento ayuda a MySQL a liberar recursos más rápidamente y es de gran utilidad (siempre desde el punto de vista de la rapidez) cuando es necesario un largo proceso de cálculo antes de enviar los resultados al cliente.

[HIGH_PRIORITY]

Esta cláusula, opcional da prioridad al comando SELECT sobre otros comandos que simultáneamente pudieran estar intentando acceder a la tabla para escribir en ella (añadir o modificar registros).

Si esta opción está activa, los intentos de escritura que pudieran producirse de forma simultánea deberían esperar al final de este proceso para ejecutarse.

campo1, campo2, ...

Tienen carácter obligatorio y señalan los campos de la tabla que deben incluirse en la consulta.

La función SELECT sólo devolverá información de aquellos campos que estén enumerados aquí.

Si se desea que la consulta incluya a todos campos bastará con incluir en esta posición un *, que es el carácter comodín que indica a MySQL que se desea incluir todos los campos en la consulta.

Los campos numéricos tienen la opción de llevar asociadas funciones MySQL que devuelven información estadística.

Algunas de esas funciones son las siguientes:
  • MAX(campo..)
    Devuelve el valor máximo de ese campo en todos los registros de la tabla, salvo que tenga la opción GROUP BY, en cuyo caso devolverá el máximo de cada grupo, o cuando tenga activada la opción WHERE, en cuyo caso la función sólo será aplicada a los registros que resulten de tal filtrado.

  • MIN(campo..)
    Idéntica a la anterior en cuanto a criterios de selección, esta función devuelve el mínimo.

  • AVG(campo..)
    Devuelve el valor promedio de todos los registros numéricos seleccionados con los mismos criterios del caso anterior.

  • SUM(campo..)
    Devuelve la suma de los valores del campo y sigue idénticos criterios de selección de campos que en los casos anteriores.

  • STDDEV(campo..)
    Devuelve la estimación de la desviación típica de la población.

  • COUNT(campo..)
    Cuenta los valores no nulos del campo indicado.
En el caso de aplicar estas funciones, el resultado de la consulta contiene una sola línea, salvo que active la opción GROUP BY, en cuyo caso devolverá tantas líneas como grupos resulten.

FROM tabla


Esta expresión -que aunque no tiene carácter obligatorio podría tomarse como tal– indica a MySQL el nombre de la tabla en el que debe efectuarse la consulta.

WHERE definicion


Esta instrucción tiene carácter opcional y su utilidad es la de filtrar la consulta estableciendo los criterios de selección de los registros que debe devolver.

Si se omite WHERE, la consulta devolverá todos los registros de la tabla.

En la parte final de la entrada tienes información sobre la manera de definir los criterios de selección de esta opción.

GROUP BY definicion

Tiene carácter opcional y su finalidad es la de presentar los resultados de la consulta agrupados según el criterio establecido en su definición.

Resulta de gran utilidad cuando se pretende obtener valores estadísticos de los registros que cumplen determinadas condiciones (las condiciones del agrupamiento).

ORDER BY definicion

También tiene carácter opcional y su utilidad es la de presentar la información de la consulta ordenada por los contenidos de uno o varios campos.

Siempre tiene como opción complementaria de que en cada campo utilizado para la ordenación puede establecerse uno de estos criterios ASC (ascendente, es el valor por defecto) o DESC.

Si no se establece ningún orden, los resultados de la consulta aparecerán en el mismo orden en el que fueron añadidos los registros.

LIMIT m, n

Esta cláusula es opcional y permite establecer cuántos y cuáles registros han de presentarse en la salida de la consulta.

Por ejemplo: LIMIT 4, 8 indicaría a MySQL que la consulta debería mostrar OCHO registros contados a partir del quinto (sí, el quinto porque LIMIT considera el primer registro como CERO).

El criterio límite se aplica sobre los resultados de la salida, es decir, sobre los resultados seleccionados, ordenados y filtrados siguiendo los criterios establecidos por las cláusulas anteriores.

Si se escribe como un solo parámetro (LIMIT k), MySQL lo interpretará como que k es el segundo de ellos y que el primero es CERO, es decir:
LIMIT 0, k

Recuento de resultados

PHP dispone de dos funciones que permiten conocer el número de registros de la tabla afectados por una sentencia MySQL.

mysql_num_rows ($c )

Esta función devuelve un valor numérico que recoge el número de registros que cumplen las condiciones establecidas en una consulta. Sólo es válido para sentencia tipo SELECT

mysql_affected_rows($c )

En este caso la función devuelve también el número de registros afectados, pero sólo en el caso de que la sentencia MySQL haya producido modificaciones en los contenidos de la tabla. Es decir, sólo recoge resultados de sentencias que: añaden, modifican o borran registros.

Manejo de fechas en las consultas

MySQL dispone de algunas cláusulas de gestión de fechas que pueden tener una gran utilidad a la hora de gestionar consultas. Son las siguientes:

DATE_FORMAT( campo,formato)

Las diferentes opciones de formato las tienes en la tabla siguiente. Es importante tener en cuenta que la sintaxis correcta es %Y (sin espacio) ya que si hubiera un espacio % Y interpretaría la letra Y como un texto a incluir.

Formatos de fechas en consultas MySQL

Los formatos soportados por la función DATE_FORMAT format son los siguientes:

FormatoDescripción SintaxisVer códigoVer http://localhost/cursophp/ejemplo
%dDía del mes en formato de dos dígitosDATE_FORMAT(Nacimiento,\'%d\')VerProbar
%eDía del mes en formato de uno ó dos dígitosDATE_FORMAT(Nacimiento,\'%e\')VerProbar
%DNúmero de día seguido del sufijo en inglésDATE_FORMAT(Nacimiento,\'%D\')VerProbar
%mNúmero del mes en formato de dos dígitosDATE_FORMAT(Nacimiento,\'%m\')VerProbar
%cNúmero del mes en formato de uno o dos dígitosDATE_FORMAT(Nacimiento,\'%c\')VerProbar
%MNombre del mes (en inglés)DATE_FORMAT(Nacimiento,\'%M\')VerProbar
%bNombre del mes abreviado (en inglés)DATE_FORMAT(Nacimiento,\'%b\')VerProbar
%yNúmero del año en formato de dos dígitosDATE_FORMAT(Nacimiento,\'%y\')VerProbar
%YNúmero del año en formato de cuatro dígitosDATE_FORMAT(Nacimiento,\'%Y\')VerProbar
%wNúmero de día de la semana 0=Domingo ... 6=SábadoDATE_FORMAT(Nacimiento,\'%w\')VerProbar
%WNombre del día de la semana (en inglés)DATE_FORMAT(Nacimiento,\'%W\')VerProbar
%WNombre abreviado del día de la semana (en inglés)DATE_FORMAT(Nacimiento,\'%W\')VerProbar
%jNúmero de día del año en formato de 3 dígitosDATE_FORMAT(Nacimiento,\'%j\')VerProbar
%UNúmero de semana del año considerando el DOMINGO como primer día de la semana (en formato de dos dígitos)DATE_FORMAT(Nacimiento,\'%U\')VerProbar
%uNúmero de semana del año considerando el LUNES como primer día de la semana (en formato de dos dígitos)DATE_FORMAT(Nacimiento,\'%u\')VerProbar
La fecha para los http://localhost/cursophp/ejemplos siguientes la extraemos de una variable del tipo:
$fecha=\"2005-10-12 14:23:42\"
ya que la tabla no contiene campos de fecha que incluyan horas, minutos y segundos
%HHora con dos dígitos (formato 0 a 24 horas)DATE_FORMAT($fecha,\'%H\')VerProbar
%kHora con uno ó dos dígitos (formato 0 a 24 horas)DATE_FORMAT($fecha,\'%k\')
%hHora con dos dígitos (formato 0 a 12 horas)DATE_FORMAT($fecha,\'%h\')
%IHora con uno ó dos dígitos (formato 0 a 12 horas)DATE_FORMAT($fecha,\'%I\')
%iMinutos con dos dígitos DATE_FORMAT($fecha,\'%i\')
%sSegundos con dos dígitos DATE_FORMAT($fecha,\'%s\')
%rHora completa (HH:mm:ss) en formato de 12 horas indicando AM ó PM DATE_FORMAT($fecha,\'%r\')
%THora completa (HH:mm:ss) en formato de 24 horas DATE_FORMAT($fecha,\'%T\')
% textoIncluye el texto que se indica detrás del % DATE_FORMAT($fecha,\'% texto\')
%pAñade AM ó PM dependiendo de la Hora DATE_FORMAT($fecha,\'%p\')
Se pueden combinar a voluntad varias opciones utilizando una sintaxis de este tipo:
\'% Hoy es: %d - %m - %Y % es %W % estamos en el mes de %M %
y van transcurridos %j % dias de este año.
Son las %r\'


CURDATE()

Dentro de DATE_FORMAT se puede incluir -en vez del nombre del campo- una cadena en la que se indique una fecha en formato YYYY-MM-DD hh:mm:ss. Puedes verlo en los ejemplos. De igual modo es posible sustituir el nombre del campo -o la cadena- por la función CURDATE() que recoge la fecha actual del sistema (únicamente día, mes y año). A efectos de horas, minutos y segundos CURDATE() va a tomar el mediodía de la fecha actual.

CURTIME()

Se comporta de forma similar a CURDATE().

Devuelve la hora actual del sistema que alberga el servidor MySQL en formato hh:mm:ss

CURRENT_TIMESTAMP()

Se comporta de forma similar a CURDATE().

Devuelve la fecha y hora actual del sistema en formato YYYY-MM-DD hh:mm:ss

NOW()

Es un alias de
CURRENT_TIMESTAMP().

mysql_result($resultado,num, campo)

Esta función PHP permite obtener un solo campo de uno solo de los registros obtenidos como resultado de una consulta MySQL.

El parámetro $resultado es la variable que recoge en resultado obtenido de la ejecución de mysql_query de forma idéntica a como lo hacíamos en otras consultas.

El valor num es un número entero que indica el número de fila de la que queremos extraer el valor contenido en uno de sus campos.

El valor campo indica el número del campo que tratamos de extraer. Este número (la primera posición siempre es cero) indica el número de orden del campo tal como está especificado en la sentencia SELECT. Si en esta sentencia se incluyera * (extraer todos los campos) consideraría el orden en el que está creada la estructura de la tabla que los contiene.

Este es el código fuente de un ejemplo comentado y este un enlace de prueba del script.


Consultar los registros de una tabla


Las consultas de los datos y registros contenidos en una tabla ofrecen un amplísimo abanico de posibilidades a partir de las opciones que tienes descritas al margen. Veamos algunas de las posibilidades.

La consulta más simple


Si utilizamos la sentencia

SELECT * FROM tabla

obtendremos información sobre todos los campos (*) y la salida estará en el mismo orden en el que fueron añadidos los datos. Si visualizas este http://localhost/cursophp/ejemplo, verás que aparecen ordenados por el valor autonumérico del campo Contador lo cual, como ves, resulta coherente con la afirmación anterior.


<?

# 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



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



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



mysql_select_db($base,$c);



# establecemos el criterio de SELECCION

# en este caso el comodin * indica que se seleccionen todos los campos



$resultado= mysql_query("SELECT * FROM $tabla" ,$c);





# CREAMOS UNA CABECERA DE UNA TABLA (codigo HTML)



echo "<table align=center border=2>";



# establecemos un bucle que recoge en un array

# cada una de las LINEAS DEL RESULTADO DE LA CONSULTA

# utilizamos en esta ocasión «mysql_fetch_row»

# en vez de «mysql_fetch_array» para EVITAR DUPLICADOS

# recuerda que esta ultima función devuelve un array escalar

# y otro asociativo con los resultados



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

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

## INDICES DE LOS ARRAYS RECOGIDOS EN $REGISTRO ##

## ##

## EN EL CASO DE QUE SELECT VAYA MARCADO CON * ##

## (CONSULTAS DE TODOS LOS CAMPOS DE LA TABLA) ##

## LA CORRESPONDENCIA ENTRE INDICE DE ESTE ARRAY ##

## ESCALAR Y LOS CAMPOS SERÍAN LA SIGUIENTES: ##

## Tendría INDICE 0 el elemento del array que recoge ##

## el valor del PRIMER CAMPO según el orden en el que ##

## fue CREADA LA TABLA, el indice 1 CORRESPONDERÍA ##

## al segundo de los campos en el ORDEN DE CREACIÓN ##

## Y ASÍ SUCESIVAMENTE.... ##

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

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





while ($registro = mysql_fetch_row($resultado)){



# insertamos un salto de línea en la tabla HTML



echo "<tr>";



# establecemos el bucle de lectura del ARRAY

# con los resultados de cada LINEA

# y encerramos cada valor en etiquetas <td></td>

# para que aparezcan en celdas distintas de la tabla



foreach($registro as $clave){

echo "<td>",$clave,"</td>";

}

}

echo "</table>";





# cerramos la conexion



mysql_close();



?>










Ejecutar la consulta

Consultando sólo algunos campos


Ahora utilizaremos la sentencia
SELECT campo1,campo2, ... FROM tabla

y tendremos como resultado una lista completa, por el mismo orden que la anterior, pero sólo mostrando los campos indicados.



<?

# 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



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



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



mysql_select_db($base,$c);



# establecemos el criterio de SELECCION

# en este caso los campos Nombre, Apellido1, Apellido2 unicamente



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

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

## INDICES DE LOS ARRAYS RECOGIDOS EN $REGISTRO ##

## ##

## EN ESTE CASO (consulta de algunos campos ##

## LA CORRESPONDENCIA ENTRE INDICE DE ESTE ARRAY ##

## ESCALAR Y LOS CAMPOS SERÍAN LA SIGUIENTES: ##

## Tendría INDICE 0 el campo Nombre (primero de la ##

## consulta. INDICE 1 correspondería a Apellido1 ##

## el indice 2 correspondería a Apellido 3 ##

## ##

## este es el criterio general de asignación de indices ##

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

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



$resultado= mysql_query("SELECT Nombre, Apellido1, Apellido2 FROM $tabla" ,$c);





# CREAMOS UNA CABECERA DE UNA TABLA (codigo HTML)



echo "<table align=center border=2>";



# establecemos un bucle que recoge en un array

# cada una de las LINEAS DEL RESULTADO DE LA CONSULTA

# utilizamos en esta ocasión «mysql_fetch_row»

# en vez de «mysql_fetch_array» para EVITAR DUPLICADOS

# recuerda que esta ultima función devuelve un array escalar

# y otro asociativo con los resultados



while ($registro = mysql_fetch_row($resultado)){



# insertamos un salto de línea en la tabla HTML



echo "<tr>";



# establecemos el bucle de lectura del ARRAY

# con los resultados de cada LINEA

# y encerramos cada valor en etiquetas <td></td>

# para que aparezcan en celdas distintas de la tabla



foreach($registro as $clave){

echo "<td>",$clave,"</td>";

}

}

echo "</table>";





# cerramos la conexion



mysql_close();



?>










En los comentarios contenidos en estos ejemplos puedes ver la forma en la que mysql_fetch_row y mysql_fetch_array tratan los índices escalares de los resultados que producen los SELECT de MySQL.


Los valores de los índices se asignan a los contenidos de los campos por el mismo orden en el que estos se escriben en la sentencia SELECT. El campo1 (primero que se escribe) será recogido por el elemento de índice cero del array, el campo2 será recogido con índice uno y así sucesivamente


Consultando sólo algunos campos y limitando la salida a n registros


Ahora utilizaremos la sentencia
SELECT campo1,campo2, ... FROM tabla LIMIT (n, m)

y tendremos como resultado una lista que contendrá m registros a partir del n+1, por el mismo orden que la anterior, y mostrando los campos indicados.


<code>


# recogemos en una variable el nombre de BASE DE DATOS <br />

<br />

$base="ejemplos"; <br />

<br />

# recogemos en una variable el nombre de la TABLA <br />

<br />

$tabla="demo4"; <br />

<br />

<br />

# establecemos la conexion con el servidor <br />

<br />

$c=mysql_connect("localhost","pepe","pepa"); <br />

<br />

#asiganamos la conexión a una base de datos determinada <br />

<br />

mysql_select_db($base,$c); <br />

<br />

# establecemos el criterio de SELECCION <br />

# en este caso los campos Nombre, Apellido1, Apellido2 unicamente <br />

<br />

############################################################ <br />

############################################################ <br />

## INDICES DE LOS ARRAYS RECOGIDOS EN $REGISTRO ## <br />

## ## <br />

## EN ESTE CASO (consulta de algunos campos ## <br />

## LA CORRESPONDENCIA ENTRE INDICE DE ESTE ARRAY ## <br />

## ESCALAR Y LOS CAMPOS SERÍAN LA SIGUIENTES: ## <br />

## Tendría INDICE 0 el campo Nombre (primero de la ## <br />

## consulta. INDICE 1 correspondería a Apellido1 ## <br />

## el indice 2 correspondería a Apellido 3 ## <br />

## ## <br />

## este es el criterio general de asignación de indices ## <br />

############################################################ <br />

############################################################ <br />

<br />

$resultado= mysql_query("SELECT Nombre, Apellido1, Apellido2 FROM $tabla" ,$c); <br />

<br />

<br />

# CREAMOS UNA CABECERA DE UNA TABLA (codigo HTML) <br />

<br />

echo "

"; <br />

<br />

# establecemos un bucle que recoge en un array <br />

# cada una de las LINEAS DEL RESULTADO DE LA CONSULTA <br />

# utilizamos en esta ocasión «mysql_fetch_row» <br />

# en vez de «mysql_fetch_array» para EVITAR DUPLICADOS <br />

# recuerda que esta ultima función devuelve un array escalar <br />

# y otro asociativo con los resultados <br />

<br />

while ($registro = mysql_fetch_row($resultado)){ <br />

<br />

# insertamos un salto de línea en la tabla HTML <br />

<br />

echo ""; <br />

<br />

# establecemos el bucle de lectura del ARRAY <br />

# con los resultados de cada LINEA <br />

# y encerramos cada valor en etiquetas <br />

# para que aparezcan en celdas distintas de la tabla <br />

<br />

foreach($registro as $clave){ <br />

echo ""; <br />

} <br />

} <br />

echo "

",$clave,"
"; <br />

<br />

<br />

# cerramos la conexion <br />

<br />

mysql_close(); <br />

<br />

?> <br />

<br />

<br />

<br />



</code>








Ejecutar la consulta


Consultando sólo algunos campos y ordenando la salida


Utilizaremos la sentencia MySQL de esta forma
SELECT campo1,campo2, ... FROM tabla ORDER BY campo_n [ASC|DESC], campo_m [ASC|DESC]

y tendremos como resultado una lista ordenada por el primero de los campos indicados en ORDER BY, y en caso de coincidencia de valores en ese campo, utilizaríamos el criterio de ordenación señalado en segundo lugar.


<?

# 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



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



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



mysql_select_db($base,$c);



# establecemos el criterio de SELECCION

# en este caso los campos Contador, Nombre, Apellido1, Apellido2 unicamente

# ordenaremos la salida por Apellido1 en sentido DESCENDENTE

# y en caso de coincidente del primer APELLIDO se ordenaría

# por el segundo en SENTIDO DESCENDENTE



$resultado= mysql_query("SELECT Contador, Nombre, Apellido1, Apellido2 FROM $tabla ORDER BY Apellido1 DESC, Apellido2 ASC" ,$c);





# CREAMOS UNA CABECERA DE UNA TABLA (codigo HTML)



echo "<table align=center border=2>";



# establecemos un bucle que recoge en un array

# cada una de las LINEAS DEL RESULTADO DE LA CONSULTA

# utilizamos en esta ocasión «mysql_fetch_row»

# en vez de «mysql_fetch_array» para EVITAR DUPLICADOS

# recuerda que esta ultima función devuelve un array escalar

# y otro asociativo con los resultados



while ($registro = mysql_fetch_row($resultado)){



# insertamos un salto de línea en la tabla HTML



echo "<tr>";



# establecemos el bucle de lectura del ARRAY

# con los resultados de cada LINEA

# y encerramos cada valor en etiquetas <td></td>

# para que aparezcan en celdas distintas de la tabla



foreach($registro as $clave){

echo "<td>",$clave,"</td>";

}

}

echo "</table>";





# cerramos la conexion



mysql_close();



?>










Ejecutar la consulta


Consulta seleccionando registros


Utilizaremos la sentencia MySQL de esta forma
SELECT campo1, ... FROM tabla WHERE condición

que nos devolverá la lista de registros que cumplen la condición indicada.
Aquí tienes un ejemplo muy sencillo.


<?

# 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



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



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



mysql_select_db($base,$c);



# establecemos el criterio de SELECCION

# en este caso los campos Contador, Nombre, Apellido1, Apellido2 unicamente

# añadimos un criterio de seleccion WHERE

# que como puedes ver es simple en este caso (que el Sexo sea masculino)

# el resultado de la consulta será UNA LISTA CON TODOS LOS VARONES DE LA TABLA



$resultado= mysql_query("SELECT Nombre, Apellido1, Apellido2 FROM $tabla WHERE (Sexo='M') ",$c);







# CREAMOS UNA CABECERA DE UNA TABLA (codigo HTML)



echo "<table align=center border=2>";



# establecemos un bucle que recoge en un array

# cada una de las LINEAS DEL RESULTADO DE LA CONSULTA

# utilizamos en esta ocasión «mysql_fetch_row»

# en vez de «mysql_fetch_array» para EVITAR DUPLICADOS

# recuerda que esta ultima función devuelve un array escalar

# y otro asociativo con los resultados



while ($registro = mysql_fetch_row($resultado)){



# insertamos un salto de línea en la tabla HTML



echo "<tr>";



# establecemos el bucle de lectura del ARRAY

# con los resultados de cada LINEA

# y encerramos cada valor en etiquetas <td></td>

# para que aparezcan en celdas distintas de la tabla



foreach($registro as $clave){

echo "<td>",$clave,"</td>";

}

}

echo "</table>";





# cerramos la conexion



mysql_close();



?>











Ejecutar la consulta


La claúsula WHERE permite un variado abanico de condiciones, que trataremos
de resumir aquí. Algunos de ellas son los siguientes:



OperadorTipo
de campo
SintaxisDescripciónCódigo
fuente
Ver
http://localhost/cursophp/ejemplo
=NuméricoWHERE campo=numSelecciona los registros que contienen en el campo un valor igual a numVerProbar
=CadenaWHERE campo=\"cadena\"Selecciona los registros que contienen en el campo una cadena idéntica a cadena (*)VerProbar
<NuméricoWHERE campoSelecciona los registros que contienen en el campo un valor menor a numVerProbar
<CadenaWHERE campo<\"cadena\"Selecciona los registros que contienen en el campo una cadena cuyos n primeros caracteres son menores que los de la cadena, siendo n el número de caracteres que contiene cadena. (**)VerProbar
<=NuméricoWHERE campo<=numSelecciona los registros que contienen en el campo un valor menor O igual a numVerProbar
<=CadenaWHERE campo<=\"cadena\"Selecciona los registros que contienen en el campo una cadena cuyos n primeros caracteres son menores que los de la cadena, siendo n el número de caracteres que contiene cadena y añade respecto al caso anterior la opción de que en caso de que ambos valores fueran iguales también los presentaría (**)VerProbar
>NuméricoWHERE campo>numSelecciona los registros que contienen en el campo un valor mayor a numVerProbar
>CadenaWHERE campo>\"cadena\"Selecciona los registros que contienen en el campo una cadena cuyos n primeros caracteres son mayores que los de la cadena, siendo n el número de caracteres que contiene cadena. (**)VerProbar
>=NuméricoWHERE campo>=numSelecciona los registros que contienen en el campo un valor mayor o igual a numVerProbar
>=CadenaWHERE campo>=\"cadena\"Selecciona los registros que contienen en el campo una cadena cuyos n primeros caracteres son mayores que los de la cadena, siendo n el número de caracteres que contiene cadena y añade respecto al caso anterior la opción de que en caso de que ambos valores fueran iguales también los presentaría (**)VerProbar
INNumérico
o
Cadena
WHERE campoIN (valor1,valor2..)Selecciona los registros que contienen en el campo valores que coinciden con alguno de los especificados dentro del paréntesis. Cuando se trata de valores no numéricoz han de ir entre comillasVerProbar
BETWEENNumérico
o
Cadena
WHERE campo BETWEEN valor1 AND valor2Selecciona los registros en los que los valores contenidos en el campo seleccionado están comprendidos en el intervalo valor1 (mínimo) – valor2 (máximo) incluyendo en la selección ambos extremos.
Cuando los contenidos de los campos son cadenas sigue los mismos criterios que se indican para los demás operadores de comparación
VerProbar
IS NULLCadenaWHERE campo IS NULLSelecciona los registros en los que los valores contenidos en el campo seleccionado son NULOSVerProbar
IS NOT NULLCadenaWHERE campo IS NOT NULLSelecciona los registros en los que los valores contenidos en el campo seleccionado son NO NULOSVerProbar
(*) Cuando se trata de cadenas de caracteres, el concepto menor que significa anterior en la ordenación de los caracteres según su código ASCII y mayor que significa posterior en esa misma ordenación.
(**) La discriminación de Mayúsculas/Minúsculas dependerá del tipo de campo.
Recuerda que los tipo BLOB hacen esa discriminación, mientras que los de tipo TEXT son insensibles a Mayúsculas/Minúsculas.




Cuando se trata de comparar cadenas MySQL dispone de una potente instrucción (LIKE)
que permite establecer los criterios de selección a toda o parte de la cadena. Su sintaxis contempla distintas posibilidades utilizando dos comodines>: % (que se comporta de forma similar al (*) en las búsquedas de Windows) y _ (de comportamiento similar a (?) en Windows). Aquí tienes algunas de sus posibilidades:




SintaxisDescripciónCódigo
fuente
Ver
http://localhost/cursophp/ejemplo
WHERE campo LIKE \'%cadena%\'Selecciona todos los registros que contengan la cadena en el campo indicado sea cual fuere su posiciónVerProbar
WHERE campo LIKE \'cadena%\'Selecciona todos los registros en los que el campo indicado que contengan la cadena exactamente al principio del campoVerProbar
WHERE campo LIKE \'%cadena\'Selecciona todos los registros en los que el campo indicado que contengan la cadena exactamente al final del campoVerProbar
WHERE campo LIKE \'_cadena%\'Selecciona todos los registros en los que el primer caracter del campo puede ser cualquiera pero los siguientes han de ser exactamente los indicados en cadena pudiendo ir seguidos de cualesquiera otros caracteres VerProbar


El comodín (_) puede ir tanto al principio como al final y puede repetirse tantas veces como sea necesario. Seria correcto LIKE '___es%' y también LIKE 'a___es%' así como: LIKE '%a___es'.


Como ves, un montón de posibilidades.


Aun tiene más opciones WHERE ya que acepta múltiples condiciones vinculadas por los operadores lógicos AND, OR, NOT o sus sintaxis equivalentes: &&, || y !.


El comportamiento de estos operadores es idéntico al descrito para sus homónimos de PHP. ¿Los recuerdas?... Aquí los tienes... por si acaso.


Un ejemplo de sintaxis puede ser:

WHERE (campo1=valor AND campo2 LIKE '_cadena%)


Utilizando funciones sobre campos


La sintaxis

SELECT MAX(campo1), MIN (campo2), ... FROM tabla

nos devolvería UNA SOLA FILA cuyos valores serían los resultados de la aplicación de las funciones a todos los registros del campo indicado.

Aquí tienes un ejemplo que determina todos los valores de esos estadísticos aplicados al campo Contador de nuestra famosa tabla demo4.


Aquí está el ejemplo

Ver código fuente

Ejecutar la consulta


Aplicando la opción GROUP BY


Tal como señalamos al margen, las funciones anteriores pueden aplicarse a grupos de registros seleccionados mediante un criterio GROUP BY (nombre del campo)


En este ejemplo obtendremos los mismos parámetros estadísticos que en el anterior, pero ahora agrupados por sexo, lo que significaría que obtendremos dos filas de resultados.
Aquí tienes el ejemplo

Ver código fuente

Ejecutar la consulta


Como habrás podido observar, la opción SELECT tiene un sinfín de posibilidades.


Creación de tablas a partir de la consulta de otra tabla


Es frecuente -podría decirse que es lo habitual- relacionar tablas mediante campos con idéntico contenido.

Supongamos que entre los individuos de nuestra tabla demo4 se pretende establecer un proceso de selección para elegir entre ellos un número determinado de astronautas, pongamos por caso.

Supongamos también, que la selección va a constar de tres pruebas que serán juzgadas y calificadas por tres tribunales distintos.

Una primera opción sería crear tres tablas -una para cada tribunal- e incluir en ellas todos los datos de cada uno de los individuos.

Esa opción es factible pero no es ni la más cómoda, ni tampoco es la más rápida ni la que menos espacio de almacenamiento necesita. No debemos olvidar que una tabla puede tener una enorme cantidad de registros.

Una opción alternativa sería crear tres nuevas tablas que sólo contuvieran dos campos cada una. Por ejemplo el campo DNI y el campo Calificación.

Como quiera que el campo DNI ha de contener los mismos valores en las cuatro tablas y además es un campo único podrían crearse las nuevas tablas y luego copiar en cada una de ellas todos los DNI de la tabla original.

Nos garantizaría que no habría errores en los DNI y además nos garantizaría que se incluyeran todos los aspirantes en esas nuevas tablas.

Aquí tienes el código fuente de un script que crea esas tres tablas (a las que hemos llamado demodat1, demodat2 y demodat3.



<?
# definimos una variable con el NOMBRE DE LA BASE DE DATOS
$base="ejemplos";

#definimos otra variable con el NOMBRE de LA TABLA ORIGEN DE LOS DATOS
$tabla="demo4";

#definimos UN ARRAY con los nombres de las tablas a crear
$tablanuev[]="demodat1";
$tablanuev[]="demodat2";
$tablanuev[]="demodat3";

# establecemos la conexión con el servidor
$c=mysql_connect ("localhost","pepe","pepa");


#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR
mysql_select_db ($base, $c);
#establecemos el bucle que repetira la creación de tabla
#hasta leer el array completo (en este caso de CERO a DOS)
#que son los indices del array de nombres

for ($i=0;$i<3;$i++){
$crear="CREATE TABLE $tablanuev[$i] (";
$crear.="DNI CHAR(8) NOT NULL, ";
$crear.="Puntos Decimal (6,3) NOT NULL DEFAULT 0, ";
$crear.=" PRIMARY KEY(DNI) ";
$crear.=")";
if(mysql_db_query ($base,$crear ,$c)) {
echo "<h2> Tabla $tablanuev[$i] creada con EXITO </h2><br>";
}else{
echo "<h2> La tabla $tablanuev[$i] NO HA PODIDO CREARSE ";

#echo mysql_error ($c)."<br>";
$numerror=mysql_errno ($c);
if ($numerror==1050){echo "porque YA EXISTE</h2>";}
}
#cerramos el bucle for

}
#ahora leeremos la tabla ORIGEN DE LOS DATOS
# y añadimos un registro a cada una de las otras tres tablas
# en el que insertamos el DNI de la original
$resultado=mysql_query("SELECT * FROM demo4 ",$c);

while ($row = mysql_fetch_array($resultado)){

$mete=$row['DNI'];

mysql_query("INSERT $tablanuev[0] (DNI, Puntos) VALUES ('$mete', 0)",$c);

mysql_query("INSERT $tablanuev[1] (DNI, Puntos) VALUES ('$mete', 0)",$c);

mysql_query("INSERT $tablanuev[2] (DNI, Puntos) VALUES ('$mete', 0)",$c);

}
echo $z;
# cerramos la conexión... y listo...

mysql_close($c)

?>


Crear las tablas
anteriores

Una consulta conjunta de varias tablas


MySQL permite realizar consultas simultáneas en registros situados en varias tablas.


Para ese menester se usa la siguiente sintaxis:


SELECT tabla1.campo1, tabla2.campo2, ... FROM tabla1, tabla2


en la que, como ves, modificamos ligeramente la sintaxis ya que anteponemos el nombre de la tabla al del campo correspondiente separando ambos nombres por un punto, con lo cual no hay posibilidad de error de identificación del campo incluso cuando campos de distinta tabla tengan el mismo nombre.

Otra innovación -respecto a los ejemplos anteriores- es que detrás de la cláusula FROM escribimos los nombres de todas las tablas que está usando SELECT.

A partir de ahí se pueden establecer todo tipo de relaciones para las sentencias WHERE, ORDER BY y GROUP BY utilizando para ello campos de cualquiera de las tablas sin otra particularidad más que poner cuidado al aludir a los campos utilizando siempre la sintaxis nombre_tabla.nombre_campo.

A modo de ejemplo -hemos procurado comentarlo línea a línea- aquí tienes un script PHP que hace una consulta conjunta de las tablas demo4, demodat1, demodat2 y demodat3 y nos presenta una tabla con los datos personales y las puntuaciones de las tres pruebas así como las suma de puntos de las tres y, además, ordena los resultados -de mayor a menor- según la suma de las tres puntuaciones.


<?



# definimos una variable con el NOMBRE DE LA BASE DE DATOS





$base="ejemplos";



#definimos otra variable con el NOMBRE de LA TABLA ORIGEN DE LOS DATOS





# establecemos la conexión con el servidor



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



#Seleccionamos la BASE DE DATOS en la que PRETENDEMOS TRABAJAR



mysql_select_db ($base, $c);





# veamos ahora una consulta SIMULTANEA de varias tablas

# fijate despues del SELECT

# anteponemos el nombre de la base al campo separados por un punto

# escribimos con esa sintaxis (tabla.campo) los campos de la consulta

# detras del FROM enumeramos las distintas TABLAS separadas por comas

# a continuación el WHERE que como ves puede relacionar campos de todas las tablas en uso

#

# la condición es que los DNI sean iguales en todas las tablas

# recuerda que lo hemos puesto como clave principal en todas ellas

#

# fijate en la ordenacion

# ordenamos por PUNTUACION TOTAL, es decir por la suma de las puntos de las tres tablas

# y ordenamos DESCENDENTE (de mayor a menor)

#

#









$resultado=mysql_query("SELECT demo4.DNI,demo4.Nombre,demo4.Apellido1, demo4.Apellido2 ,demodat1.Puntos, demodat2.Puntos, demodat3.Puntos FROM demo4, demodat1, demodat2, demodat3 WHERE (demo4.DNI=demodat1.DNI AND demo4.DNI=demodat2.DNI AND demo4.DNI=demodat3.DNI) ORDER BY demodat1.Puntos+demodat2.Puntos+demodat3.Puntos DESC ",$c);



# presentamos la salida en forma de tabla HTML



# estos son los encabezados



echo "<table align=center border=2>";

echo "<td colspan=4 align=center> Datos personales</td>";

echo "<td align=center>Prueba 1</b>";

echo "<td align=center>Prueba 2</b>";

echo "<td align=center>Prueba 3</b>";

echo "<td align=center>Puntos Totales</td></tr>";



# establecemos un bucle para leer todas las líneas del resultado de cada consulta



while($salida = mysql_fetch_array($resultado)){



# escribimos un bucle que nos lea desde el indice 0 hasta el indice 6

# de la matriz de salida ya que los indices 0,1,2,3,4...

# se corresponden con el número de orden tal como fueron establecidos

# los campos en la opción SELECT: 0 es el indice del primero

# 1 el de segundo, 2 el del tercero, etc. etc.



for ($i=0;$i<7;$i++){



#imprimimos el valor de del array de indice $i;



echo "<td>",$salida[$i],"</td>";



#cerramos el bucle for



}



# ahora imprimimos la suma de las Puntuaciones

# y hacemos una nueva linea en la tabla



echo"<td>",$salida[4]+$salida[5]+$salida[6],"</Td>";

echo "<tr>";



# cerramos el bucle while



}



#escribimos la etiqueta de cierre de la tabla (HTML)



echo "</table>";





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



mysql_close($c)

?>










Ejecutar la consulta



Fuente: