Bases de Datos

Clonar Esquema Base de Datos Postgresql

publicado a la‎(s)‎ 10 oct. 2017 7:51 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:18 ]

Clonar solo esquema y tablas

La siguiente función toma un esquema y crea uno nuevo con todas las tablas e indices.
CREATE OR REPLACE FUNCTION clone_schema(source_schema text, dest_schema text) RETURNS void AS
$BODY$
DECLARE 
  objeto text;
  buffer text;
BEGIN
    EXECUTE 'CREATE SCHEMA ' || dest_schema ;
 
    FOR objeto IN
        SELECT TABLE_NAME::text FROM information_schema.TABLES WHERE table_schema = source_schema
    LOOP        
        buffer := dest_schema || '.' || objeto;
        EXECUTE 'CREATE TABLE ' || buffer || ' (LIKE ' || source_schema || '.' || objeto || ' INCLUDING CONSTRAINTS INCLUDING INDEXES INCLUDING DEFAULTS)';
        EXECUTE 'INSERT INTO ' || buffer || '(SELECT * FROM ' || source_schema || '.' || objeto || ')';
    END LOOP;
 
END;
$BODY$
LANGUAGE plpgsql VOLATILE;
La ejecución es la siguiente:
SELECT clone_schema('old_schema','new_schema');

Clonar todo el contenido

El siguiente código posee toda la implementación para clonar el esquema al 100%.
-- Function: clone_schema(text, text)

-- DROP FUNCTION clone_schema(text, text);

CREATE OR REPLACE FUNCTION clone_schema_full(
    source_schema text,
    dest_schema text,
    include_recs boolean)
  RETURNS void AS
$BODY$

--  This function will clone all sequences, tables, data, views & functions from any existing schema to a new one
-- SAMPLE CALL:
-- SELECT clone_schema('public', 'new_schema', TRUE);

DECLARE
  src_oid          oid;
  tbl_oid          oid;
  func_oid         oid;
  object           text;
  buffer           text;
  srctbl           text;
  default_         text;
  column_          text;
  qry              text;
  dest_qry         text;
  v_def            text;
  seqval           bigint;
  sq_last_value    bigint;
  sq_max_value     bigint;
  sq_start_value   bigint;
  sq_increment_by  bigint;
  sq_min_value     bigint;
  sq_cache_value   bigint;
  sq_log_cnt       bigint;
  sq_is_called     boolean;
  sq_is_cycled     boolean;
  sq_cycled        char(10);

BEGIN

-- Check that source_schema exists
  SELECT oid INTO src_oid
    FROM pg_namespace
   WHERE nspname = quote_ident(source_schema);
  IF NOT FOUND
    THEN 
    RAISE NOTICE 'source schema % does not exist!', source_schema;
    RETURN ;
  END IF;

  -- Check that dest_schema does not yet exist
  PERFORM nspname 
    FROM pg_namespace
   WHERE nspname = quote_ident(dest_schema);
  IF FOUND
    THEN 
    RAISE NOTICE 'dest schema % already exists!', dest_schema;
    RETURN ;
  END IF;

  EXECUTE 'CREATE SCHEMA ' || quote_ident(dest_schema) ;

  -- Create sequences
  -- TODO: Find a way to make this sequence's owner is the correct table.
  FOR object IN
    SELECT sequence_name::text 
      FROM information_schema.sequences
     WHERE sequence_schema = quote_ident(source_schema)
  LOOP
    EXECUTE 'CREATE SEQUENCE ' || quote_ident(dest_schema) || '.' || quote_ident(object);
    srctbl := quote_ident(source_schema) || '.' || quote_ident(object);

    EXECUTE 'SELECT last_value, max_value, start_value, increment_by, min_value, cache_value, log_cnt, is_cycled, is_called 
              FROM ' || quote_ident(source_schema) || '.' || quote_ident(object) || ';' 
              INTO sq_last_value, sq_max_value, sq_start_value, sq_increment_by, sq_min_value, sq_cache_value, sq_log_cnt, sq_is_cycled, sq_is_called ; 

    IF sq_is_cycled 
      THEN 
        sq_cycled := 'CYCLE';
    ELSE
        sq_cycled := 'NO CYCLE';
    END IF;

    EXECUTE 'ALTER SEQUENCE '   || quote_ident(dest_schema) || '.' || quote_ident(object) 
            || ' INCREMENT BY ' || sq_increment_by
            || ' MINVALUE '     || sq_min_value 
            || ' MAXVALUE '     || sq_max_value
            || ' START WITH '   || sq_start_value
            || ' RESTART '      || sq_min_value 
            || ' CACHE '        || sq_cache_value 
            || sq_cycled || ' ;' ;

    buffer := quote_ident(dest_schema) || '.' || quote_ident(object);
    IF include_recs 
        THEN
            EXECUTE 'SELECT setval( ''' || buffer || ''', ' || sq_last_value || ', ' || sq_is_called || ');' ; 
    ELSE
            EXECUTE 'SELECT setval( ''' || buffer || ''', ' || sq_start_value || ', ' || sq_is_called || ');' ;
    END IF;

  END LOOP;

-- Create tables 
  FOR object IN
    SELECT TABLE_NAME::text 
      FROM information_schema.tables 
     WHERE table_schema = quote_ident(source_schema)
       AND table_type = 'BASE TABLE'

  LOOP
    buffer := dest_schema || '.' || quote_ident(object);
    EXECUTE 'CREATE TABLE ' || buffer || ' (LIKE ' || quote_ident(source_schema) || '.' || quote_ident(object) 
        || ' INCLUDING ALL)';

    IF include_recs 
      THEN 
      -- Insert records from source table
      EXECUTE 'INSERT INTO ' || buffer || ' SELECT * FROM ' || quote_ident(source_schema) || '.' || quote_ident(object) || ';';
    END IF;
 
    FOR column_, default_ IN
      SELECT column_name::text, 
             REPLACE(column_default::text, source_schema, dest_schema) 
        FROM information_schema.COLUMNS 
       WHERE table_schema = dest_schema 
         AND TABLE_NAME = object 
         AND column_default LIKE 'nextval(%' || quote_ident(source_schema) || '%::regclass)'
    LOOP
      EXECUTE 'ALTER TABLE ' || buffer || ' ALTER COLUMN ' || column_ || ' SET DEFAULT ' || default_;
    END LOOP;

  END LOOP;

--  add FK constraint
  FOR qry IN
    SELECT 'ALTER TABLE ' || quote_ident(dest_schema) || '.' || quote_ident(rn.relname) 
                          || ' ADD CONSTRAINT ' || quote_ident(ct.conname) || ' ' || pg_get_constraintdef(ct.oid) || ';'
      FROM pg_constraint ct
      JOIN pg_class rn ON rn.oid = ct.conrelid
     WHERE connamespace = src_oid
       AND rn.relkind = 'r'
       AND ct.contype = 'f'
         
    LOOP
      EXECUTE qry;

    END LOOP;


-- Create views 
  FOR object IN
    SELECT table_name::text,
           view_definition 
      FROM information_schema.views
     WHERE table_schema = quote_ident(source_schema)

  LOOP
    buffer := dest_schema || '.' || quote_ident(object);
    SELECT view_definition INTO v_def
      FROM information_schema.views
     WHERE table_schema = quote_ident(source_schema)
       AND table_name = quote_ident(object);
     
    EXECUTE 'CREATE OR REPLACE VIEW ' || buffer || ' AS ' || v_def || ';' ;

  END LOOP;

-- Create functions 
  FOR func_oid IN
    SELECT oid
      FROM pg_proc 
     WHERE pronamespace = src_oid

  LOOP      
    SELECT pg_get_functiondef(func_oid) INTO qry;
    SELECT replace(qry, source_schema, dest_schema) INTO dest_qry;
    EXECUTE dest_qry;

  END LOOP;
  
  RETURN; 
 
END;
 
$BODY$
  LANGUAGE plpgsql VOLATILE
  COST 100;
ALTER FUNCTION clone_schema_full(text, text, boolean)
  OWNER TO pi;
el uso es como sigue:
select clone_schema_full('old_schema', 'new_schema', boolean);
donde boolean es TRUE si quieres que se clone todo, incluido el contenido, o FALSE si quieres que no copie el contenido.

Desinstalar Postgres completamente en MacOSX

publicado a la‎(s)‎ 8 ago. 2017 8:33 por Juan Jose Ramirez Lama   [ actualizado el 12 oct. 2017 5:20 ]

Lo primero que hice fue ir a mi carpeta personal y entrar en la carpeta postgres y ejecutar el desinstalador.
Posteriormente fui a la terminal y ejecute el siguiente comando (cuidado con tu versión).
sudo /Library/PostgreSQL/9.5/uninstall-postgresql.app/Contents/MacOS/installbuilder.sh 
Luego eliminamos los directorios y archivos que el desinstalador no elimina.
sudo rm -rf /Library/PostgreSQ
sudo rm /etc/postgres-reg.ini
Por último vamos a usuarios y grupos en Preferencias del sistema y eliminamos al usuario postgres si es que esta ahí.

Conexión entre Python y Postgres

publicado a la‎(s)‎ 8 ago. 2017 7:33 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:22 ]

Primero debemos instalar Postgres

Instalación del driver PostgreSQL para conectarse desde Python

Existen varios drivers Python para PostgreSQL, para diferentes plataformas y versiones de Python. El más popular es psycopg, el cual soporta actualmente todas las versiones de Python desde 2.5 hasta 3.4 sobre plataformas Unix y Windows. Pero en mi caso decidí utilizar el driver pg8000, que está desarrollado íntegramente con Python y es liberado con licencia BSD. Además, es el driver utilizado por el framework Web2Py.

Instalar el driver pg8000 desde el gestor de paquetes pip ejecutando:
sudo pip install pg8000
En el sitio oficial existe una buena guía con ejemplos de conexión a PostgreSQL desde Python.

Creación de un script Python para verificar el acceso mediante HTTP

Para lo siguiente, se asume que se utilizo mi manual para configurar el servidor web.

Ahora creamos un script que verifique el acceso a todos los servicios.
sudo nano /usr/lib/cgi-bin/postgres.py

El siguiente script se conecta al motor de bases de datos PostgreSQL utilizando el usuario "pi" para consultar la versión del motor (ejecutando la consulta select version();):
#!/usr/bin/python
# coding=utf-8

# Imprimir los headers HTTP
print("Content-Type: text/html")
print("")

# Imprimir el contenido de la página
print("<h2>Hola mundo</h2>")
print("<p>Prueba de ejecuci&oacute;n de script Python en modo CGI.</p>")

# Mostrar la versi&oacute;n de Postgres
import pg8000
con = pg8000.connect(user="pi", password="123456", host="localhost", database="postgres")
c = con.cursor()
c.execute("select version()")
v = "".join(c.fetchone())
print("<p>La versi&oacute;n de PostgreSQL es: <b>%s</b></p>" % v.encode("utf-8"))
Recuerda cambiar los datos por los tuyos.
Guardar los cambios y ajustar los permisos adecuadamente
sudo chmod +x /usr/lib/cgi-bin/postgres.py
Verificar el funcionamiento desde línea de comandos:
sudo /usr/lib/cgi-bin/./postgres.py 


Fuente: https://www.linuxito.com/gnu-linux/nivel-medio/655-linux-apache-python-postgresql

PSQL, Primeros pasos y Comandos básicos

publicado a la‎(s)‎ 15 jun. 2016 18:08 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:21 ]

PSQL es el entorno de terminal para el manejo del motor de Base de Datos PostgreSQL. Los datos aquí presentados son basados en los que puedes encontrar en http://viviryaprenderweb.com

Para iniciarla podemos hacer con el siguiente comando:
$ psql -U username -W -h iphost basename
Parámetros:
  • -U es el usuario de la base
  • -W mostrará el prompt de solicitud de password
  • -h IP del servidor de la base de datos en caso nos conectemos remotamente sino bastaría con poner localhost
  • basename es el nombre de la base de datos
Luego ya estaremos dentro de postgres y podremos hacer consultas:
basename=# SELECT * FROM tabla; 
(no olvidemos el ; al final de cada query)

Ahora bien a veces necesitamos saber alguna información extra de nuestra base como las tablas que la componen, los campos de alguna tabla, etc., para eso existen los siguientes comandos:

El equivalente de SHOW TABLES es
basename=# \d

El equivalente de SHOW DATABASES es
basename=# \l

El equivalente de SHOW COLUMNS es
basename=# \d table

El equivalente de DESCRIBE TABLE es
basename=# \d+ table

Seleccionar una base de datos o cambiar de base:
basename=# \c basename

Ver la ayuda con respecto a la sintaxis de nuestras consultas SQL:
basename=# \h INSERT
Al utilizar este comando nos mostrará como debemos armar nuestro "insert", así como parametros y el orden correspondiente.

Mostrar la lista de las tablas de la base de datos que tengamos seleccionada:
basename=# \dt

Hacer que una consulta se ejecute cada ciertos segundos:
Primero ejecutamos nuestra consulta:
basename=# select count(*) from books;
Segundo ejecutamos nuestro comando \watch + los segundos
basename=# \watch 1

Editar la consulta que tengamos en el buffer con un editor mas amigable como nano:
basename=# \e
Al ejecutarlo por primera vez, este comando te mostrará un menu donde puedes elegir el editor.

La segunda vez que ejecutemos este comando veremos que nos lo habré automáticamente con el editor selecionado (nano) y luego de hacer los cambios y guardemos (ctrl + o) veremos que se ejecutará la consulta.

Ademas con el comando \p podemos ver lo que teníamos en el buffer

Si queremos guardar lo que tengamos en buffer en un archivo podemos utilizar el comando \w de la siguiente manera:
basename=# \w /tmp/test.sql
OJO si utilizamos un archivo que ya este creado previamente por nosotros tenemos que darle permisos de escritura (chmod 777 archivo), por ejemplo si tenemos nuestro archivo en /home/miusuario/mis.sql tendríamos que darle permisos de escritura primero antes de ejecutar nuestro comando desde la consola interactiva.

Ejecutar los consultas (querys) que tengamos en un archivo externo:
basename=# \i /tmp/test.sql

Guarda los resultados de una consulta en un archivo:
Primero ejecutamos \o seguido del archivo
basename=# \o /tmp/out.sql
Segundo ejecutamos nuestra consulta:
basename=# select * from books;
no nos muestra los resultados de la consulta en la consola sino que tendremos que ver nuestro archivo /tmp/out.sql, lo podemos hacer abriendo otra consola y ejecutar el siguiente comando:
basename=# cat /tmp/out.sql

Ahora un concejo importante después de utilizar este comando todas nuestras consultas mandaran los resultados al archivo (una tras otra), para dejar de mandar los resultados al archivo solamente ejecutamos el comando \o sin definir el archivo:
basename=# \o
Y veremos como de nuevo se nos muestran los resultados de nuestras consultas en la consola.

Mostrar la codificación que tiene activa nuestra consola interactiva:
basename=# \encoding

Obtener la salida de una consulta en formato HTML:
basename=# \H
Sirve para activar y desactivar la salidas de nuestras consultas en formato HTML, lo que hace este comando es crear una tabla HTML con los resultados de nuestra consulta.

Para desactivar las vista en formato HTML solamente tenemos que escribir nuevamente \H.

Podemos usar este comando en conjunto con nuestro comando \o y escribir de una sola vez nuestro archivo .html.

Información de nuestra conexión activa:
basename=# \conninfo

Ayuda de PSQL:
mostrará una lista de todos los comandos que podemos usar en la consola.
basename=# \?

Vaciar una tabla en especifico o el famoso TRUNCATE que conocemos:
basename=# TRUNCATE TABLE table RESTART IDENTITY
Con este comando borramos el contenido de una tabla y reiniciamos su indice sino agregamos RESTART IDENTITY nuestros indices no seran reiniciados y seguiran según el ultimo registro.

Crear Esquema:
CREATE SCHEMA schemaname;
Modificar Esquema:
ALTER SCHEMA schemaname RENAME TO newname
ALTER SCHEMA schemaname OWNER TO newowner
Eliminar Esquema:
DROP SCHEMA schemaname CASCADE;

Crear una base de datos:
basename=# CREATE DATABASE basename;
Borrar o eliminar una base de datos:
basename=# DROP DATABASE basename;
Borrar o eliminar una tabla en especifico:

basename=# DROP TABLE tablename;

Enviar resultados de una consulta a un archivo delimitado por |
basename=# COPY (SELECT * FROM tablename) TO '/home/tablename.csv' WITH DELIMITER '|';
Cabe mencionar que el archivo necesito permisos de escritura.

Uso de LIMIT y OFFSET
basename=# SELECT * FROM table LIMIT limit OFFSET offset;
Donde:
    • limit: es nuestro limite de registros a mostrar
    • offset: indica desde donde comenzaran a mostrarce los registros
Uso de comillas:
basename=# SELECT “column” FROM “table” WHERE “column” = 'value';
Generalmente podemos utilizar comillas dobles para nuestras columnas y comillas simples para nuestros valores, esto no es una regla pero a veces es necesario en casos especiales, tales como cuando ocupamos nombres reservados, por ejemplo:
basename=# SELECT to FROM table;
En este caso tenemos un campo llamado “to”, esto nos dará un error de sintaxis, por lo tanto tendremos que usar comillas dobles:
basename=# SELECT “to” FROM table;

Salir del cliente psql:
basename=# \q

Cómo importar una base de datos en PostgreSQL

El comando para importar una base de datos en postgresql es el siguiente:
$ psql -U postgres -W -h localhost nombre_base < dump_base.sql
Como vemos utilizamos el comando psql con los siguientes parámetros:
    • -U Se refiere al Usuario, en nuestro ejemplo usamos el usuario:  postgres
    • -W Con este parámetro conseguiremos que nos solicite el password del usuario antes especificado
    • -h Con este indicamos cuál es el servidor PostgreSQL al que nos conectaremos para importar nuestro dump, si estamos en el mismo servidor podemos colocar localhost, si será un servidor remoto colocaremos la IP
    • nombre_base Este es el ultimo parámetro en nuestra linea del comando, el cual hace referencia al nombre de la base de datos a la que importaremos nuestro dump.
    • < dump_base.sql Indicamos cual es el archivo que contiene el dump de la base y que por tanto queremos importar.



MAN

  \copyright      mostrar términos de uso y distribución de PostgreSQL

  \g [ARCH] o ;   enviar búfer de consulta al servidor (y resultados a archivo u |orden)

  \gset [PREFIJO] ejecutar la consulta y almacenar los resultados en variables de psql

  \h [NOMBRE]     mostrar ayuda de sintaxis de órdenes SQL; use «*» para todas las órdenes

  \q              salir de psql

  \watch [SEGS]   ejecutar consulta cada SEGS segundos


Búfer de consulta

  \e [ARCHIVO] [LÍNEA]         editar el búfer de consulta (o archivo) con editor externo

  \ef [NOMBRE-FUNCIÓN [LÍNEA]] editar una función con editor externo

  \p                           mostrar el contenido del búfer de consulta

  \r                           reiniciar (limpiar) el búfer de consulta

  \s [ARCHIVO]                 mostrar historial de órdenes o guardarlo en archivo

  \w ARCHIVO                   escribir búfer de consulta a archivo


Entrada/Salida

  \copy ...       ejecutar orden SQL COPY con flujo de datos al cliente

  \echo [CADENA]  escribir cadena a salida estándar

  \i ARCHIVO      ejecutar órdenes desde archivo

  \ir ARCHIVO     como \i, pero relativo a la ubicación del script actual

  \o [ARCHIVO]    enviar resultados de consultas a archivo u |orden

  \qecho [CADENA] escribir cadena a salida de consultas (ver \o)


Informativo

   (opciones: S = desplegar objectos de sistema, + = agregar más detalle)

  \d[S+]            listar tablas, vistas y secuencias

  \d[S+]  NOMBRE    describir tabla, índice, secuencia o vista

  \da[S]  [PATRÓN]  listar funciones de agregación

  \db[+]  [PATRÓN]  listar tablespaces

  \dc[S+] [PATRÓN]  listar conversiones

  \dC[+]  [PATRÓN]  listar conversiones de tipo (casts)

  \dd[S]  [PATRÓN]  listar comentarios de objetos que no aparecen en otra parte

  \ddp    [PATRÓN]  listar privilegios por omisión

  \dD[S+] [PATRÓN]  listar dominios

  \det[+] [PATRÓN]  listar tablas foráneas

  \des[+] [PATRÓN]  listar servidores foráneos

  \deu[+] [PATRÓN]  listar mapeos de usuario

  \dew[+] [PATRÓN]  listar conectores de datos externos

  \df[antw][S+] [PATRÓN]  listar funciones [sólo ag./normal/trigger/ventana]

  \dF[+]  [PATRÓN]  listar configuraciones de búsqueda en texto

  \dFd[+] [PATRÓN]  listar diccionarios de búsqueda en texto

  \dFp[+] [PATRÓN]  listar analizadores (parsers) de búsq. en texto

  \dFt[+] [PATRÓN]  listar plantillas de búsqueda en texto

  \dg[+]  [PATRÓN]  listar roles

  \di[S+] [PATRÓN]  listar índices

  \dl               listar objetos grandes, lo mismo que \lo_list

  \dL[S+] [PATRÓN]  listar lenguajes procedurales

 \dm[S+] [PATRÓN]   listar vistas materializadas

  \dn[S+] [PATRÓN]  listar esquemas

  \do[S]  [PATRÓN]  listar operadores

  \dO[S]  [PATRÓN]  listar ordenamientos (collations)

  \dp     [PATRÓN]  listar privilegios de acceso a tablas, vistas y secuencias

  \drds [PAT1 [PAT2]] listar parámetros de rol por base de datos

  \ds[S+] [PATRÓN]  listar secuencias

  \dt[S+] [PATRÓN]  listar tablas

  \dT[S+] [PATRÓN]  listar tipos de dato

  \du[+]  [PATRÓN]  listar roles

  \dv[S+] [PATRÓN]  listar vistas

  \dE[S+] [PATRÓN]  listar tablas foráneas

  \dx[+]  [PATRÓN]  listar extensiones

  \dy    [PATRÓN]   listar disparadores por eventos

  \l[+] [PATRÓN]    listar bases de datos

  \sf[+] FUNCIÓN    mostrar la definición de una función

  \z      [PATRÓN]  lo mismo que \dp


Formato

  \a              cambiar entre modo de salida alineado y sin alinear

  \C [CADENA]     definir título de tabla, o indefinir si es vacío

  \f [CADENA]     mostrar o definir separador de campos para modo de salida sin alinear

  \H              cambiar modo de salida HTML (actualmente desactivado)

  \pset NOMBRE [VALOR]  define opción de salida de tabla (NOMBRE := {format|border|expanded|fieldsep|fieldsep_zero|footer|null|numericlocale|recordsep|recordsep_zero|tuples_only|title|tableattr|pager})

  \t [on|off]     mostrar sólo filas (actualmente desactivado)

  \T [CADENA]     definir atributos HTML de <table>, o indefinir si es vacío

  \x [on|off|auto] cambiar modo expandido (actualmente desactivado)


Conexiones

  \c[onnect] [BASE-DE-DATOS|- USUARIO|- ANFITRIÓN|- PUERTO|- | conninfo]

                              conectar a una nueva base de datos (actual: «juaramir»)

  \encoding [CODIFICACIÓN]    mostrar o definir codificación del cliente

  \password [USUARIO]         cambiar la contraseña para un usuario en forma segura

  \conninfo                   despliega la información sobre la conexión actual


Sistema Operativo

  \cd [DIR]                 cambiar el directorio de trabajo actual

  \setenv NOMBRE [VALOR]    definir o indefinir variable de ambiente

  \timing [on|off]          mostrar tiempo de ejecución de órdenes (actualmente desactivado)

  \! [ORDEN]                ejecutar orden en intérprete de órdenes (shell), o iniciar intérprete interactivo


Variables

  \prompt [TEXTO] NOMBRE  preguntar al usuario el valor de la variable

  \set [NOMBRE [VALOR]]   definir variables internas, listar todas si no se dan parámetros

  \unset NOMBRE           indefinir (eliminar) variable interna


Objetos Grandes

  \lo_export LOBOID ARCHIVO

  \lo_import ARCHIVO [COMENTARIO]

  \lo_list

  \lo_unlink LOBOID   operaciones con objetos grandes



Abrir bases de datos Access en Ubuntu

publicado a la‎(s)‎ 13 oct. 2015 13:33 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:22 ]

MDB Viewer es una aplicación realmente interesante, que permite abrir bases de datos Access en Ubuntu y ver las tablas, datos, formularios…. que hay en la base de datos.


Para instalar MDB Viewer en Ubuntu, abrimos el terminal (Aplicaciones/Accesorios/Terminal) y escribimos:


# apt-get install mdbtools-gmb


Una vez realizada la instalación, encontraremos MDB Viewer en el menú Aplicaciones/Oficina.


Para abrir una base de datos Access, tan sólo debemos hacer clic sobre Archivo y después sobre Abrir. En la siguiente imagen se muestran las tablas de una base de datos llamada hospitales.mdb, que contiene tres tablas llamadas “Plantilla”,”Salas” y “Hospitales”.


Si seleccionamos una tabla y hacemos clic sobre el botón “Definition”, podremos ver la estructura de la tabla (campos que forman la tabla, tipo de datos de cada campo, claves primarias y tamaño de cada campo).


Si pulsamos sobre el botón “Data”, veremos los datos que hay en la tabla que tengamos seleccionada en ese momento.


Otra de las posibilidades que tenemos es la de exportar los datos de una tabla en un fichero de texto. Para ello haremos clic sobre el botón “Exportar”.


Con MDB Viewer también podremos ver las consultas, formularios, informes, macros y módulos que tengamos en una base de datos Access.


Si lo que queremos es exportar una base de datos Access a MySQL, Oracle, Sybase o Postgre, tendremos que pulsar el último botón, comenzando por la izquierda, que aparece en la barra de herramientas.


Por otro lado disponemos del paquete mdbtools, un conjunto de programas de línea de comandos que brindan más funcionalidad para gestionar bases de datos Access.


  • mdb-tables: muestra las tablas de la base de datos. La salida puede configurarse para mostrar los nombres de las tablas en una fila o una columna , separar las tablas con un separador y mostrar además las tablas de sistema de la base de datos.

  • mdb-schema: permite exportar el esquema de la base de datos entera o un tabla en particular en formatos adecuados para algunos motores de base de datos: AccessSybaseOracle, y Postgresql. Tiene una opción para sanear los nombres (por ejemplo reemplaza espacios por guiones bajos).

  • mdb-sql: un cliente interactivo con un lenguaje SQL minimal y dos comandos útiles, listar y describir tablas.

  • mdb-export: exporta los datos en formato CSV o como sentencias INSERT de SQL (la exportación de gmdb no tiene ésa opción).


Las mdbtools pueden instalarse escribiendo lo siguiente en el terminal:


# apt-get install mdbtools

Backup y Restauración Base de Datos en PostgreSQL

publicado a la‎(s)‎ 22 abr. 2015 19:39 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:18 ]

Se trata de volcar en un archivo de texto que contendrá los comandos y datos SQL necesarios para restaurar una copia exacta de la base de datos en el momento de la copia. La herramienta a utilizar es pg_dump.

Base de Datos Especifica

La forma más sencilla de hacer un backup de una base de datos completa es la siguiente:
# pg_dump basededatos > archivo.sql

En el caso de tener que especificar un host remoto o puerto de conexión distinto usaríamos los parámetros correspondientes, -h para el host y -p para el puerto, lo mismo se tenemos que especificar usuario, clave, etc.

La restauración del backup es el mismo proceso pero a la inversa:
# psql basededatos < archivo.sql

Especificando parámetros:
# psql -U usuario -d basededatos -p 5432 -h 192.168.0.111 < archivo.sql

Mediante el frontend de PostgreSQL psql volcamos el contenido del archivo SQL en la base de datos a restaurar. Al igual que con la exportación se pueden especificar un gran número de parámetros para personalizar la restauración.

Backup de todas las bases de datos del servidor PostgreSQL

Mediante pg_dumpall podemos hacer con un único comando una copia de seguridad de todas las bases de datos del servidor:
# pg_dumpall > backup_server.sql
Posteriormente para restaurar todas las bases de datos:
# psql -f backup_server.sql postgres

MySQL y PhpMyAdmin en Linux

publicado a la‎(s)‎ 19 abr. 2015 17:56 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 12:08 ]



MySQL es a menudo un aliado crucial para PHP, al desarrollar aplicaciones locales. Desafortunadamente MySQL no viene instalado por defecto en todas las distribuciones.

A continuación vamos a montar MySQL y PhpMyAdmin para poder administrar las bases de datos que más adelante nos haran falta para crear un Blog o página web.

Por si no lo sabían todos los Blogs que podemos ver en la red están vinculados a una base de datos que pueden estar en otros lenguajes pero nosotros vamos a instalar las MySQL.

Vamos a instalar unos cuantos paquetes para que nuestro servidor pueda ofrecernos bases de datos MySQL del siguiente modo.

sudo apt-get install mysql-server mysql-client php-mysql 

Configurar MySQL

Una vez visto esto vamos a configurar MySQL que formará parte de este servidor Web en el que podremos montar un Blog como WordPress o usar las bases de datos para lo que cada uno quiera.

Para ello lo primero que haremos es editar el archivo de configuración de MySQL llamado my.cnf ubicado en la ruta /etc/mysql.
# nano /etc/mysql/my.cnf

Una vez editado tenemos que buscar la linea: 
bind-address = 127.0.0.1

Y la modificamos por la IP de nuestro servidor, quedando algo así: bind-address = 192.168.0.111.  Pero si solo lo usaremos de manera local, no modifiques la linea anterior. Una vez modificada esta linea guardamos el archivo y salimos del editor.

Seguidamente instalaremos PhpMyAdmin para poder administrar nuestras bases de datos.

Al finalizar editaremos el siguiente archivo:
sudo nano /etc/php5/apache2/php.ini
Añadiremos lo siguiente. Yo en mi caso lo dejé en la primera línea.
extension=mysql.so
Guardaremos el archivo.

Instalar PhPMyAdmin

Para facilitarnos manejo y la administración de nuestras bases de datos vamos a usar el entorno web PhpMyAdmin, con este software podremos crear, borrar, modificar, dar permisos, bueno podemos hacer todo a lo que se refiere a la administración de bases de datos MySQL. Comenzamos la instalación con el siguiente comando:
 sudo apt-get install phpmyadmin
Durante la instalación nos preguntara el tipo de servido web que deseamos instalar, elegimos Apache2 y presionamos continuar.

Una vez terminada la instalación abriremos un navegador e introducimos la url de nuestro servidor seguido de la ruta phpmyadmin.
http://localhost/phpmyadmin
Una que vez veamos esta pantalla vamos a configurar el idioma y el nombre de usuario para poder acceder a PhpMyAdmin.

Deberia salir phpmyadmin. El usuario sera root y la contraseña sera la que hayamos elegido anteriormente. Si no llegara a funcionar ejecutaremos estos 2 comandos:
sudo ln -s /etc/phpmyadmin/apache.conf /etc/apache2/conf.d/phpmyadmin.conf
sudo /etc/init.d/apache2 reload
 Si siguiese sin funcionar toca reiniciar. En caso de que funcione continuamos.

Respecto al nombre de usuario y el password vamos a introducir el nombre de usuario root y el password que le dimos al administrador de las bases de datos MySQL durante la instalación del sistema operativo.


Crunchyfrog, cliente SQL para Gnome

publicado a la‎(s)‎ 27 feb. 2015 19:44 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:18 ]

crunchy


CrunchyFrog es un cliente SQL y visor de esquema para el escritorio GNOME.


Esta escrito en Python (PyGTK) y licenciado bajo la GNU General Public License v3.


Caracteristicas:


* Soporte para varias bases de datos (PostreSQL, MySQL, SQLite, Oracle, SQLServer, Firebird, Informix, MaxDB).

* Interfaz ligero de usuario para tareas diarias.

* Editor SQL con resaltado de sintaxis, auto completado y SQL formatting.

* Exporta los resultados a CSV y OpenOffice.

* Permite inspeccionar los objetos de la base de datos.

* Varias conexiones a bases de datos simultaneamente.


Para instalarlo puedes usar GetDeb o


Abrir una terminal y teclear lo siguiente:

# gedit /etc/apt/sources.list


añadir la siguiente linea a tu fichero /etc/apt/sources.list:

deb http://ppa.launchpad.net/crunchyfrog/ppa/ubuntu jaunty main
deb-src http://ppa.launchpad.net/crunchyfrog/ppa/ubuntu jaunty main


Añade la siguiente clave:

# apt-key adv --keyserver keyserver.ubuntu.com --recv-keys C7F166D8


Actualizamos los repositorios e instalamos CrunchyFrog:

# aptitude update

# aptitude install crunchyfrog crunchyfrog-gnome

Reiniciar la contraseña de root en MySQL

publicado a la‎(s)‎ 27 feb. 2015 19:43 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:21 ]

a veces me ha sucedido que tras tanto tiempo si acceder a MySQL se me olvida la contraseña y si no le puse la standar que uso siempre me demoro mucho para descubrir cual habia puesto, para quienes les sucede esto, aqui una solucion:


El problema que tengo es que cuando necesito crear una base de datos para un uso específico (Joomla, Moodle, etc.), creo un usuario para esa base de datos únicamente con los permisos necesarios. Por eso, como no suelo usar el usuario root, cuando me quiero acordar, se me ha olvidado.


Afortunadamente no nada complicado reiniciar la contraseña de root en MySQL y, aunque en el Manual de Referencia de MySQL está explicado el procedimiento, lo vamos a hacer al estilo Slice of Linux: paso a paso y con capturas para no perdernos.


Los pasos para reiniciar la contraseña de root en MySQL son los siguientes:


Detenemos MySQL con el comando:

# /etc/init.d/mysqld stop


A continuación, iniciamos MySQL con la opción skip-grant-tables para que no nos pida la contraseña. ¡Ojo! Esto es peligroso porque cualquiera podrá entrar a MySQL como usuario root y sin contraseña hasta que ejecutemos el comando FLUSH PRIVILEGES en el paso 5.

# mysqld --skip-grant-tables &


Accedemos a MySQL con el usuario root. Si el paso anterior se hizo sin problemas, ahora no nos pedirá la contraseña.

$ mysql -u root


Con el siguiente comando establecemos una nueva contraseña. Cambianuevaclave por la nueva contraseña que quieras ponerle al usuario root de MySQL.

UPDATE mysql.user SET Password=PASSWORD('nuevaclave') WHERE User='root';


Por último, le indicamos a MySQL que recargue las tablas de permisos con el comando:

FLUSH PRIVILEGES;


Salimos de MySQL:

$ quit


Fuente: Slice of Linux de &rés

LAMP - servidor web en Linux

publicado a la‎(s)‎ 27 feb. 2015 19:40 por Juan Jose Ramirez Lama   [ actualizado el 11 oct. 2017 14:18 ]

LAMP es un acronimo de "Linux, Apache, MySql y PHP" (la P también puede significar Perl o Python). Si tenemos en cuenta esto poco más hay que decir:

Conjunto de servidor web (Apache), con base de datos (MySql) y páginas web dinámicas (PHP) sobre una plataforma Linux.

Para instalar y configurar, de la manera mas fácil posible, usaremos tasksel:

# apt-get install tasksel
# tasksel install lamp-server


Una ves instalado podemos probar que todo esta en orden probando el servidor poniendo en la barra de dirección del navegador "http://localhost/" (sin las comillas). Esto nos devolverá un:

It works!


Desde este momento ya tenemos a nuestra disposición un completo banco de pruebas para nuestras webs o bases de datos en modo local o en red.

La carpeta de trabajo donde tendremos que poner la web para probarla es: /var/www/

Ahora para acabar lo único que tenemos que hacer es instalar phpmyadmin para controlar y administrar nuestras bases de datos MySQL , y listo.

# apt-get install phpmyadmin

Si prefieres copilar apache, php y mysql, o necesitas información adicional entra en howtolamp.com

1-10 of 16