Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de PostgreSQL

Curso de PostgreSQL

Oswaldo Rodríguez González

Oswaldo Rodríguez González

Simulando una conexión a Bases de Datos remotas

24/32
Recursos

Aportes 123

Preguntas 12

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

OMG! Lo tiene todo

Utilizando un right join trayendo solo aquellos usuarios que no son vip 😄

No porque exista se deba usar. Hay que pensar el en performance antes de quere usar dblink. Nunca lo eh usado pero lo primero que se me viene a la mente es lo malo que podria hacer un JOIN across servers. Esto podria degradar el rendimiento tremendamente.

Creamos una BD llamada remota
Donde tenga una tabla llamada vip(id, fecha)

Creamos la extension dblink
CREATE EXTENSION dblink;

Lo que haremos es acceder a esa BD atraves de la BD transporte
SELECT * FROM 
dblink ('dbname=remota 
        port=5432 
        host=127.0.0.1 
        user=usuario_consulta 
        password=123456',
        'SELECT * FROM vip')
        AS datos_remotos(id integer, fecha date);

Uniremos la tabla pasajero con la tabla vip de la BD remota
SELECT * FROM pasajero
JOIN 
dblink ('dbname=remota 
        port=5432 
        host=127.0.0.1 
        user=usuario_consulta 
        password=123456',
        'SELECT * FROM vip')
        AS datos_remotos(id integer, fecha date)
HAVING (id);

Simulando una conexión a Bases de Datos remotas

Obtener datos de hosts remotos

dblink

Primero debe verificarse que dblink esta instalado ya que es una extension de postgres y no viene por defecto

Crear la extension dblink que postgres incluye pero no instala por defecto, esta extension debe crearse por cada base de datos individual

CREATE EXTENSION dblink;

-- se deberian dejar espacio despues de cada instruccion ya que  son comandos diferentes
SELECT * FROM
dblink('dbname=remota 
  port=5432 
  host=127.0.0.1 
  user=xxxx 
  password=xxxx',
  'SELECT id, fecha FROM vip;')
  AS datos_remotos(id integer, "date" date);

A la query se le debe dar el formato de como llegaran los datos

Haciendo cruce de datos con una tabla local

SELECT * FROM passenger
JOIN 
dblink('dbname=remota 
  port=5432 
  host=127.0.0.1 
  user=xxxx 
  password=xxxxxxx',
'SELECT id, date FROM vip;')
AS datos_remotos(id integer, "date" date)
ON (passenger.id = datos_remotos.id);

Ya que ambas tablas se cruzan por la columna id, el JOIN se puede hacer con USING(id)

SELECT * FROM passenger
JOIN 
dblink('dbname=remota 
  port=5432 
  host=127.0.0.1 
  user=xxxx 
  password=xxxxxxx',
'SELECT id, date FROM vip;')
AS datos_remotos(id integer, "date" date)
USING(id);

Al usar usign id el query retorna solo una columna de id en lugar de ambas columnas lo cual haria si se usara un ON para realizar el JOIN

Reto

query a la tabla de pasageros desde la tabla remota

-- CREATE EXTENSION dblink;
SELECT * FROM vip
JOIN 
dblink('dbname=transporte 
  port=5432 
  host=127.0.0.1 
  user=xxxxxxx 
  password=xxxxxxxxxxxx',
'SELECT id, name, address, birthdate FROM passenger;')
AS remote_passenger(id INTEGER, name CHARACTER VARYING, address CHARACTER VARYING, birthdate DATE)
USING(id);

Aquí dejo el reto haciendolo al revés

SELECT * FROM vip
JOIN
dblink('dbname=transporte
	   port=5432
	   host=127.0.0.1
	   user=usuario_consulta
	   password=jose123',
	   'SELECT id,nombre,direccion_residencia,fecha_nacimiento FROM pasajero')
	   
	   AS datos_remotos (id integer,nombre character varying,direccion_residencia character varying,fecha_nacimiento date)
USING (id)	 

Para conectarse a una base de datos remota en un servidor remoto es aconsejable por seguridad hacerlo via tunnel.
Este artículo explica que es un tunnel y como conectarse via tunnel desde pgadmin 4
https://www.enterprisedb.com/blog/ssh-tunneling-pgadmin-4
Este artículo explica cómo realizar un tunnel con PuTTy
https://www.postgresonline.com/article_pfriendly/38.html

Mi aporte, creé un contenedor de postgres en docker exponiendo el puerto 5433 de dicha base de datos con el siguiente comando:

docker run -d --name postgres-db -e POSTGRES_PASSWORD=password -p 5433:5432 --mount src=postgr
esdbdata,dst=/var/lib/postgresql/data postgres:alpine

Luego ejecuté un bash con el comando:

docker exec -it postgres-db bash

Allí creé una tabla llamada devices y guardé un par de datos.
Y finalmente realicé la configuración para la conexión desde mi cliente local usando pgadmin:

SELECT * FROM pasajero AS pa
JOIN 
dblink ('dbname=postgresdb 
		port=5433 
		host=127.0.0.1 
		user=postgres 
		password= password',
	   'SELECT id, local_date_time, status FROM devices')
	   AS datos_remotos (id integer, fecha timestamp without time zone, status character varying(255))
USING (id);

Y tarán…

5	"Carling Capehorn"	"43901 Starling Crossing"	"2015-06-16"	"2016-01-25 21:34:55"	"RUNNING"

Mi aporte, datos basicos para usar dblink

Este debe estar activado en postgres, si no lo esta debe hacerse con

CREATE EXTENSION dblink;

Una simple consulta en la tabla remota

select * from
dblink ('dbname=RemoteDB
		port=5432 <-- puerto remoto
		host=X.x.x.x <-- IP remota
		user= postgres <-- usuario
		password= postgres', <-- password, aguas, debe estar encapsulado
	   'SELECT id FROM usuarios_vip') <-- la consulta
	   AS datos_remotos (id integer); <-- los datos deben ser expresados como otra tabla y de que tipo son


Me podrian ayudar porque no me funciona, si cree la extencion pero no me deja ejecutar el codigo.

Información resumida de esta clase
#EstudiantesDePlatzi

  • dblink es una función que me permite conectarme a servidores remotos para generar consultas

  • Al utilizar dblink debo especificar los parámetros de conexión a esta base de datos

  • Puedo usar USING si los datos que vamos a comparar son los mismos

Entendido

CREATE EXTENSION dblink;
	   
SELECT * FROM pasajero INNER JOIN
dblink ('dbname=dbz 
		port=5432 
		host=127.0.0.1 
		user=consulta 
		password=consulta ' ,
	   'SELECT id, fecha FROM usuario_vip') 
	   as datos (id INTEGER, fecha DATE)
	   USING(id); 
CREATE EXTENSION dblink;
SELECT * FROM vip
JOIN
dblink('dbname=transporte 
	  port=5432 
	  host=127.0.0.1 
	  user=usuario_consulta 
	  password=etc123',
	  'SELECT * FROM pasajero')
	  AS datos_remotos (id integer, nombre char(100), direccion_residencia char(100), fecha_nacimiento date)
USING (id);

Si en distribuciones red hat les sale un error de que no encuentra dblink.control deben instalar el siguiente paquete y luego crear la extension

sudo dnf install postgresql13-contrib

Reto:

De esta forma hacemos la conexion desde remota

  --CREATE EXTENSION dblink;
  SELECT * FROM vip
  JOIN
dblink ('dbname=transporte
	   port=5432
	   host=127.0.0.1
	   user=postgres
	   password=TijeraFacusa7',
	   'SELECT id, fecha_nacimiento FROM pasajero') 
	   AS datos_remotos (id integer, fecha date)
  ON (vip.id = datos_remotos.id);

Hola, aquí mi práctica de conexión desde la tabla remota hacia la tabla principal.

CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN 
dblink('dbname=transporte 
	   port=5432 
	   host=127.0.0.1 
	   user=usuario_consulta 
	   password=super_user2995',
	  'SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM pasajeros')
	  AS datos_remotos(id integer, nombre character varying, direccion_residencia character varying, fecha_nacimiento date) 
ON(vip.id = datos_remotos.id);

Tuve que crear nuevamente la extensión dblink

dblink es un módulo que soporta conexiones a otras bases de datos PostgreSQL desde una sesión de base de datos.

Mi aporte

SELECT * FROM vip
JOIN 
dblink ('dbname=transporte 
		port=5432 
		host=127.0.0.1 
		user=postgres
		password=*******',
	   'SELECT * FROM pasajeros')
	   AS datos_remotos (id integer, nombre character varying(100), direccion_residencia character varying, fecha_nacimiento date)
USING (id);

uff genial genial

Bastantes errores cometi aun ya teniendo el codigo.

Aqui mi solucion

SELECT * FROM vip
JOIN 
dblink('dbname=Transporte
	   port=5432
	   host=127.0.0.1
	   user=usuario_consulta
	   password=123',
	   'SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM pasajero')
	   AS pasajeros_transporte (id integer, nombre character varying, direccion_residencia character varying, fecha_nacimiento date)
USING (id)

Así sería hecha de forma inversa, es decir desde la database “remota”:

CREATE EXTENSION dblink;

SELECT * FROM public."VIP"
JOIN
dblink ('dbname = transporte
port = 5432
host = 127.0.0.1
user = usuario_consulta
password = XXXX,
‘SELECT * FROM “PASAJERO”’)
AS datos_remotos (id integer, nombre varchar, direccion varchar, fecha date)
USING (id);

select vip id,dr.nombre,dr.direccion , vipecha from VIP vip
JOIN
dblink(‘dbname=Transporte
port=5432
host=127.0.0.1
user=usuario_consulta
password=123456’,
‘select id, nombre,direccion_residencia from pasajero’)
as dr(id integer, nombre VARCHAR, direccion VARCHAR)
USING (id);

CREATE EXTENSION dblink;
SELECT * FROM vip
JOIN
dblink(‘dbname=transporte
port=5432
host=127.0.0.1
user=usuario_consulta
password=edward’,
‘SELECT id, nombre, direccion_residencia FROM pasajero’)
AS datos_remotos(id integer, nombre character varying, direccion character varying)
USING(id);

Para añadir la extensión de dblink a postgres, CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink (‘dbname=transporte
port=5432
host=127.0.0.1
user=consultas
password=etc123’,‘SELECT id, nom_pasajero, dir_pasajero FROM pasajero’)
AS datos_remotos (id integer, nom_pasajero text, dir_pasajero text )
USING (id);

CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink ('dbname=Transporte
		port=5432
		host=127.0.0.1
		user=postgres
		password=toor',
		'SELECT id, nombre, fecha_nacimiento FROM pasajeros')
		AS datos_remotos(id integer, nombre character varying, fecha_nacimiento date)
USING (id)
CREATE EXTENSION dblink;

SELECT * FROM vip RIGHT JOIN
dblink('dbname= transporte  
			port=5432 
			host=127.0.0.1 
			user= usuario_consulta 
			password=etc123', 'SELECT id, nombre FROM pasajero') 
			AS dr(id integer, nombre character varying)
USING(id)
WHERE vip.id IS NOT NULL;
SELECT * FROM vip
JOIN 
dblink('dbname= pasajero
	   port=5432 
	   host=127.0.0.1 
	   user=prueba
	   password =prueba',
	  'SELECT id, nombre FROM pasajero ') 
	  as datos_remotos (id integer, nombre character varying )
USING(id);

Reto solucionado 😃

SELECT * FROM vip 
	INNER JOIN 
	dblink('dbname=transporte
		   	host=127.0.0.1
		   	port=5432
		   	user=postgres
		    password=123',
		    'SELECT * FROM pasajero') 
			as datos_remotos (
					  id integer, 
					  nombre character varying, 
					  direccion character varying,
					  fecha_nacimiento date)
   USING(id);
SELECT * FROM vip
JOIN 
dblink ('dbname=transporte
		port=5432
		host=127.0.0.1
		user=usuario_datos
		password=123',
	   'SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM pasajero')
	   AS datos_remotos (id integer, nombre character varying, direccion_residencia character varying, fecha_nacimiento date)
USING (id);
--Crear extension
CREATE EXTENSION dblink;

--Conectar con tabla remota
SELECT * FROM
dblink('dbname=transporte
	  port=5432
	  host=127.0.0.1
	  user=postgres
	  password=714cu4Ch3$QL',
	   'SELECT * FROM pasajero')
	   AS datos_local(id integer, 
					  nombre character varying, 
					  direccion_residencia character varying,
					  fecha_nacimiento date);

--Cruzar tabla local a una base remota
SELECT * FROM vip
JOIN
dblink('dbname=transporte
	  port=5432
	  host=127.0.0.1
	  user=postgres
	  password=714cu4Ch3$QL',
	   'SELECT * FROM pasajero')
	   AS datos_local(id integer, 
					  nombre character varying, 
					  direccion_residencia character varying,
					  fecha_nacimiento date)
USING (id);

Listo si me quedo a la primera 😃

CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN 
	dblink ('dbname=transporte
	  port=5432
	  host=127.0.0.1
	  user=usuario_consulta
	  password=toor',
	  'SELECT id, nombre FROM pasajero')
	  AS pasajero_vip(id integer, nombre character varying)
USING (id);
<SELECT * FROM vip
JOIN
dblink ('dbname=transporte_masivo 
		port=5432 
		host=127.0.0.1 
		user=postgres
		password=Mm2281293.',
	   'SELECT id, nombre, direccion_residencia, fecha_nacimiento, dni FROM pasajeros')
	   AS datos_remotos (id integer, nombre character varying, direccion_residencia character varying, fecha_nacimiento date, dni character varying)
USING (id);> 

Hola a todos,
He aquí el resultado del ejercicio propuesto:

Nota: Note que se debe “instalar” la extensión de dbink al hacer una nueva conexión remota. 😲😲😲

Consultando los datos desde la base de datos DBREMOTA hacia TRANSPORTE_MASIVO:

  • Simulando un conexión a base de datos

    • Primero se debe instalar la extensión dblink.
    CREATE EXTENSION dblink;
    
    • Luego se ejecuta la sentencia para obtener los datos de la base de datos remota.
    SELECT * FROM dblink (
    	'dbname = remote 
    	port = 5432
    	host = 127.0.0.1
    	user = postgres
    	password=atc123', 
    	'SELECT * FROM remote_table_name')
    	AS remote_data (id = integer, fecha = date)
    ;
    
    • Para realizar una consulta uniendo datos locales con datos remotos.
    SELECT * FROM local_table_name
    JOIN  
    dblink (
    	'dbname = remote 
    	port = 5432
    	host = 127.0.0.1
    	user = postgres
    	password=atc123', 
    	'SELECT * FROM remote_table_name')
    	AS remote_data (id = integer, fecha = date)
    	--ON (local_table_name.id = remote_data.id)
    	USING (id)
    ;
    
    • Ejercicio: Realizar una consulta desde la bd remota a db transportes
    -- USE DATABASE remote
    SELECT * FROM remote
    JOIN  
    dblink (
    	'dbname = transportes 
    	port = 5432
    	host = 127.0.0.1
    	user = postgres
    	password=atc123', 
    	'SELECT * FROM pasajeros')
    	AS remote_data (id_pasajero = integer, fecha = date)
    	USING (id)
    ;
    

Llamando desde la db de transport a remote

SELECT id, name FROM
dblink ('dbname=remote 
	    port=5432 
	    host=127.0.0.1 
	    user=postgres 
	    password=password','SELECT id, date FROM vip') 
AS remote_data (id integer, date date)
JOIN passengers 
USING (id)
ORDER BY id DESC;


Llamando desde la db de remote a transport

SELECT * FROM 
dblink('dbname=transport 
	   port=5432 
	   host=127.0.0.1 
	   user=postgres 
	   password=password','SELECT id, name  FROM passengers')
AS remote_data (id integer, name character varying)
JOIN vip 
USING (id) 
ORDER BY id DESC;
--CREATE EXTENSION dblink;

SELECT * 
FROM vip
JOIN
	dblink ('dbname=transporte
			 port=5432 
			 host=127.0.0.1 
			 user=usuario_consulta 
			 password=etc123 ',
			 'SELECT * FROM pasajero') 
			 b (id integer, nombre character varying(100), 
				direccion_residencia character varying(50), 
				fecha_nacimiento date)
USING (id);
SELECT nombre, id, fecha FROM vip
JOIN
dblink ('dbname= transporte
	   port=5432
	   host=127.0.0.1
	   user=usuario_consulta
	   password=2289',
	   'SELECT id, nombre from pasajero')
	   AS consulta(id integer, nombre character varying)
USING (id);

Que satisfactorio es cuando funciona, que sencillo es conectarse a otra base de datos

Solución a la inversa

SELECT * FROM vip
JOIN 
dblink('dbname= transporte
	   port=5432 
	   host=127.0.0.1 
	   user=usuario_consulta
	   password =etc123',
	  'SELECT id, nombre FROM pasajero ') 
	  as datos_remotos (id integer,nombre character varying )
USING(id);

Esta fue mi solución:

SELECT * FROM vip
JOIN
dblink ('dbname=transporte 
	   port=5432 
	   host=127.0.0.1 
	   user=usuario_consulta 
	   password=root',
	  'SELECT id, nombre FROM pasajero')
	  AS datos_remotos(id integer, nombre character varying)
USING (id)

En sentido inverso, creamos una conexión entre una tabla de la base remota y solicitaremos acceso a la tabla pasajeros de la base transporte:

GRANT INSERT, SELECT, UPDATE ON TABLE public.pasajeros TO usuario_consulta;

CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink (‘dbname=transporte
port=5432
host=127.0.0.1
user=usuario_consulta
password=XXXXXXX’,
‘SELECT * FROM pasajeros’)

AS datos_remotos(nombre character varying,id integer, direccion_residencia character varying, fecha_nacimiento date)

ON (vip.id= datos_remotos.id);

-- CREATE EXTENSION dblink;

SELECT remote_data.*, uv.since FROM user_vip as uv
JOIN
dblink(
	'dbname=mattu_trains
	port=5432
	host=127.0.0.1
	user=user_query
	password=ale16',
	'SELECT * FROM passenger'
) AS remote_data( address character varying, id integer, name character varying(100),birth_date date)
ON uv.id = remote_data.id;

Listo:

CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink ('dbname=transporte 
        port=5432 
        host=127.0.0.1 
        user=usuario_consulta 
        password=1234',
        'SELECT * FROM pasajeros')
        AS datos_remotos (id integer, 
						  nombre character varying, 
						  direccion_residencia character varying, 
						  fecha_nacimiento date)
USING (id);
SELECT * FROM pasajeros_vip
JOIN
dblink('dbname=transporte 
	   host=127.0.0.1 
	   user=postgres 
	   password=******',
	   'SELECT * from pasajero')
	   AS datos_pasajero(nombre character varying, id integer, direccion_residencia character varying, 
						fecha_nacimiento character varying)
	   USING(id);
--CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink(
	'dbname=transporte
	port=5432
	host=127.0.0.1
	user=usuario_consulta2
	password=etc123', 
	'SELECT id, nombre, direccion_residencia, fecha_nacimiento 
	FROM pasajeros')
	AS datos_remotos (id integer, nombre character varying, direccion_residencia character varying , fecha_nacimiento date)
	USING (id);

Hay que abrir el Query tool en la db remota y crear nuevamente la extension dblink para que funcione

--CREATE EXTENSION dblink;

SELECT * FROM vip
RIGHT JOIN
dblink ('dbname=transporte
		port=5432
		host=127.0.0.1
		user=usuario_consulta
		password=admin1234',
	   'SELECT id, nombre, direccion_residencia FROM pasajeros')
	   AS datos_remotos (id integer, nombre character varying, direccion_residencia character varying)
USING (id)
WHERE vip IS NULL;

–CREATE EXTENSION dblink;

Select * from vip
inner join
dblink(‘dbname=transporte
port=5432
host=127.0.0.1
user=usuario_consulta
password=etc123’ ,
‘SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM pasajero’)
AS datos_remotos(id integer, nombre character(150), direccion_residencia character(250), fecha_nacimiento date)
USING (id);

👨‍💻 Super el tema no hay que recurrir a otro lenguaje sin duda para mi el gestor de bases de datos mas completo es PostgreSQL

Realizando la conexión inversa y organizando del mas reciente al mas antiguo obtuve lo siguiente:

SELECT * FROM vip_passengers
JOIN
dblink (‘dbname=transporte
port=5432
host=127.0.0.1
user=user_consulta
password=tester’,‘SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM passenger’)
AS datos_remotos (id integer, nombre_pasajero character varying, direccion_residencia character varying, fecha_nacimiento date)
USING (id)
ORDER BY fecha_vip DESC

Muy útil… pensaré cómo implementarlo próximamente.

Gracias!

A great extension !!

¿En qué escenarios es bueno implementar DBLINK?

Esta es la tarea:

Postgresql, de largo es la mejor base, open source

excelente herramienta e implentacion el ejemplo mencionado

???

Comparto a la comunidad mis notas de este curso en un repositorio, espero les sean de mucha utilidad, recuerden hacer buen uso

https://github.com/rb-one/Curso_PostgreSQL/blob/master/Notes/notes.md

listo ya esta hecho 😃

Buenas Noches.
Este es mi aporte.

![](

Para los que tuvieron problemas en instalar la extension dblink pueden ejecutar el sigueinte codigo:
CREATE EXTENCION dblink SCHEMA <schema>;
En mi caso fue:
CREATE EXTENSION dblink SCHEMA transporte_schema;

Listo!! 😄 está muy chido esto.

dblink ejecuta una consulta (generalmente una SELECT, pero puede ser cualquier instrucción SQL que devuelva filas) en una base de dato remota.

Se puede utilizar una vista materializada para ocultar la información de conexión a una bases de datos remota

SELECT * FROM dblink('dbname=remota port=number_port host=name_host user=user_name password=password','SELECT field_name1, field_name2 FROM name_table') AS name_select (name_select.field type_data)

Concediendo permiso usuario GRANT ALL ON TABLE table_name TO user_name;

USING(id) se puede remplazar el ON por el USING, Esta es una clapsula que se utiliza cuando queremos comparar dos campos que se llaman igual en tablas diferentes

SELECT * FROM ('db=name_dataBase ')

24. Simulando una conexión a Bases de Datos remotos
dblink ejecuta una consulta (generalmente una SELECT, pero puede ser cualquier instrucción SQL que devuelva filas) en una base de dato remota.

Instalación dblink en postgres

CREATE EXTENSION dblink;

Otorgar permisos a un usuario que no se postgres para realizar la consulta

GRANT ALL ON TABLE public.vip TO usuario_consulta;

Preparación para probar la consulta remota

  1. Creamos la base de dato remota para simular una consulta remota.
CREATE DATABASE remota
    WITH 
    OWNER = postgres
    ENCODING = 'UTF8'
    CONNECTION LIMIT = -1;
  1. Se crea una tabla para guardar los datos de los clientes vip del sistema de transporte.
CREATE TABLE public.vip
(
    id serial NOT NULL,
    id_pasajero integer NOT NULL,
    fecha date,
    PRIMARY KEY (id)
)
WITH (
    OIDS = FALSE
);
 
ALTER TABLE public.vip
    OWNER to postgres;
  1. Realizamos dos insert para llenar la tabla.
INSERT INTO  public.vip (id_pasajero,fecha)VALUES('50','2010-01-01'),('49','2010-01-01');

SQL Elaborando consulta remota para postgres

  1. Elaboramos la consulta para nuestra base de dato remota
SELECT * FROM 
dblink('dbname=remota
        port=5432
        host=127.0.0.1
        user=usuario_consulta
        password=1234',
    'SELECT id,id_pasajero,fecha FROM vip') AS datos_remotos(id integer,id_pasajero integer, fecha date);

SQL Elaborando JOIN con consulta remota para postgres
5. Cruce de tablas locales con tablas remotas.

SELECT * FROM pasajero 
JOIN dblink('dbname=remota
            port=5432
            host=127.0.0.1
            user=usuario_consulta
            password=1234',
        'SELECT id,id_pasajero,fecha FROM vip') AS 
        datos_remotos(id integer ,id_pasajero integer, fecha date)
        ON (pasajero.id = datos_remotos.id_pasajero);
/*USING(id)
 se puede reemplazar el ON por el  USING, Esta es una cápsula 
 que se utiliza cuando  queremos comparar dos campos que se llaman igual
 en tablas diferentes
*/

/*Reto:
desde la bases de datos remota realizar la conexión a la  tabla pasajero 
*/
CREATE EXTENSION dblink;
SELECT * FROM vip 
JOIN dblink(
	'
		dbname=transporte
		port=5432
		host=127.0.0.1
		user=usuario_consulta
		password=1234
	',
	'SELECT id,nombre,direccion_residencia,fecha_nacimiento FROM pasajero') AS 
	datos_pasajero(id integer ,nombre character varying, direccion_residencia character varying , fecha_nacimiento date)
ON (vip.id_pasajero = datos_pasajero.id);

![](

Reto cumplido:

SELECT * FROM vip
INNER JOIN
dblink('dbname = transporte
	    port = 5432
	   	host = 127.0.0.1
	   	user = usuario_consulta
	   	password = etc123',
	  	'SELECT * FROM pasajero')
		AS datos_remotos(id integer, nombre character varying, direccion character varying, fecha_nacimeinto date)
USING(id);```

Mi solucion al reto:

SELECT * FROM vip
JOIN 
dblink('dbname=transporte
	   port=5432
	   host=127.0.0.1
	   user=usuario_consulta
	   password=etc123',
	   'SELECT * FROM pasajeros'
	  ) AS datos_remotos(id integer, nombre varchar, direccion_residencia varchar, fecha_nacimiento date)
USING (id);

Que cool está este tema

SELECT *
FROM dblink ('dbname=transporte
			 port=5432
			 host=127.0.0.1
			 user= usuario_consulta
			 password= #############',
			'SELECT *
			 FROM pasajero')
			 AS datos (id integer,nombre character varying, direccion_residencia character varying, fecha_nacimiento date);

Mi ejercicio:

¿Con dblink se podria acceder a una base como mySql? o solamente sirve para postgreSQL

-- CREATE EXTENSION dblink;

SELECT * FROM vip
JOIN
dblink ('dbname=transporte 
       port=5432 
       host=127.0.0.1 
       user=usuario_consulta 
       password=etc123',
      'SELECT id, nombre, direccion_residencia, fecha_nacimiento FROM pasajero')
      AS pasajero (id integer, nombre varchar(100), direccion varchar(200), fecha date)
USING (id)

create extension dblink;
select * from vip
join
dblink(‘dbname=transporte
port=5432
host=127.0.0.1
user=usuario_consulta
password=etc123’,
‘select id, direccion_residencia, nombre, fecha_nacimiento from pasajero’)
as datos_pasajero(id integer, direccion_residencia character varying, nombre character varying, fecha_nacimiento character varying)
on vip.id = datos_pasajero.id;

Hola.

¿Saben por qué tengo este error?

<SELECT * FROM pasajeros p
JOIN
dblink ('dbname=remota
        port=5432
        host=127.0.0.1
        user=flavio28
        password=2802',
        'SELECT vip_id, fecha FROM vip')
        AS datos_remotos  (vip_id integer, fecha date)
ON p.pasajero_id = datos_remotos.vip_id;
>

Interesante,intentare hacer el reto

Join con una base de datos remota.

USING: Para cuando los dos campos son iguales.

dblink

Consulta a una base de datos externa.

CREATE EXTENSION dblink: Para instalar dblink

AS: Cuando hacemos una consulta a una base de datos externa, tenemos que especificar con qué formato vamos a recibir los datos.

Dar todos los permisos a un usuario.

Muy interesante la clase, muchas gracias!