Skip navigation

El dia de hoy visite la pagina oficial de Slackware y me llevo la grata sorpresa que ya ha sido liberada la version 13.1 de esta distro, la cual está disponible tanto en las ediciones de 32 y 64 bits, trae consigo muchas mejoras importantes, como KDE en su versión 4.4.3, el kernel 2.6.33.4, asi como una gama importante de herramientas, bibliotecas actualizadas, y las principales aplicaciones tales como Firefox y Thunderbird.

Para ver la lista completa de paquetes que vienen incluidos asi como las notas para esta versión, te dejo los siguientes enlaces de la pagina oficial:

Package List

Slackware Release Notes

Fuente:
http://www.slackware.com/

Anuncios

Por lo menos en las ultimas instalaciones de Slackware 12.2 que he realizado, al iniciar por primera vez el sistema en modo gráfico, siempre me encuentro con que el scroll de mi mouse está desactivado, para solventar este problema con nuestro editor favorito modificamos el archivo /etc/X11/xorg.conf, localizamos la seccion “InputDevice” que corresponde al mouse, de tal forma que las modificaciones queden como sigue:

Section "InputDevice"
Identifier "Mouse1"
Driver "mouse"
Option "Protocol" "IMPS/2"
Option "Buttons" "5"
Option "ZAxisMapping" "4 5"
Option "Device" "/dev/mouse"
EndSection

Para que los cambios se vean reflejados, tenemos que reiniciar la sesión gráfica.

En esta ocasión quiero compartir con ustedes un pequeño programa escrito en C++ sumamente sencillo, el cual establece una conexión al servidor de DB PostgreSQL y realiza una consulta a los datos almacenados en una tabla, además de que muestra en consola un poco mas de información.

using namespace std;
#include <iostream>
#include <libpq-fe.h>

PGconn *cnn = NULL;
PGresult *result = NULL;

char *host = "localhost";
char *port = "5432";
char *dataBase = "DataBase";
char *user = "postgres";
char *passwd = "password";

int main(int argc, char * argv[])
{
    int i;

    cnn = PQsetdbLogin(host,port,NULL,NULL,dataBase,user,passwd);

    if (PQstatus(cnn) != CONNECTION_BAD) {
        cout << "Estamos conectados a PostgreSQL!" << endl;
        result = PQexec(cnn, "SELECT * FROM nombre_tabla");

        if (result != NULL) {
            int tuplas = PQntuples(result);
            int campos = PQnfields(result);
            cout << "No. Filas:" << tuplas << endl;
            cout << "No. Campos:" << campos << endl;

            cout << "Los nombres de los campos son:" << endl;

            for (i=0; i<campos; i++) {
                cout << PQfname(result,i) << " | ";
            }

            cout << endl << "Contenido de la tabla" << endl;

            for (i=0; i<tuplas; i++) {
                for (int j=0; j<campos; j++) {
                    cout << PQgetvalue(result,i,j) << " | ";
                }
                cout << endl;
            }
        }

        // Ahora nos toca liberar la memoria
        PQclear(result);

    } else {
        cout << "Error de conexion" << endl;
        return 0;
    }

    PQfinish(cnn);

    return 0;
}

Para establecer la conexion con la Base de Datos nos apoyamos en libpq, la cual es un conjunto de librerias escritas en C que permite a un programa cliente enviarle consultas al servidor de PostgreSQL y recibir el resultado de éstas.

Como podemos observar se ha incluido en la cabecera del programa el archivo libpq-fe.h, el cual es el encargado de incluir las librerias de libpq.

Para compilar el programa, desde la consola escribimos lo siguiente:

$ g++ connPgSQL.cpp -o connPgSQL -Wall -I/usr/local/pgsql/include -L/usr/local/pgsql/lib -lpq

Como podemos observar ocupamos el compilador GCC (g++) ya que se trata de un programa escrito en C++:

connPgSQL.cpp es el nombre del archivo fuente .

-o connPgSQL le indica al compilador que genere un archivo ejecutable llamado connPgSQL.

-I/ruta indicamos el path donde se encuentran los archivos que estamos incluyendo en el programa fuente.

-L/ruta especifica la ruta del directorio donde el compilador va a buscar los archivos de biblioteca.

-Wall le indicamos que nos muestre en pantalla todos los posibles advertencias que se producen durante el proceso de compilación.

-lpq con esta opción le indicamos al “linker” ld que localize y utilice las librerias necesarias para el programa.

Fuentes:

http://gcc.gnu.org/
http://www.postgresql.org/docs/8.2/interactive/libpq.html

A veces necesitamos saber el espacio en disco duro que ocupa nuestra base de datos, para obtener ésta información desde la terminal psql escribimos la siguiente sentencia SQL:

select datname as db, pg_size_pretty(pg_database_size(datname)) as size FROM pg_database where datname = 'DBname'

Nos devuelve una tupla con los datos siguientes:
– el nombre de la base de datos.
– el tamaño que ocupa en disco duro.

PostgreSQL es un sistema administrador de base de datos objeto-relacional (ORDBMS) de código abierto liberado bajo la licencia BSD, desarrollado en la Universidad de California por Berkeley Computer Science Departament, es capaz de correr en distintas plataformas operativas como UNIX, FreeBSD, Linux, Mac OS X y MS Windows (NT/2000/2003 servers).

Este material intenta ser una guía de referencia de como llevar a cabo la instalación desde el código fuente de este administrador de base de datos, cabe mencionar que la instalacion se realizó sobre Slackware 12.2 y la versión 8.4.2 de PostgreSQL.

Antes de comenzar, te recomiendo que revises los requerimientos previos a la instalacion, esta información la puedes encontrar en esta dirección:

http://www.postgresql.org/docs/8.4/static/install-requirements.html

Pasos previos a la instalación.

Abrimos una terminal y nos logueamos como root.

Primeramente creamos la cuenta para el superusuario de PostgreSQL, normalmente usamos el nombre “postgres”, éste deberá ser un usuario normal de sistema.

Para lo cual escribimos el siguiente comando:

# adduser postgres

Ingresamos toda la información que nos solicita la consola.

Ahora creamos el directorio donde vamos a descargar, desempaquetar y descomprimir las fuentes, para efectos de este manual será debajo de /usr/src/pgsql, ésta ubicación no es obligatoria, por lo que la ruta la dejamos a tu consideración.

# mkdir /usr/src/pgsql

Hacemos dueño de este directorio al usuario postgres

# chwon postgres:users /usr/src/pgsql

Como siguiente paso creamos el directorio donde realizaremos la instalación del Servidor, para nuestro caso será debajo de /usr/local/pgsql

La ubicación del directorio de instalación puedes personalizarlo de acuerdo a tus necesidades, por lo que si quieres utilizar alguna otra en especifico deberas crear el directorio en la ruta de tu elección.

# mkdir /usr/local/pgsql

Hacemos dueño de este directorio al usuario postgres

# chown postgres:users /usr/local/pgsql

Abandonamos la cuenta de root:

# exit

Nos logueamos con la cuenta del usuario “postgres”, a partir de aqui toda la configuración e instalación se realizará desde esta cuenta.

Ingresamos al directorio donde descargaremos las fuentes:

$ cd /usr/src/pgsql

Ahora conseguimos las fuentes del PostgreSQL, las cuales puedes obtener desde la dirección FTP ftp://ftp.postgresql.org/pub/source/v8.4.2/postgresql-8.4.2.tar.gz.

$ wget ftp://ftp.postgresql.org/pub/source/v8.4.2/postgresql-8.4.2.tar.gz

Desempaquetamos y descomprimimos el tarball:

$ tar -xzvf postgresql-8.4.2.tar.gz

Lo anterior nos crea un directorio llamado postgresql-8.4.2, nos movemos a éste para iniciar la configuración, compilación e instalación:

Configuración.

Realizamos la configuracion utilizando el script configure:

$ ./configure --prefix=/usr/local/pgsql --with-perl --with-tcl --with-python --with-openssl

Donde prefix es el directorio de instalación, para nuestro caso es el directorio /usr/local/pgsql.

Nota: Para este ejemplo, en el script configure estamos ocupando sólo algunos de los parametros de configuración, si deseas utilizar otros, puedes visualizar la lista completa ejecutando el comando ./configure --help, la documentación que describe en forma más detallada cada una de estas opciones la puedes encontrar en la siguiente URL:

http://www.postgresql.org/docs/8.4/static/install-procedure.html

Compilación.

Procedemos a realizar la compilación:

$ make

Cuando la compilacion se lleva a cabo exitósamente, toda la salida que nos presenta la consola en su última linea debe indicar el siguiente mensaje:

All of PostgreSQL successfully made. Ready to install.

Instalación.

Una ves concluida la compilación de los paquetes, pasamos a la instalación con el siguiente comando:

$ make install

Si la instalación se realiza en forma correcta, el proceso le muestra en la ultima linea de la consola el siguiente mensaje:

PostgreSQL installation complete.

Con esto hemos completado el proceso de la instalación.

Ya para finalizar debemos iniciar el “cluster” de las bases de datos y de esta forma empezar a utilizar el Servidor PostgreSQL:

$ /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data -E LATIN1 --locale=es_MX

The files belonging to this database system will be owned by user "postgres".
This user must also own the server process.

The database cluster will be initialized with locale es_MX.
The default text search configuration will be set to "spanish".

creating directory /home/postgres/pgsql/data ... ok
creating subdirectories ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 28MB
creating configuration files ... ok
creating template1 database in /home/postgres/pgsql/data/base/1 ... ok
initializing pg_authid ... ok
initializing dependencies ... ok
creating system views ... ok
loading system objects' descriptions ... ok
creating conversions ... ok
creating dictionaries ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok
copying template1 to postgres ... ok

WARNING: enabling "trust" authentication for local connections
You can change this by editing pg_hba.conf or using the -A option the
next time you run initdb.

Success. You can now start the database server using:

./postgres -D /home/postgres/pgsql/data
or
./pg_ctl -D /home/postgres/pgsql/data -l logfile start

Iniciando el servidor.

Bien, ahora solo nos queda iniciar el servidor de PostgreSQL, de esta forma vamos a verificar que todo este funcionando correctamente, escribimos el siguiente comando:

$ /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l error_postgres.log start

Listo! Ya debemos tener corriendo el Servidor en nuestro sistema .

Para visualizar la lista de DB que tenemos instaladas ejecutamos el siguiente comando:

$ /usr/local/pgsql/bin/psql -l

List of databases
Name | Owner | Encoding | Collation | Ctype | Access privileges
-----------+----------+----------+-----------+-------+-----------------------
postgres | postgres | LATIN1 | es_MX | es_MX |
template0 | postgres | LATIN1 | es_MX | es_MX | =c/postgres
: postgres=CTc/postgres
template1 | postgres | LATIN1 | es_MX | es_MX | =c/postgres
: postgres=CTc/postgres

Accesando a una base de datos.

Para poder acceder a una base de datos, PostgreSQL cuenta con un programa que te permite interactuar con los datos, es una terminal llamada psql, en la cual podemos ejecutar comandos SQL.
Por ejemplo si queremos acceder a una base de datos llamada facturas escribimos:

$ psql facturas

De esta manera el comando psql invoca la terminal y le pasamos como parámetro el nombre de la DB.

Espero que esta información te haya sido de gran ayuda, si tienes algunas sugerencias para mejorar este procedimiento de instalación no dudes en dejar tus comentarios.

Fuente: http://www.postgresql.org/docs/8.4/static/index.html

Leyendo la documentacion oficial de PostgreSQL versión 8.4.2, en lo que respecta a la programación de funciones con PL/pgSQL, resulta que ahora ya es posible codificar mas de una sección de declaracion de variables (DECLARE) las cuales pasan a formar un subblock, además de que se puede declarar mas de una variable con el mismo nombre en distintos subblock, solo que de acuerdo al alcance o duración de éste será diferente el valor para la variable.
Para poder acceder al valor de la variable tenemos que indicar el nombre del subblock seguido del nombre de la variable separados por un punto ‘.’ (nombre_subblock.nombre_variable), ejemplo de como quedaria la estructura de la función:

fuente:
http://www.postgresql.org/docs/8.4/static/plpgsql-structure.html

Una de las primeras computadoras, propiedad de las fuerzas armadas se negaba un día a imprimir unos datos importantes. Luego que sus programadores trataron durante varias horas de encontrar algún error en el programa, una de ellos, llamada Grace Hoper, decidió inspeccionar la impresora.
Grace halló que había una pequeña polilla alojada entre dos cables importantes. Cuando extrajo la polilla de allí, la impresora comenzó a funcionar perfectamente (aunque se desconoce si la polilla tuvo la misma suerte).
Grace Hoper es en la actualidad una almirante retirada de la Marina, y aunque entre sus antecedentes figure el desarrollo de varios conceptos informáticos importantes (fue la autora de la versión original del lenguaje COBOL), resulta más conocida por haber encontrado el primer bug (bicho) presente en una computadora.
A pesar de que lo que descubrió la almirante Hoper era un bug verdadero (la polilla) los errores presentes en los programas de computación (y en el hardware) se han denominado de allí en más bugs de computación. Cuando usted comprueba un programa, puede llegar a tener que depurarlo o desbicharlo (debug), o sea, eliminar los bugs (errores) mediante la corrección de las inconsistencias de tipeo en el código fuente o la modificación de la lógica implementada de manera que el programa haga exactamente lo que se desea.

Fuente:
Libro “C con ejemplos”
Greg Perry
Prentice Hall
Pag. 14

Aqui les dejo los pasos para instalar desde las fuentes el gestor de base de Datos MySQL (versión 5.1.39 al momento de realizar este manual):
La instalación se llevó a cabo en Slackware 12.2, aunque no debería tener problemas en alguna otra distro.

Nos descargamos las fuentes desde la página oficial desde el siguiente enlace:
http://dev.mysql.com/downloads/

La ruta de descarga en tu sistema es opcional puede ser (/usr/src/, /opt/ ).

como root:

Primeramente vamos a crear el grupo mysql en nuestro sistema:
# groupadd mysql

Creamos el usuario mysql y lo agregamos al grupo que acabamos de crear:
# useradd -g mysql mysql

Descomprimimos y desempaquetamos las fuentes:
# tar -xzvf mysql-version.tar.gz

El comando anterior nos crea un directorio llamado mysql-version, nos movemos a él:
# cd mysql-version

Configuramos la instalación y compilamos:
#./configure --prefix=/usr/local/mysql --with-plugins=innobase

Nota: puedes añadir mas opciones al comando ./configure, la lista completa de éstas se despliegan ejecutando ./configure --help

# make >& make.log &

Ahora procedemos a instalar:
# make install >& install.log &

Copiamos el archivo de configuración de opciones:
# cp support-files/my-medium.cnf /etc/my.cnf

Ingresamos al directorio de la instalación:
# cd /usr/local/mysql/

Construimos las tablas que contendrán los permisos:
# bin/mysql_install_db --user=mysql

Procedemos a cambiar los atributos de propietario y grupo a los siguientes ficheros:

Hacemos propietario al usuario root todos los ficheros que estan debajo del directorio de instalación.
# chown -R root .

Ahora al directorio var le asignamos como propietario el usuario mysql, recuerda que aqui es la ubicación donde se almacenarán los datos:
# chown -R mysql var

Finalmente modificamos el atributo de grupo para que todos los ficheros pertenezcan al grupo mysql.
# chgrp -R mysql .

Listo ahora sólo falta iniciar el demonio de MySQL:

# /usr/local/mysql/bin/mysqld_safe --datadir=/usr/local/mysql/var/ --user=mysql &

Para lograr que MySQL se inicie al arranque del sistema tendras que realizar lo siguiente:

Copiar el archivo support-files/mysql.server (el cual se encuentra dentro de la carpeta principal de las fuentes) a /etc/rc.d/ :
# cp path_de_tus_fuentes/support-files/mysql.server /etc/rc.d/mysql.server

Le otorgamos permisos de ejecucion.
# chmod +x /etc/rc.d/mysql.server

Posteriormente le agregamos una nueva linea a nuestro archivo /etc/rc.d/rc.local asi:
# echo '/etc/rc.d/mysql.server start' >> /etc/rc.d/rc.local

Listo!, la próxima ves que inicies tu equipo, arrancará MySQL automáticamente.

Fuentes:
http://dev.mysql.com/doc/refman/5.0/en/index.html

Cancelando todos los trabajos a una impresora
cancel -a nombre_impresora

Borrar una impresora
/usr/sbin/lpadmin -x nombre_impresora

Desplegar todo la información del estado de las impresoras instaladas en el equipo
lpstat -t

Mandar a imprimir un trabajo
lp -d nombre_impresora nombre_archivo

Borrar un trabajo de impresion
lprm numero_trabajo

Definitivamente cuando hablamos de PostgreSQL nos estamos refiriendo a uno de los mejores sistemas gestores de base de datos que existen en la actualidad, una de sus principales caracteristicas son las funciones, es decir, “fragmentos” de código que se pueden programar en varios lenguajes como C, C++, PL/pgsql, PL/Python, PL/Ruby, PL/php, entre otros, y que son ejecutados directamente en el Servidor.
Como podemos observar, PHP también ya se ha integrado a ésta lista de lenguajes, permitiendo así, la posibilidad de escribir funciones dentro de la base de datos.

A continuación explico los pasos para instalar PL/php como lenguaje de procedimientos. La instalación se llevó a cabo en Slackware versión 12. Éste manual asume que ya tiene instalado Postgres en su equipo.

En mi caso tengo instalado lo siguiente:
PostgreSQL 8.3.0 ( ruta de instalación: /home/postgres/pgsql/ )
Php 5.2.4 ( /usr/local/php/ )

Antes de empezar necesitamos conseguir las fuentes (las cuales vamos a configurar, compilar e instalar) de los siguientes paquetes, les dejo el nombre y la dirección donde pueden descargarlos:

Php-5.2.6
www.php.net/downloads.php

plphp-1.3.2
https://projects.commandprompt.com/public/plphp/wiki/Downloads

Como usuario root:

Instalando PHP
Ahora es turno de instalar el lenguaje PHP pero de forma embebida, la ruta que vamos a utilizar será /usr/local/plphp, así aunque tuvieramos alguna instalación de php en nuestro equipo, ésta no se verá afectada.

Descomprimimos las fuentes:

# tar -xzvf php-5.2.6.tar.gz

Lo anterior nos crea un directorio llamado php-5.2.6, nos movemos a él y comenzamos a realizar la instalación:

# ./configure --prefix=/usr/local/plphp --enable-embed
# make
# make install

Instalación del lenguaje PL/php
Ahora sólo nos falta instalar el lenguaje PL/php, para mi caso agregue a la variable de entorno PATH del root, la ruta donde se encuentran los binarios del postgres:

# export PATH=$PATH:/home/postgres/pgsql/bin

verifico que se haya registrado correctamente:

# echo $PATH

/usr/local/sbin:/usr/local/bin:/sbin:/usr/sbin:/bin:/usr/bin:/home/postgres/pgsql/bin

como podemos ver ya se encuentra enlistada al final.

Descomprimimos las fuentes del plphp:

# tar -xzvf plphp-1.3.2

Realizado lo anterior se nos crea el directorio plphp-1.3.2, nos movemos a él y comenzamos a instalar:

# ./configure --with-php=/usr/local/plphp --with-postgres=/home/postgres/pgsql/bin
# make
# make install

Creamos un enlace simbólico para que PostgreSQL pueda usar el lenguaje PL/php:

# ln -sf /usr/local/plphp/lib/libphp5.so $(pg_config --libdir)

asegúrate de que todos los archivos contenidos en la carpeta pgsql/lib ( en mi caso /home/postgres/pgsql/lib) pertenezcan al superusuario del postgres.

Creando el lenguaje a la Base de Datos:
Una ves que ya tenemos todo instalado dejamos la cuenta de root y nos logueamos con el superusuario de postgres ( en mi caso es el usuario postgres ) para cargar el lenguage PL/php a la Base de Datos.

Seleccionamos la DB

postgres@pclinux:~$ psql data_base

data_base=# INSERT INTO pg_pltemplate VALUES
('plphp', 't', 't', 'plphp_call_handler', 'plphp_validator', '$libdir/plphp', NULL);

data_base=# INSERT INTO pg_pltemplate VALUES
('plphpu', 'f', 't', 'plphp_call_handler', 'plphp_validator', '$libdir/plphp', NULL);

data_base=# CREATE LANGUAGE plphp;

Listo ahora ya tenemos cargado el Lenguaje.

Verifica con la siguiente consulta a tu base de datos:

data_base=# select * from pg_language;
lanname | lanowner | lanispl | lanpltrusted | lanplcallfoid | lanvalidator | lanacl
----------+----------+---------+--------------+---------------+--------------+--------
internal | 10 | f | f | 0 | 2246 |
c | 10 | f | f | 0 | 2247 |
sql | 10 | f | t | 0 | 2248 |
plpgsql | 10 | t | t | 22256858 | 22256859 |
plphp | 10 | t | t | 22397512 | 22397513 |

Para comprobar creamos la siguiente función:

CREATE FUNCTION plphp_max(integer, integer) RETURNS integer AS $$
if ($args[0] > $args[1]) {
return $args[0];
} else {
return $args[1];
}
$$ STRICT LANGUAGE 'plphp'

data_base=# select plphp_max(5,10);
plphp_max
-----------
10

Sólo como nota:
* Para obtener información acerca de la configuración de PostgreSQL utiliza el siguiente comando:
postgres@pclinux:~$ $(pg_config --bindir)/pg_config

* Para mi usuario postgres tengo configurado el archivo /home/postgres/.profile de la siguiente forma:

#!/bin/bash
PATH=$PATH:/home/postgres/pgsql/bin
LD_LIBRARY_PATH=/usr/local/plphp/lib

export PATH LD_LIBRARY_PATH

Esto para que la variable de entorno PATH tenga registrada la ruta de los binarios de Postgres, también inicializo la variable LD_LIBRARY_PATH con la ruta de las librerias del PL/php.

* Y el archivo /etc/ld.so.conf lo tengo como sigue:

/usr/local/lib
/usr/X11R6/lib
/usr/i486-slackware-linux/lib
/opt/kde/lib
/usr/lib/qt/lib
/usr/local/plphp/lib
/home/postgres/pgsql/lib
/usr/local/apache2/modules

Ojalá y esta información les haya sido de gran utilidad.

fuentes:
http://www.commandprompt.com/
http://blog.santiago.zarate.net.ve/archives/1-Como-instalar-plphp-en-ubuntu-7.04-y-7.10
http://www.postgresql.org