Programación: Hacer el backup y restaurar una tabla en PostgreSQL

Hicieron esta consulta en un foro hace unos días y ahora les comparto esta solución:

Este ejemplo se realizó sobre un servidor PostgreSQL 9.6.8. corriendo sobre Windows.


Paso 1: Acceder por consola los utilitarios que provee el servidor.

La ruta usual (si instalaron en la ruta sugerida por el Wizard) de los utilitarios es:

C:\Program Files\PostgreSQL\9.6\bin\

La carpeta 9.6 cambiará obviamente si es que tienen otra versión.

En mi caso lo tengo en la unidad D:

Paso 2: Ejecutar el comando para realizar el backup de una tabla específica.

El comando es pg_dump

Este comando tiene múltiples parámetros, pueden obtener más información en:

https://www.postgresql.org/docs/9.6/app-pgdump.html

Para cuestiones de lo que queremos hacer la sentencia es:


D:\Program Files\PostgreSQL\9.6\bin>pg_dump --file "E:\\Data\\NombreDeArchivoBackup" --host "nombredeservidor" --port "5432" --username "usuariobd" --verbose --format=c --blobs --table "public.\"NombreDeMiTablaOrigen\"" "NombreDeMiBaseDeDatosOrigen"

Detalles:

E:\\Data\\: Nombre de la carpeta donde se generará el archivo backup.

nombredeservidor: Nombre o IP del servidor que contiene la tabla que desean hacer el backup.

public.\"NombreDeMiTablaOrigen\" : Nombre del esquema seguido de la tabla. Noten que coloco el nombre de la tabla entre "". Esto debido a que el servidor reconoce las mayúsculas y minúsculas.

Paso 3: Ingresar la contraseña del usuario utilizado para el backup.

Luego de ejecutar el comando, le pediré que ingresen el password del usuario indicado en la sentencia.

Paso 4: Esperar a que termine la ejecución y verán que se genera el archivo de backup con el nombre indicado y en la carpeta indicada en la sentencia.

Paso 5: Restaurar el archivo backup

Para restaurar usaremos la utilidad pg_restore.
La sentencia es:


D:\Program Files\PostgreSQL\9.6\bin>pg_restore --host "nombredeservidor" --port "5432" --username "usuariobd" --dbname "NombreDeMiBaseDeDatosDestino" --data-only --verbose --schema "public" --table "NombreDeMiTablaDestino" "E:\\Data\NombreDeArchivoBackup"


Detalles:
La tabla origen "NombreDeMiTablaOrigen" y la tabla destino "NombreDeMiTablaDestino" deben tener la misma estructura (obvio).

Paso 6: Verifica la correcta restauración.

No está de más hacer:

select count(*) from "NombreDeMiTablaOrigen"

y

select count(*) from "NombreDeMiTablaDestino"

para verificar la misma cantidad de registros.


Espero les sirva.

Saludos

Java: Ejemplo de como conectar a una base de datos PostgreSQL con Java

Siguiendo con la serie de posteos con ejemplos simples y prácticos de programación Java, les dejo un ejemplo de como conectar a una base de datos PostgreSQL.

El ejemplo está hecho para cualquier versión de PostgreSQL, lo único que cambiará será el correspondiente conector que pueden descargar desde:

https://jdbc.postgresql.org/

Nota:
Algunas veces ponen como nombres de tablas o columnas caracteres mayúsculas y minúsculas. Por ese motivo la query que se ejecuta incluye el caracter "\" para poner el nombre de la tabla o columna entre comillas dobles.

El puerto por defecto del PostgreSQL es el 5432, si usaron otro puerto en su instalación, cambiarlo.


Espero les sea de utilidad.

/////////////////////////////

package postgresql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class SimplePostgreSqlConnector {

public static void main(String[] args) {
conectaPG();
}


private static void conectaPG(){
try {
        Class.forName("org.postgresql.Driver");
            Connection connection = null;
             connection = DriverManager.getConnection("jdbc:postgresql://MiServidor:5432/NombreDeBaseDeDatos","usuario", "password");
             Statement s = null;
       if (connection != null)
          {
               
        s = connection.createStatement();

                  String query="select \"Columna\" from \"Tabla\" ";
                  ResultSet rs=s.executeQuery(query);
                  while(rs.next())
                  {
                      System.out.println(rs.getString(1));
                  }
               

          }
          else
              System.out.println("Connection Failed!");
      }
          catch(Exception e){
                              e.printStackTrace();
          }
}

}

/////////////////////////////

Java: Pangrama o frase holoalfabética

Hola, acá les dejo la solución de una tarea de programación en la que me solicitaron ayuda.

Verificar si una frase o texto es un pangrama.


Un pangrama (del griego: παν γραμμα, «todas las letras») o frase holoalfabética es un texto que usa todas las letras posibles del alfabeto de un idioma.

https://es.wikipedia.org/wiki/Pangrama


Esta simple clase contiene cuatro metódos diferentes de verificar si un texto es un pangrama

Espero les sea de utilidad

////////////////////////////////


public class Panagrama {

public static void main(String[] args) {
//String strFrase = "abcdefghijklmnopqrstuvwxyz";
String strFrase = "El cadáver de Wamba, rey godo de España, fue exhumado y trasladado en una caja de zinc que pesó un kilo";
char [] arrFrase = strFrase.toCharArray();
String strAlfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char [] arrAlfabeto = strAlfabeto.toCharArray();

boolean blnTodas = isPanagram2(arrAlfabeto,arrFrase);
System.out.println("La frase : "+ strFrase );
if(blnTodas) System.out.println("Es Pangrama");
else System.out.println("No es Pangrama");

}

public static boolean isPanagram(String strFrase){
//recorro todas las letras del alfabeto
for(int i = 0 ; i < 26 ; i++){
if(!strFrase.toUpperCase().contains(""+(char)(65+i)))
return false;
}
return true;
}


public static boolean isPanagram2(String strFrase){
boolean blnLetra = false;
for(int i = 0 ; i < 26 ; i++){
blnLetra = false;
for(int j=0;j if((""+(char)(65+i)).equals(""+strFrase.toUpperCase().charAt(j))){
blnLetra=true;
break;
}

}
if(!blnLetra) return false;
}
return true;
}

public static boolean isPanagram3(String strFrase){
for(int i = 0 ; i < 26 ; i++){
boolean blnLetra = true;
for(int j=0;j if((""+(char)(65+i)).equals(""+strFrase.toUpperCase().charAt(j))){
blnLetra = false; ;
break;
}

}
if(blnLetra) return false;
}
return true;
}


public static boolean isPanagram2(char[] arrAlfabeto, char[] arrFrase){
boolean blnLetra;
for(int i = 0 ; i < arrAlfabeto.length; i++){
blnLetra = false;
for(int j=0;j if((""+arrAlfabeto[i]).toUpperCase().equals((""+arrFrase[j]).toUpperCase())){
blnLetra=true;
break;
}

}
if(!blnLetra) return false;
}
return true;
}

}

////////////////////////////////

Java: Descomprimir archivos con java

Hola, acá les dejo un ejemplo que me estuvieron pidiendo hace tiempo.
Desempaquetar / descomprimir uno o varios archivos:

.ZIP
.RAR
etc

con sentencias de java, sin utilizar librería externas.

Espero les sea de utilidad.


////////////////////////////////////////////
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipInputStream;


public class Descomprime {

public static void main(String[] args) {
 
try{

File carpeta = new File("D://DATA//pruebadescomprime");
  for (File f : carpeta.listFiles()) {
  if(f.getName().contains(".zip")){
System.out.println(f.getName());
  descomprimir(f.getAbsolutePath(), f.getAbsolutePath().substring(0, f.getPath().length()-4));
  //f.delete(); opcional, si desea también borrar el archivo zip original
  }
  }

}
catch(Exception e){
System.out.println(e.getMessage());
}
}

public static void descomprimir(String archivoZIP, String archivoDescomprimido) throws Exception {
  int BUFFER_SIZE = 1024;
  BufferedOutputStream bos = null;
  FileInputStream fis = null;
  ZipInputStream zipis = null;
  FileOutputStream fos = null;

  try {
   fis = new FileInputStream(archivoZIP);
   zipis = new ZipInputStream(new BufferedInputStream(fis));
   if (zipis.getNextEntry() != null) {
    int len = 0;
    byte[] buffer = new byte[BUFFER_SIZE];
    fos = new FileOutputStream(archivoDescomprimido);
    bos = new BufferedOutputStream(fos, BUFFER_SIZE);

    while  ((len = zipis.read(buffer, 0, BUFFER_SIZE)) != -1)
     bos.write(buffer, 0, len);
    bos.flush();
   } else {
    throw new Exception("Zip Vacio");
   } // cierra if
  } catch (Exception e) {
   throw e;
  } finally {
   bos.close();
   zipis.close();
   fos.close();
   fis.close();
  } // cierra try

} // cierra descomprimir

}

////////////////////////////////////////////

Java: Listar fechas intermedias dentro de un rango

Ejemplo de un algoritmo que es muy usado en programación, como es el tratamiento de fechas.
Esta utilidad les permitirá obtener las fechas intermedias entre una fecha inicial y una fecha final, para cualquier formato de fecha que tengan:

yyyy/MM/dd
yyyyMMdd
yyMMdd
yyyy.MM.dd
yy MM dd


Espero les sirva


//////////////////////////////////////////

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

public class UtilFechas {

public static void main(String[] args) {

List listaResultado = listarFechasIntermedias("2018-12-28", "2019-01-03" , "yyyy-MM-dd", "yyyy MM dd");
//fecha inicial, fecha final, formato input, formato output
for(String fecha : listaResultado)
System.out.println(fecha);

}

private static List listarFechasIntermedias(String strFechaInicial, String strFechaFinal, String formatoIn, String formatoOut)
{
List listaFechasGC = listaFechas(strFechaInicial, strFechaFinal, formatoIn);
List listaFechasString = new ArrayList();

for(GregorianCalendar gc : listaFechasGC)
listaFechasString.add(formateaFecha(gc,formatoOut));

return listaFechasString;
}

private static List listaFechas(String fi, String ff, String formato ) {

List listFechas = new ArrayList();

try{
DateFormat df = new SimpleDateFormat(formato);
Date dateI = df.parse(fi);
Date dateF = df.parse(ff);
Calendar calI = Calendar.getInstance();
Calendar calF = Calendar.getInstance();
calI.setTime(dateI);
calF.setTime(dateF);
GregorianCalendar gcI = (GregorianCalendar)calI;
GregorianCalendar gcF = (GregorianCalendar)calF;
if(gcF.compareTo(gcI)>=0)
{
SimpleDateFormat fmt = new SimpleDateFormat();
GregorianCalendar temp = (GregorianCalendar) gcI.clone();
listFechas.add(gcI);
while (!fmt.format((temp).getTime()).equals(fmt.format(gcF.getTime()))) {
temp.add(GregorianCalendar.DAY_OF_MONTH, 1);
GregorianCalendar n = (GregorianCalendar) temp.clone();
listFechas.add(n);
}
}
else
{
System.out.println("Rango de fechas incorrecto.");
}

}
catch(Exception e)
{
System.out.println("Ocurrió un error : " + e.getMessage());
}
return listFechas;
}

private static String formateaFecha(GregorianCalendar f, String formato) {
SimpleDateFormat fmt = new SimpleDateFormat(formato);
return fmt.format(f.getTime());
}

}

//////////////////////////////////////////

Java: Generar dígito verificador - Algoritmo de Luhn - Algoritmo de módulo 10

El algoritmo de Lenin o fórmula de Luhn, también conocida como "algoritmo de módulo 10", es una fórmula de suma de verificación, utilizada para validar una diversidad de números de identificación; como números de tarjetas de crédito, números IMEI, etc.

https://es.wikipedia.org/wiki/Algoritmo_de_Luhn

Simple Clase: DigitoVerificadorLuhn.java

////////////////////////


import java.util.ArrayList;
import java.util.List;

public class DigitoVerificadorLuhn {

    public static boolean correctoVerificador(String card) {
        if (card == null)
            return false;
        char digitoverificador = card.charAt(card.length() - 1);
        String digito = calculaDigitoVerificador(card.substring(0, card.length() - 1));
        return digitoverificador == digito.charAt(0);
    }
   
    public static String calculaDigitoVerificador(String original) {
        if (original == null)
            return null;
        String digit;
        /* se convierte el número en un arreglo de digitos */
        int[] digits = new int[original.length()];
        for (int i = 0; i < original.length(); i++) {
            digits[i] = Character.getNumericValue(original.charAt(i));
        }
       
        /* se duplica cada dígito desde la derecha saltando de dos en dos*/
        for (int i = digits.length - 1; i >= 0; i -= 2)    {
            digits[i] += digits[i];
           
            /* si la suma de los digitos es más de 10, se resta 9 */
            if (digits[i] >= 10) {
                digits[i] = digits[i] - 9;
            }
        }
        int sum = 0;
        for (int i = 0; i < digits.length; i++) {
            sum += digits[i];
        }
       
        /* se multiplica por 9 */
        sum = sum * 9;
       
        /* se convierte a cadena para obtener facilmente el último dígito */
        digit = sum + "";
        return digit.substring(digit.length() - 1);
    }
   
    public static void main(String[] args)    {
        List lista = new ArrayList();
        lista.add("702766100030681288");
        for(String s : lista)
        {
            String digit = calculaDigitoVerificador(s);
            System.out.println(s +"," + digit);
        }
    }
   
}

////////////////////////