Exportar consultas SQL a CSV con MySQL

Al exportar registros en formato csv por lo general utilizamos PHP y vamos recorriendo los registros
Una manera fácil y rápida para generar archivos csv de nuestros registros en la base de datos las podemos hacer con una consulta sencilla desde MySQL.

SELECT id,nombre,email,direccion
FROM usuarios
INTO OUTFILE '/rp/usuarios.csv'
FIELDS TERMINATED BY ','
ENCLOSED BY '"'
LINES TERMINATED BY 'n'

donde:

• 
  
• INTO OUTFILE : directorio y archivo donde se guardara.
• FIELDS TERMINATED BY : separador de cada campo.
• ENCLOSED BY : delimitación de campo.
• LINES TERMINATED BY : separador de fila.

Este simple script puede hacer backups directamente, si utilizas PHP tal vez te interese generar archivos CSV con PHP, con esto puedes personalizar mejor el modo de exportación de registros ya que PHP recorrerá cada campo para generarlo.

Funciones en PHP no tan usadas pero útiles

Incluso después de trabajar con PHP desde hace muchos años, a veces nos encontramos con funciones y funcionalidades o características de las que no eramos conscientes. Algunas pueden ser útiles pero no se usan mucho, ya sea por el tipo de proyecto o el nivel de tecnología que tengamos. En este artículo comentaré unas cuantas funciones y características de PHP que quizá no sabías.

Funciones en PHP con número arbitrario de argumentos

Seguro que ya sabes que PHP permite definir funciones con argumentos opcionales. Pero existe un método para permitir un numero arbitrario de argumentos en las funciones.
Ejemplo de función con argumentos opcionales:

1	// función con 2 argumentos opcionales

2	function foo($arg1 = '', $arg2 = '') {

3

4	echo "arg1: $arg1n";

5	echo "arg2: $arg2n";

6

7

}

8

9

10	foo('hello','world');

11	/* muestra

12	arg1: hello

13	arg2: world

14

*/

15

16

foo();

17	/* Muestra

18

arg1:

19

arg2:

20

*/

Ahora, vamos a construir una función que acepte cualquier número de argumentos. Esta vez vamos a utilizar func_get_args():

1	// si, la lista de argumentos va vacía

2	function foo() {

3

4	// devuelve un array con todos los argumentos que se han pasado

5	$args = func_get_args();

6

7	foreach ($args as $k => $v) {

8	echo "arg".($k+1).": $vn";

9

}

10

11

}

12

13

foo();

14	/* no muestra nada */

15

16	foo('hello');

17	/* muestra

18	arg1: hello

19

*/

20

21	foo('hello', 'world', 'again');

22	/* muestra

23	arg1: hello

24	arg2: world

25	arg3: again

26

*/

Buscar y encontrar ficheros en PHP con GLob()

Muchas funciones en PHP tienen nombres largos y descriptivos, sin embargo es difícil saber que hace una función llamada glob(), a no ser que lo busques en la documentación o ya la hayas usado previamente.
Es una función mucho más potente que scandir() ya que también permite búsqueda de ficheros usando patrones.

1	// buscados todos los archivos con extensión .php, podría ser cualquier otra extensión.

2	$files = glob('*.php');

3

4	print_r($files);

5	/* los datos de salida serán algo similar a esto

6

Array

7

(

8	[0] => phptest.php

9	[1] => pi.php

10	[2] => post_output.php

11	[3] => test.php

12

)

13

*/

También se pueden extraer múltiples tipos de ficheros de la siguiente manera:

1	// sacamos todos los archivos con extensión .php y .txt

2	$files = glob('*.{php,txt}', GLOB_BRACE);

3

4	print_r($files);

5	/* los datos de salida se parecerán a los siguientes

6

Array

7

(

8	[0] => phptest.php

9	[1] => pi.php

10	[2] => post_output.php

11	[3] => test.php

12	[4] => log.txt

13	[5] => test.txt

14

)

15

*/

NOTA: Los archivos se pueden devolver con su ruta, dependiendo de la búsqueda que se haga

1	$files = glob('../images/a*.jpg');

2

3	print_r($files);

4	/* datos de salida

5

Array

6

(

7	[0] => ../images/apple.jpg

8	[1] => ../images/art.jpg

9

)

10

*/

Si quieres obtener la ruta completa de cada archivo, tendrías que llamar a la función realpath() en los valores retornados.

1	$files = glob('../images/a*.jpg');

2

3	// aplico la función a cada elemento del array

4	$files = array_map('realpath',$files);

5

6	print_r($files);

7	/* datos de salida

8

Array

9

(

10	[0] => C:wampwwwimagesapple.jpg

11	[1] => C:wampwwwimagesart.jpg

12

)

13

*/

Procesar con PHP información de la memoria usada

Monitorizando la memoria usada de tus scripts serás capaz de optimizar tu código mucho mejor. La monitorización ya sea en los servidores, base de datos o en nuestro código siempre es un práctica muy aconsejable de realizar y con la que tendremos una información valiosa de la calidad de nuestro software, con esta información se pueden hacer muchas “cosas” pero eso da para otro artículo.
PHP tiene un complejo administrador de memoria, La cantidad total de memoria que esta siendo usada por un script puede subir y bajar durante la ejecución del mismo. Para obtener la memoria usada en un determinado momento se tiene que usar la función memory_get_usage(), para conseguir la cantidad más alta de memoria usada a lo largo de la ejecución del script usar la función memory_get_peak_usage()
Pongamos a prueba el uso de la memoria con el siguiente ejemplo.

1	echo "Bytes iniciales: ".memory_get_usage()."n";

2	/* mostrará por ejemploo

3	Bytes iniciales: 361400

4

*/

5

6	// vamos a forzar el uso de memoria

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

8	$array []= md5($i);

9

}

10

11	// vamos a eliminar la mitad del array

12	for ($i = 0; $i < 100000; $i++) {

13	unset($array[$i]);

14

}

15

16	echo "Final: ".memory_get_usage()." bytes n";

17	/* imprime

18	Final: 885912 bytes

19

*/

20

21	echo "Peak: ".memory_get_peak_usage()." bytes n";

22	/* imprime

23	Peak: 13687072 bytes

24

*/

NOTA: Es muy posible que no os van a dar los mismo resultados que a mi, porque el equipo donde ejecutáis vuestro código es diferente al mío, o incluso si fuera idéntico tampoco tendría porque salir lo mismo. Todo depende de la memoria que vaya a asignar vuestro sistema operativo y la configuración que tengáis en el servidor Apache y PHP.

Información del uso de CPU

Para obtener la información del uso de la CPU en PHP usaremos la función getrusage(). Por el momento no esta disponible en plataformas con Windows.

1	print_r(getrusage());

2	/* devuelve el siguiente array de datos

3

Array

4

(

5	[ru_oublock] => 0

6	[ru_inblock] => 0

7	[ru_msgsnd] => 2

8	[ru_msgrcv] => 3

9	[ru_maxrss] => 12692

10	[ru_ixrss] => 764

11	[ru_idrss] => 3864

12	[ru_minflt] => 94

13	[ru_majflt] => 0

14	[ru_nsignals] => 1

15	[ru_nvcsw] => 67

16	[ru_nivcsw] => 4

17	[ru_nswap] => 0

18	[ru_utime.tv_usec] => 0

19	[ru_utime.tv_sec] => 0

20	[ru_stime.tv_usec] => 6269

21	[ru_stime.tv_sec] => 0

22

)

23

24

*/

Explicación de cada valor:

• ru_oublock: block output operations
• ru_inblock: block input operations
• ru_msgsnd: messages sent
• ru_msgrcv: messages received
• ru_maxrss: maximum resident set size
• ru_ixrss: integral shared memory size
• ru_idrss: integral unshared data size
• ru_minflt: page reclaims
• ru_majflt: page faults
• ru_nsignals: signals received
• ru_nvcsw: voluntary context switches
• ru_nivcsw: involuntary context switches
• ru_nswap: swaps
• ru_utime.tv_usec: user time used (microseconds)
• ru_utime.tv_sec: user time used (seconds)
• ru_stime.tv_usec: system time used (microseconds)
• ru_stime.tv_sec: system time used (seconds)

Para determinar cuanta energía ha consumido la CPU, habría que mirar a los valores de ‘user time’ y ‘system time’. Los segundos y las porciones de milisegundos son entregadas separadas por defecto. Se podría dividir el valor de milisegundos por 1 millón, y añadir el resultado a los segundos, para obtener el total de segundos como un número decimal.
Ver siguiente ejemplo:

1	// sleep de 3 segundos (non-busy)

2

sleep(3);

3

4	$data = getrusage();

5	echo "User time: ".

6	($data['ru_utime.tv_sec'] +

7	$data['ru_utime.tv_usec'] / 1000000);

8	echo "System time: ".

9	($data['ru_stime.tv_sec'] +

10	$data['ru_stime.tv_usec'] / 1000000);

11

12	/* devuelve

13	User time: 0.011552

14	System time: 0

15

*/

A pesar de que el script duró 3 segundos para ejecutarse, el uso de la CPU es muy muy bajo. Durante la ejecución del sleep() el script no esta consumiendo recursos de CPU. Hay otras muchas tareas que se ejecutan en tiempo real pero que no consumen tiempo de CPU, como por ejemplo esperar para operaciones de disco. Por lo que, como se puede ver, el uso de la CPU y el tiempo de ejecución de un scipt no siempre coinciden.
Otro ejemplo:

1	// bucle de 10 millones de veces (busy, vamos a forzar un poquito)

2	for($i=0;$i<10000000;$i++) {

3

4

}

5

6	$data = getrusage();

7	echo "User time: ".

8	($data['ru_utime.tv_sec'] +

9	$data['ru_utime.tv_usec'] / 1000000);

10	echo "System time: ".

11	($data['ru_stime.tv_sec'] +

12	$data['ru_stime.tv_usec'] / 1000000);

13

14	/* devuelve

15	User time: 1.424592

16	System time: 0.004204

17

*/

Esta operación ha llevado 1.4 segundos de tiempo de CPU, casi todas por parte de tiempo de usuario ya que no existían otras llamadas al sistema.
El tiempo del sistema (System time) es el total de tiempo de CPU gasta en ejecutar llamadas por el kernel en el nombre del programa. Veamos un ejemplo:

1	$start = microtime(true);

2	// seguimos llamando a microtime durante 3 segundos

3	while(microtime(true) - $start < 3) {

4

5

}

6

7	$data = getrusage();

8	echo "User time: ".

9	($data['ru_utime.tv_sec'] +

10	$data['ru_utime.tv_usec'] / 1000000);

11	echo "System time: ".

12	($data['ru_stime.tv_sec'] +

13	$data['ru_stime.tv_usec'] / 1000000);

14

15	/* devuelve

16	User time: 1.088171

17	System time: 1.675315

18

*/

Ahora tenemos más uso del tiempo del sistema. Esto es porque el script llama a la función microtime() varias veces, que ejecuta una petición a través del sistema operativo para recoger la fecha.

Magic Constants

PHP provee de una herramienta super útil las: magic constants al español constantes mágicas (que suena un poco peor,no?).
Para obtener la linea actual donde estamos(__LINE__), la ruta del fichero (__FILE__), la ruta del directorio (__DIR__), el nombre de la función (__FUNCTION__), el nombre de la clase (__CLASS__), el nombre del método (__METHOD__) y namespace (__NAMESPACE__).
Este tipo de constantes son usada en desarrollo Open Source, como CakePHP, WordPress y otros códigos donde cada desarrollador los instala en diferentes rutas y el código debe ser capaz de determinar las rutas y cualquier otra información para poder funcionar correctamente

1	// Esto es relativo a la ruta del script cargado

2	// Este método puede dar problemas cuando se ejecutan scripts desde diferentes rutas

3	require_once('config/database.php');

4

5	// Esto siempre es relativo a la ruta del fichero

6	// no importa desde donde se esté ejecutando el include

7	require_once(dirname(__FILE__) . '/config/database.php');

Usar __LINE__ hace que el debuging o la localización de errores sea mucho más fácil. Puedes obtener el número de linea que esta fallando.

1	// cualquier código

2

// ...

3	my_debug("some debug message", __LINE__);

4	/* devuelve

5	Line 4: some debug message

6

*/

7

8	// otro código diferente

9

// ...

10	my_debug("another debug message", __LINE__);

11

/* prints

12	Line 11: another debug message

13

*/

14

15	function my_debug($msg, $line) {

16	echo "Line $line: $msgn";

17

}

También se podría hablar mucho sobre las constantes: __FUNCTION__, __CLASS__ y __METHOD__ las cuales pueden ayudar muchísimo al trabajo con objetos y con la creación y definición de patrones de diseño en el código, pero el uso de éstas constantes para trabajar con objetos podría ser motivo de un artículo tan sólo para esto. En la documentación de php http://php.net/manual/en/language.constants.predefined.php hay otros consejos y ejemplos.

Generar IDs únicos

There may be situations where you need to generate a unique string. I have seen many people use the md5() function for this, even though it’s not exactly meant for this purpose:
En muchas situaciones vamos a necesitar generar identificadores o cadenas únicas. Confieso que yo suelo hacer esto: md5(time()) para generar string únicos, aunque puede que no sea 100% optimo. PHP propone la siguiente función específica para llevar a cabo esta tarea, uniqid().

1	// genera una cadena única

2	echo uniqid();

3	/* devuelve

4	4bd67c947233e

5

*/

El inicio de la cadena suele ser similar entre los diferentes identificadores que vamos generando, ya que el string generado está relacionando con la fecha del servidor, es decir con la función time(). Esto tiene una ventaja ya que todos los ids generados van en orden alfabético y se podrían ordenar.
Puedes enviar como primer parámetro en la función un prefijo y puede poner a true el segundo valor para aumentar la entropía, (usando el generador de congruencia lineal combinado) al final del valor de retorno, lo que aumenta la probabilidad de que el resultado será único. Por defecto devuelve una cadena de 13 caracteres, si se activa la entropía devuelve una cadena de 23 caracteres.

1	// con prefijo

2	echo uniqid('foo_');

3	/* devuelve

4	foo_4bd67d6cd8b8f

5

*/

6

7	// con más entropía

8	echo uniqid('',true);

9	/* devuelve

10	4bd67d6cd8b926.12135106

11

*/

12

13

// ambos

14	echo uniqid('bar_',true);

15	/* devuelve

16	bar_4bd67da367b650.43684647

17

*/

Esta función genera una cadena más corta que md5(), con lo que nos ayudará a ahorrar algo de espacio.

Serialización en PHP

La serialización básicamente es el formateo de arrays u objetos para convertirlos en un string. PHP ya tiene funciones que hacen esta tarea.
Hay 2 métodos para serializar variables, serialize() y unserialize():

1	// datos en un array

2	$myvar = array(

3

'hello',

4

42,

5	array(1,'two'),

6

'apple'

7

);

8

9	// convertimos a string

10	$string = serialize($myvar);

11

12	echo $string;

13	/* devuelve

14	a:4:{i:0;s:5:"hello";i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:"two";}i:3;s:5:"apple";}

15

*/

16

17	// incluso puedes volver al estado original

18	$newvar = unserialize($string);

19

20	print_r($newvar);

21	/* devuelve

22

Array

23

(

24	[0] => hello

25

[1] => 42

26	[2] => Array

27

(

28

[0] => 1

29	[1] => two

30

)

31

32	[3] => apple

33

)

34

*/

This was the native PHP serialization method. However, since JSON has become so popular in recent years, they decided to add support for it in PHP 5.2. Now you can use the json_encode() and json_decode() functions as well:
Estos son los métodos nativos de PHP para serializar. Sin embargo desde que JSON se volvió más popular, PHP sacó las funciones de json_encode() y json_decode en la versión 5.2.
Si tienes una versión de PHP inferior a 5.2 y llamas a las funciones de json_decode() o json_encode(), te aparecerá un error similar a este PHP Fatal error: Call to undefined function: json_encode(). Como he dicho, esta mejora aparece en la versión 5.2, para más información leer el siguiente artículo donde ya lo comentaba hace unos años http://www.pedroventura.com/php/php-fatal-error-call-to-undefined-function-json_encode/

1	// un array

2	$myvar = array(

3

'hello',

4

42,

5	array(1,'two'),

6

'apple'

7

);

8

9	// convertimos a string

10	$string = json_encode($myvar);

11

12	echo $string;

13	/* devuelve

14	["hello",42,[1,"two"],"apple"]

15

*/

16

17	// podemos volver al array original

18	$newvar = json_decode($string);

19

20	print_r($newvar);

21	/* devuelve

22

Array

23

(

24	[0] => hello

25

[1] => 42

26	[2] => Array

27

(

28

[0] => 1

29	[1] => two

30

)

31

32	[3] => apple

33

)

34

*/

Comprimir cadenas en PHP

Cuando hablamos de compresión, casi siempre nos referimos a ficheros, tales como los archivos ZIP. Pero es posible comprimir largas cadenas en PHP sin involucrar la creación de ningún archivo.
Para esta tarea usaremos las funciones gzcompress() y gzuncompress()

1

$string =

2	"Lorem ipsum dolor sit amet, consectetur

3	adipiscing elit. Nunc ut elit id mi ultricies

4	adipiscing. Nulla facilisi. Praesent pulvinar,

5	sapien vel feugiat vestibulum, nulla dui pretium orci,

6	non ultricies elit lacus quis ante. Lorem ipsum dolor

7	sit amet, consectetur adipiscing elit. Aliquam

8	pretium ullamcorper urna quis iaculis. Etiam ac massa

9	sed turpis tempor luctus. Curabitur sed nibh eu elit

10	mollis congue. Praesent ipsum diam, consectetur vitae

11	ornare a, aliquam a nunc. In id magna pellentesque

12	tellus posuere adipiscing. Sed non mi metus, at lacinia

13	augue. Sed magna nisi, ornare in mollis in, mollis

14	sed nunc. Etiam at justo in leo congue mollis.

15	Nullam in neque eget metus hendrerit scelerisque

16	eu non enim. Ut malesuada lacus eu nulla bibendum

17	id euismod urna sodales. ";

18

19	$compressed = gzcompress($string);

20

21	echo "Original size: ". strlen($string)."n";

22

/* prints

23	Original size: 800

24

*/

25

26

27

28	echo "Compressed size: ". strlen($compressed)."n";

29

/* prints

30	Compressed size: 418

31

*/

32

33	// getting it back

34	$original = gzuncompress($compressed);

Con esta técnica somos capaces de reducir al 50% el tamaño. También están las funciones gzencode() y gzdecode() que obtienen resultados similares pero con diferentes algoritmos de compresión
Lecturas recomendadas sobre compresión de archivos:

• comprimir y descomprimir un archivo con .gz GZip
• Como comprimir una carpeta entera en linux desde consola

Registrar función de apagado (shutdown)

Hay una función llamada register_shutdown_function() que te permite ejecutar código justo después de que termine la ejecución del script.
Imagina que quieres capturas datos para estadísticas al final de la ejecución de un script, como por ejemplo cuanto tiempo tardó en ejecutarse.

1	// obtenemos el tiempo inicial

2	$start_time = microtime(true);

3

4	// aquí todo el código y la lógica

5

// ...

6

7	// mostramos cuanto tiempo tardó el script

8	echo "execution took: ".

9	(microtime(true) - $start_time).

10	" seconds.";

En este ejemplo parece un poco simple y sin mucho sentido, es un código al inicio y otro al final y no parece que esta función se pueda estar ejecutando al final del script, ya que está al final. Pero hay que tener en cuenta, de que si se añade un exit(), el código devuelve un fatal error o incluso si el usuario detiene la ejecución del script con el botón de parar del navegador esta función siempre se va seguir ejecutando a pesar de todo.

Conclusión

Que te ha parecido? has aprendido algunas funciones nuevas? Yo por lo menos he aprendido unas cuantas y he refrescado otras que hacía mucho tiempo no había utilizado.
De todas maneras si conoces de otras funciones que sean desconocidas pero útiles no dudes en comentarlas, con tus comentarios aportas tu experiencia y opinión al resto de lectores
Fuente: http://net.tutsplus.com/tutorials/php/9-useful-php-functions-and-features-you-need-to-know/

Crear y usar plantillas para páginas de WordPress

Las plantillas de página son muy útiles: Permiten crear páginas personalizadas, por ejemplo la creación de una página de archivo que muestra todos tus posts, o una página para mostrar información sobre mi, histórico de posts mensuales, una página de portfolio, así como lo tengo yo en mi blog.
Una plantilla de página se define por el siguiente código, insertado en las primeras líneas del archivo:

1

<?php

2

/*

3	Template Name: Portfolio

4

*/

5

?>

De esta manera yo creo mi plantilla para mi Portfolio (o Portafolio)
El archivo lo guardamos en el directorio principal de wordpress como page-portfolio.php
En la sección para crear nuevas páginas veremos el menú de atributos, ahora tendrá que aparecer una nueva plantilla, para seleccionar, la que acabamos de crear.

Tags de búsquedas:

cómo aplicar una plantilla en wordpress,usar paginas wordpress,usar más de una plantilla wordpress,tutorial usar plantilla wordpress,nueva plantilla en wordpress,modificar plantillas wordpress,modificar plantilla html home en wordpress,editar plantillas wordpress,editar plantilla wordpress,crear una plantilla para las entradas de wordpress

Como usar los DNS publicos de Google para navegar mejor.

Te va lento internet? Se te corta? o estas en clase y la red te va como el orto!! jeje
Pues a continuación voy a poner un truco para usar los DNS públicos de Google para poder navegar mucho mejor y sin cortes, ojo no significa que vaya a ir más rápido, sino que que irá sin tantos cortes. O bien en una red todo el mundo esta usando un mismo servidor de DNS y va lento, pues te cambias a otro servidor y listo!
Las direcciones IP de las DNS publicas de Google son las siguientes:
* 8.8.8.8
* 8.8.4.4
Si ya lo habéis hecho mas veces, pues no hace falta que leáis los siguientes pasos, cogéis las direcciones IP publicas y listo.
Configurar el server DNS en Windows 7
- Clic en Inicio y seleccionar Panel de control
- De la lista mostrada seleccionar Redes e Internet, luego seleccionar Centro de redes y recursos compartidos
- Hacer clic sobre Cambiar configuración del adaptador, eso se encuentra ubicado en el panel izquierdo.
- Seleccionar el adaptador de red usado actualmente
- Hacer clic derecho y seleccionar Propiedades del menú contextual mostrado
- Seleccionar la pestaña Funciones de red y de lista mostrada seleccionar Protocolo de Internet versión 4 (TCP/IPv4)
- Hacer Clic en Propiedades y se mostrará la venta Propiedades: Protocolo de Internet Versión 4 (TCP/IP v4)
- Seleccionar Usar las siguientes direcciones de Servidor DNS, en caso tener seleccionado la obtención automática. OJO! Antes de borrar las DNS que tienes, copialas en algún sitio por si las quieres poner otro día, siempre que se pueda y haya tiempo backup!
- En Servidor DNS predefinido, borrar la dirección actual e ingresar
8.8.8.8
- En Servidor DNS Alternativo, borrar la dirección actual e ingresar
8.8.4.4
- Hacer clic en Aceptar, luego en Cerrar y verificar que todo funcione correctamente
Configurar el server DNS en Linux
Editamos el archivo /etc/resolv.conf

1	vi /etc/resolv.conf

Comenta las lineas que pueda haber definidas con nameserver, para no tener que borrarlas.
A continuación agrega las de Google
nameserver 8.8.8.8
nameserver 8.8.4.4
Guarda y listo!
Para mas info esta es la pagina oficial de http://code.google.com/intl/es-ES/speed/public-dns/docs/using.html

Tags de búsquedas:

dns google,DNS de Google,dns 2011,dns de google 2011,dns google 2011,google dns,que dns usar,que dns puedo usar,dns para usar,poner dns en android