Configuración básica de PostgreSQL

Dom, 29/03/2009 - 21:56 — rafaelma

PostgreSQL se puede empezar a utilizar nada más terminar de instalarlo y despues de inicializar nuestro "cluster", sin necesidad de configurar nada. Pero si vamos a utilizar PostgreSQL para algo importante y con cierto volumen de datos y usuarios es imprescindible que lo configuremos para dicho trabajo.

No es la primera vez que algun asuario protesta o esta super preocupado de lo mal y lo lento que funciona su cluster de base de datos PostgreSQL en un servidor ultimo modelo con muchisima memoria. Normalmente el problema es que PostgreSQL no ha sido configurado para trabajar con el volumen de datos y usuarios con el que lo estamos usando. No es una gran ayuda tener un servidor con varios GBytes de memoria RAM si le hemos dicho a PostgreSQL, por ejemplo, que no utilice más de 32MBytes.

Tambien tenemos que decir que cualquier base de datos que se este usando activamente, no solo PostgreSQL, es un elemento dinamico y vivo en el que estamos cambiando los datos constantemente y donde el tamaño de los datos almacenados suele ir creciendo con el tiempo. Esto significa que una configuracion que funcione bien con ciertos valores hoy, puede que no funcione tan bien despues de unos meses de uso y que necesite ajustarse para que funcione optimalmente.

El comportamiento de PostgreSQL en nuestro sistema se puede controlar con tres ficheros de configuración que se encuentran en el directorio de datos donde inicializamos nuestro cluster PostgreSQL (En nuestro caso /var/pgsql/data). Estos tres ficheros son:

pg_hba.conf: Este fichero se utiliza para definir los diferentes tipos de accesos que un usuario tiene en el cluster.

pg_ident.conf: Este fichero se utiliza para definir la información necesaria en el caso que utilicemos un acceso del tipo ident en pg_hba.conf .

postgresql.conf: En este fichero podemos cambiar todos los parametros de configuracion que afectan al funcionamiento y al comportamiento de PostgreSQL en nuestra maquina.

Pasamos a continuación a explicar los cambios mas importantes que podemos hacer en algunos de estos ficheros.

pg_hba.conf

Este fichero se utiliza para definir como, donde y desde que sitio un usuario puede utilizar nuestro cluster PostgreSQL. Todas las lineas que empiezen con el caracter # se interpretan como comentarios. El resto debe de tener el siguiente formato:

[Tipo de conexion][database][usuario][IP][Netmask][Tipo de autentificacion][opciones]

Dependiendo del tipo de conexion y del tipo de autentificacion, [IP],[Netmask] y [opciones] pueden ser opcionales. Vamos a explicar un poco como definir las reglas de acceso. El tipo de conexion puede tener los siguientes valores, local, host, hostssl y hostnossl. El tipo de metodo puede tener los siguientes valores, trust, reject, md5, crypt, password, krb5, ident, pam o ldap

Una serie de ejemplos nos ayudaran a comprender mejor como podemos configurar diferentes accesos al cluster PostgreSQL.

Ejemplo 1 .- Acceso por tcp/ip (red) a la base de datos test001, como usuario test desde el ordenador con IP 10.0.0.100, y metodo de autentificacion md5:

host test001 test 10.0.0.100 255.255.255.255 md5

Esta misma entrada se podria escribir tambien con la mascara de red en notacion CIDR:

host test001 test 10.0.0.100/32 md5

Ejemplo 2 .- Acceso por tcp/ip (red) a la base de datos test001, como usuario test desde todos los ordenadores de la red 10.0.0.0, con mascara de red 255.255.255.0 (254 ordenadores en total) y metodo de autentificacion md5:

host test001 test 10.0.0.0 255.255.255.0 md5

Esta misma entrada se podria escribir tambien con la mascara de red en notacion CIDR:

host test001 test 10.0.0.0/24 md5

Ejemplo 3 .- Acceso por tcp/ip (red), encriptado, a todas las bases de datos de nuestro cluster, como usuario test desde el ordenador con IP 10.0.0.100, y el ordenador 10.1.1.100 y metodo de autentificacion md5 (necesitamos dos entradas en nuestro fichero pg_hba.conf:

hostssl all test 10.0.0.100 255.255.255.255 md5hostssl all test 10.1.1.100 255.255.255.255 md5

Ejemplo 4.- Denegar el acceso a todos las bases de datos de nuestro cluster al usuario test, desde todos los ordenadores de la red 10.0.0.0/24 y dar accesso al resto del mundo con el metodo md5:

host all test 10.0.0.0/24 reject

host all all 0.0.0.0/0 md5

Asi podriamos seguir jugando con todas las posibilidades que nos brinda este fichero de configuracion. Por supuesto que las bases de datos y usuarios usados en este fichero tienen que existir en nuestro cluster para que todo funcione y algunos de los parametros solo se pueden usar si hemos compilado con las opciones pertinentes en el proceso de instalacion (por ejemplo, hostssl, pam, krb5)

Para poder en produccion los cambios en este fichero tendremos que decirle a PostgreSQL que vuelva a leerlo. Basta con un simple 'reload' (/usr/local/bin/pg_ctl -D /var/pgsql/data reload) desde la linea de comandos o con la funcion pg_reload_conf() como usuario postgres desde psql, el cliente PostgreSQL.

[postgres@servidor]# /usr/local/bin/psql

Welcome to psql 8.2.4, the PostgreSQL interactive terminal.

Type: \copyright for distribution terms \h for help with SQL commands \? for help with psql commands \g or terminate with semicolon to execute query \q to quit

postgres=# SELECT pg_reload_conf();

pg_reload_conf ---------------- t(1 row)

postgres=#

Para una documentacion detallada sobre el fichero pg_hba.con, pasaros por la seccion Chapter 20. Client Authentication de la documentacion oficial de PostgreSQL.

postgresql.conf

Los cambios que realicemos en este fichero afectaran a todas las bases de datos que tengamos definidas en nuestro cluster PostgreSQL. La mayoria de los cambios se pueden poner en produccion con un simple 'reload' (/usr/local/bin/pg_ctl -D /var/pgsql/data reload), otros cambios necesitan que arranquemos de nuevo nuestro cluster (/usr/local/bin/pg_ctl -D /var/pgsql/data restart).

Mas informacion sobre todos los parametros que podemos cambiar en este fichero, que afectan y como se pueden poner en produccion se puede encontrar en la seccion 17. Server Configuration de la documentacion oficial de PostgreSQL.

A continuacion vamos a ver los parametros mas importantes que deberiamos cambiar si empezamos a usar PostgreSQL para un uso serio y si queremos sacarle el maximo partido a nuestra maquina. Existen muchos mas parametros que se pueden y con el tiempo se

deberan de ajustar, aqui nos vamos a centrar en los mas importantes y los cuales deberiamos cambiar antes de empezar a utilizar PostgreSQL de una manera seria.

max_connections: Numero maximo de clientes conectados a la vez a nuestras bases de datos. Deberiamos de incrementar este valor en proporcion al numero de clientes concurrentes en nuestro cluster PostgreSQL. Un buen valor para empezar es el 100:

max_connections = 100

shared_buffers: Este parametro es importantisimo y define el tamaño del buffer de memoria utilizado por PostgreSQL. No por aumentar este valor mucho tendremos mejor respuesta. En un servidor dedicado podemos empezar con un 25% del total de nuestra memoria. Nunca mas de 1/3 (33%) del total. Por ejemplo, en un servidor con 4Gbytes de memoria, podemos usar 1024MB como valor inicial.

shared_buffers = 1024MB

work_mem: Usada en operaciones que contengan ORDER BY, DISTINCT, joins, .... En un servidor dedicado podemos usar un 2-4% del total de nuestra memoria si tenemos solamente unas pocas sesiones (clientes) grandes. Como valor inicial podemos usar 8 Mbytes.

work_mem = 8MB

maintenance_work_mem: Usada en operaciones del tipo VACUUM, ANALYZE, CREATE INDEX, ALTER TABLE, ADD FOREIGN KEY. Su valor dependera mucho del tamaño de nuestras bases de datos. Por ejemplo, en un servidor con 4Gbytes de memoria, podemos usar 256MB como valor inicial.

maintenance_work_mem = 256MB

effective_cache_size: Parametro usado por el 'query planner' de nuestro motor de bases de datos para optimizar la lectura de datos. En un servidor dedicado podemos empezar con un 50% del total de nuestra memoria. Como maximo unos 2/3 (66%) del total. Por ejemplo, en un servidor con 4Gbytes de memoria, podemos usar 2048MB como valor inicial.

effective_cache_size = 2048MB

checkpoint_segments: Este parametro es muy importante en bases de datos con numerosas operaciones de escritura (insert,update,delete). Para empezar podemos empezar con un valor de 64. En grandes databases con muchos Gbytes de datos escritos podemos aumentar este valor hasta 128-256.

checkpoint_segments = 64

Es muy importante tener en cuenta que al aumentar los valores por defecto de muchos de estos parametros, tendremos que aumentar los valores por defecto de algunos parametros

del kernel de nuestro sistema. Informacion detallada de como hacer esto se encuentra en la seccion 16.4. Managing Kernel Resources de la documentacion oficial de PostgreSQL.

En fin, esto es solo un aperitivo de lo que podemos hacer. Con la practica y la experiencia podremos y tendremos que ajustar otros muchos parametros. Pero esto sera materia de un proximo articulo.

Fuentes: postgresql.org.

PostgreSQL: Extraer los campos de una fecha

Uno de los recursos más almacenados en las bases de datos son las fecha, existiendo ocasiones en las cuales se deben obtener algunos campos de la fecha, para este ejemplo se utilizará la tabla personas creada como se observa a continuación:

create table personas (   id                     SERIAL      NOT NULL,   rut                   varchar(15) NULL,   nombre           varchar(30) NULL,   apaterno         varchar(30) NULL,   amaterno        varchar(30) NULL,   fecha_nac        date   NULL,   hora_nac         time NULL,   sexo                 varchar(1)  NULL,   direccion         varchar(30) NULL,   ciudad             varchar(30) NULL,   telefono           integer     NULL,   created            timestamp   NOT NULL,   modified          timestamp   NULL,   constraint pk_personas primary key (id));

De esta tabla se rescataran cada uno de los campos de la creación del registro por separados y a demás se obtendrá el día de la semana al que corresponde la fecha de creación del registro.

SELECT rut, extract(year from created)::int as anyo, extract(month from created)::int as mes, extract(day from created)::int as dia, extract(hour from created)::int as hour, extract(minute from created)::int as minuto, extract(second from created)::int as segundo,

 CASE extract(dow from created)  WHEN 0 THEN 'Domingo'   WHEN 1 THEN 'Lunes'  WHEN 2 THEN 'Martes'  WHEN 3 THEN 'Miercoles'  WHEN 4 THEN 'Jueves'  WHEN 5 THEN 'Viernes'  WHEN 6 THEN 'Sabado' END as dowFROM personas;

Con esta consulta se obtiene toda la fecha de creación desglosada completamente, a demás permite obtener el día de la semana en que fue creado utilizando el CASE que permite seleccionar entre los valores el valor obtenidos y lo convierte en una cadena con el nombre del día.

extract(campo from fuente)

Recupera los valores de una fecha/hora, donde la fuente es un campo del tipo de dato fecha/hora, en este caso en particular un timestamp, mientras que el campo es el tipo de valor recuperado de la fecha, los campos existentes en las variables de fecha/hora son los siguientes:

century: devuelve el siglo de la fecha, no existe siglo 0, solo existe desde el -1 al 1. Ej. el año 2000 es el siglo 20, mientras que el año 2001 es el siglo 21.

day: devuelve el día del mes, va desde el 1 al 31 según el mes que corresponda.

decade: divide el campo del año en 10. Ej. el año 2001 sería la decada 200.

dow: devuelve el día de la semana que va desde 0 a 6, donde el 0 corresponde al domingo.

doy: devuelve el día del año que va desde 1 al 365/366 según corresponda.

epoch: devuelve el numero de segundos desde el 1970-01-01. Este valor puede ser negativo.También se puede utilizar para obtener el numero de segundos en un intervalo de tiempo. Ej. SELECT EXTRACT(EPOCH FROM INTERVAL'5 day 3 hours');

hour: devuelve la hora de la fecha, este valor esta entre 0 y 23.

microseconds: El tiempo en segundos, incluyendo la parte fraccionaria multiplicada por 1.000.000.

millennium: devuelve el valor del milenio del año. Ej. el año 1990 es el milenio 2 y el año 2001 es el milenio 3.

milliseconds: devuelve los segundos del campo tiempo multiplicado por 1.000.

minute: devuelve los minutos del campo, este valor esta definido entre 0 y 59.

month: Para valores timestamp, devuelve el numero del mes sin el año, los valores están definidos entre 0 y 12. También permite obtener intervalos de meses. Ej. SELECT EXTRACT (MONTH FROM INTERVAL '2 years 3 months');

quarter: Divide el año en cuatro y devuelve valores entre 1 y 4, según el intervalo en que se encuentre el día en el año.

second: devuelve la cantidad de segundos incluyendo la parte fraccionaria del campo.

timezone: La zona horaria en UTC, medida en segundos, los valores positivos corresponden a la zona horaria este de UTC y los valores negativos a la zona horaria oeste de UTC.

timezone_hour: La hora correspondiente de la zona horaria.

timezone_minute: Los minutos correspondientes a la zona horaria.

week: El número de la semana del año.

year: devuelve el año de la fecha, no hay año 0, así que hay años antes de Cristo y después de Cristo.

"Gracias, por compartir tus conocimientos"  Publicado por jp (Juan Pablo) en 22:05 No hay comentarios: Enviar por correo electrónico Escribe un blog Compartir con Twitter Compartir con FacebookEtiquetas: PostgreSQL

jueves, 28 de octubre de 2010

PostgreSQL: Ingreso a la base de datos sin clave

El usuario de una base de datos postgres puede desear acceder al motor de base de datos sin tener que ingresar la clave.Para lograr esto se debe crear el archivo ".pgpass" en el directorio home del usuario que desea ingresar sin la password.El archivo debe contener líneas con el siguiente formato.

hostname:port:database:username:password

En el archivo los campos descritos contienen la siguiente información: hostname -> debe escribir "localhost" si la base de datos se encuentra en el mismo

equipo, de encontrarse en otro se debe escribir la ip del equipo o el nombre del equipo en la red.

port -> se debe ingresar el numero del puerto de conexión al postgres, por defecto el puerto de conexión de postgres es "5432".

database -> se debe escribir el nombre de la base de datos a la cual se desea ingresar.

username -> se debe escribir el nombre de usuario con el cual se desea acceder a la base de datos.

password -> se debe ingresar la password utilizada por el usuario para ingresar a la base de datos.

Este archivo debe tener estrictamente los permisos de lectura y escritura solo para el usuario y ningún permiso para el grupo u otros. Para revisar los permisos del archivo se puede ejecutar el siguiente comando.

ls -la .pgpass

Esto entregara la siguiente línea como respuesta. -rw-------     1     nombreusuario     nombregrupo     tamaño     fechamodificacion     .

pgpass

Si los permisos del archivo no están como se observa en la línea anterior, se debe utilizar el siguiente comando para cambiar los permisos del archivo.

chmod 600 .pgpass

"Gracias, por compartir tus conocimientos" Publicado por jp (Juan Pablo) en 22:44 1 comentario: Enviar por correo electrónico Escribe un blog Compartir con Twitter Compartir con FacebookEtiquetas: PostgreSQL

miércoles, 27 de octubre de 2010

PostgreSQL: Copiar resultado de un SELECT a un archivo

Existen ocasiones en las que es deseable pasar los resultados de un SELECt a un archivo, postgres permite que realices esta operación. Para esto debes ejecutar el siguiente comando en la consola del postgres.

postgres=#copy (select * from nombre_tabla) to 'directorio_name/file_name';

Esto permite copiar todos los datos obtenidos en el select al archivo ubicado en el directorio seleccionado. Para que quede más claro se puede observar el siguiente ejemplo que es ejecutado en la consola de postgres en un equipo con linux instalado.

postgres=#copy (select * from alumnos) to '/tmp/datos.txt';

IMPORTANTE:Es importante recordar algunos comandos de postgres que permiten obtener ayuda.

postgres=#\h => permite obtener ayuda de los comandos de postgres. postgres=#\help comando => permite obtener ayuda de un comando especifico de

postgres.

postgres=#\? => permite obtener ayuda de los comandos del cliente de postgres.

Antes de terminar debo aclarar que "postgres=#" indica que el comando es ejecutado en la consola del postgres.

"Gracias, por compartir tus conocimientos" Publicado por jp (Juan Pablo) en 21:07 No hay comentarios: Enviar por correo electrónico Escribe un blog Compartir con Twitter Compartir con FacebookEtiquetas: PostgreSQL

martes, 26 de octubre de 2010

PostgreSQL: Modos de ingreso, creación de usuarios y base de datos

Después de instalar PostgreSQL en un equipo con Ubuntu se debe ingresar al sistema con un usuario y a una base de datos existentes en el motor de base de datos, para esto se puede utilizar el siguiente comando.

sudo -u usuario psql base_de_datos

Como usuario se debe utilizar postgres y como base de datos postgres, esto permitirá al usuario ingresar al motor de base de datos sin necesidad de una clave más que la del superusuario.

Una vez que se ha ingresado se debe crear un usuario para trabajar con las bases de datos, esto se puede realizar con el siguiente comando.

CREATE USER "usuario" WITH CREATEDB CREATEUSER PASSWORD 'password'

Como usuario se debe ingresar el nombre del usuario que se creará y como password la clave de ingreso del usuario, por ejemplo para crear como usuario el mismo de php se debe escribir lo siguiente.

CREATE USER "www-data" WITH CREATEDB CREATEUSER PASSWORD 'www-data'

Para crear una base de datos que sea propiedad del usuario que se ha creado se debe utilizar el comando escrito a continuación.

CREATE DATABASE nombre_base_datos WITH OWNER = "usuario"

Una vez que el usuario y la base de datos del mismo han sido creados se puede ingresar a PostgreSQL con el siguiente comando.

psql -h localhost -U usuario nombre_base_datos

Luego el motor solicita la password ingresada para el usuario en el proceso de creación. Ahora puedes realizar todas las operaciones que desees con la base de datos que acabas de crear.

"Gracias, por compartir tus conocimientos" Publicado por jp (Juan Pablo) en 22:54 No hay comentarios: Enviar por correo electrónico Escribe un blog Compartir con Twitter Compartir con FacebookEtiquetas: PostgreSQL

lunes, 25 de octubre de 2010

PostgreSQL: Control de Secuencias

En PostgreSQL se pueden crear tablas con "primary key" autoincrementables, como se pude observar en el siguiente ejemplo.

create table alumnos (   id        SERIAL       not null,   nombre varchar(255) NULL,   constraint pk_beneficios primary key (id));

Esto creara una secuencia autoincrementable para la "primary key" como se observa a continuación.

 id      integer        not null valor por omisión nextval('alumnos_id_seq'::regclass)

En ocaciones es necesario observar o modificar los valores de la secuencia, para realizar estas operaciones, se pueden utilizar las siguientes sentencias.

"SELECT last_value FROM nombre_secuencia;": Retorna el último valor de la secuencia.

"SELECT nextval('nombre_secuencia');": Retorna el valor del último número de la secuencia y lo incrementa en 1.

"SELECT setval ('nombre_secuencia', valor);": Asigna el valor a la secuencia, obligando a nextval a retornar (valor + 1).

"SELECT setval('nombre_secuencia',valor,true);": Funciona del mismo modo que la sentencia anterior.

"SELECT setval('nombre_secuencia',valor,false);": Asigna el valor a la secuencia, obligando a nextval a retornar (valor).

"SELECT currval('nombre_secuencia');": Retorna el valor del último número de la secuencia.

El nombre_secuencia puede ser remplazado por "alumno_id_seq" del primer ejemplo, mientras que el valor debe ser un entero mayor que 0 (cero).

"Gracias, por compartir tus conocimientos"

Saludos comunidad,

Haciendo pruebas respaldando una base de datos PostgreSQL en formato de texto, el típico script .sql, me di cuenta que puede resultar un dolor de cabeza restaurarla.

La razón es porque al restaurarla, con psql, puede quedar con otro dueño diferente al original, por ejemplo del usuario postgres. Entonces, por problemas de permisos nos comienza a joder. Ya comprobé que con un ALTER DATABASE $basename OWNER TO $user; no se resuelve el problema.

Leyendo este artículo: http://www.commandprompt.com/blogs/joshua_drake/2010/07/a_better_backup_with_postgresql_using_pg_dump/

me doy cuenta que lo ideal es respaldarla en formato "custom" (usando pg_dump), con esto fácilmente restauramos parte (funciones, tablas, ...) o toda la base y, ya lo comprobé, con el dueño original (con pg_restore). Resulta ideal también para respaldar bases muy grandes.

En resumen:

Respaldar: pg_dump -U $username --format=c --file=$mydatabase.sqlc $dbname

Restaurar parte de la base: pg_restore -U $username --dbname=$dbname --index=$indexname pg_restore -U $username --dbname=$dbname --function=$functionname(args) pg_restore -U $username --dbname=$dbname --table=$tablename

o la base completa: pg_restore -h localhost -U$username --dbname=$databasename $filename

Léanse el artículo completo para más detalles.

En esto todavía estoy novato, cualquier aporte es bienvenido :-)

-- Leo Jiménez San José, Costa Rica

www.geekgolo.net www.softwarelibre.ucr.ac.cr

fb.com/leojimenezcr twitter.com/geekgolo

Copiar una Base de Datos Postgresql de un Equipo a Otro

Buenas.

luego de buscar por muchas webs de como copiar una base de datos Postgresql y no encontrar nada decidi realizar este post espero que sea de utilidad.

Version del Postgresql 9.2

como bien saben las bases de datos Postgresql no crean una carpeta con el nombre de ella como lo hacen otros motores de bases de datos, he hay el problema cuando queremos pasar nuestra base de datos a otro equipo, una forma de hacerlo es la siguiente.

1. junto con Postgresql tener pgAdmin, el cual es un herramienta grafica que nos facilita trabajar con las bases de datos.

2. le damos click derecho a la base de datos que nesecitamos pasar a otro equipo y click sobre resguardo (backup)

como se muestra en la imagen.

[/URL] Subido en subir imagenes]

Ver mas grande http://www.subeimagenes.com/img/imagen1-590225.html

luego nos aparece

[/URL] Subido en subir imagenes]

Ver mas http://www.subeimagenes.com/img/imagen2-590227.html

esta parte es donde crearemos nuestro archivo que guardara la base de datos en el nombre de archivo el que deseen (ejemplo:backup prueba), el formato si es muy importante que escojan entre Custom o Tar (recomiendo Custom) y por ultimo el Rolename seleccionamos postgres, luego damos en el boton resguardo (backup), hay nos muestra una serie de mensajes y el ultimo que es El proceso retornó el código de salida 0. debe tener como valor siempre cero si tiene otro numero es que algo ha quedado mal.

3. ya teniendo nuestro archivo (resguardo o backup) el cual tiene comprimida nuestra base de datos, solo es ir al otro equipo y realizar lo siguiente, creamos una base de datos no importa el nombre y le damos click derecho y seleccionamos restaurar.

como se ve en la imagen.

[/URL] Subido en subir imagenes] Ver mas grande http://www.subeimagenes.com/img/imagen3-590235.html

luego nos aparece.

[/URL] Subido en subir imagenes] www.subeimagenes.com/img/imagen4-590236.html ver mas grande

en esta parte es donde seleccionamos nuestro archivo (resguardo o backup) teniendo en cuenta el Formato que sea el mismo que le indicamos al momento de crear el archivo y Rolename este seleccion postgres, despues le damos restaurar.

nuestro mensaje El proceso retornó el código de salida 0. debe tener como valor cero de lo contrario algo quedo mal, observarcion al momento de generar mas de una restauracion a una base de datos lo mas posibles es que no lo genere, asi que recomiendo que la creen de nuevo, recuerden que lo que vamos a pasar es la informacion de la base de datos y el nombre no importa.

Visitemen en: http://www.websit.com.co/ Diseño y Programacion de paginas web.

Copia y recuperación de una base de datos PostgreSQL

Posted by: Roberto Lizana

¿Cuantas veces hemos necesitado hacer copias y recuperaciones de nuestras base de datos en PostgreSQL? En esta entrada le daremos un repaso a dos comandos imprescindibles para el administrador de base de datos.

Me he encontrado a varios administradores de DB que usan las copias y la restauración para renombrar una base de datos, o simplemente para copiarlas. Si esta es tu intención revisa el comando ALTER DATABASE (para renombrar una BD) o CREATE DATABASE [nombre_bd] WITH TEMPLATE (para hacer una copia).

Si tu intención es volcar los datos en un fichero, sigue leyendo.

Copiar datos con pg_dump

pg_dump -i -h localhost -p 5432 -U postgres -F c -b -v -f "/usr/local/backup/10.70.0.61.backup" my_database

La lista de las opciones de pg_dump…

pg_dump -?

-p, –port=PORT database server port number-i, –ignore-version proceed even when server version mismatches-h, –host=HOSTNAME database server host or socket directory-U, –username=NAME connect as specified database user-W, –password force password prompt (should happen automatically)-d, –dbname=NAME connect to database name-v, –verbose verbose mode-F, –format=c|t|p output file format (custom, tar, plain text)-c, –clean clean (drop) schema prior to create-b, –blobs include large objects in dump-v, –verbose verbose mode-f, –file=FILENAME output file name

Restaurar datos con pg_restore

pg_restore -i -h localhost -p 5432 -U postgres -d my_database -v "/usr/local/backup/10.70.0.61.backup"

La lista de las opciones de pg_dump…

pg_restore -? -p, –port=PORT database server port number -i, –ignore-version proceed even when server version mismatches -h, –host=HOSTNAME database server host or socket directory -U, –username=NAME connect as specified database user -W, –password force password prompt (should happen automatically) -d, –dbname=NAME connect to database name -v, –verbose verbose mode[latest_tweets user="your_user_name_here" num="3"]

Realizar consultas a una base de datos PostgreSQL empleando las instrucciones del lenguaje SQL.

Una vez que ya nos hemos introducido un poco en el mundo de las base en dos artículos anteriores, vamos a comenzar a ver cómo podemos consultar los datos registrados en ellas, para ello vamos a ir ilustrado algunos ejemplos y ver algunos ejercicios prácticos que sin duda nos van a ir ayudando mucho más a comprender de lo que hablamos:

La sentencia SELECT es usada para obtener la información guardada en una tabla. La forma general de esta sentencia es:

SELECT Información

FROM Tabla

WHERE Condición.

Aquí, Información es la información que queremos ver. Esta puede ser una lista de columnas, o un * para indicar "todas las columnas".

Tabla indica el nombre de la tabla de la cual vamos a obtener los datos.

La cláusula WHERE es opcional. Si está presente, la Condición especifica las condiciones que los registros deben satisfacer para que puedan ser mostrados.

La manera más sencilla de la sentencia SELECT es cuando se recuperan todos los datos de la tabla: SELECT * FROM public."trabajadores";

Si no deseamos ver los registros completos de una tabla, entonces tenemos que usar los nombres de las columnas en las que estamos interesados separándolas por coma.

SELECT nombre, apellido1, apellido2, salario FROM

trabajadores;

También es posible mostrar columnas calculadas a partir de la información contenida en otras columnas de la tabla. Ejemplo:

SELECT nombre, salario, salario*0.3 FROM trabajadores;

Los campos en la tabla resultante se muestran en el orden en que los solicitamos con la sentencia SELECT independientemente de cuál sea el orden que tengan en la estructura de la tabla.

SELECT nombre, apellido1, apellido2 FROM trabajadores;

O podemos intercambiar el orden por ejemplo:

SELECT nombre, apellido1, apellido2 FROM trabajadores;

En ocasiones la cantidad de registros que recuperamos es muy grande y el resultado de la consulta ocupa varias pantallas. Es posible “limitar” la cantidad de filas que se mostrarán como resultado de una consulta empleando la cláusula LIMIT de la manera siguiente:

SELECT * FROM trabajadores LIMIT 5;

¿Qué podemos hacer para mostrar sólo el 3er registro en la tabla trabajadores?

En Postgre las posiciones de los registros en la tabla comienzan a contarse a partir de cero. EL primer registro está en la fila cero. El segundo registro está en la fila 1 y así sucesivamente hasta el registro n que estará en la fila n-1. Por tanto para mostrar el registro que ocupa la 3ra posición debemos recuperar el registro de la fila #2 y para lo cual podemos usar la cláusula LIMIT de la manera siguiente:

SELECT * FROM trabajadores LIMIT 1 OFFSET 2

Con LIMIT 1 OFFSET 2 estamos ordenando a PostgreSQL que devuelva 1 registro a partir de la fila 2.

Ahora vamos a pasar a explicar una función que consideramos pueda ser muy útil e interesante para los usuarios: CAST, aplicando la función CAST podemos convertir una cadena que contenga números en su representación como número tal como se muestra a continuación:

CAST (SUBSTR(idnum,10,1) AS INTEGER)

Con esta expresión extraemos el carácter que ocupa la posición 10 en el número de identidad y lo convertimos o representamos como un número entero

PostgreSQL posee una estructura muy útil que permite seleccionar cuál debe ser el valor definitivo de campos calculados a partir de evaluar expresiones aritméticas que devuelvan un valor entero. La sintaxis de esta estructura es:

CASE expression

WHEN value THEN result

[WHEN ...]

[ELSE result]

END

Ejemplos de su uso:

CASE CAST (SUBSTR(idnum,10,1) AS INTEGER ) % 2

WHEN 0 THEN ‘HOMBRE’

WHEN 1 THEN ‘MUJER’

END

Un posible problema real para utilizar esta función de manera muy práctica puede ser a partir de posibles numeraciones de identidad y donde se sabe que en la posición 10 de la numeración se encuentra el dato de si es Masculino o Femenino a partir de si es par es Masculino y si es impar es Femenino puede ser la siguiente:

Selecciones los 10 primeros registros a partir de la tabla de trabajadores y conociendo los números de identificación diga si son M o F.

SELECT idnum, nombre,

CASE CAST (SUBSTR(idnum,10,1) AS INTEGER ) % 2

WHEN 0 THEN 'HOMBRE'

WHEN 1 THEN 'MUJER'

END AS sexo

FROM TRABAJADORES

LIMIT 10;

Volviendo a sintaxis más sencillas para no perder neuronas con funciones de carácter un poco más complejos vamos a terminar con la misma cláusula que comenzamos pero profundizando un poquito más en la misma. Es decir hasta el momento hemos empleado los comandos de PostgreSQL para recuperar y mostrar información almacenada en una tabla de la base de datos. Pero en todos los casos la información ha estado desorganizada. En SQL es posible hacer una consulta indicando que los resultados queden ordenados atendiendo a un determinado criterio. Dicho de manera más práctica, es posible recuperar datos y mostrarlos ordenados por una o más columnas.

Por ejemplo: Queremos obtener el listado de todos los trabajadores pero mostrarlo ordenado alfabéticamente por el nombre.

SELECT

nombre,

apellido1,

apellido2

FROM TRABAJADORES

ORDER BY nombre;

Bueno colegas con este ejemplo un poco más sencillo cerramos por ahora exhortándolos a profundizar un poco más en las consultas y estudiando sus funciones más potentes, síganos en próximos artículos.

68 - Vistas

Una vista es una alternativa para mostrar datos de varias tablas. Una vista es como una tabla virtual que almacena una consulta. Los datos accesibles a través de la vista no están almacenados en la base de datos como un objeto.

Entonces, una vista almacena una consulta como un objeto para utilizarse posteriormente. Las tablas consultadas en una vista se llaman tablas base. En general, se puede dar un nombre a cualquier consulta y almacenarla como una vista.

Una vista suele llamarse también tabla virtual porque los resultados que retorna y la manera de referenciarlas es la misma que para una tabla.

Las vistas permiten:

- ocultar información: permitiendo el acceso a algunos datos y manteniendo oculto el resto de la información que no se incluye en la vista. El usuario solo puede consultar la vista.

- simplificar la administración de los permisos de usuario: se pueden dar al usuario permisos para que solamente pueda acceder a los datos a través de vistas, en lugar de concederle permisos para acceder a ciertos campos, así se protegen las tablas base de cambios en su estructura.

- mejorar el rendimiento: se puede evitar tipear instrucciones repetidamente almacenando en una vista el resultado de una consulta compleja que incluya información de varias tablas.

Podemos crear vistas con: un subconjunto de registros y campos de una tabla; una unión de varias tablas; una combinación de varias tablas; un resumen estadístico de una tabla; un subconjunto de otra vista, combinación de vistas y tablas.

Una vista se define usando un "select".

La sintaxis básica parcial para crear una vista es la siguiente:

create view NOMBREVISTA as SENTENCIAS SELECT from TABLA;

El contenido de una vista se muestra con un "select":

select *from NOMBREVISTA;

En el siguiente ejemplo creamos la vista "vista_empleados", que es resultado de una combinación en la cual se muestran 4 campos:

create view vista_empleados as select (apellido||' '||e.nombre) as nombre,sexo, s.nombre as seccion, cantidadhijos from empleados as e join secciones as s on codigo=seccion

Para ver la información contenida en la vista creada anteriormente tipeamos:

select *from vista_empleados;

Podemos realizar consultas a una vista como si se tratara de una tabla:

select seccion,count(*) as cantidad from vista_empleados;

Los nombres para vistas deben seguir las mismas reglas que cualquier identificador. Para distinguir una tabla de una vista podemos fijar una convención para darle nombres, por ejemplo, colocar el sufijo “vista” y luego el nombre de las tablas consultadas en ellas.

Los campos y expresiones de la consulta que define una vista DEBEN tener un nombre. Se debe colocar nombre de campo cuando es un campo calculado o si hay 2 campos con el mismo nombre. Note que en el ejemplo, al concatenar los campos "apellido" y "nombre" colocamos un alias; si no lo hubiésemos hecho aparecería un mensaje de error porque dicha expresión DEBE tener un encabezado, PostgreSQL no lo coloca por defecto.

Los nombres de los campos y expresiones de la consulta que define una vista DEBEN ser únicos (no puede haber dos campos o encabezados con igual nombre). Note que en la vista definida en el ejemplo, al campo "s.nombre" le colocamos un alias porque ya había un encabezado (el alias de la concatenación) llamado "nombre" y no pueden repetirse, si sucediera, aparecería un mensaje de error.

Otra sintaxis es la siguiente:

create view NOMBREVISTA (NOMBRESDEENCABEZADOS) as SENTENCIASSELECT from TABLA;

Creamos otra vista de "empleados" denominada "vista_empleados_ingreso" que almacena la cantidad de empleados por año:

create view vista_empleados_ingreso (fecha,cantidad) as

select extract(year from fechaingreso),count(*) from empleados group by extract(year from fechaingreso);

La diferencia es que se colocan entre paréntesis los encabezados de las columnas que aparecerán en la vista. Si no los colocamos y empleamos la sintaxis vista anteriormente, se emplean los nombres de los campos o alias (que en este caso habría que agregar) colocados en el "select" que define la vista. Los nombres que se colocan entre paréntesis deben ser tantos como los campos o expresiones que se definen en la vista.

Las vistas se crean en la base de datos activa.

Al crear una vista, PostgreSQL verifica que existan las tablas a las que se hacen referencia en ella.

Se aconseja probar la sentencia "select" con la cual definiremos la vista antes de crearla para asegurarnos que el resultado que retorna es el imaginado.

Se pueden construir vistas sobre otras vistas.

pg_dump – pg_restore (PostgreSQL) Posted on March 19, 2013 by admin Posted in Bases de Datos

Cuando se trabaja con base de datos, uno de las cosas más importantes de hacer es respaldar los datos en caso de que ocurra cualquier situación que dañe nuestro servidor de base de datos. De nada nos serviría hacer esos respaldos si no los podemos volver a cargar (restaurar) cuando lo necesitemos.En este post,  trataremos la forma de hacer respaldos y restauración de datos cuando se utiliza postgreSQL como DBMS.

Respaldando los datos: pg_dump

pg_dump es una herramienta de línea de comandos que nos permita hacer un respaldo de alguna de las bases de datos  (o todas) en nuestro servidor postgres. Permite hacer el volcado de datos en diferentes formatos ya sean compresos, texto plano, etc. En resumen, escribe en un archivo (o salida estándar) las instrucciones SQL necesarias para hacer un respaldo de la base de datos.

El formato del comando pg_dump es:

   pg_dump [opciones] [nombre_base]

Entre las opciones que se pueden utilizar están:

dbname: Nombre de la base de datos de la que se desea hacer respaldo.

-a o –data-only: Hace un volcado solo de los datos y no del esquema.

-c o –clean: Crea instrucciones para eliminar los elementos antes de crearlos. Es útil para evitar los errores del tipo ‘la relacion nombre_relación ya existe’ a la hora de restaurar el respaldo.

-C o –create:  Escribe las instrucciones para la creación de la base de datos dentro del script del respaldo.

-f <archivo> o –file=<archivo>:  Escriba la salida (el volcado) en el archivo especificado. En caso de que no se utilice esta opción, el volcado se hace a la salida estándar.

-F <formato_de_archivo> o –format=<formato_de_archivo>: Permite especificar el formato de la salida del dump. El formato de salida puede ser:

p o plain: Texto plano.

c o custom:  Formato de salida customizable. Este tipo de salida siempre se realiza compreso por defecto.

t o tar: Crea la salida en formato tar.

-n <nombre_esquema> o –schema=<nombre_esquema>: Realiza el dumpúnicamente del esquema (y todos los objetos que contengan) que concuerde con el<nombre_esquema>. Si no se especifica, se hará un dump de todos los esquemas que no sean del sistema y que estén en la base destino. Si se quiere incluir en el dump más de un esquema se pueden poner multiples -n <nombre_esquema> como sean necesarios.

-N <nombre_esquema> o –exclude-schema=<nombre_esquema>: Omite los esquemas que concuerden con <nombre_esquema> del dump a realizarse. Se pueden incluir tantos -N como sean necesarios.

-s o –schema-only: Hace un volcado únicamente del esquema, no de los datos.

-t <nombre_tabla> o –table=<nombre_tabla>: Hace un volcado solo de las tablas que se especifiquen. Se pueden utilizar -t <nombre_tabla> tantas veces como se necesite. Se debe tener en cuenta que pg_dump no hace un seguimiento de las tablas de las que pueda depender la tabla que se desee volcar con el dump, así que hay que tener cuidado de incluirlas todas las que sean necesarias (que tengan relación con llaves primarias o foráneas) para garantizar que se puede hacer la restauración de los datos exitosamente.

-T <nombre_tabla> o – exclude-table: <nombre_tabla>: Excluye del dumplas tablas listadas. Esta opción puede ser utilizada más de una vez.

– inserts: Utiliza inserts en lugar de copy en las instrucciones de SQL.

– port = <puerto>: Especifica el puerto TCP o local en el cual el servidor está escuchando.

-U <nombre_de_usuario>: Especifica el nombre de usuario con el que se hará la conexión a la base de datos que se desea respaldar.

Ejemplos:

Si tenemos una base de datos llamada base_de_prueba y queremos respaldarla completamente en un archivo llamado base_de_prueba.sql, podemos utilizar el siguiente comando:

   pg_dump base_de_prueba > base_de_prueba.sql

Para hacer el volcado en un archivo de extensión personalizada (opción -F y c para custom):

   pg_dump -Fc base_de_prueba > base_de_prueba.dump

Para volcar solo una tabla de la base:

   pg_dump -t nombre_tabla base_de_prueba > mi_tabla_dump.sql

Restaurando los datos: pg_restore

Para realizar la restauración de los datos volcados con pg_dump, podemos utilizar la herramienta pg_restore. pg_restore restaura una base de datos que ha sido respaldada con pg_dump.

Entre las ventajas de utilizar esta utilidad para la restauración es que se puede seleccionar qué partes del respaldo se quieren restaurar o incluso reordenar los items antes de hacer la restauración

La sintáxis del comando es la siguiente:

pg_restore [opciones] [fichero_a_restaurar]

Entre las opciones más comunes utilizadas con este comando están:

-a o –data-only:  Restaura solo los datos, no el esquema.

-c o –clean: Elimina los objetos antes de volverlos a crear.

-C o –create: Crea la base de datos especificada con la opción -d, sin embargo, los datos son restaurados a la base de datos que aparece en el script.-d <nombre_base> o –dbname=<nombre_base>: Conecta a la base de datos<nombre_base> y restaura los datos directamente en ella.

-j <numero> o –jobs=<numero>: Realiza la restauración de los datos utilizando<numero> hilos o procesos (dependiendo del sistema operativo). Cada jobs es un proceso o hilo que utiliza una conexión separada. La utlización de esta opción, permite poder restaurar un dump en una forma más rápida, sin embargo, utiliza más recursos en el servidor. La velocidad de la restauración, por tanto, depende en gran medida de la configuración del hardware del servidor.

-n <nombre_esquema> o –schema=<nombre_esquema>: Realiza la restauración únicamente del esquema llamado <nombre_esquema>.

-s o –schema-only: Restura solo el esquema, no los datos.

-t <nombre_tabla> o –table=<nombre_tabla>:  Restaura únicamente la tabla con el nombre <nombre_tabla>. <nombre_tabla> puede ser una expresión regular.

-U <nombre_usuario> o –username=<nombre_usuario>:  Nombre de usuario con el que se desea hacer la conexión.Uno de las cosas a tomar en cuenta a la hora de restaurar un respaldo es que si éste ha sido hecho en un formato particular (custom), no podrá ser visible con herramientas como more,cat o algún editor de texto.

Debido a que no se puede ver que usuarios se utilizan o a que base de debe conectar, se pueden correr problemas a la hora de quererlos restaurar en otra máquina que no tenga los usuarios o bases que correspondan con los que están en el archivo creado con pg_dump.

Una forma de solucionar esto es hacer una restauración sin especificar la base de datos a la que se desea restaurar los datos. Esto hace que pg_restore mande la salida a la salida estandar. Esta salida estandar puede ser enviada a un archivo que contendrá las instrucciones de respaldo en texto plano.

Por ejemplo, asumiendo que tenemos un archivo creado con pg_dump en formato .dump, llamado respaldo-base.dump y queremos pasarlo a texto plano en un fichero, podemos hacer lo siguiente:

$ pg_restore respaldo-base.dump > respaldo-base.sql

El operador > redirecciona la salida de la salida estándar (pantalla) al archivo respaldo-base.sql. Después de haberse ejecutado el comando, el fichero puede ser leido con cualquier editor de texto.

Otros ejemplos:

$ pg_restore -C -d postgres db.dump

Crea la base de datos postgres (por la opción -C) pero siempre vuelca los datos en la base que el script especifica.

 $ pg_restore -d mi_base db.dump

Restaura los datos en la base llamada mi_base. Esta base debe haber sido creada previamente.

 

Como habrán notado, las herramientas pg_dump y pg_restore comparten muchas opciones comunes entre sí y representan un par de herramientas bastante útiles a la hora de restaurar y manipular los respaldos hechos de nuestras bases de datos.

Funciones en PostgreSQL y pgAdmin

Los procedimientos almacenados de MySQL , en postgreSQL se llaman funciones, pueden crearse desde consola, pero es mucho mas fácil utilizar pgAdmin.

Para este tutorial, se emplearan dos tablas que consisten en una tabla llamada PERSONA y otra tabla, llamada TORNEO, el código para su creación esta más abajo, la tabla Torneo ademas hace uso de un SEQUENCE para generar un ID autoincrementable, puedes ver un tutorial AQUI.

CREATE TABLE persona( "CI" character(7) NOT NULL, "Nombre" character(32) NOT NULL, edad integer NOT NULL DEFAULT 18, CONSTRAINT "CI" PRIMARY KEY ("CI"))

CREATE SEQUENCE id_secuencia INCREMENT 1 MINVALUE 1 MAXVALUE 9223372036854775807 START 18 CACHE 1;ALTER TABLE id_secuencia OWNER TO postgres;

CREATE TABLE torneo( "ID" integer NOT NULL DEFAULT nextval('id_secuencia'::regclass), ci_participante character(7) NOT NULL,

categoria character(16) NOT NULL, CONSTRAINT "ID" PRIMARY KEY ("ID"))

El ejemplo que crearemos es muy simple, teniendo algunos registros en la tabla PERSONA, crearemos una función que nos permita registrar participantes en la tabla TORNEO, con la restricción de que si la edad es mayor o igual de 18 años, se registren en la categoría ”Mayores”, caso contrario si la edad es menor de 18 años, corresponden a la categoría ”Menores”. Un ejemplo muy simple, pero que nos sirve para ver en su mayoría las instrucción más utilizadas en las funciones, parámetros, variables, consultas, instrucciones condicionales, etc.

la función completa la tienes en el siguiente código:

declare-- se declaran las variables a utilizarci character(7); -- ID de tabla persona = CEDULA DE IDENTIDADedad integer; -- la edad del participante--la funcion va entre BEGIN y ENDbegin

ci = $1 ; -- ci toma valor del parametro de entrada-- el valor de edad, sera calculado mediante una consulta a la tabla personaedad = ( select p."edad" from "persona" as p where p."CI" = ci );-- de acuerdo al valor de EDAD registramos al participante en la categoria-- >=18 Mayores <18 Menores sino, NO SE REGISTRA NADAif( edad >= 18 ) then insert into torneo( ci_participante, categoria ) values ( ci, 'Mayores' ); return 'Participante registrado en la categoria MAYORES';elsif ( edad <18 ) then insert into torneo( ci_participante, categoria ) values ( ci, 'Menores' ); return 'Participante registrado en la categoria MENORES';else return 'Error: No se pudo completar el registro';end if;

end;

En el siguiente video, veremos paso a paso su construcción y ejecución

Campo autoincrement en PostgreSQL con pgAdminIII

En Postgres a diferencia de MySQL, colocar un campo con un valor autonumerico incrementable es un poco más complicado pero no imposible, puede realizarse a través de comandos SQL, pero para facilitar el trabajo es preferible utilizar una interfaz gráfica como pgAdminIII.

- Conéctate a Postgres y abre el pgAdminIII, selecciona la base de datos con la que trabajaras y busca el campo “Sequences”, dale click derecho y elegi la opción “New Sequence…”.

- En la ventana que aparece “New Sequence…”, debes rellenar el campo Name: nombre para la secuencia, Owner: el propietario que hara uso de la secuencia, en mi caso se llama “postgres“, Increment: el incremento, si lo dejas vacio, incrementara de 1 en 1, pero es mejor especificarlo, Start: en que valor iniciara el incremento, tenemos otros valores para completar, pero por el momento lo que tenemos es suficiente. Para terminar dale OK

- Para agregar esta secuencia en un campo de cualquier tabla, debemos darle un nombre a la columna, en este caso sera tambien “id”, el tipo de dato Data Type sera Integer y en campo Default Value, debemos agregar la secuencia que creamos en el paso anterior, de la siguiente manera: NEXTVAL(‘secuencia_id’), es decir:

Y dale OK para crear la columna

Ya tenemos nuestra campo creado con un valor autoincrementable de 1 en 1, cada vez que se agregue un registro a nuestra tabla, la secuencia añade 1 a nuestro campo “id”.