Archivo

Entradas Etiquetadas ‘fichero’

Exportar desde MySQL a CSV

Jueves, 3 de Febrero de 2011 Gaspar Fernández 3 comentarios

Hace tiempo leí en los foros de MySQL una chuleta interesante. La copié en una página de keepnote hasta ahora. Es para hacer una petición que escriba su salida en un archivo en formato CSV directamente.

Para ello, la petición debe tener esta forma:

1
2
3
4
SELECT campos INTO OUTFILE '/ruta/archvo.csv'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n'
FROM tabla;

Donde campos son los campos que vas a pedir, por ejemplo * para pedir todos; /ruta/archivo.csv es el archivo que se creará y tabla es la tabla a consultar en cuestión. Eso sí, no sólo vale para una tabla, podemos hacer peticiones todo lo complicadas que queramos y guardarlas en CSV.

Precaución, el usuario mysql (o el usuario con el que se ejecuta mysql debe tener permisos de creación en el directorio seleccionado); el archivo NO puede existir, esto es una medida de precaución para que no nos podamos cargar nada al crear archivos con MySQL; y, por último, tenemos que tener el permiso FILE en el usuario de mysql con el que estemos haciendo la consulta, para ello podemos, desde root, hacer lo siguiente:

1
GRANT FILE ON *  . *  TO 'usuario'@'host' ;

Como aclaración, debo recalcar que el permiso FILE es para usuarios de MySQL no de nuestro sistema; y el query anterior debe ser lanzado como root de MySQL.

Categories: MySQL Tags: , , , , , , , , , , , , , , , ,

Crear un archivo PHP que sólo contenga un array (desde un programa PHP)

Domingo, 9 de Enero de 2011 Gaspar Fernández Sin comentarios

Aunque puede parecer redundante, pero es una idea curiosa. Sobre todo cuando creamos un sitio web con muchas opciones. Tenemos varias opciones:

  • Guardarlas en base de datos. Con lo cual cada página que carguemos tiene que hacer una petición, y si hay muchas visitas podemos saturar el sistema. Además una petición es una tarea un poco lenta
  • Guardarlas en un archivo de texto. Por lo que tendremos que hacer un programa que lea el fichero y lo interprete. Puede llegar a ser lento si el formato de nuestro archivo es complicado.
  • Guardarlas en un fichero binario. Los problemas son parecidos a los del fichero de texto, aunque a lo mejor ahorramos algo en sintaxis al representar todo en bloques; pero si tenemos un problema podemos tardar mucho tiempo depurando y leyendo el fichero de configuración con un editor hexadecimal.
  • Archivo de texto con el array serializado (serialize()) y des-serializarlo (unserialize()) cuando vayamos a leer… Aunque no tengo claro cuánto tiempo invierten serialize() / unserialize(), pero supongo que más tiempo que una lectura simple de un array.
  • Crear un archivo PHP que contenga la configuración. Es lo más rápido ya que no tenemos que crear texto que interprete y se lee de forma nativa (hay que tener en cuenta que PHP es un lenguaje interpretado, sólo tiene que interpretar el código y no un lector que interprete la configuración como en los casos anteriores).

Vamos con este último. Estas rutinas las creé con esa idea en mente. Lo que hago es insertar un array en un archivo PHP, que luego leeré desde el programa con include()/require()/etc… y si tenemos que guardar la configuración, podemos utilizar esta función array_to_phpcode():

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
<?php

function var2php(&$var)
{
  if (is_numeric($var))
    $o=$var;
  else
    $o='\''.addslashes($var).'\'';

  return $o;
}

function array2php(&$array)
{
  $o='';
  if (is_array($array))
    {
      $o.=' array (';
      foreach ($array as $key=>$value)
    {
      $o.=var2php($key).' => '.array2php($value).",\n";
    }
      $o.=')';
    }
  else
    $o.=var2php($array);
  return $o;
}

/**
******************************************************************
* @brief Crea código PHP con un array como contenido
*
* @param $array    Array a insertar
* @param $phpvar   Variable PHP donde vamos a asignarlo
* @param $precode  Código PHP a incluir antes
* @param $postcode Código PHP a incluir después
*
* @return Código PHP
*
******************************************************************/
function array_to_phpcode(&$array, $phpvar, $precode, $postcode, $comment=false)
{
  $o ="<?php\n/* Fichero generado automáticamente por LYB el ".date("Ymd")." a las ".date("H:i").
    " */\n".$comment."\n\n".$precode."\n\n/* Array a incluir */\n";
  $o.=$phpvar.' = '.array2php($array).';';
  $o.="\n/* Información incluida */\n".$postcode."\n?>";

  return $o;
    }

$array=array('user' => 'Gaspy',
         'blog' => 'Poesía Binaria',
         'URL'  => 'http://totaki.com/poesiabinaria/'
         );

echo array_to_phpcode($array, 'usuario', "echo \"Hola Mundo\";", "/* DESPUÉS OTRO COMENTARIO */", "/* COMENTARIO INICIAL */");
?>

Aunque a la hora de salvar la información sea poco óptimo (ya que machacamos el archivo entero con contenidos nuevos cuando tal vez sólo cambia un elemento), pero la lectura de las opciones será muy rápida (y es lo que nos interesa porque tendremos que hacerlo a cada página que se cargue). De todas formas, siempre podemos desarrollar una nueva versión que busque las diferencias y sea capaz de ubicarlas en el archivo y sustituirlas, pero seguramente nos de un código bastante más lento.

Categories: PHP Tags: , , , , , , , ,

Now playing… para mplayer

Domingo, 14 de Noviembre de 2010 Gaspar Fernández Sin comentarios

screenshot-14-11-2010-201150Se trata de un script para bash que representará en pantalla información del archivo que se está reproduciendo al mismo tiempo que este se visualiza. Perfecto para un sistema mediacenter.

Requerimientos:

  • bash >=3.0
  • mplayer
  • xosd
  • utilidades de sistema utilizadas: date, sed, tr, cut, sleep

Entre sus características destaca la escritura de un archivo: $HOME/.videolog con los archivos que se reproducen. Uno de los posibles usos es la descarga de muchos vídeos de youtube en un directorio concreto, posterior visualización y borrado de cada uno de los archivos tras su visionado.

Además, si el archivo de audio o vídeo a reproducir contiene metadatos de Artista y Título, se visualizará la información de estos metadatos siempre que no estén en la lista negra (variable $ARTISTAS_PROHIBIDOS), en otro caso visualizaremos el nombre del archivo arreglado (eliminando las cadenas que aparecen en la variable FILENAME_RECORTADO, aquí podemos incluir extensiones o pequeñas anotaciones sobre la calidad o resolución de un vídeo).

Se recomienda modificar XOSD_OPTIONS_ARTISTA, XOSD_OPTIONS_TITULO, XOSD_OPTIONS_INFO y XOSD_OPTIONS_DURACION de acuerdo a los tipos de letra, colores y todo lo que se desee. Dejo una pequeña referencia de las opciones de osd_cat:

–pos Posición del texto: top(arriba), middle(en medio de la pantalla), bottom(abajo)
-A Alineación del texto: left(izquierda), center(centrado), right(derecha)
-c Color: puede ser en notación html #rrggbb o por su nombre
-s Offset o desplazamiento de la sombra
-o Offset o desplazamiento desde la parte superior o inferior de la pantalla
-d Tiempo en segundos que se mantendrá el texto en la pantalla
-f Tipo de letra. Para ver los tipos de letra disponibles ejecutar xfontsel.

Inicio del archivo: mplayernp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#!/bin/bash

##########################################################################
#
# MPLAYER NOW PLAYING version 0.1
# Copyright (C) 2010 by Gaspar Fernández <gaspy at totaki.com>
# http://totaki.com/poesiabinaria
#
##########################################################################

#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License.

#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.

#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.

XOSD_OPTIONS_ARTISTA="--pos=bottom -A left -c #fff -o -110 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-520-*-*-*-*-*-*"
XOSD_OPTIONS_TITULO="--pos=bottom -A left -c #fff -o -100 -s 2 -d 10 -f -*-utopia-*-*-*-*-*-420-*-*-*-*-*-*"
XOSD_OPTIONS_INFO="--pos=bottom -A left -c #fff -s 2 -o -80 -d 10 -f -*-utopia-*-*-*-*-*-320-*-*-*-*-*-*"
XOSD_OPTIONS_DURACION="--pos=bottom -A left -c #fff -s 2 -o -60 -d 10 -f -*-utopia-*-*-*-*-*-220-*-*-*-*-*-*"

# Si precalculamos esto, damos velocidad
ESCAPE=`echo -e "\e"`

ARTISTAS_PROHIBIDOS=("virtualdub")
FILENAME_RECORTADO=(".avi" ".flv" ".mp3" ".mp4")

function print_info()
{
    artist="$1"
    title="$2"
    filename="$3"
    width="$4"
    height="$5"
    fps="$6"
    minutos="${7/./,}"      # Si nuestra locale es es_ES debemos sustituir puntos por comas
    segundos="${8/./,}"
    if [[ -n $artist ]]
    then
    artist_text=${info_val[$artist]}
    for proh in ${ARTISTAS_PROHIBIDOS[*]}
    do
        if [[ `echo $artist_text | tr [:upper:] [:lower:]` =~ $proh ]]
        then
        artist="";
        title="";
        break;
        fi
    done
    fi

    if [[ -n $artist ]]
    then
    echo $artist_text | osd_cat $XOSD_OPTIONS_ARTISTA &
    fi
    if [[ -n $title ]]
    then
    title_text=${info_val[$title]}
    echo $title_text | osd_cat $XOSD_OPTIONS_TITULO &
    else
    # Si no tenemos la codificación correcta configurada, esto puede saltar
#   fname=`basename "$filename"`
#   dname=`dirname "$filename"`
#   defname=`ls "$dname/$fname"*`
#   defname=`basename "$defname"`
    defname=`basename "$filename"`
    for recorte in ${FILENAME_RECORTADO[*]}
    do
        defname=${defname/$recorte/}
    done
    echo $defname | osd_cat $XOSD_OPTIONS_TITULO &
    fi
    if [[ -n $fps ]]
    then
    echo $width"x"$height"@"$fps | osd_cat $XOSD_OPTIONS_INFO &
    fi
    duracion=`printf "%1.0f:%1.0f" "$minutos" "$segundos"`
    echo $duracion | osd_cat $XOSD_OPTIONS_DURACION &

    echo "`date +"%d/%m/%Y %H:%M"` Media: $filename Dur: $duracion" >> $HOME/.videolog

}

function keyvalue()
{
    key=`echo "$1" | cut -d= -f1`
    value=`echo "$1" | cut -d= -f2`

    res[0]=$key;
    if [[ -n $value ]]
    then
    res[1]=$value;
    else
    res[1]="0";
    fi

    if [[ -n `echo $key | grep "ID_CLIP_INFO_NAME\|ID_CLIP_INFO_VALUE"` ]]
    then
    # Si tenemos un ID_CLIP_INFO_NAMEx o ID_CLIP_INFO_VALUEx extraemos el x
    info=(`echo $key | sed -n -e "s/\([a-zA-Z_]*\)\([0-9]*\)/\1\n\2/p"`)
   
    res[0]=${info[0]}
    res[2]=${info[1]}
    fi
    echo -e ${res[0]}"\n"${res[1]}"\n"${res[2]}"\n"


}

function tituladora()
{

artist="";
title="";
while read -n 200 dato 
do
    if [[ -n `echo $dato | grep ID_` ]] # Extraemos información de mplayer
    then
    OLD_IFS=$IFS;
    IFS="
";
    kval=( `keyvalue $dato` );
#   echo ${kval[0]} "********"
    IFS=$OLD_IFS

    case ${kval[0]} in
        "ID_FILENAME")
        filename="${kval[1]}"          
        ;;
        "ID_VIDEO_WIDTH")
        width=${kval[1]}
        ;;
        "ID_VIDEO_HEIGHT")
        height=${kval[1]}
        ;;
        "ID_VIDEO_FPS")
        fps=${kval[1]}
        ;;
        "ID_LENGTH")
        seconds=${kval[1]};
        # Extrae la duración en minutos y segundos
        duration=( `echo "scale=0; $seconds / 60; scale=0; $seconds % 60" | bc` )
        ;;
        "ID_CLIP_INFO_NAME")
        if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "artist" ]]
            then
#           echo "ARTISTA CAPTURADO "${kval[2]};
            artist=${kval[2]} # Donde encontramos el artista
        else
            if [[ `echo ${kval[1]} | tr [:upper:] [:lower:]` == "title" ]]
            then
            title=${kval[2]} # Donde encontramos el artista
#           echo "TITULO CAPTURADO"
            fi
        fi
        ;;
        "ID_CLIP_INFO_VALUE")
        # Almacenamos el valor obtenido
#       echo "ALMACENO EN "${kval[2]} "ESTO" ${kval[1]} "**" ${kval[0]} ${kval[2]} = ${kval[1]}
        info_val[${kval[2]}]="${kval[1]}"
        ;;
    esac
#   echo ${info_val[@]}
    else
    # Si encontramos caracteres de control....
    if [[ $dato =~ $ESCAPE ]]
    then

        # Tal vez podamos comentar esto para dar velocidad --- INICIO
        if [[ $dato =~ "Position" ]]
        then       
        printf "%s\n" "$dato"
        else
        printf "%s" "$dato"
        fi
        # Tal vez podamos comentar esto para dar velocidad --- INICIO
    else
        if [[ ${dato:0:3} == "AO:" ]] # Aquí empieza el Audio... saltaremos tanto para archivos de audio como
                                      # para vídeos / películas... que también tengan audio
        then
        # Empieza la reproducción
        sleep 1 && print_info "$artist" "$title" "$filename" "$width" "$height" "$fps" "${duration[0]}" "${duration[1]}"
        fi

        echo $dato;
    fi
    fi
done
}
mplayer -identify $@ | tituladora

Por último, para utilizar este programa, podemos crear un alias a mplayer:

alias mplayer=”mplayernp”

Para finalizar dejo algúnos ejemplo de uso (son válidos también para mplayer, ya que mplayernp pasa los comandos tal cual a mplayer:

1
2
# Para reproducir archivos dentro de un directorio con orden aleatorio y en pantalla completa
mplayernp -fs `ls /directorio/*.avi | sort -R`

Vídeo de la foto: El Hombre de Negro - Greenfield

Categories: Bash, General, Linux Tags: , , , , , , , , , , , ,

Terminal transparente para visualizar logs

Jueves, 5 de Agosto de 2010 Gaspar Fernández Sin comentarios

screenshot-01-08-2010-140805Es muy de 2002/2003, aunque todavía a muchos les gusta tener un pequeño terminal transparente en el fondo para ejecutar comandos o mostrar logs u otra información importante.

Aquí comentaré algunas soluciones que he encontrado y cómo obtenerlas.

xrootconsole

Es muy ligero y rápido. Y vale para mostrar logs en xroot; el fondo es supuestamente transparente, aunque si cambiamos el fondo veremos que no, ya que en la ventana de xrootconsole se mantendrá el fondo anterior. Está bien para hacer el apaño, pero no lo recomiendo. La forma de ejecutar xrootconsole es:

$ xrootconsole [fichero]

donde fichero es el que vamos a vigilar, la visualización se actualiza automáticamente con cada cambio que se observa en el archivo. Es ideal para ver /var/log/messages.

aterm

Muestra un terminal transparente, con muchas opciones, y que podemos ejecutar de la siguiente manera para mostrar las últimas líneas de dmesg en el escritorio:

$ aterm -fg black -geometry 100×10+0+0 -e watch –no-title -n10 -d ‘dmesg | tail’

donde:

-fg Indica el color de las letras
-geometry Indica la posición y dimensiones de la ventana: ancho x alto + x + y
-e Ejecuta el comando que especificamos a continuación (La referencia del comando watch la incluyo al final del post

Por supuesto podemos sustituir el comando que esta en negrita por lo que queramos mostrar.
Aún así, de esta forma aterm nos muestra decoración de ventana, barra de scroll y no es transparente. Esto lo podemos solucionar ejecutando aterm de la siguiente manera:

$ aterm -tr -bl -sb -fg black -geometry 100×10+0+0 -e watch –no-title -n10 -d ‘dmesg | tail’

-tr Ventana transparente
-bl Ventana sin borde
-sb Ventana sin barra de desplazamiento (scrollbar)

O, editando el archivo $HOME/.Xdefaults y añadiendo estas líneas

aterm*transparent:true
aterm*borderLess:true
aterm*scrollBar:false

El problema de aterm es que no admite sombra en las letras, por lo que la lectura sobre algunos fondos es algo complicada.

Eterm

Este emulador de terminal es el más completo y tiene más opciones, y por lo menos es el que soporta poner sombra en las letras, lo que proporciona una mejor visibilidad, y es el que aparece en la captura de pantalla que hay arriba. Para ello, lo podemos ejecutar de la siguiente forma:

Eterm –buttonbar 0 –scrollbar off -f white -n dmessenger -g 211×10+0+0 -O -0 -e watch –no-title -n10 -d ‘dmesg | tail’

–buttonbar 0 Elimina la barra de menú y botones superior
–scrollbar off Elimina la barra de desplazamiento.
-f white Especifica el color de las letras (blanco en este caso)
-n dmessenger Especificamos el nombre de la aplicación, la llamamos dmessenger. Será útil más adelante.
–O (letra o) Hace la ventana transparente
-0 (cero) Activa algunas optimizaciones de transparencia (sobre todo para ventanas que no se moverán demasiado), desactivar esta opción si no funciona correctamente o hay fallos en la ventana.
-x La pondré más adelante, elimina la decoración de la ventana y oculta el terminal de la barra de aplicaciones.
-g Indica la posición y dimensiones de la ventana: ancho x alto + x + y
-e Ejecuta el comando que especificamos a continuación (La referencia del comando watch la incluyo al final del post

Aunque veremos un problema, la decoración de la ventana, para ello hay varias soluciones, dependiendo del sistema en el que trabajemos, para muchos, la solución será incluir el parámetro -x:

$ Eterm -x –buttonbar 0 –scrollbar off -f white -n dmessenger -g 211×10+0+0 -O -0 -e watch –no-title -n10 -d ‘dmesg | tail’

(en negrita aparece el comando, en cursiva un comando opcional), aunque a veces el entorno de ventanas, entre ellos Fluxbox, el que uso actualmente, no se lleva muy bien con ese modo sin decoración de ventanas, y aunque se muestra bien, la ventana aparece sobre todas las demás (on top).
Para solucionar eso, nos vamos a complicar un poco la vida. Para ello, editamos el archivo $HOME/.fluxbox/apps y añadimos las siguientes líneas:

[app] (name=dmessenger)
[Deco] {NONE}
[Sticky] {yes}
[Layer] {10}
[end]

Y a la hora de ejecutar Eterm lo hacemos de la siguiente manera:

Eterm –buttonbar 0 –scrollbar off -f white -n dmessenger -g 211×10+0+0 -O -0 -e watch –no-title -n10 -d ‘dmesg | tail’ & sleep 2 && wmctrl -r dmessenger -b add,skip_taskbar

donde ejecutamos Eterm en segundo plano (al terminar el comando con &) y ejecutamos un sleep 2 (para esperar 2 segundos antes de ejecutar el siguiente comando), a continuación ejecutamos wmctrl donde,

-r dmessenger Especificamos el nombre de la ventana a ocultar; en este caso dmessenger
-b add,skip_taskbar Eliminamos la aplicación Eterm de la barra de aplicaciones, si queremos que la ventana aparezca también por debajo de las demás ventanas, podemos añadir la opción below de la siguiente forma: -b add,skip_taskbar,below

dmesg

En el ejemplo estamos ejecutando dmesg de la siguiente forma (con la ayuda de watch):

watch –no-title -n10 -d ‘dmesg | tail’

donde,

–no-title watch introduce un título donde indica el periodo de actualización, con este modificador lo eliminamos.
-n10 dmesg no está cambiando continuamente, por lo que escogemos un periodo de actualización de 10segundos (podemos modificar este parámetro como queramos)
-d ‘dmesg | tail’ Obtenemos los últimos 10 mensajes del kernel, podemos incluir un modificador -n4 a tail para obtener sólo las últimas 4.
Categories: General Tags: , , , , , , , , , , , ,

Tamaño de un fichero en C

Lunes, 19 de Abril de 2010 Gaspar Fernández 2 comentarios

Veo en nosolounix un ejercicio similar. Se trata de averiguar el tamaño en bytes de un archivo (Luego podemos saber su tamaño en Kb, Mb, Gb…).

Yo propongo una solución algo más ligera (sin necesidad de recorrer el fichero para contar sus bytes), utilizando las funciones fseek y ftell para posicionarnos y averiguar la posición del puntero del fichero en un instante:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>


main ()

{

  FILE *fich;

  fich=fopen("test.c","r");

  fseek(fich, 0L, SEEK_END);
  printf("test.c ocupa %d bytes", ftell(fich));
  fclose(fich);

}
Categories: C/C++ Tags: , , , ,

Visita otras webs de la red