
## Realizar Backup con pgdump

Hay una herramienta de PostgreSQL que permite volcar bases de datos individuales de forma rápida: el comando **pgdump**. Veamos un ejemplo de cómo hacer un backup (copia de seguridad) de una base de datos:

```bash
pg_dump nombre_base_de_datos > archivo_de_backup.sql
```

Con esta herramienta se pueden ejecutar backups de forma remota siempre que se tengan permisos (un usuario y una contraseña), también debemos indicar la dirección del servidor:

```bash
pg_dump -h 127.0.0.1 -U usuario -W
```

Este comando pedirá la contraseña

## Restaurar la copia de seguridad

Para restaurar el backup en PostgreSQL es igual de sencillo que para hacer la copia. En este caso usaremos el comando **psql**:

```bash
psql nombre_base_de_datos < archivo_de_backup.sql
```

## Hacer backup de una base de datos y restaurarla en otra

Si deseamos hacer una copia de una base de datos y guardarla en otra (por ejemplo en otro servidor), podemos usar este comando:

```bash
pg_dump -h 127.0.0.1 nombre_base_de_datos | psql -h 192.168.1.100 nombre_base_de_datos
```


Comandos para gestionar copias de seguridad de la base de datos PostgreSQL

Backup en PostgreSQL

backup-en-postgresql


En muchas bases de datos como MySQL, PostgreSQL, etc que usan el lenguaje SQL permiten usar una instrucción llamada UNION, que permite unir los resultados de varias consultas. El problema que me encontré es que los resultados que devuelve unidos sólo se pueden ordenar de forma general, no por cada consulta individual. Veamos un ejemplo práctico.

Imaginad que queremos hacer una consulta que nos devuelva un conjunto de elementos ordenados por fecha, de modo que nos muestre los x primeros elementos ordenados de una forma y los y siguientes de otra.

```sql
SELECT title, IFNULL(eventos_proximos,eventos_pasados)
FROM (
  (
    SELECT title, begin_at as eventos_proximos,null as eventos_pasados FROM eventos
    WHERE begin_at >= NOW()
  )
  UNION
  (
    SELECT title, null, begin_at FROM eventos AND begin_at < NOW()
  )
) t2
ORDER BY eventos_proximos, eventos_pasados DESC;
```

En PostgreSQL podemos usar COALESCE en vez de IFNULL para comprobar que si el valor es nulo, y en Oracle podríamos usar la funcion NVL.


Ejemplo práctico de la instrucción UNION para obtener una lista de elementos ordenados

Consulta avanzada de SQL usando UNION

consulta-avanzada-de-sql-usando-union


Como ya sabréis, la marca de tiempo de UNIX empieza en 1970 y tiene caducidad en 2037. Aunque es posible que cualquier aplicación que desarrollemos ya no esté operativa para esas fechas, ¿por qué usar UNIX_TIMESTAMP? Hasta no hace demasiado un servidor lo usaba, pero al tratar con otros lenguajes de programación he visto que no tiene demasiado sentido, y aunque puede ser más cómodo en algunos casos usarlo (como en PHP), finalmente cada vez que desarrollo una nueva aplicación utilizo el tipo de dato DATE de MySQL.

Si tenéis tablas de MySQL con un campo definido como INT 11 que guarda esta marca de tiempo, os recomiendo pasaros a DATE con estas sencillas instrucciones.

```sql
ALTER TABLE `horario` ADD `fecha2` DATETIME NULL AFTER `fecha`;
UPDATE horario SET fecha2 = FROM_UNIXTIME(fecha);
```

Simplemente añadir un nuevo campo al lado del campo que queremos cambiar y luego utilizar la función **FROM_UNIXTIME**

```sql
ALTER TABLE `horario` DROP `fecha`;
```

Finalmente podemos borrar el campo antiguo si estamos seguros del cambio.


Usar la función de MYSQL FROM_UNIXTIME para convertir la fecha UNIX_TIMESTAMP a Date

Convertir fecha UNIX_TIMESTAMP a fecha DATE

convertir-fecha-unix_timestamp-a-fecha-date


Oracle permite gestionar excepciones. Las excepciones suelen producirse cuando hay un error en la ejecución de un bloque PL/SQL, y como en otros lenguajes de programación es posible manipularlas, ya sea interrumpiendo la ejecución o propagando la excepción para que se trate en otra parte del código.

## Sintaxis de excepción en Oracle

Un ejemplo de sintaxis podría ser este.

```sql
WHEN excepcion1 
  OR excepcion2 
THEN
  expression;

WHEN excepcion3 
  THEN expression;
  WHEN OTHERS 
  THEN
  expression;
```

Vemos que podemos especificar la excepción a tratar. WHEN OTHERS sirve para tratar el resto de excepciones sin especificar su nombre.

## Tipos de Excepciones PL/SQL

**Predefinida por Oracle**. Son las que ya vienen predefinidas por el servidor Oracle como por ejemplo.

- **ACCESS_INTO_NULL**. Un programa intenta asignar valores a atributos de un objeto no inicializado.
- **CASE_NOT_FOUND**. Ninguna de las posibilidades en una cláusula WHEN de una expressión CASE está seleccionada y no hay cláusula ELSE.
- **COLLECTION_IS_NULL**. Un programa intenta aplicar otros métodos diferentes de EXISTS a una tabla o array no inicializada.
- **CURSOR_ALREADY_OPEN**. Se intenta abrir un cursor ya abierto. Se debe cerrar siempre los cursores después de usarlos. Un bucle FOR siempre abre los cursores automáticamente.
- **DUP_VAL_ON_INDEX**. Duplicación de valores en una columna que contiene un índice único.
- **INVALID_CURSOR**. Operacion de cursor no permitida, como cerrar un cursor no abierto.
- **INVALID_NUMBER**. Conversion de un caracter a número fallida porque la cadena no representa un número válido.
- **LOGIN_DENIED**. Nombre de usuario y/o contraseñna inválida.
- **NO_DATA_FOUND**. Si un SELECT INTO no devuelve filas
- **NOT_LOGGED_ON**. Si no se está conectado a Oracle.
- **PROGRAM_ERROR**. Error interno de PL/SQL.
- **ROWTYPE_MISTMATCH**. Valores de retorno incompatibles.
- **SELF_IS_NULL**. Llamada al método de un objeto no inicializado.
- **STORAGE_ERROR**. PL/SQL se queda sin memoria, o la memoria se ha corrompido.
- **SUBSCRIPT_BEYOND_COUNT**. Un programa hace referencia a una tabla o array usando un índice mayour que el número de elementos que contiene.
- **SUBSCRIPT_OUTSIDE_LIMIT**. Un programa hace referencia a una tabla o array usando un índice fuera de rango.
- **SYS_INVALID_ROWID**. La conversion de cadena de texto a identificador de fila falla porque no representa un identificador de fila válido.
- **TIMEOUT_ON_RESOURCE**. Se supera el tiempo de espera máximo para el uso de un recurso.
- **TOO_MANY_ROWS**. Demasiadas filas devueltas.
- **VALUE_ERROR**. Error aritmético, de conversión o truncación.
- **ZERO_DIVIDE**. División por zero.

Ejemplo:

```sql
BEGIN
  SELECT ...;
    EXCEPTION
  WHEN ZERO_DIVIDE 
  THEN
    expression;
  DBMS_OUTPUT.PUT_LINE('La operación de ' || TO_CHAR(variable) || ' es inválida');
END
```

**No predefinida por Oracle**. Son las que no tienen un nombre asociado como las anteriores, pero sí un número. Por ejemplo para interrumpir en caso de una violación de integridad:

```sql
DECLARE
  nombreExcepcion EXCEPTION;
  PRAGMA EXCEPTION_INIT(nombreExcepcion, -2292);
  ...
  BEGIN
  ...
  EXCEPTION
  WHEN nombreExcepcion THEN
    DBMS_OUTPUT.PUT_LINE ('Excepción de integridad producida');
  ...
END;
```

**Definida por el programador**. Son las que pueden definir los programadores para gestionar los errores en su código.

```sql
DECLARE
nombreExcepcion EXCEPTION;

...
BEGIN
...
RAISE nombreExcepcion;
...
EXCEPTION
WHEN nombreExcepcion THEN
DBMS_OUTPUT.PUT_LINE('Se ha producido una excepción');
```

Esto son los tipos de excepciones que existen en PLSQL del servidor Oracle.


Tipos de excepciones en Oracle PLSQL y su sintaxis

Gestión de Excepciones en Oracle PL/SQL

gestion-de-excepciones-en-oracle-pl-sql


## ¿Qué es un cursor?

En el lenguaje SQL existen unos tipos de controles llamados cursores que son útiles para recorrer los registros que devuelve una consulta. Este tipo de estructuras sólo deben utilizarse cuando no haya otra forma de manipular conjuntos de datos en una sola instrucción.

## Ejemplo de cursor en MySQL

Cada base de datos tiene su forma de declarar un cursor e incluso sus propios tipos de cursores (Oracle PL/SQL, Transact, etc). En este caso nos detendremos a ver cómo es la sintaxis para definir un cursor en MySQL.

```sql
DELIMITER ;;
DROP PROCEDURE IF EXISTS `micursor`;;
CREATE PROCEDURE `micursor`()
BEGIN

DECLARE done BOOLEAN DEFAULT FALSE;
DECLARE uid integer;
DECLARE newdate integer;

DECLARE c1 cursor for SELECT id,timestamp from employers ORDER BY id ASC;
DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = TRUE;

open c1;
c1_loop: LOOP
fetch c1 into uid,newdate;
IF `done` THEN LEAVE c1_loop; END IF;
UPDATE calendar SET timestamp = newdate WHERE id=uid;
END LOOP c1_loop;
CLOSE c1;
END ;;
```

Este cursor en concreto se podría realizar con una única consulta UPDATE, pero sirve para ver cómo se declara en la sintaxis de MySQL.

Como delimitador se ha usado el doble punto y coma (;;), se puede utilizar cualquier otro, pero deberás sustituirlo en todos los sitios.

Básicamente se declaran dos variables uid y newdate que contendrán el valor de cada campo de la fila. Luego se define el cursor mediante una consulta SQL (es como si se creara una tabla temporal). Finalmente, se recorre el cursor y se aplica la operación adecuada según nuestro programa.

## ¿Cómo ejecutar un cursor?

Para ejecutar el cursor podemos usar el método call:

```sql
call timechange();
```

Para guardar el cursor o llamarlo, se puede ejecutar desde el propio programa, utilizando phpMyAdmin, la consola de mysql o MySQL Query Browser por ejemplo.


Ejemplo de cómo se declara un cursor en MySQL

Cursor MySQL

cursor-mysql


## VB.net y MySQL

En este tutorial se mostrará cómo crear una tabla (_datagridview_) para mostrar datos en Visual Studio 2008 conectando a una base de datos MySql.

## Conectar a MySQL desde Visual Studio 2008

Antes de nada es necesario instalar un driver para poder realizar conexiones desde VS a MySQL. Podemos descargar la última versión del conector .NET en la página oficial de [MySQL](http://dev.mysql.com/downloads/connector/net/).

## Añadir un Datasource

Después de instalar el driver abrimos Visual Studio y creamos un nuevo proyecto (WindowsFormApplication). Pulsamos en el menú Data > Add new Datasource. El asistente nos pregunta de dónde queremos obtener la información. Pulsamos sobre el icono Database y en la siguiente pantalla sobre New Connection. Si se ha instalado el driver correctamente, nos aparecerá la opción de MySQL Database. La seleccionamos y pulsamos aceptar. Rellenamos con los datos adecuados para conectarnos a la base de datos MySQL (servidor, nombre de usuario, password, guardar password y nombre de la base de datos sobre la que trabajaremos). Finalmente nos pregunta si deseamos incluir la contraseña en la connection string. Para este ejemplo seleccionamos que sí.

Tras haber realizado la conexión satisfactoriamente, el asistente nos pregunta que objetos de la base de datos deseamos escojer. Seleccionamos todas las tablas que necesitemos (más adelante se podrán quitar o añadir nuevas tablas) y asignamos un nombre descriptivo al Dataset. Pulsamos finalizar y en la ventana de data sources, vemos que ya se ha agregado.

## DatagridView

Ahora rellenaremos una tabla con información de la base de datos. Para ello arrastramos el control DatagridView del panel de controles al formulario. Automáticamente se abre un menú contextual con distintas tareas que podemos realizar sobre el datagridview, o si lo preferimos se pueden acceder a las mismas opciones desde las propiedades del control. En las propiedades del DatagridView, buscamos la opción Datasource y en el desplegable pulsamos sobre Other Data Sources > Project Data Sources > El Dataset que hemos creado con el asistente y finalmente la tabla que deseamos mostrar en la datagrid.

Al realizar esta asignación se han creado varios elementos automáticamente: Una referencia al dataset, un BindingSource y un TableAdapter. Todos ellos referentes a la tabla usada. Si visualizamos el método Load en el código fuente veremos que ya se ha rellenado automáticamente el dataset a partir del TableAdapter con el método fill (En versiones anteriores de visual studio se debía rellenar manualmente).

Finalmente podemos compilar el proyecto y ejecutarlo y en la tabla se verá toda la información de la tabla de la base de datos.


DatagridView con VB.net y MySQL

datagridview-con-vb-net-y-mysql


## Variables PL/SQL

Para programar en PL/SQL se pueden usar las variables de tipo PL/SQL (escalares o registros) y las variables de tipo Host.

## Declaración de Variables PL/SQL

En un bloque anónimo se utilizará la palabra DECLARE para declarar las variables y sus tipos:

```sql
DECLARE
    v_fecha DATE;
    v_numero NUMBER(2):=10;
    v_nombre VARCHAR2(50):='Laura';
    constante CONSTANT NUMBER:=100;
BEGIN
    dbms_output.put_line('Aquí vendría el código del programa');
END;
```

## Tipos de Variables Escalares

Los principales tipos de variables escalares en Oracle PL/SQL son los siguientes:

VARCHAR2(tamaño)  
NUMBER[(precisión,escala)]  
DATE  
CHAR(tamaño)  
LONG  
BOOLEAN  
BINARY_INTEGER

Un ejemplo de declaración de tipos de variable:

```sql
variable1 VARCHAR2(50);
variable2 BINARY_INTEGER:=0;
variable3 NUMBER(10,4);
```

## Variables de tipo HOST

Las variables No-PL/SQL o de tipo HOST son variables globales que pueden usarse tanto dentro como fuera de los bloques PL/SQL.

Las referencias a estas variables vienen precedidas por dos puntos (:)

```sql
VARIABLE total NUMBER(3,2);
:total := 10/2;
```

## Atributo %TYPE

El atributo %TYPE sirve para declarar una variable a partir de otras declaradas previamente, o a partir del tipo de una columna de la base de datos. Es decir, copiar el tipo de otra variable.

El siguiente ejemplo asigna a la variable1 el mismo tipo que el campo de la base de datos.

```sql
variable1 tabla.campo%TYPE;
```


Definición de tipos de variables en Oracle PL/SQL

Declaración de Variables PL/SQL

declaracion-de-variables-pl-sql


## Definición de un Bloque PL/SQL

Un bloque es la estructura básica de un programa PL/SQL y se define con la siguiente estructura:

DECLARE – Opcional
Variables, cursores, excepciones definidas por el usuario
BEGIN – Obligatorio. Indica que empieza el programa
Sentencias SQL y Sentencias de Control PL/SQL
EXCEPTION – Opcional
Acciones a realizar cuando se produzcan errores
END; – Obligatorio

Un ejemplo de bloque PL/SQL sería el siguiente:

```sql
DECLARE
    v_variable VARCHAR2(2);
BEGIN
    SELECT nombre_columna
    INTO v_variable
    FROM nombre_tabla;
    EXCEPTION
    WHEN exception_name THEN
    dbms_output.put_line('Se ha producido una excepción');
END;
```

Este programa selecciona un campo de la base de datos y lo guarda en una variable. Si se produce algún error, salta la excepción

## Tipos de Bloques PL/SQL

Un bloque PL/SQL se puede programar dentro de un Procedimiento, dentro de una función o de forma independiente. Este último caso se conoce como bloque anónimo.

Estructura de un bloque anónimo:

```text
[DECLARE]
BEGIN
-- instrucciones
[EXCEPTION]
END;
```

Estructura de un bloque dentro de un procedimiento:

```text
PROCEDURE nombreProcedimiento
IS
[DECLARE]
BEGIN
-- instrucciones
[EXCEPTION]
END;
```

Estructura de un bloque dentro de una función:

```text
FUNCTION nombreFuncion
RETURN tipodedato
IS
[DECLARE]
BEGIN
-- instrucciones
RETURN valor;
[EXCEPTION]
END;
```


Estructura de un Bloque PL/SQL

estructura-de-un-bloque-pl-sql


## Restricciones FOREIGN KEY

MySQL permite trabajar con distintos tipos de motores de almacenamiento (MyIsam, Memory/HEAP, BDB, InnoDB, etc). Para poder trabajar con claves foráneas las tablas deben tener asignado el motor InnoDB.

Se han de cumplir ciertas condiciones para poder crear un enlace de este tipo entre distintas tablas:  
Las tablas que se enlazan deben tener el mismo motor (InnoDB).  
Los campos que se enlazan deben ser del mismo tipo de dato y tamaño.  
Los nombres de las claves foráneas deben ser únicos en la base de datos  
En la tabla que hace referencia, debe haber un índice donde las columnas de clave extranjera estén listadas en primer lugar, en el mismo orden.

## Crear una clave foránea en MySQL

En esta instrucción SQL se modifica la **tabla1** para añadirle una clave foránea al **campotabla1** indicándole a que tabla y campo hace referencia.

```sql
ALTER TABLE tabla1
ADD CONSTRAINT nombreclaveforanea
FOREIGN KEY (campotabla1)
REFERENCES tablaquereferencia (campoquereferencia)
ON DELETE NO ACTION
ON UPDATE NO ACTION;
```

## Eliminar una clave foránea

```sql
ALTER TABLE nombretabla DROP FOREIGN KEY nombre_clave_foranea;
```


Sintaxis para añadir una clave foránea en MySQL

Claves foráneas en MySQL

claves-foraneas-en-mysql


## Listado de Comandos para administrar MySQL

La base de datos MySQL se puede administrar desde la línea de comandos. En Windows se accede al menú Inicio > Ejecutar > Se escribe **cmd** y se pulsa enter. Se accede a la ruta donde se tiene instalada MySQL y dentro de la carpeta bin se ejecuta este comando:

```bash
mysql -u usuario -p
```

Para moverse dentro de esta aplicación se pueden utilizar algunos de estos comandos (Todos los comandos deben acabar con ; y ocupar una línea):

```txt
? - (\\?) Sinónimo de Ayuda.  
charset - (\\C) Cambiar codificación de lenguaje.  
clear - (\\c) Limpiar.  
connect - (\\r) Reconectar al servidor. Argumentos opcionales son la bd y el servidor.  
delimiter - (\\d) Establece un conjunto delimitador. NOTE: Toma el resto de la línea como un nuevo delimitador.  
edit - (\\e) Modifica el comando con $EDITOR.  
ego - (\\G) Envía un comando al servidor mysql y muestra el resultado verticalmente.  
exit - (\\q) Sale de mysql. Igual que quit.  
go - (\\g) Envía un comando al servidor mysql.  
help - (\\h) Muestra la ayuda en inglés.  
nopager - (\\n) Deshabilita el paginado, lo imprime en stdout.  
notee - (\\t) No escribe dentro del archivo de salida.  
pager - (\\P) Establece un paginador. Imprime los resultados de la consulta utilizando el paginador.  
print - (\\p) Imprime el comando actual.  
prompt - (\\R) Modifica el prompt mysql.  
quit - (\\q) Sale de mysql.  
rehash - (\\#) Reconstruye el hash.  
source - (\\.) Ejecuta un archivo de SQL scripting. El argumento es el nombre del archivo.  
status - (\\s) Obtiene información del estado del servidor.  
system - (\\!) Ejecuta un comando shell del sistema.  
tee - (\\T) Establece un archivo de salida.  
use - (\\u) Utiliza otra base de datos. El argumento es el nombre de la base de datos.  
warnings - (\\W) Muestra avisos después de cada declaración.  
nowarning - (\\w) No muestra avisos después de cada declaración.
```


Listado de comandos para administrar mysql desde la consola

Comandos consola MySQL

comandos-consola-mysql


## Actualizar el contenido de un DataGrid cuando se han modificado sus datos en la BD

Si la información de la base de datos ha cambiado, se tienen que recargar los datos que contiene el control DataGrid para mostrar la nueva información.

Antes de volver a rellenar el DataSet, es necesario eliminar sus contenidos, sino se añadirían a continuación de lo que ya contiene. Después se llama el método fill para rellenar el dataset con la nueva información.

Finalmente, se actualiza el contenido de la tabla DataGrid para que se vean los cambios visualmente. Para ello se utiliza la función ResetBindings.

dataSet.Clear() ' Elimina la información antigua.
dataAdapter.Fill(dataSet) ' Recarga la nueva información.
DataGrid1.ResetBindings() ' Vuelve a mostrar los datos.


Actualizar un datagrid al modificar la base de datos

Recargar datos en un Datagrid

recargar-datos-en-un-datagrid


## Estructura de los campos de una Tabla con Microsoft SQL

Tanto en el sistema de base de datos relacional de Oracle como en MySQL existe la instrucción DESCRIBE que te permite conocer la estructura de una tabla, es decir, todos los campos que contiene y de qué tipo son. En cambio, en la base de datos de Microsoft no hay ninguna instrucción predefinida equivalente a DESCRIBE.

Es por ello que hemos creado un script que al ejecutarse mostrará toda la información sobre los campos de la tabla que queramos (nombre, tipo, precisión, escala, permite nulos, valor por defecto, si es clave primaria y nombre del indice si tiene). El código es el siguiente:

```sql
CREATE Procedure MostrarEstructura(
        @TableName varchar(50)
)
AS
IF EXISTS (SELECT * FROM dbo.sysobjects
WHERE id = OBJECT_ID(N'[dbo].['+@tableName+']')
AND OBJECTPROPERTY(id, N'IsUserTable') = 1)
  SELECT
    cols.name as 'Nombre del Campo',
    typs.name as 'Tipo de Datos',
    cols.prec as 'Precisión',
    cols.Scale as 'Escala',
    Allownulls as 'Permite Nulos',
    c.text as 'Valor por Defecto',
    pk.xtype AS 'Primary Key',
    indx.name as 'Nombre del Índice'
  FROM sysobjects sobj
  INNER JOIN syscolumns cols ON sobj.id=cols.id
  INNER JOIN systypes typs ON cols.xusertype=typs.xusertype
  LEFT JOIN syscomments c ON cdefault=c.id
  LEFT JOIN  sysindexkeys ik ON ik.id = cols.id AND ik.colid = cols.colid
  LEFT JOIN  sysindexes indx ON indx.id = ik.id AND indx.indid = ik.indid
  LEFT JOIN  sysobjects pk ON indx.name = pk.name AND pk.parent_obj = indx.id AND pk.xtype = 'PK'
  WHERE cols.id = OBJECT_ID(@tableName)
ELSE
PRINT 'No existe ninguna tabla llamada '+@tableName + ' en la base de datos ' + db_name() + '.'
RETURN
```

Este código crea una función (Procedure) donde se comprueba si la tabla existe. Si existe se seleccionan los campos necesarios de diferentes tablas del sistema dónde está guardada la información de los campos de la tabla entrada.

Para que este script funcione deberemos ejecutarlo una vez para que Microsoft SQL Server la guarde. Posteriormente ya podremos llamar la función pasándole como parámetro el nombre de la tabla. Por ejemplo:

```sql
MostrarEstructura NombreTabla;
```

Script para ver los campos de una tabla en Microsoft SQL Server

Estructura de una tabla en MSSQL

estructura-de-una-tabla-en-mssql


## Hacer una copia de seguridad de las tablas y bases de datos MySQL

Cuando una base de datos crece, es importante hacer backups de forma regular. Hay varias formas de realizar un backup en MySQL, desde la linea de comandos (usando el comando mysqldump) o usando una aplicación externa como phpMyAdmin.

## Hacer un backup con Linux

Si estamos en un servidor linux podemos ejecutar el siguiente código en la linea de comandos para realizar un backup

mysqldump --opt -u nombredeusuario -p basededatos tabla1 > archivodebackup

**nombredeusuario**: es el nombre del usuario que tiene permisos para acceder a la base de datos.  
**basededatos**: el nombre de la base de datos de la que queremos realizar el backup.  
**tabla1**: es un parámetro opcional necesario si queremos realizar el backup de sólo una tabla de la base de datos. Podemos escribir más tablas separadas por espacios en blanco. No es necesario especificar ninguna tabla si queremos hacer un respaldo de toda la base de datos.  
**archivodebackup**: es el nombre del archivo que contendrá el backup de la base de datos (la estructura de las tablas y los datos).

Una vez ejecutado este comando nos pedirá la password del usuario y se creará el archivo de backup en el directorio en el que nos encontramos.

## Hacer un backup con Windows

Si queremos realizar una copia de seguridad desde entornos Windows, deberemos utilizar la linea de comandos ("cmd"). Para abrir la linea de comandos en Windows podemos ir al menú Inicio>Ejecutar, escribir **cmd** y pulsar enter). Se nos abrirá la linea de comandos de Windows. Ahora hemos de situarnos en la carpeta donde tenemos instalados los binarios de MySQL por ejemplo: c:\\mysql\\bin (esta ruta depende de dónde instalaste MYSQL) y escribimos el mismo comando que en linux:

mysqldump --opt -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

## Comprimir un backup en Linux

Podemos comprimir el archivo resultante de hacer el backup tras ejecutar el comando mysql dump. Por ejemplo:

mysqldump --opt -u nombredeusuario --password=clave basededatos > archivodebackup.sql

tar -cfv archivodebackup.sql.tar archivodebackup.sql

gzip archivodebackup.sql

## Backup de una base de datos InnoDB

Para una base de datos transaccional (de tipo InnoDB o BDB) y de gran tamaño, se puede utilizar este comando

mysqldump --opt -q --single-transaction -u nombredeusuario -p basededatos tabla1 > archivodebackup.txt

El parámetro -q es útil para bases de datos de gran tamaño.

## Backup con phpMyAdmin

[phpMyAdmin](http://www.phpmyadmin.net/) es una aplicación para navegar a través de las tablas creadas en la base de datos mysql que te permite realizar muchas operaciones.

Es muy sencillo exportar tablas y bases de datos con esta aplicación. Una vez lo hayas instalado, puedes hacer click en la base de datos de la que quieras una copia de seguridad. En el menú de arriba puedes hacer click sobre EXPORT. Entrarás en una página donde podrás escoger el tipo de archivo en que quieres guardar el backup (txt,pdf,csv,etc) y después si quieres exportar sólamente la estructura de la tabla, sólo los datos o los dos. También hay la posibilidad de comprimir el archivo, útil para grandes bases de datos. Finalmente, presionas sobre el botón EXPORT del formulario y te podrás descargar el creado con todos los datos de tus tablas.


Realizar un backup mysql (copia de seguridad) de las bases de datos y tablas MySQL

Backup MySQL

backup-mysql


## Servidores SQL, Librerías de Bases de Datos

Recopilación de librerías para conectar Bases de Datos con tus aplicaciones, servidores SQL (Structured Query Language), herramientas SQL, drivers ODBC, código fuente para manejar bases de datos relacionales, etc...

[SQLite](http://www.sqlite.org/) es una librería en C que permite incorporar un motor de bases de datos en tus aplicaciones. Soporta hasta 2 terabytes de datos.

[mySQL](http://www.mysql.com) es un servidor de bases de datos que funciona en gran cantidad de sistemas operativos cómo Windows y Linux. Es de uso gratuito.

[PostgreSQL](http://www.postgresql.org/) es un potente servidor de bases de datos de código abierto (Open Source) con más de 15 años de experiencia. Es portable en la gran mayoría de sistemas operativos como Linux, Windows, Unix, etc. Incluye la mayoría de SQL92 y SQL99 tipos de datos, incluyendo INTEGER, NUMERIC, BOOLEAN, CHAR, VARCHAR, DATE, INTERVAL, y TIMESTAMP. Soporta el almacenamiento de objetos binarios de gran tamaño incluyendo imágenes, sonidos o video. También incluye interficies nativas para lenguajes cómo C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC, entre otros.


Descarga librerías de programación para conectar tus aplicaciones con las bases de datos. Servidores SQL,.

Servidores y librerías SQL

servidores-y-librerias-sql


Ejemplo práctico para eliminar entradas repetidas en una tabla determinada.

Supongamos que tenemos una tabla con la siguiente estructura:

```sql
CREATE TABLE repetidas (
id int(11) NOT NULL auto_increment,
a int,
b int,
c int,
fecha timestamp(14),
PRIMARY KEY (id)  
);
```

Insertamos cuatro registros:

```sql
insert into repetidas (a,b,c) values (1,2,3),(1,2,3),(1,5,4),(1,6,4);
```

Vemos que las dos primeras filas insertadas son elementos repetidos : (1,2,3) y (1,2,3).

Con el siguiente comando SQL modificamos los campos a y b para que contengan elementos únicos, de esta forma eliminamos las entradas duplicadas:

```sql
mysql> ALTER IGNORE TABLE repetidas ADD UNIQUE INDEX(a,b);
```

Ejemplo práctico para eliminar entradas repetidas en una tabla de una base de datos MySQL