Merge pull request #397 from Algunenano/plpy_warnings

Remove leftover plpython warnings

.travis.yml

@@ -1,4 +1,3 @@
-dist: xenial
 language: c
 sudo: required
 
@@ -7,27 +6,30 @@ env:
     - PGUSER=postgres
     - PGDATABASE=postgres
     - PGOPTIONS='-c client_min_messages=NOTICE'
-    - PGPORT=5432
-    - POSTGIS_VERSION="2.5"
 
-  matrix:
-    - POSTGRESQL_VERSION="9.6"
-    - POSTGRESQL_VERSION="10"
-    - POSTGRESQL_VERSION="11"
+jobs:
+  include:
+    - env: POSTGRESQL_VERSION="9.6" POSTGIS_VERSION="2.5"
+      dist: xenial
+    - env: POSTGRESQL_VERSION="10" POSTGIS_VERSION="2.5"
+      dist: xenial
+    - env: POSTGRESQL_VERSION="11" POSTGIS_VERSION="2.5"
+      dist: xenial
+    - env: POSTGRESQL_VERSION="12" POSTGIS_VERSION="2.5"
+      dist: bionic
+    - env: POSTGRESQL_VERSION="12" POSTGIS_VERSION="3"
+      dist: bionic
 
-
-before_install:
-  - sudo service postgresql stop;
-  - sudo apt-get remove postgresql* -y
+script:
   - sudo apt-get install -y --allow-unauthenticated --no-install-recommends --no-install-suggests postgresql-$POSTGRESQL_VERSION postgresql-client-$POSTGRESQL_VERSION postgresql-server-dev-$POSTGRESQL_VERSION postgresql-common
   - if [[ $POSTGRESQL_VERSION == '9.6' ]]; then sudo apt-get install -y postgresql-contrib-9.6; fi;
-  - sudo apt-get install -y --allow-unauthenticated postgresql-$POSTGRESQL_VERSION-postgis-$POSTGIS_VERSION postgresql-$POSTGRESQL_VERSION-postgis-$POSTGIS_VERSION-scripts postgis postgresql-plpython-$POSTGRESQL_VERSION
+  - sudo apt-get install -y --allow-unauthenticated postgresql-$POSTGRESQL_VERSION-postgis-$POSTGIS_VERSION postgresql-$POSTGRESQL_VERSION-postgis-$POSTGIS_VERSION-scripts postgis
+  # For pre12, install plpython2. For PG12 install plpython3
+  - if [[ $POSTGRESQL_VERSION != '12' ]]; then sudo apt-get install -y postgresql-plpython-$POSTGRESQL_VERSION python python-redis; else sudo apt-get install -y postgresql-plpython3-12 python3 python3-redis; fi;
   - sudo pg_dropcluster --stop $POSTGRESQL_VERSION main
-  - sudo rm -rf /etc/postgresql/$POSTGRESQL_VERSION /var/lib/postgresql/$POSTGRESQL_VERSION
-  - sudo pg_createcluster -u postgres $POSTGRESQL_VERSION main -- -A trust
-  - sudo /etc/init.d/postgresql start $POSTGRESQL_VERSION || sudo journalctl -xe
-  - sudo pip install redis==2.4.9
-script:
+  - sudo rm -rf /etc/postgresql/$POSTGRESQL_VERSION /var/lib/postgresql/$POSTGRESQL_VERSION /var/ramfs/postgresql/$POSTGRESQL_VERSION
+  - sudo pg_createcluster -u postgres $POSTGRESQL_VERSION main --start -- --auth-local trust --auth-host password
+  - export PGPORT=$(pg_lsclusters | grep $POSTGRESQL_VERSION | awk '{print $3}')
   - make
   - sudo make install
   - make installcheck
@@ -36,3 +38,5 @@ after_failure:
   - pg_lsclusters
   - cat regression.out
   - cat regression.diffs
+  - echo $PGPORT
+  - cat /var/log/postgresql/postgresql-$POSTGRESQL_VERSION-main.log

Makefile

@@ -1,7 +1,7 @@
 # cartodb/Makefile
 
 EXTENSION = cartodb
-EXTVERSION = 0.27.1
+EXTVERSION = 0.36.0
 
 SED = sed
 AWK = awk
@@ -98,6 +98,17 @@ UPGRADABLE = \
   0.26.1 \
   0.27.0 \
   0.27.1 \
+  0.27.2 \
+  0.28.0 \
+  0.28.1 \
+  0.29.0 \
+  0.30.0 \
+  0.31.0 \
+  0.32.0 \
+  0.33.0 \
+  0.34.0 \
+  0.35.0 \
+  0.36.0 \
   $(EXTVERSION)dev \
   $(EXTVERSION)next \
   $(END)
@@ -121,17 +132,27 @@ EXTRA_CLEAN = cartodb_version.sql
 DOCS = README.md
 REGRESS_OLD = $(wildcard test/*.sql)
 REGRESS_LEGACY = $(REGRESS_OLD:.sql=)
-REGRESS = test_setup $(REGRESS_LEGACY)
+REGRESS = test/test_setup $(REGRESS_LEGACY)
 
 PG_CONFIG = pg_config
 PGXS := $(shell $(PG_CONFIG) --pgxs)
 include $(PGXS)
 
+PG_VERSION := $(shell $(PG_CONFIG) --version | $(AWK) '{split($$2,a,"."); print a[1]}')
+PG_12_GE := $(shell [ $(PG_VERSION) -ge 12 ] && echo true)
+PLPYTHONU := plpythonu
+ifeq ($(PG_12_GE), true)
+PLPYTHONU := plpython3u
+endif
+PGPORT ?= '5432'
+PGUSER ?= 'postgres'
+
 $(EXTENSION)--$(EXTVERSION).sql: $(CDBSCRIPTS) cartodb_version.sql Makefile
 	echo '\echo Use "CREATE EXTENSION $(EXTENSION)" to load this file. \quit' > $@
 	cat $(CDBSCRIPTS) | \
 	$(SED) 	-e 's/@extschema@/cartodb/g' \
-		-e "s/@postgisschema@/public/g" >> $@
+		-e 's/@postgisschema@/public/g' \
+		-e 's/@@plpythonu@@/$(PLPYTHONU)/g' >> $@
 	echo "GRANT USAGE ON SCHEMA cartodb TO public;" >> $@
 	cat cartodb_version.sql >> $@
 
@@ -145,10 +166,10 @@ $(EXTENSION)--$(EXTVERSION)--$(EXTVERSION)next.sql: $(EXTENSION)--$(EXTVERSION).
 	cp $< $@
 
 $(EXTENSION).control: $(EXTENSION).control.in Makefile
-	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' $< > $@
+	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/g' -e 's/@@plpythonu@@/$(PLPYTHONU)/g' $< > $@
 
 cartodb_version.sql: cartodb_version.sql.in Makefile $(GITDIR)/index
-	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' -e 's/@extschema@/cartodb/g' -e "s/@postgisschema@/public/g" $< > $@
+	$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' -e 's/@extschema@/cartodb/g' -e "s/@postgisschema@/public/g" -e 's/@@plpythonu@@/$(PLPYTHONU)/g' $< > $@
 
 # Needed for consistent `echo` results with backslashes
 SHELL = bash
@@ -157,6 +178,10 @@ legacy_regress: $(REGRESS_OLD) Makefile
 	mkdir -p sql/test/
 	mkdir -p expected/test/
 	mkdir -p results/test/
+	cat sql/test_setup.sql | \
+			$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' -e 's/@extschema@/cartodb/g' -e "s/@postgisschema@/public/g" -e 's/@@plpythonu@@/$(PLPYTHONU)/g' \
+			> sql/test/test_setup.sql
+	cp sql/test_setup_expect expected/test/test_setup.out
 	for f in $(REGRESS_OLD); do \
 		tn=`basename $${f} .sql`; \
 		of=sql/test/$${tn}.sql; \
@@ -165,10 +190,23 @@ legacy_regress: $(REGRESS_OLD) Makefile
 		echo '\t' >> $${of}; \
 		echo '\set QUIET off' >> $${of}; \
 		cat $${f} | \
-			$(SED) -e 's/@@VERSION@@/$(EXTVERSION)/' -e 's/@extschema@/cartodb/g' -e "s/@postgisschema@/public/g" >> $${of}; \
+			$(SED) 	-e 's/@@VERSION@@/$(EXTVERSION)/' \
+				-e 's/@extschema@/cartodb/g' \
+				-e "s/@postgisschema@/public/g" \
+				-e 's/@@plpythonu@@/$(PLPYTHONU)/g' \
+				-e 's/@@PGPORT@@/$(PGPORT)/g' \
+				-e 's/@@PGUSER@@/$(PGUSER)/g' \
+				>> $${of}; \
 		exp=expected/test/$${tn}.out; \
 		echo '\set ECHO none' > $${exp}; \
-		cat test/$${tn}_expect >> $${exp}; \
+		cat test/$${tn}_expect | \
+			$(SED) 	-e 's/@@VERSION@@/$(EXTVERSION)/' \
+				-e 's/@extschema@/cartodb/g' \
+				-e "s/@postgisschema@/public/g" \
+				-e 's/@@plpythonu@@/$(PLPYTHONU)/g' \
+				-e 's/@@PGPORT@@/$(PGPORT)/g' \
+				-e 's/@@PGUSER@@/$(PGUSER)/g' \
+				>> $${exp}; \
 	done
 
 test_organization:
@@ -177,7 +215,15 @@ test_organization:
 test_extension_new:
 	bash test/extension/test.sh
 
-legacy_tests: legacy_regress
+legacy_tests: legacy_regress $(EXTENSION)--unpackaged--$(EXTVERSION).sql
 
-installcheck: legacy_tests test_extension_new test_organization
+PGREGRESS := $(shell dirname `$(PG_CONFIG) --pgxs`)/../../src/test/regress/pg_regress
+PGBINDIR := $(shell $(PG_CONFIG) --bindir)
+PGREGRESSDATABASE = 'contrib_regression'
+regress: legacy_tests
+	PGUSER=$(PGUSER) \
+	PGPORT=$(PGPORT) \
+	$(PGREGRESS) --inputdir=./ --bindir='$(PGBINDIR)' --dbname=$(PGREGRESSDATABASE) $(REGRESS)
 
+installcheck: test_extension_new test_organization
+	$(MAKE) -C . regress

NEWS.md

@@ -1,3 +1,49 @@
+0.36.0 (2020-02-13)
+* Make `_CDB_Group_API_Auth` python3 compatible by passing bytes representation instead of a string.
+* Make `_CDB_Group_API_Request` python3 compatible by adapting the function signature of `HTTPConnection`.
+
+0.35.0 (2019-12-30)
+* Reapply the changes in 0.33.0 (the issue we were looking for was unrelated)
+* Reapply `Make PG12 depend on plpython3u instead of plpythonu`
+* Fix identifier quotation in `CDB_UserDataSize`
+
+0.34.0 (2019-12-23)
+* Revert changes done in 0.33.0, keeping function signature to drop them
+
+0.33.0 (2019-12-20)
+* Revert `Make PG12 depend on plpython3u instead of plpythonu`.
+* Add functions to manage Federated Tables (Foreign Data Wrapper)
+
+0.32.0 (2019-11-08)
+* Fix oAuth ownership re-assignation for functions
+* Some fixes for PG12.
+* Make PG12 depend on plpython3u instead of plpythonu
+* CDB_UserDataSize is now compatible with postgis 3 without postgis_raster.
+* Makefile: Add regress target (checks regress tests without needing to install the extension)
+
+0.31.0 (2019-10-08)
+* Ghost tables: Add missing tags (#370)
+* Set search_path in security definer functions.
+
+0.30.0 (2019-07-17)
+* Added new admin functions to connect CARTO with user FDW's (#369)
+
+0.29.0 (2019-07-15)
+* Added new function CDB_OAuth:
+  * Install event trigger to check for table/view/sequence/function creation
+  * Reassign the ownership of new objects to a defined role in the cdb_conf
+* Changed MakeFile to support different expects for differents PG versions
+
+0.28.1 (2019-07-04)
+* Avoid temporary tables creation in CDB_SyncTable (#366)
+* Make CDB_Get_Foreign_Updated_At robust to missing CDB_TableMetadata (#362)
+
+0.28.0 (2019-07-01)
+* New function CDB_SyncTable (#355)
+
+0.27.2 (2019-06-21)
+* Improvements and fixes in Ghost tables functions (#360)
+
 0.27.1 (2019-06-03)
 * Add some qualifications that were left in the previous release.
 

README.md

@@ -10,7 +10,7 @@ See [the cartodb-postgresql wiki](https://github.com/CartoDB/cartodb-postgresql/
 Dependencies
 ------------
 
- * PostgreSQL 9.6+ (with plpythonu extension and xml support)
+ * PostgreSQL 9.6+ (with plpythonu extension and xml support). For PostgreSQL 12+ plpython3u is required instead of plpythonu.
  * [PostGIS extension](http://postgis.net)
  * Python with [Redis module](https://pypi.org/project/redis/)
 

carto-package.json

@@ -2,7 +2,7 @@
     "name": "carto_postgresql_ext",
     "current_version": {
         "requires": {
-            "postgresql": ">=10.0",
+            "postgresql": ">=10.0.0",
             "postgis": ">=2.4.0.0"
         },
         "works_with": {

cartodb.control.in

@@ -3,4 +3,4 @@ comment = 'Turn a database into a cartodb user database.'
 superuser = true
 relocatable = false
 schema = cartodb
-requires = 'plpythonu, postgis'
+requires = '@@plpythonu@@, postgis'

doc/CDB_SyncTable.md

@@ -0,0 +1,56 @@
+Synchronize two tables. This function will synchronize a *destination* table with a *source* table.
+The idea is that the *destination* is a replica of *source* and *source* has been subject to
+modifications that are to be applied to *destination*.
+
+This will be achieved by deleting the rows in the destination not present
+in the source, inserting rows of the source not in the destination and updating modified rows.
+If the destination table does not exist it will be created and all the rows of the source inserted into it.
+
+Both tables must have a consistent `cartodb_id` primary key column which will be used to match
+the source and destination rows.
+
+Note that both tables do not necessarily become identical after the synchronization, since additional columns
+may have been added to the destination; those columns will not be altered by the synchronization.
+
+In addition some source columns may be skipped by listing them in the optional last argument; such columns
+will not be updated in the destination, so if they are present in it their values won't be altered.
+
+
+#### Using the function
+
+Import some data using COPY FROM into a temporary table, then synchronize a table with the data and
+finally delete the temporary table. This could be used import and update some data periodically while
+allowing to add columns to the data that will be preserved across updates.
+
+```sql
+CREATE tmp_pois(cartodb_id int, name text, type text, longitude double precision, latitude double precision, rank int);
+COPY tmp_pois FROM '/tmp/pois.csv';
+SELECT CDB_SyncTable('tmp_pois', 'public', 'pois');
+DROP TABLE tmp_pois;
+```
+
+Now we could perform some changes to the `pois` to maintain our own ranking:
+
+```sql
+UPDATE pois SET rank = random()*4 + 1;
+```
+
+Then, if the source were updated at `/tmp/pois.csv` we could synchronize with it while preserving our `rank` values with:
+
+```sql
+CREATE tmp_pois(cartodb_id int, name text, type text, longitude double precision, latitude double precision, rank int);
+COPY tmp_pois FROM '/tmp/pois.csv';
+SELECT CDB_SyncTable('tmp_pois', 'public', 'pois', '{rank}');
+DROP TABLE tmp_pois;
+```
+
+#### Arguments
+
+```
+CDB_SyncTable(src_table, dst_schema, dst_table, skip_cols)
+```
+
+* **src_table** REGCLASS the source data for the synchronization
+* **dst_scgena** REGNAMESPACE the destination schema
+* **dst_table** NAME the destination table to be updated
+* **skip_cols** NAME[] an array of column names, empty by default, which will be skipped

expected/test_setup.out

@@ -1,6 +1,5 @@
-CREATE EXTENSION postgis;
-CREATE EXTENSION plpythonu;
-CREATE EXTENSION cartodb;
+SET client_min_messages TO error;
+CREATE EXTENSION cartodb CASCADE;
 CREATE FUNCTION public.cdb_invalidate_varnish(table_name text)
 RETURNS void AS $$
 BEGIN

scripts-available/CDB_AnalysisCheck.sql

@@ -6,8 +6,11 @@ $$
 BEGIN
   RETURN @extschema@.CDB_Conf_GetConf('analysis_quota_factor')::text::float8;
 END;
-$$
-LANGUAGE 'plpgsql' STABLE PARALLEL SAFE SECURITY DEFINER;
+$$  LANGUAGE 'plpgsql'
+    STABLE
+    PARALLEL SAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 
 -- Get the factor (fraction of the quota) for Camshaft cached analysis tables

scripts-available/CDB_CartodbfyTable.sql

@@ -1071,7 +1071,7 @@ BEGIN
   -- by selecting their names into an array and
   -- joining the array with a comma
   SELECT
-    ',' || array_to_string(array_agg(Format('%I',a.attname)),',') AS column_name_sql,
+    ',' || array_to_string(array_agg(Format('%I',a.attname) ORDER BY a.attnum),',') AS column_name_sql,
     Count(*) AS count
   INTO rec
   FROM pg_class c

scripts-available/CDB_EstimateRowCount.sql

@@ -12,7 +12,12 @@ BEGIN
     EXECUTE Format('ANALYZE %s;', reloid);
   END IF;
 END
-$$ LANGUAGE 'plpgsql' VOLATILE STRICT PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE 'plpgsql'
+    VOLATILE
+    STRICT
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 -- Return a row count estimate of the result of a query using statistics
 CREATE OR REPLACE FUNCTION @extschema@.CDB_EstimateRowCount(query text)

scripts-available/CDB_FederatedServer.sql

@@ -0,0 +1,437 @@
+--------------------------------------------------------------------------------
+-- Private functions
+--------------------------------------------------------------------------------
+
+--
+-- This function is just a placement to store and use the pattern for
+-- foreign object names
+-- Servers:         cdb_fs_$(server_name)
+-- View schema:     cdb_fs_$(server_name)
+--  > This is where all views created when importing tables are placed
+--  > One server has only one view schema
+-- Import Schemas:  cdb_fs_schema_$(md5sum(server_name || remote_schema_name))
+--  > This is where the foreign tables are placed
+--  > One server has one import schema per remote schema plus auxiliar ones used
+--      to access the remote catalog (pg_catalog, information_schema...)
+-- Owner role:      cdb_fs_$(md5sum(current_database() || server_name)
+--  > This is the role than owns all schemas and tables related to the server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Name_Pattern()
+RETURNS TEXT
+AS $$
+    SELECT 'cdb_fs_'::text;
+$$
+LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Produce a valid DB name for servers generated for the Federated Server
+-- If check_existence is true, it'll throw if the server doesn't exists
+-- This name is also used as the schema to store views
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Generate_Server_Name(input_name TEXT, check_existence BOOL)
+RETURNS NAME
+AS $$
+DECLARE
+    internal_server_name text := format('%s%s', @extschema@.__CDB_FS_Name_Pattern(), input_name);
+BEGIN
+    IF input_name IS NULL OR char_length(input_name) = 0 THEN
+        RAISE EXCEPTION 'Server name cannot be NULL';
+    END IF;
+
+    -- We discard anything that would be truncated
+    IF (char_length(internal_server_name) >= 64) THEN
+        RAISE EXCEPTION 'Server name (%) is too long to be used as identifier', input_name;
+    END IF;
+
+    IF (check_existence AND (NOT EXISTS (SELECT * FROM pg_foreign_server WHERE srvname = internal_server_name))) THEN
+        RAISE EXCEPTION 'Server "%" does not exist', input_name;
+    END IF;
+
+    RETURN internal_server_name::name;
+END
+$$
+LANGUAGE PLPGSQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Given the internal name for a remote server, it returns the name used by the user
+-- Reverses __CDB_FS_Generate_Server_Name
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Extract_Server_Name(internal_server_name NAME)
+RETURNS TEXT
+AS $$
+    SELECT right(internal_server_name,
+            char_length(internal_server_name::TEXT) - char_length(@extschema@.__CDB_FS_Name_Pattern()))::TEXT;
+$$
+LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Produce a valid name for a schema generated for the Federated Server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Generate_Schema_Name(internal_server_name NAME, schema_name TEXT)
+RETURNS NAME
+AS $$
+DECLARE
+    hash_value text := md5(internal_server_name::text || '__' || schema_name::text);
+BEGIN
+    IF schema_name IS NULL THEN
+        RAISE EXCEPTION 'Schema name cannot be NULL';
+    END IF;
+    RETURN format('%s%s%s', @extschema@.__CDB_FS_Name_Pattern(), 'schema_', hash_value)::name;
+END
+$$
+LANGUAGE PLPGSQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Produce a valid name for a role generated for the Federated Server
+-- This needs to include the current database in its hash to avoid collisions in clusters with more than one database
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Generate_Server_Role_Name(internal_server_name NAME)
+RETURNS NAME
+AS $$
+DECLARE
+    hash_value text := md5(current_database()::text || '__' || internal_server_name::text);
+    role_name text := format('%s%s%s', @extschema@.__CDB_FS_Name_Pattern(), 'role_', hash_value);
+BEGIN
+    RETURN role_name::name;
+END
+$$
+LANGUAGE PLPGSQL STABLE PARALLEL SAFE;
+
+--
+-- Creates (if not exist) a schema to place the objects for a remote schema
+-- The schema is with the same AUTHORIZATION as the server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Create_Schema(internal_server_name NAME, schema_name TEXT)
+RETURNS NAME
+AS $$
+DECLARE
+    schema_name name := @extschema@.__CDB_FS_Generate_Schema_Name(internal_server_name, schema_name);
+    role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(internal_server_name);
+BEGIN
+    -- By changing the local role to the owner of the server we have an
+    -- easy way to check for permissions and keep all objects under the same owner
+    BEGIN
+        EXECUTE 'SET LOCAL ROLE ' || quote_ident(role_name);
+    EXCEPTION
+    WHEN invalid_parameter_value THEN
+        RAISE EXCEPTION 'Server "%" does not exist',
+                        @extschema@.__CDB_FS_Extract_Server_Name(internal_server_name);
+    WHEN OTHERS THEN
+        RAISE EXCEPTION 'Not enough permissions to access the server "%"',
+                        @extschema@.__CDB_FS_Extract_Server_Name(internal_server_name);
+    END;
+
+    IF NOT EXISTS (SELECT oid FROM pg_namespace WHERE nspname = schema_name) THEN
+        EXECUTE 'CREATE SCHEMA ' || quote_ident(schema_name) || ' AUTHORIZATION ' || quote_ident(role_name);
+    END IF;
+    RETURN schema_name;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Returns the type of a server by internal name
+-- Currently all of them should be postgres_fdw
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_server_type(internal_server_name NAME)
+RETURNS name
+AS $$
+    SELECT f.fdwname
+        FROM pg_foreign_server s
+        JOIN pg_foreign_data_wrapper f ON s.srvfdw = f.oid
+        WHERE s.srvname = internal_server_name;
+$$
+LANGUAGE SQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Take a config jsonb and transform it to an input suitable for _CDB_SetUp_User_PG_FDW_Server
+-- 
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_credentials_to_user_mapping(input_config JSONB)
+RETURNS jsonb
+AS $$
+DECLARE
+    mapping jsonb := '{}'::jsonb;
+BEGIN
+    IF NOT (input_config ? 'credentials') THEN
+        RAISE EXCEPTION 'Credentials are mandatory';
+    END IF;
+
+    -- For now, allow not passing username or password
+    IF input_config->'credentials'->'username' IS NOT NULL THEN
+        mapping := jsonb_build_object('user', input_config->'credentials'->'username');
+    END IF;
+    IF input_config->'credentials'->'password' IS NOT NULL THEN
+        mapping := mapping || jsonb_build_object('password', input_config->'credentials'->'password');
+    END IF;
+
+    RETURN (input_config - 'credentials')::jsonb || jsonb_build_object('user_mapping', mapping);
+END
+$$
+LANGUAGE PLPGSQL IMMUTABLE PARALLEL SAFE;
+
+-- Take a config jsonb as input and return it augmented with default
+-- options
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_add_default_options(input_config jsonb)
+RETURNS jsonb
+AS $$
+DECLARE
+    default_options jsonb := '{
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    }';
+    server_config jsonb;
+BEGIN
+    IF NOT (input_config ? 'server') THEN
+        RAISE EXCEPTION 'Server information is mandatory';
+    END IF;
+    server_config := default_options || to_jsonb(input_config->'server');
+    RETURN jsonb_set(input_config, '{server}'::text[], server_config);
+END
+$$
+LANGUAGE PLPGSQL IMMUTABLE PARALLEL SAFE;
+
+-- Given an server name, returns the username used in the configuration if the caller has rights to access it
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_get_usermapping_username(internal_server_name NAME)
+RETURNS text
+AS $$
+DECLARE
+    role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(internal_server_name);
+    username text;
+BEGIN
+    BEGIN
+        EXECUTE 'SET LOCAL ROLE ' || quote_ident(role_name);
+    EXCEPTION WHEN OTHERS THEN
+        RETURN NULL;
+    END;
+
+    SELECT (SELECT option_value FROM pg_options_to_table(u.umoptions) WHERE option_name LIKE 'user') as name INTO username
+        FROM pg_foreign_server s
+        LEFT JOIN pg_user_mappings u
+        ON u.srvid = s.oid
+        WHERE s.srvname = internal_server_name
+        ORDER BY 1;
+
+    RESET ROLE;
+
+    RETURN username;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--------------------------------------------------------------------------------
+-- Public functions
+--------------------------------------------------------------------------------
+
+
+--
+-- Registers a new PG server
+--
+-- Example config: '{
+--     "server": {
+--         "dbname": "fdw_target",
+--         "host": "localhost",
+--         "port": 5432,
+--         "extensions": "postgis",
+--         "updatable": "false",
+--         "use_remote_estimate": "true",
+--         "fetch_size": "1000"
+--     },
+--     "credentials": {
+--         "username": "fdw_user",
+--         "password": "foobarino"
+--     }
+-- }'
+--
+-- The configuration from __CDB_FS_add_default_options will be appended
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_Register_PG(server TEXT, config JSONB)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => false);
+    final_config json := @extschema@.__CDB_FS_credentials_to_user_mapping(@extschema@.__CDB_FS_add_default_options(config));
+    role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(server_internal);
+    row record;
+    option record;
+BEGIN
+    IF NOT EXISTS (SELECT * FROM pg_extension WHERE extname = 'postgres_fdw') THEN
+        RAISE EXCEPTION 'postgres_fdw extension is not installed'
+            USING HINT = 'Please install it with `CREATE EXTENSION postgres_fdw`';
+    END IF;
+
+    -- We only create server and roles if the server didn't exist before
+    IF NOT EXISTS (SELECT * FROM pg_foreign_server WHERE srvname = server_internal) THEN
+        BEGIN
+            EXECUTE FORMAT('CREATE SERVER %I FOREIGN DATA WRAPPER postgres_fdw', server_internal);
+            IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = role_name) THEN
+                EXECUTE FORMAT('CREATE ROLE %I NOLOGIN', role_name);
+            END IF;
+            EXECUTE FORMAT('GRANT ALL PRIVILEGES ON DATABASE %I TO %I', current_database(), role_name);
+
+            -- These grants over `@extschema@` and `@postgisschema@` are necessary for the cases
+            -- where the schemas aren't accessible to PUBLIC, which is what happens in a CARTO database
+            EXECUTE FORMAT('GRANT USAGE ON SCHEMA %I TO %I', '@extschema@', role_name);
+            EXECUTE FORMAT('GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA %I TO %I', '@extschema@', role_name);
+            EXECUTE FORMAT('GRANT USAGE ON SCHEMA %I TO %I', '@postgisschema@', role_name);
+            EXECUTE FORMAT('GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA %I TO %I', '@postgisschema@', role_name);
+            EXECUTE FORMAT('GRANT SELECT ON ALL TABLES IN SCHEMA %I TO %I', '@postgisschema@', role_name);
+
+            EXECUTE FORMAT('GRANT USAGE ON FOREIGN DATA WRAPPER postgres_fdw TO %I', role_name);
+            EXECUTE FORMAT('GRANT USAGE ON FOREIGN DATA WRAPPER postgres_fdw TO %I', role_name);
+            EXECUTE FORMAT('GRANT USAGE ON FOREIGN SERVER %I TO %I', server_internal, role_name);
+            EXECUTE FORMAT('ALTER SERVER %I OWNER TO %I', server_internal, role_name);
+            EXECUTE FORMAT ('CREATE USER MAPPING FOR %I SERVER %I', role_name, server_internal);
+        EXCEPTION WHEN OTHERS THEN
+            RAISE EXCEPTION 'Could not create server %: %', server, SQLERRM
+                USING HINT = 'Please clean the left over objects';
+        END;
+    END IF;
+
+    -- Add new options
+    FOR row IN SELECT p.key, p.value from lateral json_each_text(final_config->'server') p
+    LOOP
+        IF NOT EXISTS (
+            WITH a AS (
+                SELECT split_part(unnest(srvoptions), '=', 1) AS options FROM pg_foreign_server WHERE srvname=server_internal
+            ) SELECT * from a where options = row.key)
+        THEN
+            EXECUTE FORMAT('ALTER SERVER %I OPTIONS (ADD %I %L)', server_internal, row.key, row.value);
+        ELSE
+            EXECUTE FORMAT('ALTER SERVER %I OPTIONS (SET %I %L)', server_internal, row.key, row.value);
+        END IF;
+    END LOOP;
+
+    -- Update user mapping settings
+    FOR option IN SELECT o.key, o.value from lateral json_each_text(final_config->'user_mapping') o
+    LOOP
+        IF NOT EXISTS (
+            WITH a AS (
+                SELECT split_part(unnest(umoptions), '=', 1) as options from pg_user_mappings WHERE srvname = server_internal AND usename = role_name
+            ) SELECT * from a where options = option.key)
+        THEN
+            EXECUTE FORMAT('ALTER USER MAPPING FOR %I SERVER %I OPTIONS (ADD %I %L)', role_name, server_internal, option.key, option.value);
+        ELSE
+            EXECUTE FORMAT('ALTER USER MAPPING FOR %I SERVER %I OPTIONS (SET %I %L)', role_name, server_internal, option.key, option.value);
+        END IF;
+    END LOOP;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Drops a registered server and all the objects associated with it
+-- 
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_Unregister(server TEXT)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(server_internal);
+BEGIN
+    SET client_min_messages = ERROR;
+    BEGIN
+        EXECUTE FORMAT ('DROP USER MAPPING FOR %I SERVER %I', role_name, server_internal);
+        EXECUTE FORMAT ('DROP OWNED BY %I', role_name);
+        EXECUTE FORMAT ('DROP ROLE %I', role_name);
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Not enough permissions to drop the server "%"', server;
+    END;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- List registered servers
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_List_Servers(server TEXT DEFAULT '%')
+RETURNS TABLE (
+    name        text,
+    driver      text,
+    host        text,
+    port        text,
+    dbname      text,
+    readmode    text,
+    username    text
+)
+AS $$
+DECLARE
+    server_name text := concat(@extschema@.__CDB_FS_Name_Pattern(), server);
+BEGIN
+    RETURN QUERY SELECT 
+        -- Name as shown to the user
+        @extschema@.__CDB_FS_Extract_Server_Name(s.srvname) AS "Name",
+
+        -- Which driver are we using (postgres_fdw, odbc_fdw...)
+        @extschema@.__CDB_FS_server_type(s.srvname)::text AS "Driver",
+
+        -- Read options from pg_foreign_server
+        (SELECT option_value FROM pg_options_to_table(s.srvoptions) WHERE option_name LIKE 'host') AS "Host",
+        (SELECT option_value FROM pg_options_to_table(s.srvoptions) WHERE option_name LIKE 'port') AS "Port",
+        (SELECT option_value FROM pg_options_to_table(s.srvoptions) WHERE option_name LIKE 'dbname') AS "DBName",
+        CASE WHEN (SELECT NOT option_value::boolean FROM pg_options_to_table(s.srvoptions) WHERE option_name LIKE 'updatable') THEN 'read-only' ELSE 'read-write' END AS "ReadMode",
+
+        @extschema@.__CDB_FS_get_usermapping_username(s.srvname)::text AS "Username"
+    FROM pg_foreign_server s
+    LEFT JOIN pg_user_mappings u
+    ON u.srvid = s.oid
+    WHERE s.srvname ILIKE server_name
+    ORDER BY 1;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL SAFE;
+
+
+--
+-- Grant access to a server
+-- In the future we might consider adding the server's view schema to the role search_path
+-- to make it easier to access the created views
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_Grant_Access(server TEXT, db_role NAME)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(server_internal);
+BEGIN
+    IF (db_role IS NULL) THEN
+        RAISE EXCEPTION 'User role "%" cannot be NULL', username;
+    END IF;
+    BEGIN
+        EXECUTE format('GRANT %I TO %I', server_role_name, db_role);
+    EXCEPTION
+    WHEN insufficient_privilege THEN
+        RAISE EXCEPTION 'You do not have rights to grant access on "%"', server;
+    WHEN OTHERS THEN
+        RAISE EXCEPTION 'Could not grant access on "%" to "%": %', server, db_role, SQLERRM;
+    END;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Revoke access to a server
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_Revoke_Access(server TEXT, db_role NAME)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(server_internal);
+BEGIN
+    IF (db_role IS NULL) THEN
+        RAISE EXCEPTION 'User role "%" cannot be NULL', username;
+    END IF;
+    BEGIN
+        EXECUTE format('REVOKE %I FROM %I', server_role_name, db_role);
+    EXCEPTION
+    WHEN insufficient_privilege THEN
+        RAISE EXCEPTION 'You do not have rights to revoke access on "%"', server;
+    WHEN OTHERS THEN
+        RAISE EXCEPTION 'Could not revoke access on "%" to "%": %', server, db_role, SQLERRM;
+    END;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_FederatedServerDiagnostics.sql

@@ -0,0 +1,243 @@
+--------------------------------------------------------------------------------
+-- Private functions
+--------------------------------------------------------------------------------
+
+--
+-- Import a foreign table if it does not exist
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Import_If_Not_Exists(server_internal name, remote_schema name, remote_table name)
+RETURNS void
+AS $$
+DECLARE
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+BEGIN
+    IF NOT EXISTS (
+        SELECT * FROM pg_class
+        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = local_schema)
+        AND relname = remote_table
+    ) THEN
+        EXECUTE format('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I',
+                    remote_schema, remote_table, server_internal, local_schema);
+    END IF;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Get the version of a remote PG server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Foreign_Server_Version_PG(server_internal name)
+RETURNS text
+AS $$
+DECLARE
+    remote_schema name := 'pg_catalog';
+    remote_table name := 'pg_settings';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+    remote_server_version text;
+BEGIN
+    PERFORM @extschema@.__CDB_FS_Import_If_Not_Exists(server_internal, remote_schema, remote_table);
+
+    BEGIN
+        EXECUTE format('
+            SELECT setting FROM %I.%I WHERE name = ''server_version'';
+        ', local_schema, remote_table) INTO remote_server_version;
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Not enough permissions to access the server "%"',
+                        @extschema@.__CDB_FS_Extract_Server_Name(server_internal);
+    END;
+
+    RETURN remote_server_version;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- Get the PostGIS extension version of a remote PG server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Foreign_PostGIS_Version_PG(server_internal name)
+RETURNS text
+AS $$
+DECLARE
+    remote_schema name := 'pg_catalog';
+    remote_table name := 'pg_extension';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+    remote_postgis_version text;
+BEGIN
+    PERFORM @extschema@.__CDB_FS_Import_If_Not_Exists(server_internal, remote_schema, remote_table);
+
+    BEGIN
+        EXECUTE format('
+            SELECT extversion FROM %I.%I WHERE extname = ''postgis'';
+        ', local_schema, remote_table) INTO remote_postgis_version;
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Not enough permissions to access the server "%"',
+                        @extschema@.__CDB_FS_Extract_Server_Name(server_internal);
+    END;
+
+    RETURN remote_postgis_version;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- Get the foreign server options of a remote PG server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Foreign_Server_Options_PG(server_internal name)
+RETURNS jsonb
+AS $$
+    -- See https://www.postgresql.org/docs/current/catalog-pg-foreign-server.html
+    -- See https://www.postgresql.org/docs/current/functions-info.html
+    SELECT jsonb_object_agg(opt.option_name, opt.option_value) FROM (
+        SELECT (pg_options_to_table(srvoptions)).*
+        FROM pg_foreign_server
+        WHERE srvname = server_internal
+    ) AS opt;
+$$
+LANGUAGE SQL VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- Get a foreign PG server hostname from the catalog
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Foreign_Server_Host_PG(server_internal name)
+RETURNS text
+AS $$
+    SELECT option_value FROM (
+        SELECT (pg_options_to_table(srvoptions)).*
+        FROM pg_foreign_server WHERE srvname = server_internal
+    ) AS opt WHERE opt.option_name = 'host';
+$$
+LANGUAGE SQL VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- Get a foreign PG server port from the catalog
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Foreign_Server_Port_PG(server_internal name)
+RETURNS integer
+AS $$
+    SELECT option_value::integer FROM (
+        SELECT (pg_options_to_table(srvoptions)).*
+        FROM pg_foreign_server WHERE srvname = server_internal
+    ) AS opt WHERE opt.option_name = 'port';
+$$
+LANGUAGE SQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Get one measure of network latency in ms to a remote TCP server
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_TCP_Foreign_Server_Latency(
+    server_internal name,
+    timeout_seconds float DEFAULT 5.0,
+    n_samples integer DEFAULT 10
+)
+RETURNS jsonb
+AS $$
+    import socket
+    import json
+    import math
+    from timeit import default_timer as timer
+
+    plan = plpy.prepare("SELECT @extschema@.__CDB_FS_Foreign_Server_Host_PG($1) AS host", ['name'])
+    rv = plpy.execute(plan, [server_internal], 1)
+    host = rv[0]['host']
+
+    plan = plpy.prepare("SELECT @extschema@.__CDB_FS_Foreign_Server_Port_PG($1) AS port", ['name'])
+    rv = plpy.execute(plan, [server_internal], 1)
+    port = rv[0]['port'] or 5432
+
+    n_errors = 0
+    samples = []
+
+    for i in range(n_samples):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(timeout_seconds)
+
+        t_start = timer()
+
+        try:
+            s.connect((host, int(port)))
+            t_stop = timer()
+            s.shutdown(socket.SHUT_RD)
+        except (socket.timeout, OSError, socket.error) as ex:
+            plpy.warning('could not connect to server %s:%d, %s' % (host, port, str(ex)))
+            n_errors += 1
+        finally:
+            s.close()
+
+        t_connect = (t_stop - t_start) * 1000.0
+        plpy.debug('TCP connection %s:%d time=%.2f ms' % (host, port, t_connect))
+        samples.append(t_connect)
+
+    stats = {
+        'n_samples': n_samples,
+        'n_errors': n_errors,
+    }
+    n = len(samples)
+    if n >= 1:
+        mean = sum(samples) / n
+        stats.update({
+            'avg': round(mean, 3),
+            'min': round(min(samples), 3),
+            'max': round(max(samples), 3)
+        })
+    if n >= 2:
+        var = sum([ (x - mean)**2 for x in samples ]) / (n-1)
+        stdev = math.sqrt(var)
+        stats.update({
+            'stdev': round(stdev, 3)
+        })
+    return json.dumps(stats)
+$$
+LANGUAGE @@plpythonu@@ VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- Collect and return diagnostics info from a remote PG into a jsonb
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Server_Diagnostics_PG(server_internal name)
+RETURNS jsonb
+AS $$
+DECLARE
+    remote_server_version  text    := @extschema@.__CDB_FS_Foreign_Server_Version_PG(server_internal);
+    remote_postgis_version text    := @extschema@.__CDB_FS_Foreign_PostGIS_Version_PG(server_internal);
+    remote_server_options jsonb    := @extschema@.__CDB_FS_Foreign_Server_Options_PG(server_internal);
+    remote_server_latency_ms jsonb := @extschema@.__CDB_FS_TCP_Foreign_Server_Latency(server_internal);
+BEGIN
+    RETURN jsonb_build_object(
+        'server_version', remote_server_version,
+        'postgis_version', remote_postgis_version,
+        'server_options', remote_server_options,
+        'server_latency_ms', remote_server_latency_ms
+    );
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+
+--------------------------------------------------------------------------------
+-- Public functions
+--------------------------------------------------------------------------------
+
+--
+-- Collect and return diagnostics info from a remote PG into a jsonb
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_Diagnostics(server TEXT)
+RETURNS jsonb
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_type name := @extschema@.__CDB_FS_server_type(server_internal);
+BEGIN
+    CASE server_type
+    WHEN 'postgres_fdw' THEN
+        RETURN @extschema@.__CDB_FS_Server_Diagnostics_PG(server_internal);
+    ELSE
+        RAISE EXCEPTION 'Not implemented server type % for remote server %', server_type, server;
+    END CASE;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_FederatedServerListRemote.sql

@@ -0,0 +1,298 @@
+--------------------------------------------------------------------------------
+-- Private functions
+--------------------------------------------------------------------------------
+
+--
+-- List the schemas of a remote PG server
+-- 
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_List_Foreign_Schemas_PG(server_internal name)
+RETURNS TABLE(remote_schema name)
+AS $$
+DECLARE
+    -- Import schemata from the information schema
+    --
+    -- "The view schemata contains all schemas in the current database
+    -- that the current user has access to (by way of being the owner
+    -- or having some privilege)."
+    -- See https://www.postgresql.org/docs/11/infoschema-schemata.html
+    --
+    -- "The information schema is defined in the SQL standard and can
+    -- therefore be expected to be portable and remain stable"
+    -- See https://www.postgresql.org/docs/11/information-schema.html
+    inf_schema name := 'information_schema';
+    remote_table name := 'schemata';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, inf_schema);
+BEGIN
+    -- Import the foreign schemata table
+    IF NOT EXISTS (
+        SELECT * FROM pg_class
+        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = local_schema)
+        AND relname = remote_table
+    ) THEN
+        EXECUTE format('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I',
+                    inf_schema, remote_table, server_internal, local_schema);
+    END IF;
+
+    -- Return the result we're interested in. Exclude toast and temp schemas
+    BEGIN
+        RETURN QUERY EXECUTE format('
+            SELECT schema_name::name AS remote_schema FROM %I.%I
+            WHERE schema_name NOT LIKE %s
+            ORDER BY remote_schema
+        ', local_schema, remote_table, '''pg_%''');
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Not enough permissions to access the server "%"',
+                        @extschema@.__CDB_FS_Extract_Server_Name(server_internal);
+    END;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- List the names of the tables in a remote PG schema
+-- 
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_List_Foreign_Tables_PG(server_internal name, remote_schema name)
+RETURNS TABLE(remote_table name)
+AS $func$
+DECLARE
+    -- Import `tables` from the information schema
+    --
+    -- "The view tables contains all tables and views defined in the
+    -- current database. Only those tables and views are shown that
+    -- the current user has access to (by way of being the owner or
+    -- having some privilege)."
+    -- https://www.postgresql.org/docs/11/infoschema-tables.html
+
+    -- Create local target schema if it does not exists
+    inf_schema name := 'information_schema';
+    remote_table name := 'tables';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, inf_schema);
+BEGIN
+    -- Import the foreign `tables` if not done
+    IF NOT EXISTS (
+        SELECT * FROM pg_class
+        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = local_schema)
+        AND relname = remote_table
+    ) THEN
+        EXECUTE format('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I',
+                    inf_schema, remote_table, server_internal, local_schema);
+    END IF;
+
+    -- Note: in this context, schema names are not to be quoted
+    RETURN QUERY EXECUTE format($q$
+        SELECT table_name::name AS remote_table FROM %I.%I WHERE table_schema = '%s' ORDER BY table_name
+        $q$, local_schema, remote_table, remote_schema);
+END
+$func$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--
+-- List the columns in a remote PG schema
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_List_Foreign_Columns_PG(server_internal name, remote_schema name)
+RETURNS TABLE(table_name name, column_name name, column_type text)
+AS $func$
+DECLARE
+    -- Import `columns` from the information schema
+    --
+    -- "The view columns contains information about all table columns (or view columns)
+    -- in the database. System columns (oid, etc.) are not included. Only those columns 
+    -- are shown that the current user has access to (by way of being the owner or having some privilege)."
+    -- https://www.postgresql.org/docs/11/infoschema-columns.html
+
+    -- Create local target schema if it does not exists
+    inf_schema name := 'information_schema';
+    remote_col_table name := 'columns';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, inf_schema);
+BEGIN
+    -- Import the foreign `columns` if not done
+    IF NOT EXISTS (
+        SELECT * FROM pg_class
+        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = local_schema)
+        AND relname = remote_col_table
+    ) THEN
+        EXECUTE format('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I',
+                    inf_schema, remote_col_table, server_internal, local_schema);
+    END IF;
+
+    -- Note: in this context, schema names are not to be quoted
+    -- We join with the geometry columns to change the type `USER-DEFINED` 
+    -- by its appropiate geometry and srid
+    RETURN QUERY EXECUTE format($q$
+        SELECT 
+            a.table_name::name,
+            a.column_name::name,
+            COALESCE(b.column_type, a.data_type)::TEXT as column_type
+        FROM
+            %I.%I a
+        LEFT JOIN
+            @extschema@.__CDB_FS_List_Foreign_Geometry_Columns_PG('%s', '%s') b
+        ON a.table_name = b.table_name AND a.column_name = b.column_name
+        WHERE table_schema = '%s'
+        ORDER BY a.table_name, a.column_name $q$,
+        local_schema, remote_col_table,
+        server_internal, remote_schema,
+        remote_schema);
+END
+$func$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- List the geometry columns in a remote PG schema
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_List_Foreign_Geometry_Columns_PG(server_internal name, remote_schema name, postgis_schema name DEFAULT 'public')
+RETURNS TABLE(table_name name, column_name name, column_type text)
+AS $func$
+DECLARE
+    -- Import `geometry_columns` and `geography_columns` from the postgis schema
+    -- We assume that postgis is installed in the public schema
+
+    -- Create local target schema if it does not exists
+    remote_geometry_view name := 'geometry_columns';
+    remote_geography_view name := 'geography_columns';
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, postgis_schema);
+BEGIN
+    -- Import the foreign `geometry_columns` and `geography_columns` if not done
+    IF NOT EXISTS (
+        SELECT * FROM pg_class
+        WHERE relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = local_schema)
+        AND relname = remote_geometry_view
+    ) THEN
+        EXECUTE format('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I, %I) FROM SERVER %I INTO %I',
+                    postgis_schema, remote_geometry_view, remote_geography_view, server_internal, local_schema);
+    END IF;
+
+    BEGIN
+    -- Note: We return both the type and srid as the type
+        RETURN QUERY EXECUTE format($q$
+            SELECT 
+                f_table_name::NAME as table_name,
+                f_geometry_column::NAME as column_name,
+                type::TEXT || ',' || srid::TEXT as column_type
+            FROM
+            (
+                SELECT * FROM %I.%I UNION ALL SELECT * FROM %I.%I
+            ) _geo_views
+            WHERE f_table_schema = '%s'
+        $q$,
+            local_schema, remote_geometry_view,
+            local_schema, remote_geography_view,
+            remote_schema);
+    EXCEPTION WHEN OTHERS THEN
+        RAISE INFO 'Could not find Postgis installation in the remote "%" schema in server "%"',
+                    postgis_schema, @extschema@.__CDB_FS_Extract_Server_Name(server_internal);
+        RETURN;
+    END;
+END
+$func$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--------------------------------------------------------------------------------
+-- Public functions
+--------------------------------------------------------------------------------
+
+--
+-- List remote schemas in a federated server that the current user has access to.
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_List_Remote_Schemas(server TEXT)
+RETURNS TABLE(remote_schema name)
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_type name := @extschema@.__CDB_FS_server_type(server_internal);
+BEGIN
+    CASE server_type
+    WHEN 'postgres_fdw' THEN
+        RETURN QUERY SELECT @extschema@.__CDB_FS_List_Foreign_Schemas_PG(server_internal);
+    ELSE
+        RAISE EXCEPTION 'Not implemented server type % for remote server %', server_type, server;
+    END CASE;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- List remote tables in a federated server that the current user has access to.
+-- For registered tables it returns also the associated configuration
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_List_Remote_Tables(server TEXT, remote_schema TEXT)
+RETURNS TABLE(
+    registered boolean,
+    remote_table TEXT,
+    local_qualified_name TEXT,
+    id_column_name TEXT,
+    geom_column_name TEXT,
+    webmercator_column_name TEXT,
+    columns JSON
+    )
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_type name := @extschema@.__CDB_FS_server_type(server_internal);
+BEGIN
+    CASE server_type
+    WHEN 'postgres_fdw' THEN
+        RETURN QUERY
+            SELECT
+                coalesce(registered_tables.registered, false)::boolean as registered,
+                foreign_tables.remote_table::text as remote_table,
+                registered_tables.local_qualified_name as local_qualified_name,
+                registered_tables.id_column_name as id_column_name,
+                registered_tables.geom_column_name as geom_column_name,
+                registered_tables.webmercator_column_name as webmercator_column_name,
+                remote_columns.columns as columns
+            FROM
+                @extschema@.__CDB_FS_List_Foreign_Tables_PG(server_internal, remote_schema) foreign_tables
+            LEFT JOIN
+                @extschema@.__CDB_FS_List_Registered_Tables(server_internal, remote_schema) registered_tables
+            ON foreign_tables.remote_table = registered_tables.remote_table
+            LEFT JOIN
+                (   -- Extract and group columns with their remote table
+                    SELECT  table_name,
+                            json_agg(json_build_object('Name', column_name, 'Type', column_type)) as columns
+                    FROM @extschema@.__CDB_FS_List_Foreign_Columns_PG(server_internal, remote_schema)
+                    GROUP BY table_name
+                ) remote_columns
+            ON foreign_tables.remote_table = remote_columns.table_name
+            ORDER BY foreign_tables.remote_table;
+    ELSE
+        RAISE EXCEPTION 'Not implemented server type % for remote server %', server_type, remote_server;
+    END CASE;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- List the columns of a remote table in a federated server that the current user has access to.
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Server_List_Remote_Columns(
+    server TEXT,
+    remote_schema TEXT,
+    remote_table TEXT)
+RETURNS TABLE(column_n name, column_t text)
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => true);
+    server_type name := @extschema@.__CDB_FS_server_type(server_internal);
+BEGIN
+    IF remote_table IS NULL THEN
+        RAISE EXCEPTION 'Remote table name cannot be NULL';
+    END IF;
+
+    CASE server_type
+    WHEN 'postgres_fdw' THEN
+        RETURN QUERY
+        SELECT 
+            column_name,
+            column_type
+        FROM @extschema@.__CDB_FS_List_Foreign_Columns_PG(server_internal, remote_schema)
+        WHERE table_name = remote_table
+        ORDER BY column_name;
+    ELSE
+        RAISE EXCEPTION 'Not implemented server type % for remote server %', server_type, remote_server;
+    END CASE;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_FederatedServerTables.sql

@@ -0,0 +1,345 @@
+--------------------------------------------------------------------------------
+-- Private functions
+--------------------------------------------------------------------------------
+
+--
+-- Checks if a column is of integer type
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Column_Is_Integer(input_table REGCLASS, colname NAME)
+RETURNS boolean
+AS $$
+BEGIN
+    PERFORM atttypid FROM pg_catalog.pg_attribute
+       WHERE attrelid = input_table
+         AND attname = colname
+         AND atttypid IN (SELECT oid FROM pg_type
+           WHERE typname IN
+             ('smallint', 'integer', 'bigint', 'int2', 'int4', 'int8'));
+    RETURN FOUND;
+END
+$$
+LANGUAGE PLPGSQL STABLE PARALLEL UNSAFE;
+
+--
+-- Checks if a column is of geometry type
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Column_Is_Geometry(input_table REGCLASS, colname NAME)
+RETURNS boolean
+AS $$
+BEGIN
+    PERFORM atttypid FROM pg_catalog.pg_attribute
+        WHERE attrelid = input_table
+           AND attname = colname
+           AND atttypid = '@postgisschema@.geometry'::regtype;
+    RETURN FOUND;
+END
+$$
+LANGUAGE PLPGSQL STABLE PARALLEL UNSAFE;
+
+--
+-- Returns the name of all the columns from a table
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_GetColumns(input_table REGCLASS)
+RETURNS SETOF NAME
+AS $$
+    SELECT
+        a.attname as "colname"
+    FROM pg_catalog.pg_attribute a
+    WHERE
+        a.attnum > 0
+            AND NOT a.attisdropped
+            AND a.attrelid = (
+                SELECT c.oid
+                FROM pg_catalog.pg_class c
+                LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                WHERE c.oid = input_table::oid
+            )
+    ORDER BY a.attnum;
+$$ LANGUAGE SQL STABLE PARALLEL UNSAFE;
+
+--
+-- Returns the id column from a view definition
+-- Note: The id is always of one of this forms:
+-- SELECT t.cartodb_id,
+-- SELECT t.my_id as cartodb_id,
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Get_View_id_column(view_def TEXT)
+RETURNS TEXT
+AS $$
+    WITH column_definitions AS
+    (
+        SELECT regexp_split_to_array(trim(leading from regexp_split_to_table(view_def, '\n')), ' ') AS col_def
+    )
+    SELECT trim(trailing ',' FROM split_part(col_def[2], '.', 2))
+    FROM column_definitions
+    WHERE trim(trailing ',' FROM col_def[array_length(col_def, 1)]) IN ('t.cartodb_id', 'cartodb_id')
+    LIMIT 1;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Returns the geom column from a view definition
+--
+-- Note: The the_geom is always of one of this forms:
+--      t.the_geom,
+--      t.my_geom as the_geom,
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Get_View_geom_column(view_def TEXT)
+RETURNS TEXT
+AS $$
+    WITH column_definitions AS
+    (
+        SELECT regexp_split_to_array(trim(leading from regexp_split_to_table(view_def, '\n')), ' ') AS col_def
+    )
+    SELECT trim(trailing ',' FROM split_part(col_def[1], '.', 2))
+    FROM column_definitions
+    WHERE trim(trailing ',' FROM col_def[array_length(col_def, 1)]) IN ('t.the_geom', 'the_geom')
+    LIMIT 1;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+--
+-- Returns the webmercatorcolumn from a view definition
+-- Note: The the_geom_webmercator is always of one of this forms:
+--      t.the_geom_webmercator,
+--      t.my_geom as the_geom_webmercator,
+-- Or without the trailing comma:
+--      t.the_geom_webmercator
+--      t.my_geom as the_geom_webmercator
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_Get_View_webmercator_column(view_def TEXT)
+RETURNS TEXT
+AS $$
+    WITH column_definitions AS
+    (
+        SELECT regexp_split_to_array(trim(leading from regexp_split_to_table(view_def, '\n')), ' ') AS col_def
+    )
+    SELECT trim(trailing ',' FROM split_part(col_def[1], '.', 2))
+    FROM column_definitions
+    WHERE trim(trailing ',' FROM col_def[array_length(col_def, 1)]) IN ('t.the_geom_webmercator', 'the_geom_webmercator')
+    LIMIT 1;
+$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
+
+
+--
+-- List all registered tables in a server + schema
+--
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_FS_List_Registered_Tables(
+    server_internal NAME,
+    remote_schema TEXT
+    )
+RETURNS TABLE(
+    registered boolean,
+    remote_table TEXT,
+    local_qualified_name TEXT,
+    id_column_name TEXT,
+    geom_column_name TEXT,
+    webmercator_column_name TEXT
+    )
+AS $$
+DECLARE
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+BEGIN
+    RETURN QUERY SELECT
+        true as registered,
+        source_table::text as remote_table,
+        format('%I.%I', dependent_schema, dependent_view)::text as local_qualified_name,
+        @extschema@.__CDB_FS_Get_View_id_column(view_definition) as id_column_name,
+        @extschema@.__CDB_FS_Get_View_geom_column(view_definition) as geom_column_name,
+        @extschema@.__CDB_FS_Get_View_webmercator_column(view_definition) as webmercator_column_name
+    FROM
+    (
+        SELECT DISTINCT
+            dependent_ns.nspname as dependent_schema,
+            dependent_view.relname as dependent_view,
+            source_table.relname as source_table,
+            pg_get_viewdef(dependent_view.oid) as view_definition
+        FROM pg_depend
+        JOIN pg_rewrite ON pg_depend.objid = pg_rewrite.oid
+        JOIN pg_class as dependent_view ON pg_rewrite.ev_class = dependent_view.oid
+        JOIN pg_class as source_table ON pg_depend.refobjid = source_table.oid
+        JOIN pg_namespace dependent_ns ON dependent_ns.oid = dependent_view.relnamespace
+        JOIN pg_namespace source_ns ON source_ns.oid = source_table.relnamespace
+        WHERE
+        source_ns.nspname = local_schema
+        ORDER BY 1,2
+    ) _aux;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--------------------------------------------------------------------------------
+-- Public functions
+--------------------------------------------------------------------------------
+
+--
+-- Sets up a Federated Table
+--
+-- Precondition: the federated server has to be set up via
+-- CDB_Federated_Server_Register_PG
+--
+-- Postcondition: it generates a view in the schema of the user that
+-- can be used through SQL and Maps API's.
+-- If the table was already exported, it will be dropped and re-imported
+--
+-- The view is placed under the server's view schema (cdb_fs_$(server_name))
+--
+-- E.g:
+-- SELECT cartodb.CDB_SetUp_PG_Federated_Table(
+--   'amazon',                  -- mandatory, name of the federated server
+--   'my_remote_schema',        -- mandatory, schema name
+--   'my_remote_table',         -- mandatory, table name
+--   'id',                      -- mandatory, name of the id column
+--   'geom',                    -- optional, name of the geom column, preferably in 4326
+--   'webmercator'              -- optional, should be in 3857 if present
+--   'local_name'               -- optional, name of the local view (uses the remote_name if not declared)
+-- );
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Table_Register(
+    server TEXT,
+    remote_schema TEXT,
+    remote_table TEXT,
+    id_column TEXT,
+    geom_column TEXT DEFAULT NULL,
+    webmercator_column TEXT DEFAULT NULL,
+    local_name NAME DEFAULT NULL
+)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => false);
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+    role_name name := @extschema@.__CDB_FS_Generate_Server_Role_Name(server_internal);
+
+    src_table REGCLASS; -- import_schema.remote_table  - import_schema is local_schema
+    local_view text;    -- view_schema.local_name      - view_schema is server_internal
+
+    rest_of_cols TEXT[];
+    geom_expression TEXT;
+    webmercator_expression TEXT;
+    carto_columns_expression TEXT[];
+BEGIN
+    IF remote_table IS NULL THEN
+        RAISE EXCEPTION 'Remote table name cannot be NULL';
+    END IF;
+
+    -- Make do with whatever columns are provided
+    IF webmercator_column IS NULL THEN
+        webmercator_column := geom_column;
+    ELSIF geom_column IS NULL THEN
+        geom_column := webmercator_column;
+    END IF;
+
+    IF local_name IS NULL THEN
+        local_name := remote_table;
+    END IF;
+
+    -- Import the foreign table
+    -- Drop the old view / table if there was one
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = local_schema AND table_name = remote_table) THEN
+        EXECUTE @extschema@.CDB_Federated_Table_Unregister(server, remote_schema, remote_table);
+    END IF;
+    BEGIN
+        EXECUTE FORMAT('IMPORT FOREIGN SCHEMA %I LIMIT TO (%I) FROM SERVER %I INTO %I;',
+                        remote_schema, remote_table, server_internal, local_schema);
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Could not import schema "%" of server "%": %', remote_schema, server, SQLERRM;
+    END;
+
+    BEGIN
+        src_table := format('%I.%I', local_schema, remote_table);
+    EXCEPTION WHEN OTHERS THEN
+        RAISE EXCEPTION 'Could not import table "%.%" of server "%"', remote_schema, remote_table, server;
+    END;
+
+    -- Check id_column is numeric
+    IF NOT @extschema@.__CDB_FS_Column_Is_Integer(src_table, id_column) THEN
+        RAISE EXCEPTION 'non integer id_column "%"', id_column;
+    END IF;
+
+    -- Check if the geom and mercator columns have a geometry type (if provided)
+    IF geom_column IS NOT NULL AND NOT @extschema@.__CDB_FS_Column_Is_Geometry(src_table, geom_column) THEN
+        RAISE EXCEPTION 'non geometry column "%"', geom_column;
+    END IF;
+    IF webmercator_column IS NOT NULL AND NOT @extschema@.__CDB_FS_Column_Is_Geometry(src_table, webmercator_column) THEN
+        RAISE EXCEPTION 'non geometry column "%"', webmercator_column;
+    END IF;
+
+    -- Get a list of columns excluding the id, geom and the_geom_webmercator
+    SELECT ARRAY(
+        SELECT quote_ident(c) FROM @extschema@.__CDB_FS_GetColumns(src_table) AS c
+        WHERE c NOT IN (SELECT * FROM (SELECT unnest(ARRAY[id_column, geom_column, webmercator_column, 'cartodb_id', 'the_geom', 'the_geom_webmercator']) col) carto WHERE carto.col IS NOT NULL)
+    ) INTO rest_of_cols;
+
+    IF geom_column IS NULL
+    THEN
+        geom_expression := 'NULL AS the_geom';
+    ELSIF @postgisschema@.Find_SRID(local_schema::varchar, remote_table::varchar, geom_column::varchar) = 4326
+    THEN
+        geom_expression := format('t.%I AS the_geom', geom_column);
+    ELSE
+        -- It needs an ST_Transform to 4326
+        geom_expression := format('@postgisschema@.ST_Transform(t.%I,4326) AS the_geom', geom_column);
+    END IF;
+
+    IF webmercator_column IS NULL
+    THEN
+        webmercator_expression := 'NULL AS the_geom_webmercator';
+    ELSIF @postgisschema@.Find_SRID(local_schema::varchar, remote_table::varchar, webmercator_column::varchar) = 3857
+    THEN
+        webmercator_expression := format('t.%I AS the_geom_webmercator', webmercator_column);
+    ELSE
+        -- It needs an ST_Transform to 3857
+        webmercator_expression := format('@postgisschema@.ST_Transform(t.%I,3857) AS the_geom_webmercator', webmercator_column);
+    END IF;
+
+    -- CARTO columns expressions
+    carto_columns_expression := ARRAY[
+        format('t.%1$I AS cartodb_id', id_column),
+        geom_expression,
+        webmercator_expression
+    ];
+
+    -- Create view schema if it doesn't exist
+    IF NOT EXISTS (SELECT oid FROM pg_namespace WHERE nspname = server_internal) THEN
+        EXECUTE 'CREATE SCHEMA ' || quote_ident(server_internal) || ' AUTHORIZATION ' || quote_ident(role_name);
+    END IF;
+
+    -- Create a view with homogeneous CDB fields
+    BEGIN
+        EXECUTE format(
+            'CREATE OR REPLACE VIEW %1$I.%2$I AS
+                SELECT %3s
+                FROM %4$s t',
+            server_internal, local_name,
+            array_to_string(carto_columns_expression || rest_of_cols, ','),
+            src_table
+        );
+    EXCEPTION WHEN OTHERS THEN
+        IF EXISTS (SELECT to_regclass(format('%1$I.%2$I', server_internal, local_name))) THEN
+            RAISE EXCEPTION 'Could not import table "%" as "%.%" already exists', remote_table, server_internal, local_name;
+        ELSE
+            RAISE EXCEPTION 'Could not import table "%" as "%": %', remote_table, local_name, SQLERRM;
+        END IF;
+    END;
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+--
+-- Unregisters a remote table. Any dependent object will be dropped
+--
+CREATE OR REPLACE FUNCTION @extschema@.CDB_Federated_Table_Unregister(
+    server TEXT,
+    remote_schema TEXT,
+    remote_table TEXT
+)
+RETURNS void
+AS $$
+DECLARE
+    server_internal name := @extschema@.__CDB_FS_Generate_Server_Name(input_name => server, check_existence => false);
+    local_schema name := @extschema@.__CDB_FS_Create_Schema(server_internal, remote_schema);
+BEGIN
+    EXECUTE FORMAT ('DROP FOREIGN TABLE %I.%I CASCADE;', local_schema, remote_table);
+END
+$$
+LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_ForeignTable.sql

@@ -125,7 +125,14 @@ BEGIN
 
   -- We assume that the remote cdb_tablemetadata is called cdb_tablemetadata and is on the same schema as the queried table.
   SELECT nspname FROM pg_class c, pg_namespace n WHERE c.oid=foreign_table AND c.relnamespace = n.oid INTO fdw_schema_name;
-  EXECUTE FORMAT('SELECT updated_at FROM %I.cdb_tablemetadata WHERE tabname=%L ORDER BY updated_at DESC LIMIT 1', fdw_schema_name, remote_table_name) INTO time;
+  BEGIN
+    EXECUTE FORMAT('SELECT updated_at FROM %I.cdb_tablemetadata WHERE tabname=%L ORDER BY updated_at DESC LIMIT 1', fdw_schema_name, remote_table_name) INTO time;
+  EXCEPTION
+    WHEN undefined_table THEN
+      -- If you add a GET STACKED DIAGNOSTICS text_var = RETURNED_SQLSTATE
+      -- you get a code 42P01 which corresponds to undefined_table
+      RAISE NOTICE 'CDB_Get_Foreign_Updated_At: could not find %.cdb_tablemetadata while checking % updated_at, returning NULL timestamp', fdw_schema_name, foreign_table;
+  END;
   RETURN time;
 END
 $$
@@ -197,3 +204,12 @@ RETURNS timestamptz AS $$
         LEFT JOIN pg_catalog.pg_class c ON c.oid = reloid
     ) SELECT max(updated_at) FROM t_updated_at;
 $$ LANGUAGE SQL VOLATILE PARALLEL UNSAFE;
+
+
+--------------------------------------------------------------------------------
+-- Deprecated
+--------------------------------------------------------------------------------
+DROP FUNCTION IF EXISTS @extschema@.__CDB_User_FDW_Object_Names(name);
+DROP FUNCTION IF EXISTS @extschema@._CDB_SetUp_User_PG_FDW_Server(name, json);
+DROP FUNCTION IF EXISTS @extschema@._CDB_Drop_User_PG_FDW_Server(name, boolean);
+DROP FUNCTION IF EXISTS @extschema@.CDB_SetUp_User_PG_FDW_Table(name, name, name);

scripts-available/CDB_GhostTables.sql

@@ -32,7 +32,6 @@ AS $$
           client = redis.Redis(host=tis_host, port=tis_port, socket_timeout=tis_timeout)
           GD['invalidation'] = client
         except Exception as err:
-          error = "client_error - %s" % str(err)
           # NOTE: no retries on connection error
           plpy.warning('Error trying to connect to Invalidation Service to link Ghost Tables: ' +  str(err))
           break
@@ -41,13 +40,12 @@ AS $$
       client.execute_command('DBSCH', db_name, username, event_name)
       break
     except Exception as err:
-      error = "request_error - %s" % str(err)
       client = GD['invalidation'] = None # force reconnect
       if not tis_retry:
         plpy.warning('Error calling Invalidation Service to link Ghost Tables: ' +  str(err))
         break
       tis_retry -= 1 # try reconnecting
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE;
+$$ LANGUAGE '@@plpythonu@@' VOLATILE PARALLEL UNSAFE;
 
 -- Enqueues a job to run Ghost tables linking process for the current user
 CREATE OR REPLACE FUNCTION @extschema@.CDB_LinkGhostTables(event_name text DEFAULT 'USER')
@@ -61,9 +59,13 @@ AS $$
     EXECUTE 'SELECT current_database();' INTO db_name;
 
     PERFORM @extschema@._CDB_LinkGhostTables(username, db_name, event_name);
-    RAISE NOTICE '_CDB_LinkGhostTables() called with username=%, event_name=%', username, event_name;
+    RAISE INFO '_CDB_LinkGhostTables() called with username=%, event_name=%', username, event_name;
   END;
-$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 -- Trigger function to call CDB_LinkGhostTables()
 CREATE OR REPLACE FUNCTION @extschema@._CDB_LinkGhostTablesTrigger()
@@ -76,16 +78,24 @@ AS $$
     PERFORM @extschema@.CDB_LinkGhostTables(ddl_tag);
     RETURN NULL;
   END;
-$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 -- Event trigger to save the current transaction in @extschema@.cdb_ddl_execution
 CREATE OR REPLACE FUNCTION @extschema@.CDB_SaveDDLTransaction()
 RETURNS event_trigger
 AS $$
   BEGIN
-    INSERT INTO @extschema@.cdb_ddl_execution VALUES (txid_current(), tg_tag) ON CONFLICT (txid) DO NOTHING;
+    INSERT INTO @extschema@.cdb_ddl_execution VALUES (txid_current(), tg_tag) ON CONFLICT ON CONSTRAINT cdb_ddl_execution_pkey DO NOTHING;
   END;
-$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 -- Creates the trigger on DDL events to link ghost tables
 CREATE OR REPLACE FUNCTION @extschema@.CDB_EnableGhostTablesTrigger()
@@ -96,7 +106,7 @@ AS $$
     DROP TRIGGER IF EXISTS check_ddl_update ON @extschema@.cdb_ddl_execution;
 
     -- Table to store the transaction id from DDL events to avoid multiple executions
-    CREATE TABLE IF NOT EXISTS @extschema@.cdb_ddl_execution(txid integer PRIMARY KEY, tag text);
+    CREATE TABLE IF NOT EXISTS @extschema@.cdb_ddl_execution(txid bigint PRIMARY KEY, tag text);
 
     CREATE CONSTRAINT TRIGGER check_ddl_update
     AFTER INSERT ON @extschema@.cdb_ddl_execution
@@ -106,7 +116,33 @@ AS $$
 
     CREATE EVENT TRIGGER link_ghost_tables
     ON ddl_command_end
-    WHEN TAG IN ('CREATE TABLE', 'SELECT INTO', 'DROP TABLE', 'ALTER TABLE', 'CREATE TRIGGER', 'DROP TRIGGER', 'CREATE VIEW', 'DROP VIEW', 'ALTER VIEW')
+    WHEN TAG IN ('CREATE TABLE',
+                'SELECT INTO',
+                'DROP TABLE',
+                'ALTER TABLE',
+
+                'CREATE TRIGGER',
+                'DROP TRIGGER',
+                'ALTER TRIGGER',
+
+                'CREATE VIEW',
+                'DROP VIEW',
+                'ALTER VIEW',
+
+                'CREATE FOREIGN TABLE',
+                'ALTER FOREIGN TABLE',
+                'DROP FOREIGN TABLE',
+
+                'ALTER MATERIALIZED VIEW',
+                'CREATE MATERIALIZED VIEW',
+                'DROP MATERIALIZED VIEW',
+
+                'IMPORT FOREIGN SCHEMA',
+
+                'DROP EXTENSION',
+                'DROP SCHEMA',
+                'DROP SERVER',
+                'DROP TYPE')
     EXECUTE PROCEDURE @extschema@.CDB_SaveDDLTransaction();
   END;
 $$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_Groups_API.sql

@@ -5,7 +5,6 @@
 -- Requires configuration parameter. Example: SELECT @extschema@.CDB_Conf_SetConf('groups_api', '{ "host": "127.0.0.1", "port": 3000, "timeout": 10, "username": "extension", "password": "elephant" }');
 ----------------------------------
 
--- TODO: delete this development cleanup before final merge
 DROP FUNCTION IF EXISTS @extschema@.CDB_Group_AddMember(group_name text, username text);
 DROP FUNCTION IF EXISTS @extschema@.CDB_Group_RemoveMember(group_name text, username text);
 DROP FUNCTION IF EXISTS @extschema@._CDB_Group_AddMember_API(group_name text, username text);
@@ -22,59 +21,91 @@ $$
     body = '{ "name": "%s", "database_role": "%s" }' % (group_name, group_role)
     query = "select @extschema@._CDB_Group_API_Request('POST', '%s', '%s', '{200, 409}') as response_status" % (url, body)
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_DropGroup_API(group_name text)
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s' % (urllib.pathname2url(group_name))
+    url = '/api/v1/databases/{0}/groups/%s' % (pathname2url(group_name))
 
     query = "select @extschema@._CDB_Group_API_Request('DELETE', '%s', '', '{204, 404}') as response_status" % url
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_RenameGroup_API(old_group_name text, new_group_name text, new_group_role text)
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s' % (urllib.pathname2url(old_group_name))
+    url = '/api/v1/databases/{0}/groups/%s' % (pathname2url(old_group_name))
     body = '{ "name": "%s", "database_role": "%s" }' % (new_group_name, new_group_role)
     query = "select @extschema@._CDB_Group_API_Request('PUT', '%s', '%s', '{200, 409}') as response_status" % (url, body)
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_AddUsers_API(group_name text, usernames text[])
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s/users' % (urllib.pathname2url(group_name))
+    url = '/api/v1/databases/{0}/groups/%s/users' % (pathname2url(group_name))
     body = "{ \"users\": [\"%s\"] }" % "\",\"".join(usernames)
     query = "select @extschema@._CDB_Group_API_Request('POST', '%s', '%s', '{200, 409}') as response_status" % (url, body)
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_RemoveUsers_API(group_name text, usernames text[])
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s/users' % (urllib.pathname2url(group_name))
+    url = '/api/v1/databases/{0}/groups/%s/users' % (pathname2url(group_name))
     body = "{ \"users\": [\"%s\"] }" % "\",\"".join(usernames)
     query = "select @extschema@._CDB_Group_API_Request('DELETE', '%s', '%s', '{200, 404}') as response_status" % (url, body)
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 DO LANGUAGE 'plpgsql' $$
 BEGIN
@@ -89,13 +120,20 @@ FUNCTION @extschema@._CDB_Group_Table_GrantPermission_API(group_name text, usern
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (urllib.pathname2url(group_name), username, table_name)
+    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (pathname2url(group_name), username, table_name)
     body = '{ "access": "%s" }' % access
     query = "select @extschema@._CDB_Group_API_Request('PUT', '%s', '%s', '{200, 409}') as response_status" % (url, body)
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 DO LANGUAGE 'plpgsql' $$
 BEGIN
@@ -110,12 +148,19 @@ FUNCTION @extschema@._CDB_Group_Table_RevokeAllPermission_API(group_name text, u
     RETURNS VOID AS
 $$
     import string
-    import urllib
+    try:
+        from urllib import pathname2url
+    except:
+        from urllib.request import pathname2url
 
-    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (urllib.pathname2url(group_name), username, table_name)
+    url = '/api/v1/databases/{0}/groups/%s/permission/%s/tables/%s' % (pathname2url(group_name), username, table_name)
     query = "select @extschema@._CDB_Group_API_Request('DELETE', '%s', '', '{200, 404}') as response_status" % url
     plpy.execute(query)
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE '@@plpythonu@@'
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 DO LANGUAGE 'plpgsql' $$
 BEGIN
@@ -146,22 +191,36 @@ $$
       params = json.loads(conf)
       auth = 'Basic %s' % plpy.execute("SELECT @extschema@._CDB_Group_API_Auth('%s', '%s') as auth" % (params['username'], params['password']))[0]['auth']
       return { "host": params['host'], "port": params['port'], 'timeout': params['timeout'], 'auth': auth }
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE;
+$$ LANGUAGE '@@plpythonu@@' VOLATILE PARALLEL UNSAFE;
 
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_API_Auth(username text, password text)
     RETURNS TEXT AS
 $$
+    import sys
     import base64
-    return base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE;
+
+    data_to_encode = '%s:%s' % (username, password)
+    if sys.version_info[0] < 3:
+      data_encoded = base64.encodestring(data_to_encode)
+    else:
+      data_encoded = base64.b64encode(data_to_encode.encode()).decode()
+
+    data_encoded = data_encoded.replace('\n', '')
+    return data_encoded
+$$ LANGUAGE '@@plpythonu@@' VOLATILE PARALLEL UNSAFE;
 
 -- url must contain a '%s' placeholder that will be replaced by current_database, for security reasons.
 CREATE OR REPLACE
 FUNCTION @extschema@._CDB_Group_API_Request(method text, url text, body text, valid_return_codes int[])
     RETURNS int AS
 $$
-    import httplib
+    python_v2 = True
+    try:
+      import httplib as client
+    except:
+      from http import client
+      python_v2 = False
 
     params = plpy.execute("select c.host, c.port, c.timeout, c.auth from @extschema@._CDB_Group_API_Conf() c;")[0]
     if params['host'] is None:
@@ -174,22 +233,25 @@ $$
     last_err = None
     while retry > 0:
       try:
-        client = SD['groups_api_client'] = httplib.HTTPConnection(params['host'], params['port'], False, params['timeout'])
+        if python_v2:
+          conn = SD['groups_api_client'] = client.HTTPConnection(params['host'], params['port'], False, params['timeout'])
+        else:
+          conn = SD['groups_api_client'] = client.HTTPConnection(params['host'], port=params['port'], timeout=params['timeout'])
         database_name = plpy.execute("select current_database();")[0]['current_database']
-        client.request(method, url.format(database_name), body, headers)
-        response = client.getresponse()
+        conn.request(method, url.format(database_name), body, headers)
+        response = conn.getresponse()
         assert response.status in valid_return_codes
         return response.status
       except Exception as err:
         retry -= 1
         last_err = err
         plpy.warning('Retrying after: ' + str(err))
-        client = SD['groups_api_client'] = None
+        conn = SD['groups_api_client'] = None
 
     if last_err is not None:
       plpy.error('Fatal Group API error: ' + str(last_err))
       raise last_err
 
     return None
-$$ LANGUAGE 'plpythonu' VOLATILE PARALLEL UNSAFE;
+$$ LANGUAGE '@@plpythonu@@' VOLATILE PARALLEL UNSAFE;
 revoke all on function @extschema@._CDB_Group_API_Request(text, text, text, int[]) from public;

scripts-available/CDB_OAuth.sql

@@ -0,0 +1,65 @@
+-- Function that reassign the owner of a table to their ownership_role
+CREATE OR REPLACE FUNCTION @extschema@.CDB_OAuthReassignTableOwnerOnCreation()
+  RETURNS event_trigger
+  AS $$
+DECLARE
+    obj record;
+    owner_role text;
+    creator_role text;
+BEGIN
+    FOR obj IN SELECT * FROM pg_event_trigger_ddl_commands()
+    LOOP
+      RAISE DEBUG '% ddl object: % % % %',
+                  tg_tag,
+                  obj.command_tag,
+                  obj.object_type,
+                  obj.schema_name,
+                  obj.object_identity;
+      IF obj.object_type = 'function' THEN
+        SELECT rolname FROM pg_proc JOIN pg_roles ON proowner = pg_roles.oid WHERE pg_proc.oid = obj.objid INTO creator_role;
+      ELSE
+	      SELECT rolname FROM pg_class JOIN pg_roles ON relowner = pg_roles.oid WHERE pg_class.oid = obj.objid INTO creator_role;
+      END IF;
+      SELECT value->>'ownership_role_name' from @extschema@.CDB_Conf_GetConf('api_keys_' || quote_ident(creator_role)) value INTO owner_role;
+      IF owner_role IS NULL OR owner_role = '' THEN
+        RAISE DEBUG 'owner_role not found';
+        CONTINUE;
+      ELSE
+        EXECUTE 'ALTER ' || obj.object_type || ' ' || obj.object_identity || ' OWNER TO ' || quote_ident(owner_role);
+        IF obj.object_type = 'function' THEN
+          EXECUTE 'GRANT ALL ON FUNCTION ' || obj.object_identity || ' TO ' || QUOTE_IDENT(creator_role);
+        ELSE
+          EXECUTE 'GRANT ALL ON ' || obj.object_identity || ' TO ' || QUOTE_IDENT(creator_role);
+        END IF;        
+        RAISE DEBUG 'Changing ownership from % to %', creator_role, owner_role;
+      END IF;
+    END LOOP;
+END;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
+
+-- Creates the trigger on DDL events in order to reassign the owner
+CREATE OR REPLACE FUNCTION @extschema@.CDB_EnableOAuthReassignTablesTrigger()
+RETURNS void
+AS $$
+  BEGIN
+    DROP EVENT TRIGGER IF EXISTS oauth_reassign_tables_trigger;
+
+    CREATE EVENT TRIGGER oauth_reassign_tables_trigger
+    ON ddl_command_end
+    WHEN TAG IN ('CREATE TABLE', 'CREATE TABLE AS', 'SELECT INTO', 'CREATE VIEW', 'CREATE FOREIGN TABLE', 'CREATE MATERIALIZED VIEW', 'CREATE SEQUENCE', 'CREATE FUNCTION')
+    EXECUTE PROCEDURE @extschema@.CDB_OAuthReassignTableOwnerOnCreation();
+  END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;
+
+-- Deletes the trigger on DDL events in order to reassign the owner
+CREATE OR REPLACE FUNCTION @extschema@.CDB_DisableOAuthReassignTablesTrigger()
+RETURNS void
+AS $$
+  BEGIN
+    DROP EVENT TRIGGER IF EXISTS oauth_reassign_tables_trigger;
+  END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_Organizations.sql

@@ -6,6 +6,13 @@ AS $$
 $$
 LANGUAGE SQL STABLE PARALLEL SAFE;
 
+
+----- ########################## WARNING ##########################
+----- The code below creates a new role for the organization but
+----- only when the extension is INSTALLED in a database, i.e. it
+----- won't work if you clone a database that has it installed.
+----- If you do, you need to update the extension to next and back
+----- ########################## WARNING ##########################
 DO LANGUAGE 'plpgsql' $$
 DECLARE
     cdb_org_member_role_name TEXT;
@@ -38,6 +45,12 @@ AS $$
 $$
 LANGUAGE SQL STABLE PARALLEL SAFE;
 
+----- ########################## WARNING ##########################
+----- The code below creates a new role for the organization but
+----- only when the extension is INSTALLED in a database, i.e. it
+----- won't work if you clone a database that has it installed.
+----- If you do, you need to update the extension to next and back
+----- ########################## WARNING ##########################
 -- Administrator role creation on extension install
 DO LANGUAGE 'plpgsql' $$
 DECLARE
@@ -169,3 +182,10 @@ BEGIN
     EXECUTE 'SELECT @extschema@.CDB_Organization_Remove_Access_Permission(''' || from_schema || ''', ''' || table_name || ''', ''' || @extschema@.CDB_Organization_Member_Group_Role_Member_Name() || ''');';
 END
 $$ LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
+
+
+--------------------------------------------------------------------------------
+-- Deprecated
+--------------------------------------------------------------------------------
+DROP FUNCTION IF EXISTS @extschema@.CDB_Organization_Grant_Role(name);
+DROP FUNCTION IF EXISTS @extschema@.CDB_Organization_Revoke_Role(name);

scripts-available/CDB_Overviews.sql

@@ -318,7 +318,7 @@ $$ LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE;
 -- This function is declared SECURITY DEFINER so it executes with the privileges
 -- of the function creator to have a chance to alter the privileges of the
 -- overview table to match those of the dataset. It will only perform any change
--- if the overview table belgons to the same scheme as the dataset and it
+-- if the overview table belongs to the same scheme as the dataset and it
 -- matches the scheme naming for overview tables.
 CREATE OR REPLACE FUNCTION @extschema@._CDB_Register_Overview(dataset REGCLASS, overview_table REGCLASS, overview_z INTEGER)
 RETURNS VOID
@@ -362,7 +362,11 @@ AS $$
       -- it should be done here (CDB_Overviews would consume such metadata)
     END IF;
   END
-$$ LANGUAGE PLPGSQL VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE PLPGSQL
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 -- Dataset attributes (column names other than the
 -- CartoDB primary key and geometry columns) which should be aggregated
@@ -393,7 +397,7 @@ DECLARE
   attr_list TEXT;
 BEGIN
   SELECT string_agg(s.c, ',') FROM (
-    SELECT * FROM @extschema@._CDB_Aggregable_Attributes(reloid) c
+    SELECT @extschema@._CDB_Aggregable_Attributes(reloid)::text c
   ) AS s INTO attr_list;
 
   RETURN attr_list;
@@ -550,7 +554,7 @@ DECLARE
 BEGIN
   SELECT string_agg(@extschema@._CDB_Attribute_Aggregation_Expression(reloid, s.c, table_alias) || Format(' AS %s', s.c), ',')
   FROM (
-    SELECT * FROM @extschema@._CDB_Aggregable_Attributes(reloid) c
+    SELECT @extschema@._CDB_Aggregable_Attributes(reloid)::text c
   ) AS s INTO attr_list;
 
   RETURN attr_list;
@@ -658,7 +662,7 @@ AS $$
       offset_y := Format('%2$s/2 - MOD((%1$s)::numeric, (%2$s)::numeric)::float8', cell_y, pixel_m);
     END IF;
 
-    point_geom := Format('ST_SetSRID(ST_MakePoint(%1$s + %3$s, %2$s + %4$s), 3857)', cell_x, cell_y, offset_x, offset_y);
+    point_geom := Format('@postgisschema@.ST_SetSRID(@postgisschema@.ST_MakePoint(%1$s + %3$s, %2$s + %4$s), 3857)', cell_x, cell_y, offset_x, offset_y);
 
     -- compute the resulting columns in the same order as in the base table
     WITH cols AS (
@@ -669,7 +673,7 @@ AS $$
           Format('@postgisschema@.ST_Transform(%s, 4326) AS the_geom', point_geom)
         WHEN 'the_geom_webmercator' THEN
            Format('%s AS the_geom_webmercator', point_geom)
-        ELSE c
+        ELSE c::text
         END AS column
         FROM @extschema@.CDB_ColumnNames(reloid) c
     )
@@ -796,7 +800,7 @@ AS $$
           '@postgisschema@.ST_Transform(@postgisschema@.ST_SetSRID(@postgisschema@.ST_MakePoint(_sum_of_x/n, _sum_of_y/n), 3857), 4326) AS the_geom'
         WHEN 'the_geom_webmercator' THEN
           '@postgisschema@.ST_SetSRID(@postgisschema@.ST_MakePoint(_sum_of_x/n, _sum_of_y/n), 3857) AS the_geom_webmercator'
-        ELSE c
+        ELSE c::text
         END AS column
         FROM CDB_ColumnNames(reloid) c
     )
@@ -920,7 +924,7 @@ AS $$
       SELECT
         CASE c
         WHEN 'cartodb_id' THEN 'cartodb_id'
-        ELSE c
+        ELSE c::text
         END AS column
         FROM @extschema@.CDB_ColumnNames(reloid) c
     )

scripts-available/CDB_QueryStatements.sql

@@ -11,4 +11,4 @@ RETURNS SETOF TEXT AS $$
     cleaned = match[0].strip()
     if ( cleaned ):
       yield cleaned
-$$ language 'plpythonu' IMMUTABLE STRICT PARALLEL SAFE;
+$$ language '@@plpythonu@@' IMMUTABLE STRICT PARALLEL SAFE;

scripts-available/CDB_Quota.sql

@@ -20,33 +20,50 @@ RETURNS bigint AS
 $$
 DECLARE
   total_size INT8;
+  raster_available BOOLEAN;
+  raster_read_query TEXT;
 BEGIN
+  -- Postgis 3+ might not install raster
+  raster_available := EXISTS (
+        SELECT 1
+        FROM   pg_views
+        WHERE  schemaname = '@postgisschema@'
+        AND    viewname = 'raster_overviews'
+   );
+
+   IF raster_available THEN
+       raster_read_query := Format('SELECT o_table_name, r_table_name FROM @postgisschema@.raster_overviews
+                        WHERE o_table_schema = %L AND o_table_catalog = current_database()', schema_name);
+   ELSE
+       raster_read_query := 'SELECT NULL::text AS o_table_name, NULL::text AS r_table_name';
+   END IF;
+   EXECUTE Format('
   WITH raster_tables AS (
-    SELECT o_table_name, r_table_name FROM raster_overviews
-      WHERE o_table_schema = schema_name AND o_table_catalog = current_database()
+    %s
   ),
   user_tables AS (
-    SELECT table_name FROM @extschema@._CDB_NonAnalysisTablesInSchema(schema_name)
+    SELECT table_name FROM @extschema@._CDB_NonAnalysisTablesInSchema(%L)
   ),
   table_cat AS (
     SELECT
       table_name,
       (
         EXISTS(select * from raster_tables where o_table_name = table_name)
-        OR table_name SIMILAR TO @extschema@._CDB_OverviewTableDiscriminator() || '[\w\d]*'
+        OR table_name SIMILAR TO @extschema@._CDB_OverviewTableDiscriminator() || ''[\w\d]*''
       ) AS is_overview,
       EXISTS(SELECT * FROM raster_tables WHERE r_table_name = table_name) AS is_raster
     FROM user_tables
   ),
   sizes AS (
-    SELECT COALESCE(INT8(SUM(@extschema@._CDB_total_relation_size(schema_name, table_name)))) table_size,
+    SELECT COALESCE(INT8(SUM(@extschema@._CDB_total_relation_size(%L, table_name)))) table_size,
       CASE
         WHEN is_overview THEN 0
 	WHEN is_raster THEN 1
 	ELSE 0.5 -- Division by 2 is for not counting the_geom_webmercator
       END AS multiplier FROM table_cat GROUP BY is_overview, is_raster
   )
-  SELECT sum(table_size*multiplier)::int8 INTO total_size FROM sizes;
+  SELECT sum(table_size*multiplier)::int8 FROM sizes
+  ', raster_read_query, schema_name, schema_name) INTO total_size;
 
   IF total_size IS NOT NULL THEN
     RETURN total_size;

scripts-available/CDB_SyncTable.sql

@@ -0,0 +1,167 @@
+/*
+   Gets the column names of a given table.
+
+   Sample usage:
+
+     SELECT @extschema@._CDB_GetColumns('public.films');
+*/
+CREATE OR REPLACE FUNCTION @extschema@._CDB_GetColumns(src_table REGCLASS)
+RETURNS SETOF NAME
+AS $$
+  SELECT
+    a.attname as "colname"
+  FROM
+    pg_catalog.pg_attribute a
+  WHERE
+    a.attnum > 0
+      AND NOT a.attisdropped
+      AND a.attrelid = (
+        SELECT c.oid
+          FROM pg_catalog.pg_class c
+          LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+          WHERE c.oid = src_table::oid
+            AND pg_catalog.pg_table_is_visible(c.oid)
+      )
+  ORDER BY a.attnum;
+$$ LANGUAGE sql STABLE PARALLEL UNSAFE;
+
+
+/*
+    Given an array of quoted column names, it generates an UPDATE SET
+    clause with the following form:
+
+        the_geom = changed.the_geom,
+        id = changed.id,
+        elevation = changed.elevation
+
+    Example of usage:
+
+       SELECT @extschema@.__CDB_GetUpdateSetClause('{the_geom, id, elevation}', 'changed');
+*/
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_GetUpdateSetClause(colnames TEXT[], update_source TEXT)
+RETURNS TEXT
+AS $$
+DECLARE
+  set_clause_list TEXT[];
+  col TEXT;
+BEGIN
+  FOREACH col IN ARRAY colnames
+  LOOP
+    set_clause_list := array_append(set_clause_list, format('%1$s = %2$s.%1$s', col, update_source));
+  END lOOP;
+  RETURN array_to_string(set_clause_list, ', ');
+END;
+$$ LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
+
+
+/*
+    Given a prefix, generate a safe unique NAME for a temp table.
+
+    Example of usage:
+
+       SELECT @extschema@.__CDB_GenerateUniqueName('src_sync'); --> src_sync_718794_120106
+
+*/
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_GenerateUniqueName(prefix TEXT)
+RETURNS NAME
+AS $$
+  SELECT format('%s_%s_%s', prefix, txid_current(), (random()*1000000)::int)::NAME;
+$$ LANGUAGE sql VOLATILE PARALLEL UNSAFE;
+
+/*
+    Given a table name and an array of column names,
+    return array of column names qualified with the table name and quoted when necessary
+    tablename and colnames should be properly quoted, and for this reason the type NAME is not
+    used for them (with quotes they could exceed the maximum identifier length)
+
+    Example of usage:
+
+       SELECT @extschema@.__CDB_QualifyColumns('t', ARRAY['a','"b-1"']); --> ARRAY['t.a','t."b-1"']
+
+*/
+CREATE OR REPLACE FUNCTION @extschema@.__CDB_QualifyColumns(tablename NAME, colnames NAME[]) RETURNS TEXT[] AS
+$$
+    SELECT array_agg(tablename || '.' || _colname) from unnest(colnames) _colname;
+$$ LANGUAGE sql IMMUTABLE PARALLEL SAFE;
+
+/*
+   A Table Syncer
+
+   Assumptions:
+     - Both tables contain a consistent cartodb_id column
+     - Destination table has all columns of the source or does not exist
+
+   Sample usage:
+
+     SELECT CDB_SyncTable('radar_stations', 'public', 'syncdest');
+     SELECT CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest', '{the_geom, the_geom_webmercator}');
+
+*/
+CREATE OR REPLACE FUNCTION @extschema@.CDB_SyncTable(src_table REGCLASS, dst_schema REGNAMESPACE, dst_table NAME, skip_cols NAME[] = '{}')
+RETURNS void
+AS $$
+DECLARE
+  fq_dest_table TEXT;
+
+  colnames TEXT[];
+  dst_colnames TEXT;
+  src_colnames TEXT;
+
+  update_set_clause TEXT;
+
+  num_rows BIGINT;
+  err_context text;
+
+  t timestamptz;
+BEGIN
+  -- If the destination table does not exist, just copy the source table
+  fq_dest_table := format('%s.%I', dst_schema, dst_table);
+  EXECUTE format('CREATE TABLE IF NOT EXISTS %s as TABLE %s', fq_dest_table, src_table);
+  GET DIAGNOSTICS num_rows = ROW_COUNT;
+  IF num_rows > 0 THEN
+    RAISE NOTICE 'INSERTED % row(s)', num_rows;
+    RETURN;
+  END IF;
+
+  skip_cols := skip_cols || '{cartodb_id}';
+
+  -- Get the list of columns from the source table, excluding skip_cols
+  SELECT ARRAY(SELECT quote_ident(c) FROM @extschema@._CDB_GetColumns(src_table) as c EXCEPT SELECT unnest(skip_cols)) INTO colnames;
+
+  -- Deal with deleted rows: ids in dest but not in source
+  t := clock_timestamp();
+  EXECUTE format(
+    'DELETE FROM %1$s _dst WHERE NOT EXISTS (SELECT * FROM %2$s _src WHERE _src.cartodb_id=_dst.cartodb_id)',
+    fq_dest_table, src_table);
+  GET DIAGNOSTICS num_rows = ROW_COUNT;
+  RAISE NOTICE 'DELETED % row(s)', num_rows;
+  RAISE DEBUG 'DELETE time (s): %', clock_timestamp() - t;
+
+  -- Deal with inserted rows: ids in source but not in dest
+  t := clock_timestamp();
+  EXECUTE format('
+      INSERT INTO %1$s(cartodb_id, %2$s)
+      SELECT cartodb_id, %2$s FROM %3$s _src WHERE NOT EXISTS (SELECT * FROM %1$s _dst WHERE _src.cartodb_id=_dst.cartodb_id)
+  ', fq_dest_table, array_to_string(colnames, ','), src_table);
+  GET DIAGNOSTICS num_rows = ROW_COUNT;
+  RAISE NOTICE 'INSERTED % row(s)', num_rows;
+  RAISE DEBUG 'INSERT time (s): %', clock_timestamp() - t;
+
+  -- Deal with modified rows: ids in source and dest but different hashes
+  t := clock_timestamp();
+  update_set_clause :=  @extschema@.__CDB_GetUpdateSetClause(colnames, '_changed');
+  dst_colnames := array_to_string(@extschema@.__CDB_QualifyColumns('_dst', colnames), ',');
+  src_colnames := array_to_string(@extschema@.__CDB_QualifyColumns('_src', colnames), ',');
+  EXECUTE format('
+      UPDATE %1$s _update SET %2$s
+      FROM (
+        SELECT _src.* FROM %3$s _src JOIN %1$s _dst ON (_dst.cartodb_id = _src.cartodb_id)
+        WHERE  md5(ROW(%4$s)::text) <> md5(ROW(%5$s)::text)
+      ) _changed
+      WHERE _update.cartodb_id = _changed.cartodb_id;
+  ', fq_dest_table, update_set_clause, src_table, dst_colnames, src_colnames);
+  GET DIAGNOSTICS num_rows = ROW_COUNT;
+  RAISE NOTICE 'MODIFIED % row(s)', num_rows;
+  RAISE DEBUG 'UPDATE time (s): %', clock_timestamp() - t;
+END;
+$$ LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE;

scripts-available/CDB_TableMetadata.sql

@@ -43,7 +43,7 @@ BEGIN
   );
 
   WITH nv as (
-    SELECT TG_RELID as tabname, NOW() as t
+    SELECT TG_RELID as tabname, now() as t
   ), updated as (
     UPDATE @extschema@.CDB_TableMetadata x SET updated_at = nv.t
     FROM nv WHERE x.tabname = nv.tabname
@@ -55,8 +55,11 @@ BEGIN
 
   RETURN NULL;
 END;
-$$
-LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 --
 -- Trigger invalidating varnish whenever CDB_TableMetadata
@@ -116,8 +119,11 @@ BEGIN
 
   RETURN NULL;
 END;
-$$
-LANGUAGE plpgsql VOLATILE PARALLEL UNSAFE SECURITY DEFINER;
+$$  LANGUAGE plpgsql
+    VOLATILE
+    PARALLEL UNSAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;
 
 DROP TRIGGER IF EXISTS table_modified ON @extschema@.CDB_TableMetadata;
 -- NOTE: on DELETE we would be unable to convert the table

scripts-available/CDB_Username.sql

@@ -2,5 +2,9 @@
 CREATE OR REPLACE FUNCTION @extschema@.CDB_Username()
 RETURNS text
 AS $$
-  SELECT @extschema@.CDB_Conf_GetConf(CONCAT('api_keys_', session_user))->>'username';
-$$ LANGUAGE SQL STABLE PARALLEL SAFE SECURITY DEFINER;
+  SELECT @extschema@.CDB_Conf_GetConf(concat('api_keys_', session_user))->>'username';
+$$  LANGUAGE SQL
+    STABLE
+    PARALLEL SAFE
+    SECURITY DEFINER
+    SET search_path = pg_temp;

scripts-enabled/300-CDB_OAuth.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_OAuth.sql

scripts-enabled/400-CDB_FederatedServer.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_FederatedServer.sql

scripts-enabled/401_CDB_FederatedServerTables.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_FederatedServerTables.sql

scripts-enabled/402_CDB_FederatedServerListRemote.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_FederatedServerListRemote.sql

scripts-enabled/403-CDB_FederatedServerDiagnostics.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_FederatedServerDiagnostics.sql

scripts-enabled/CDB_SyncTable.sql

@@ -0,0 +1 @@
+../scripts-available/CDB_SyncTable.sql

sql/test_setup.sql

@@ -1,9 +1,14 @@
+\set ECHO none
+\set QUIET on
+SET client_min_messages TO error;
 CREATE EXTENSION postgis;
-CREATE EXTENSION plpythonu;
-CREATE EXTENSION cartodb;
+CREATE EXTENSION @@plpythonu@@;
+CREATE SCHEMA cartodb;
+\i 'cartodb--unpackaged--@@VERSION@@.sql'
 CREATE FUNCTION public.cdb_invalidate_varnish(table_name text)
 RETURNS void AS $$
 BEGIN
   RAISE NOTICE 'cdb_invalidate_varnish(%) called', table_name;
 END;
 $$ LANGUAGE 'plpgsql';
+\set QUIET off

sql/test_setup_expect

@@ -0,0 +1 @@
+\set ECHO none

test/CDB_AnalysisCheckTest.sql

@@ -7,7 +7,7 @@ SELECT _CDB_AnalysisDataSize('public');
 CREATE TABLE analysis_2f13a3dbd7_41bd92976fc6dd97072afe4ee450054f4c0715d5(id int);
 CREATE TABLE analysis_2f13a3dbd7_f00cee44e9e6152b450bde3a92eb9ae0d099da94(id int);
 CREATE TABLE analysis_2f13a3dbd7_f00cee44e9e6152b450bde3a92eb9ae0d099da9(id int);
-SELECT _CDB_AnalysisTablesInSchema('public');
+SELECT _CDB_AnalysisTablesInSchema('public') t ORDER BY t;
 SELECT _CDB_AnalysisDataSize('public');
 SELECT CDB_CheckAnalysisQuota('analysis_2f13a3dbd7_f00cee44e9e6152b450bde3a92eb9ae0d099da94');
 SELECT CDB_SetUserQuotaInBytes(1);

test/CDB_CartodbfyTableTest.sql

@@ -134,9 +134,9 @@ DROP TABLE t;
 -- table with single non-geometrical column
 CREATE TABLE t AS SELECT ST_SetSRID(ST_MakePoint(-1,-1),4326) as the_geom, 1::int as cartodb_id, 'this is a sentence' as description;
 SELECT CDB_CartodbfyTableCheck('t', 'check function idempotence');
-SELECT * FROM t;
+SELECT cartodb_id, the_geom, description FROM t;
 SELECT CDB_CartodbfyTableCheck('t', 'check function idempotence');
-SELECT * FROM t;
+SELECT cartodb_id, the_geom, description FROM t;
 DROP TABLE t;
 
 -- table with existing srid-unconstrained (but type-constrained) the_geom

test/CDB_CartodbfyTableTest_expect

@@ -7,9 +7,9 @@ single non-geometrical column cartodbfied fine
 DROP TABLE
 SELECT 1
 check function idempotence cartodbfied fine
-1|0101000020E6100000000000000000F0BF000000000000F0BF|0101000020110F0000DB0B4ADA772DFBC077432E49D22DFBC0|this is a sentence
+1|0101000020E6100000000000000000F0BF000000000000F0BF|this is a sentence
 check function idempotence cartodbfied fine
-1|0101000020E6100000000000000000F0BF000000000000F0BF|0101000020110F0000DB0B4ADA772DFBC077432E49D22DFBC0|this is a sentence
+1|0101000020E6100000000000000000F0BF000000000000F0BF|this is a sentence
 DROP TABLE
 SELECT 1
 srid-unconstrained the_geom cartodbfied fine

test/CDB_FederatedServer.sql

@@ -0,0 +1,220 @@
+-- Setup
+\set QUIET on
+SET client_min_messages TO error;
+\set VERBOSITY terse
+SET SESSION AUTHORIZATION postgres;
+CREATE EXTENSION postgres_fdw;
+\set QUIET off
+
+\echo '## List empty servers shows nothing'
+SELECT '1.1', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## List non-existent server shows nothing'
+SELECT '1.2', cartodb.CDB_Federated_Server_List_Servers(server => 'doesNotExist');
+
+\echo '## Create and list a server works'
+SELECT '1.3', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "fdw_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+SELECT '1.4', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## Create and list a second server works'
+SELECT '2.1', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote2'::text, config => '{
+    "server": {
+        "dbname": "fdw_target",
+        "host": "localhost",
+        "port": @@PGPORT@@,
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    },
+    "credentials": {
+        "username": "fdw_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+SELECT '2.2', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## List server by name works'
+SELECT '2.3', cartodb.CDB_Federated_Server_List_Servers(server => 'myRemote');
+
+
+\echo '## Re-register a second server works'
+SELECT '3.1', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote2'::text, config => '{
+    "server": {
+        "dbname": "fdw_target",
+        "host": "localhost",
+        "port": @@PGPORT@@,
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    },
+    "credentials": {
+        "username": "other_remote_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+SELECT '3.2', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## Unregister server 1 works'
+SELECT '4.1', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote'::text);
+SELECT '4.2', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## Unregistering a server that does not exist fails'
+SELECT '5.1', cartodb.CDB_Federated_Server_Unregister(server => 'doesNotExist'::text);
+
+\echo '## Unregister the second server works'
+SELECT '6.1', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote2'::text);
+SELECT '6.2', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## Create a server with NULL name fails'
+SELECT '7.0', cartodb.CDB_Federated_Server_Register_PG(server => NULL::text, config => '{ "server": {}, "credentials" : {}}');
+\echo '## Create a server with NULL config fails'
+SELECT '7.01', cartodb.CDB_Federated_Server_Register_PG(server => 'empty'::text, config => NULL::jsonb);
+\echo '## Create a server with empty config fails'
+SELECT '7.1', cartodb.CDB_Federated_Server_Register_PG(server => 'empty'::text, config => '{}');
+\echo '## Create a server without credentials fails'
+SELECT '7.2', cartodb.CDB_Federated_Server_Register_PG(server => 'empty'::text, config => '{
+    "server": {
+        "dbname": "fdw_target",
+        "host": "localhost",
+        "port": @@PGPORT@@,
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    }
+}'::jsonb);
+\echo '## Create a server with empty credentials works'
+SELECT '7.3', cartodb.CDB_Federated_Server_Register_PG(server => 'empty'::text, config => '{
+    "server": {
+        "dbname": "fdw_target",
+        "host": "localhost",
+        "port": @@PGPORT@@,
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    },
+    "credentials": { }
+}'::jsonb);
+SELECT '7.4', cartodb.CDB_Federated_Server_List_Servers();
+SELECT '7.5', cartodb.CDB_Federated_Server_Unregister(server => 'empty'::text);
+\echo '## Create a server without options fails'
+SELECT '7.6', cartodb.CDB_Federated_Server_Register_PG(server => 'empty'::text, config => '{
+    "credentials": {
+        "username": "other_remote_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+
+\echo '## Create a server with special characters works'
+SELECT '8.1', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote" or''not'::text, config => '{
+    "server": {
+        "dbname": "fdw target",
+        "host": "localhost",
+        "port": @@PGPORT@@,
+        "extensions": "postgis",
+        "updatable": "false",
+        "use_remote_estimate": "true",
+        "fetch_size": "1000"
+    },
+    "credentials": {
+        "username": "fdw user",
+        "password": "foo barino"
+    }
+}'::jsonb);
+SELECT '8.2', cartodb.CDB_Federated_Server_List_Servers();
+SELECT '8.3', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote" or''not'::text);
+
+-- Test permissions
+\set QUIET on
+CREATE ROLE cdb_fs_tester LOGIN PASSWORD 'cdb_fs_passwd';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester;
+\set QUIET off
+
+SELECT '9.1', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote3'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "fdw_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+
+\c contrib_regression cdb_fs_tester
+
+\echo '## All users are able to list servers'
+SELECT '9.2', cartodb.CDB_Federated_Server_List_Servers();
+
+\echo '## Only superadmins can create servers'
+SELECT '9.3', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote4'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "fdw_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+
+
+\c contrib_regression postgres
+
+\echo '## Granting access to a user works'
+SELECT '9.5', cartodb.CDB_Federated_Server_Grant_Access(server => 'myRemote3', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT '9.55', cartodb.CDB_Federated_Server_List_Servers();
+\c contrib_regression postgres
+SELECT '9.6', cartodb.CDB_Federated_Server_Grant_Access(server => 'does not exist', db_role => 'cdb_fs_tester'::name);
+SELECT '9.7', cartodb.CDB_Federated_Server_Grant_Access(server => 'myRemote3', db_role => 'does not exist'::name);
+
+\echo '## Granting access again raises a notice'
+SELECT '9.8', cartodb.CDB_Federated_Server_Grant_Access(server => 'myRemote3', db_role => 'cdb_fs_tester'::name);
+
+\echo '## Revoking access to a user works'
+SELECT '9.9', cartodb.CDB_Federated_Server_Revoke_Access(server => 'myRemote3', db_role => 'cdb_fs_tester'::name);
+SELECT '9.10', cartodb.CDB_Federated_Server_Grant_Access(server => 'myRemote3', db_role => 'cdb_fs_tester'::name);
+
+\echo '## Unregistering a server with active grants works'
+SELECT '9.11', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote3'::text);
+
+
+\echo '## A user with granted access can not drop a server'
+SELECT '10.1', cartodb.CDB_Federated_Server_Register_PG(server => 'myRemote4'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "fdw_user",
+        "password": "foobarino"
+    }
+}'::jsonb);
+SELECT '10.2', cartodb.CDB_Federated_Server_Grant_Access(server => 'myRemote4', db_role => 'cdb_fs_tester'::name);
+
+\c contrib_regression cdb_fs_tester
+SELECT '10.3', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote4'::text);
+
+\c contrib_regression postgres
+SELECT '10.4', cartodb.CDB_Federated_Server_Unregister(server => 'myRemote4'::text);
+
+
+-- Cleanup
+\set QUIET on
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester;
+DROP ROLE cdb_fs_tester;
+DROP EXTENSION postgres_fdw;
+\set QUIET off

test/CDB_FederatedServerDiagnostics.sql

@@ -0,0 +1,126 @@
+-- ===================================================================
+-- create FDW objects
+-- ===================================================================
+\set QUIET on
+SET client_min_messages TO error;
+\set VERBOSITY terse
+CREATE EXTENSION postgres_fdw;
+
+CREATE ROLE cdb_fs_tester LOGIN PASSWORD 'cdb_fs_passwd';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester;
+
+-- Create database to be used as remote
+CREATE DATABASE cdb_fs_tester OWNER cdb_fs_tester;
+
+SELECT 'C1', cartodb.CDB_Federated_Server_Register_PG(server => 'loopback'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+SELECT 'C2', cartodb.CDB_Federated_Server_Register_PG(server => 'wrong-port'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": "12345"
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+SELECT 'C3', cartodb.CDB_Federated_Server_Register_PG(server => 'loopback-no-port'::text, config => '{
+    "server": {
+        "host": "localhost"
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+\c cdb_fs_tester postgres
+CREATE EXTENSION postgis;
+\c contrib_regression postgres
+\set QUIET off
+
+
+-- ===================================================================
+-- Test server diagnostics function(s)
+-- ===================================================================
+\echo '%% It raises an error if the server does not exist'
+SELECT '1.1', cartodb.CDB_Federated_Server_Diagnostics(server => 'doesNotExist');
+
+\echo '%% It returns a jsonb object'
+SELECT '1.2', pg_typeof(cartodb.CDB_Federated_Server_Diagnostics(server => 'loopback'));
+
+\echo '%% It returns the server version'
+SELECT '1.3', cartodb.CDB_Federated_Server_Diagnostics(server => 'loopback') @> format('{"server_version": "%s"}', setting)::jsonb
+    FROM pg_settings WHERE name = 'server_version';
+
+\echo '%% It returns the postgis version'
+SELECT '1.4', cartodb.CDB_Federated_Server_Diagnostics(server => 'loopback') @> format('{"postgis_version": "%s"}', extversion)::jsonb
+    FROM pg_extension WHERE extname = 'postgis';
+
+\echo '%% It returns null as the postgis version if it is not installed'
+\set QUIET on
+\c cdb_fs_tester postgres
+DROP EXTENSION postgis;
+\c contrib_regression postgres
+\set QUIET off
+SELECT '1.5', cartodb.CDB_Federated_Server_Diagnostics(server => 'loopback') @> '{"postgis_version": null}'::jsonb;
+
+\echo '%% It returns the remote server options'
+SELECT '1.6', cartodb.CDB_Federated_Server_Diagnostics(server => 'loopback') @> '{"server_options": {"host": "localhost", "port": "@@PGPORT@@", "updatable": "false", "extensions": "postgis", "fetch_size": "1000", "use_remote_estimate": "true"}}'::jsonb;
+
+\echo '%% It returns network latency stats to the remote server: min <= avg <= max'
+WITH latency AS (
+   SELECT CDB_Federated_Server_Diagnostics('loopback')->'server_latency_ms' ms
+) SELECT '2.1', (latency.ms->'min')::text::float <= (latency.ms->'avg')::text::float, (latency.ms->'avg')::text::float <= (latency.ms->'max')::text::float
+FROM latency;
+
+\echo '%% Latency stats: 0 <= min <= max <= 1000 ms (local connection)'
+WITH latency AS (
+   SELECT CDB_Federated_Server_Diagnostics('loopback')->'server_latency_ms' ms
+) SELECT '2.2', 0.0 <= (latency.ms->'min')::text::float, (latency.ms->'max')::text::float <= 1000.0
+FROM latency;
+
+\echo '%% Latency stats: stdev > 0'
+WITH latency AS (
+   SELECT CDB_Federated_Server_Diagnostics('loopback')->'server_latency_ms' ms
+) SELECT '2.3', (latency.ms->'stdev')::text::float >= 0.0
+FROM latency;
+
+\echo '%% It raises an error if the wrong port is provided'
+SELECT '3.0', cartodb.CDB_Federated_Server_Diagnostics(server => 'wrong-port');
+
+-- Disabled: It's not compatible with Travis since the target database (self) might be in a different port
+-- \echo '%% Latency stats: can get them on default PG port 5432 when not provided'
+-- WITH latency AS (
+--    SELECT CDB_Federated_Server_Diagnostics('loopback-no-port')->'server_latency_ms' ms
+-- ) SELECT '2.4', 0.0 <= (latency.ms->'min')::text::float, (latency.ms->'max')::text::float <= 1000.0
+-- FROM latency;
+
+
+-- ===================================================================
+-- Cleanup
+-- ===================================================================
+\set QUIET on
+SELECT 'D1', cartodb.CDB_Federated_Server_Unregister(server => 'loopback'::text);
+SELECT 'D2', cartodb.CDB_Federated_Server_Unregister(server => 'wrong-port'::text);
+SELECT 'D3', cartodb.CDB_Federated_Server_Unregister(server => 'loopback-no-port'::text);
+-- Reconnect, using a new session in order to close FDW connections
+\connect
+DROP DATABASE cdb_fs_tester;
+
+-- Drop role
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester;
+DROP ROLE cdb_fs_tester;
+
+DROP EXTENSION postgres_fdw;
+\set QUIET off

test/CDB_FederatedServerDiagnostics_expect

@@ -0,0 +1,26 @@
+C1|
+C2|
+C3|
+%% It raises an error if the server does not exist
+ERROR:  Server "doesNotExist" does not exist
+%% It returns a jsonb object
+1.2|jsonb
+%% It returns the server version
+1.3|t
+%% It returns the postgis version
+1.4|t
+%% It returns null as the postgis version if it is not installed
+1.5|t
+%% It returns the remote server options
+1.6|t
+%% It returns network latency stats to the remote server: min <= avg <= max
+2.1|t|t
+%% Latency stats: 0 <= min <= max <= 1000 ms (local connection)
+2.2|t|t
+%% Latency stats: stdev > 0
+2.3|t
+%% It raises an error if the wrong port is provided
+ERROR:  could not connect to server "cdb_fs_wrong-port"
+D1|
+D2|
+D3|

test/CDB_FederatedServerListRemote.sql

@@ -0,0 +1,319 @@
+-- ===================================================================
+-- create FDW objects
+-- ===================================================================
+\set QUIET on
+SET client_min_messages TO error;
+\set VERBOSITY terse
+CREATE EXTENSION postgres_fdw;
+
+CREATE ROLE cdb_fs_tester LOGIN PASSWORD 'cdb_fs_passwd';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester;
+CREATE ROLE cdb_fs_tester2 LOGIN PASSWORD 'cdb_fs_passwd2';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester2;
+
+-- Create database to be used as remote
+CREATE DATABASE cdb_fs_tester OWNER cdb_fs_tester;
+
+SELECT 'C1', cartodb.CDB_Federated_Server_Register_PG(server => 'loopback'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+SELECT 'C2', cartodb.CDB_Federated_Server_Register_PG(server => 'loopback2'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+-- ===================================================================
+-- Setup 1
+-- ===================================================================
+\c cdb_fs_tester cdb_fs_tester
+
+CREATE TYPE user_enum AS ENUM ('foo', 'bar', 'buz');
+CREATE SCHEMA "S 1";
+CREATE TABLE "S 1"."T 1" (
+	"C 1" int NOT NULL,
+	c2 int NOT NULL,
+	c3 text,
+	c4 timestamptz,
+	c5 timestamp,
+	c6 varchar(10),
+	c7 char(10),
+	c8 user_enum,
+	CONSTRAINT t1_pkey PRIMARY KEY ("C 1")
+);
+CREATE TABLE "S 1"."T 2" (
+	c1 int NOT NULL,
+	c2 text,
+	CONSTRAINT t2_pkey PRIMARY KEY (c1)
+);
+CREATE TABLE "S 1"."T 3" (
+	c1 int NOT NULL,
+	c2 int NOT NULL,
+	c3 text,
+	CONSTRAINT t3_pkey PRIMARY KEY (c1)
+);
+CREATE TABLE "S 1"."T 4" (
+	c1 int NOT NULL,
+	c2 int NOT NULL,
+	c3 text,
+	CONSTRAINT t4_pkey PRIMARY KEY (c1)
+);
+
+-- Disable autovacuum for these tables to avoid unexpected effects of that
+ALTER TABLE "S 1"."T 1" SET (autovacuum_enabled = 'false');
+ALTER TABLE "S 1"."T 2" SET (autovacuum_enabled = 'false');
+ALTER TABLE "S 1"."T 3" SET (autovacuum_enabled = 'false');
+ALTER TABLE "S 1"."T 4" SET (autovacuum_enabled = 'false');
+
+\c contrib_regression postgres
+SET client_min_messages TO notice;
+\set VERBOSITY terse
+\set QUIET off
+
+
+-- ===================================================================
+-- Test listing remote schemas
+-- ===================================================================
+\echo '## Test listing of remote schemas without permissions before the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote schemas (sunny day)'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback');
+
+\echo '## Test listing of remote schemas without permissions after the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote schemas with permissions (sunny day)'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote schemas without permissions after revoking access (rainy day)'
+SELECT cartodb.CDB_Federated_Server_Revoke_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote schemas (rainy day): Server does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'Does Not Exist');
+
+
+-- ===================================================================
+-- Test listing remote tables
+-- ===================================================================
+
+\echo '## Test listing of remote tables without permissions before the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'S 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote tables (sunny day)'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'S 1');
+
+\echo '## Test listing of remote tables without permissions after the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'S 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote tables with permissions (sunny day)'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'S 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote tables without permissions after revoking access (rainy day)'
+SELECT cartodb.CDB_Federated_Server_Revoke_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'S 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote tables (rainy day): Server does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'Does Not Exist', remote_schema => 'S 1');
+
+\echo '## Test listing of remote tables (rainy day): Remote schema does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'Does Not Exist');
+
+
+-- ===================================================================
+-- Test listing remote columns
+-- ===================================================================
+
+\echo '## Test listing of remote columns without permissions before the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote columns (sunny day)'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 1');
+
+\echo '## Test listing of remote columns without permissions after the first instantiation (rainy day)'
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote columns with permissions (sunny day)'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote columns without permissions after revoking access (rainy day)'
+SELECT cartodb.CDB_Federated_Server_Revoke_Access(server => 'loopback', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 1');
+\c contrib_regression postgres
+
+\echo '## Test listing of remote columns (rainy day): Server does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'Does Not Exist', remote_schema => 'S 1', remote_table => 'T 1');
+
+\echo '## Test listing of remote columns (rainy day): Remote schema does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'Does Not Exist', remote_table => 'T 1');
+
+\echo '## Test listing of remote columns (rainy day): Remote table does not exist'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'Does Not Exist');
+
+\echo '## Test listing of remote columns (rainy day): Remote table is NULL'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => NULL::text);
+
+
+-- ===================================================================
+-- Test that using a different user to list tables and dropping it
+-- does not break the server: We use loopback2 as it's in a clean state
+-- ===================================================================
+
+
+\echo '## Test listing of remote objects with permissions (sunny day)'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server => 'loopback2', db_role => 'cdb_fs_tester2'::name);
+\c contrib_regression cdb_fs_tester2
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback2');
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback2', remote_schema => 'S 1');
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback2', remote_schema => 'S 1', remote_table => 'T 1');
+
+\c contrib_regression postgres
+\echo '## Test that dropping the granted user works fine (sunny day)'
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester2;
+DROP ROLE cdb_fs_tester2;
+
+\echo '## Test listing of remote objects with other user still works (sunny day)'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server => 'loopback2', db_role => 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback2');
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback2', remote_schema => 'S 1');
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback2', remote_schema => 'S 1', remote_table => 'T 1');
+
+
+-- ===================================================================
+-- Cleanup 1
+-- ===================================================================
+\set QUIET on
+
+\c cdb_fs_tester cdb_fs_tester
+DROP TABLE "S 1". "T 1";
+DROP TABLE "S 1". "T 2";
+DROP TABLE "S 1". "T 3";
+DROP TABLE "S 1". "T 4";
+
+DROP SCHEMA "S 1";
+DROP TYPE user_enum;
+
+
+-- ===================================================================
+-- Setup 2: Using Postgis too
+-- ===================================================================
+
+\c cdb_fs_tester postgres
+
+CREATE EXTENSION postgis;
+
+\c cdb_fs_tester cdb_fs_tester
+
+CREATE SCHEMA "S 1";
+CREATE TABLE "S 1"."T 5" (
+	geom       geometry(Geometry,4326),
+	geom_wm    geometry(GeometryZ,3857),
+	geo_nosrid geometry,
+	geog       geography
+);
+
+\c contrib_regression postgres
+SET client_min_messages TO notice;
+\set VERBOSITY terse
+\set QUIET off
+
+
+-- ===================================================================
+-- Test the listing functions
+-- ===================================================================
+
+\echo '## Test listing of remote geometry columns (sunny day)'
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 5');
+\echo '## Test listing of remote geometry columns (sunny day) - Rerun'
+-- Rerun should be ok
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Columns(server => 'loopback', remote_schema => 'S 1', remote_table => 'T 5');
+
+
+-- ===================================================================
+-- Test invalid password
+-- ===================================================================
+
+\echo '## Check error message with invalid password (rainy day)'
+SELECT cartodb.CDB_Federated_Server_Register_PG(server => 'loopback_invalid'::text, config => '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "wrong password"
+    }
+}'::jsonb);
+
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Schemas(server => 'loopback_invalid');
+
+SELECT cartodb.CDB_Federated_Server_Unregister(server => 'loopback_invalid'::text);
+
+-- ===================================================================
+-- Cleanup 2
+-- ===================================================================
+\set QUIET on
+
+\c cdb_fs_tester cdb_fs_tester
+DROP TABLE "S 1". "T 5";
+
+DROP SCHEMA "S 1";
+
+\c contrib_regression postgres
+\set QUIET on
+SET client_min_messages TO error;
+\set VERBOSITY terse
+
+SELECT 'D1', cartodb.CDB_Federated_Server_Unregister(server => 'loopback'::text);
+SELECT 'D2', cartodb.CDB_Federated_Server_Unregister(server => 'loopback2'::text);
+
+DROP DATABASE cdb_fs_tester;
+
+-- Drop role
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester;
+DROP ROLE cdb_fs_tester;
+
+DROP EXTENSION postgres_fdw;
+
+\set QUIET off

test/CDB_FederatedServerListRemote_expect

@@ -0,0 +1,162 @@
+C1|
+C2|
+## Test listing of remote schemas without permissions before the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote schemas (sunny day)
+S 1
+information_schema
+public
+## Test listing of remote schemas without permissions after the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote schemas with permissions (sunny day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+S 1
+information_schema
+public
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote schemas without permissions after revoking access (rainy day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote schemas (rainy day): Server does not exist
+ERROR:  Server "Does Not Exist" does not exist
+## Test listing of remote tables without permissions before the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote tables (sunny day)
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback"
+f|T 1|||||[{"Name" : "C 1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}, {"Name" : "c4", "Type" : "timestamp with time zone"}, {"Name" : "c5", "Type" : "timestamp without time zone"}, {"Name" : "c6", "Type" : "character varying"}, {"Name" : "c7", "Type" : "character"}, {"Name" : "c8", "Type" : "USER-DEFINED"}]
+f|T 2|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "text"}]
+f|T 3|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+f|T 4|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+## Test listing of remote tables without permissions after the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote tables with permissions (sunny day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback"
+f|T 1|||||[{"Name" : "C 1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}, {"Name" : "c4", "Type" : "timestamp with time zone"}, {"Name" : "c5", "Type" : "timestamp without time zone"}, {"Name" : "c6", "Type" : "character varying"}, {"Name" : "c7", "Type" : "character"}, {"Name" : "c8", "Type" : "USER-DEFINED"}]
+f|T 2|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "text"}]
+f|T 3|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+f|T 4|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote tables without permissions after revoking access (rainy day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote tables (rainy day): Server does not exist
+ERROR:  Server "Does Not Exist" does not exist
+## Test listing of remote tables (rainy day): Remote schema does not exist
+## Test listing of remote columns without permissions before the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote columns (sunny day)
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback"
+C 1|integer
+c2|integer
+c3|text
+c4|timestamp with time zone
+c5|timestamp without time zone
+c6|character varying
+c7|character
+c8|USER-DEFINED
+## Test listing of remote columns without permissions after the first instantiation (rainy day)
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote columns with permissions (sunny day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback"
+C 1|integer
+c2|integer
+c3|text
+c4|timestamp with time zone
+c5|timestamp without time zone
+c6|character varying
+c7|character
+c8|USER-DEFINED
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote columns without permissions after revoking access (rainy day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+You are now connected to database "contrib_regression" as user "postgres".
+## Test listing of remote columns (rainy day): Server does not exist
+ERROR:  Server "Does Not Exist" does not exist
+## Test listing of remote columns (rainy day): Remote schema does not exist
+## Test listing of remote columns (rainy day): Remote table does not exist
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback"
+## Test listing of remote columns (rainy day): Remote table is NULL
+ERROR:  Remote table name cannot be NULL
+## Test listing of remote objects with permissions (sunny day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester2".
+S 1
+information_schema
+public
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback2"
+f|T 1|||||[{"Name" : "C 1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}, {"Name" : "c4", "Type" : "timestamp with time zone"}, {"Name" : "c5", "Type" : "timestamp without time zone"}, {"Name" : "c6", "Type" : "character varying"}, {"Name" : "c7", "Type" : "character"}, {"Name" : "c8", "Type" : "USER-DEFINED"}]
+f|T 2|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "text"}]
+f|T 3|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+f|T 4|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback2"
+C 1|integer
+c2|integer
+c3|text
+c4|timestamp with time zone
+c5|timestamp without time zone
+c6|character varying
+c7|character
+c8|USER-DEFINED
+You are now connected to database "contrib_regression" as user "postgres".
+## Test that dropping the granted user works fine (sunny day)
+REVOKE
+DROP ROLE
+## Test listing of remote objects with other user still works (sunny day)
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+S 1
+information_schema
+public
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback2"
+f|T 1|||||[{"Name" : "C 1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}, {"Name" : "c4", "Type" : "timestamp with time zone"}, {"Name" : "c5", "Type" : "timestamp without time zone"}, {"Name" : "c6", "Type" : "character varying"}, {"Name" : "c7", "Type" : "character"}, {"Name" : "c8", "Type" : "USER-DEFINED"}]
+f|T 2|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "text"}]
+f|T 3|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+f|T 4|||||[{"Name" : "c1", "Type" : "integer"}, {"Name" : "c2", "Type" : "integer"}, {"Name" : "c3", "Type" : "text"}]
+INFO:  Could not find Postgis installation in the remote "public" schema in server "loopback2"
+C 1|integer
+c2|integer
+c3|text
+c4|timestamp with time zone
+c5|timestamp without time zone
+c6|character varying
+c7|character
+c8|USER-DEFINED
+## Test listing of remote geometry columns (sunny day)
+geo_nosrid|GEOMETRY,0
+geog|Geometry,0
+geom|GEOMETRY,4326
+geom_wm|GEOMETRY,3857
+## Test listing of remote geometry columns (sunny day) - Rerun
+geo_nosrid|GEOMETRY,0
+geog|Geometry,0
+geom|GEOMETRY,4326
+geom_wm|GEOMETRY,3857
+## Check error message with invalid password (rainy day)
+
+ERROR:  could not connect to server "cdb_fs_loopback_invalid"
+
+D1|
+D2|

test/CDB_FederatedServerTables.sql

@@ -0,0 +1,405 @@
+-- ===================================================================
+-- create FDW objects
+-- ===================================================================
+\set QUIET on
+SET client_min_messages TO error;
+\set VERBOSITY terse
+
+CREATE EXTENSION postgres_fdw;
+
+-- We create a username following the same steps as organization members
+CREATE ROLE cdb_fs_tester LOGIN PASSWORD 'cdb_fs_passwd';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester;
+
+CREATE ROLE cdb_fs_tester2 LOGIN PASSWORD 'cdb_fs_passwd2';
+GRANT CONNECT ON DATABASE contrib_regression TO cdb_fs_tester2;
+
+-- Create database to be used as remote
+CREATE DATABASE cdb_fs_tester OWNER cdb_fs_tester;
+
+SELECT 'C1', cartodb.CDB_Federated_Server_Register_PG(server := 'loopback'::text, config := '{
+    "server": {
+        "host": "localhost",
+        "port": @@PGPORT@@
+    },
+    "credentials": {
+        "username": "cdb_fs_tester",
+        "password": "cdb_fs_passwd"
+    }
+}'::jsonb);
+
+
+-- ===================================================================
+-- create objects used through FDW loopback server
+-- ===================================================================
+
+\c cdb_fs_tester postgres
+
+CREATE EXTENSION postgis;
+
+\c cdb_fs_tester cdb_fs_tester
+
+CREATE SCHEMA remote_schema;
+CREATE TABLE remote_schema.remote_geom(id int, another_field text, geom geometry(Geometry,4326));
+
+INSERT INTO remote_schema.remote_geom VALUES (1, 'patata', 'SRID=4326;POINT(1 1)'::geometry);
+INSERT INTO remote_schema.remote_geom VALUES (2, 'patata2', 'SRID=4326;POINT(2 2)'::geometry);
+
+CREATE TABLE remote_schema.remote_geom2(cartodb_id bigint, another_field text, the_geom geometry(Geometry,4326), the_geom_webmercator geometry(Geometry,3857));
+
+INSERT INTO remote_schema.remote_geom2 VALUES (3, 'patata', 'SRID=4326;POINT(3 3)'::geometry, 'SRID=3857;POINT(3 3)');
+
+CREATE TABLE remote_schema.remote_other(id bigint, field text, field2 text);
+INSERT INTO remote_schema.remote_other VALUES (1, 'delicious', 'potatoes');
+
+CREATE TABLE remote_schema.remote_geom3(id bigint, geom geometry(Geometry,4326), geom_mercator geometry(Geometry,3857));
+
+-- ===================================================================
+-- Test the listing functions
+-- ===================================================================
+
+\c contrib_regression postgres
+SET client_min_messages TO error;
+\set VERBOSITY terse
+\set QUIET off
+
+\echo '## Registering an existing table works'
+SELECT 'R1', cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+SELECT 'S1', cartodb_id, ST_AsText(the_geom), another_field FROM cdb_fs_loopback.remote_geom;
+
+Select * FROM CDB_Federated_Server_List_Remote_Tables(
+    server => 'loopback',
+    remote_schema => 'remote_schema'
+);
+
+\echo '## Registering another existing table works'
+SELECT 'R2', cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom2',
+    id_column => 'cartodb_id',
+    geom_column => 'the_geom',
+    webmercator_column => 'the_geom_webmercator',
+    local_name => 'myFullTable'
+    );
+
+SELECT 'S2', cartodb_id, ST_AsText(the_geom), another_field FROM cdb_fs_loopback."myFullTable";
+Select * FROM CDB_Federated_Server_List_Remote_Tables(
+    server => 'loopback',
+    remote_schema => 'remote_schema'
+);
+
+\echo '## Re-registering a table works'
+SELECT 'R3', cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom2',
+    id_column => 'cartodb_id',
+    -- Switch geom and geom_column on purpose to force ST_Transform to be used
+    geom_column => 'the_geom_webmercator',
+    webmercator_column => 'the_geom',
+    local_name => 'different_name'
+    );
+
+-- The old view should dissapear
+SELECT 'S3_old', cartodb_id, another_field FROM cdb_fs_loopback."myFullTable";
+-- And the new appear
+SELECT 'S3_new', cartodb_id, another_field FROM cdb_fs_loopback.different_name;
+
+\echo '## Unregistering works'
+-- Deregistering the first table
+SELECT 'U1', cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom'
+    );
+-- Selecting from the created view should fail now
+SELECT 'UCheck1', cartodb_id, ST_AsText(the_geom), another_field FROM remote_geom;
+
+Select * FROM CDB_Federated_Server_List_Remote_Tables(
+    server => 'loopback',
+    remote_schema => 'remote_schema'
+);
+
+-- ===================================================================
+-- Test input
+-- ===================================================================
+
+\echo '## Registering a table: Invalid server fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'Does not exist',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: NULL server fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => NULL::text,
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: Invalid schema fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'Does not exist',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: NULL schema fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => NULL::text,
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: Invalid table fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'Does not exist',
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: NULL table fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => NULL::text,
+    id_column => 'id',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: Invalid id fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'Does not exist',
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: NULL id fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  NULL::text,
+    geom_column => 'geom'
+    );
+
+\echo '## Registering a table: Invalid geom_column fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'Does not exists'
+    );
+
+\echo '## Registering a table: NULL geom_column is OK: Reuses geom_mercator'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => NULL::text,
+    webmercator_column => 'geom'
+    );
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema') where remote_table = 'remote_geom';
+
+SELECT cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom'
+    );
+
+\echo '## Registering a table: Invalid webmercator_column fails'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column => 'id',
+    geom_column => 'geom',
+    webmercator_column => 'Does not exists'
+    );
+
+\echo '## Registering a table: NULL webmercator_column is OK: Reuses geom'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => 'geom',
+    webmercator_column => NULL::text
+    );
+SELECT * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema') where remote_table = 'remote_geom';
+SELECT cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom'
+    );
+
+\echo '##Registering a table with extra columns show the correct information'
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom3',
+    id_column =>  'id',
+    geom_column => 'geom',
+    webmercator_column => 'geom_mercator'
+    );
+Select * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema') where remote_table = 'remote_geom3';
+SELECT cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom3'
+    );
+
+-- ===================================================================
+-- Test conflicts
+-- ===================================================================
+
+\echo '## Target conflict is handled nicely: Table'
+CREATE TABLE cdb_fs_loopback.localtable (a integer);
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => 'geom',
+    local_name => 'localtable');
+
+\echo '## Target conflict is handled nicely: View'
+CREATE VIEW cdb_fs_loopback.localtable2 AS Select * from cdb_fs_loopback.localtable;
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => 'geom',
+    local_name => 'localtable2');
+
+DROP VIEW cdb_fs_loopback.localtable2;
+DROP TABLE cdb_fs_loopback.localtable;
+
+-- ===================================================================
+-- Test permissions
+-- ===================================================================
+
+
+\echo '## Registering tables does not work without permissions'
+\c contrib_regression cdb_fs_tester
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => 'geom',
+    local_name => 'localtable');
+
+\echo '## Normal users can not write in the import schema'
+CREATE TABLE cdb_fs_loopback.localtable (a integer);
+
+\echo '## Listing remote tables does not work without permissions'
+Select * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema');
+
+\echo '## Registering tables works with granted permissions'
+\c contrib_regression postgres
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server := 'loopback', db_role := 'cdb_fs_tester'::name);
+\c contrib_regression cdb_fs_tester
+SELECT cartodb.CDB_Federated_Table_Register(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom',
+    id_column =>  'id',
+    geom_column => 'geom',
+    local_name => 'localtable');
+
+\echo '## Listing remote tables works with granted permissions'
+Select * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema');
+
+\echo '## Selecting from a registered table with granted permissions works'
+Select cartodb_id, ST_AsText(the_geom) from cdb_fs_loopback.localtable;
+
+\echo '## Selecting from a registered table without permissions does not work'
+\c contrib_regression cdb_fs_tester2
+CREATE OR REPLACE FUNCTION catch_permission_error(query text)
+RETURNS bool
+AS $$
+BEGIN
+    EXECUTE query;
+    RETURN FALSE;
+EXCEPTION
+    WHEN insufficient_privilege THEN
+        RETURN TRUE;
+    WHEN OTHERS THEN
+        RAISE WARNING 'Exception %', sqlstate;
+        RETURN FALSE;
+END
+$$ LANGUAGE 'plpgsql';
+Select catch_permission_error($$SELECT cartodb_id, ST_AsText(the_geom) from cdb_fs_loopback.localtable$$);
+DROP FUNCTION catch_permission_error(text);
+
+\echo '## Deleting a registered table without permissions does not work'
+SELECT cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom'
+    );
+
+\echo '## Only the owner can grant permissions over the server'
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server := 'loopback', db_role := 'cdb_fs_tester2'::name);
+
+\echo '## Everything works for a different user when granted permissions'
+\c contrib_regression postgres
+SELECT cartodb.CDB_Federated_Server_Grant_Access(server := 'loopback', db_role := 'cdb_fs_tester2'::name);
+\c contrib_regression cdb_fs_tester2
+Select * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema');
+Select cartodb_id, ST_AsText(the_geom) from cdb_fs_loopback.localtable;
+
+\echo '## A different user can unregister a table'
+SELECT cartodb.CDB_Federated_Table_Unregister(
+    server => 'loopback',
+    remote_schema => 'remote_schema',
+    remote_table => 'remote_geom'
+    );
+Select * FROM cartodb.CDB_Federated_Server_List_Remote_Tables(server => 'loopback', remote_schema => 'remote_schema');
+
+\echo '## Only the owner can revoke permissions over the server'
+SELECT cartodb.CDB_Federated_Server_Revoke_Access(server := 'loopback', db_role := 'cdb_fs_tester'::name);
+
+-- ===================================================================
+-- Cleanup
+-- ===================================================================
+
+\set QUIET on
+\c contrib_regression postgres
+SET client_min_messages TO error;
+\set VERBOSITY terse
+
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester2;
+DROP ROLE cdb_fs_tester2;
+
+SELECT 'D1', cartodb.CDB_Federated_Server_Unregister(server := 'loopback'::text);
+DROP DATABASE cdb_fs_tester;
+REVOKE CONNECT ON DATABASE contrib_regression FROM cdb_fs_tester;
+DROP ROLE cdb_fs_tester;
+DROP EXTENSION postgres_fdw;
+\set QUIET off

test/CDB_FederatedServerTables_expect

@@ -0,0 +1,116 @@
+C1|
+## Registering an existing table works
+R1|
+S1|1|POINT(1 1)|patata
+S1|2|POINT(2 2)|patata2
+t|remote_geom|cdb_fs_loopback.remote_geom|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+f|remote_geom2|||||[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+## Registering another existing table works
+R2|
+S2|3|POINT(3 3)|patata
+t|remote_geom|cdb_fs_loopback.remote_geom|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+t|remote_geom2|cdb_fs_loopback."myFullTable"|cartodb_id|the_geom|the_geom_webmercator|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+## Re-registering a table works
+R3|
+ERROR:  relation "cdb_fs_loopback.myFullTable" does not exist at character 49
+S3_new|3|patata
+## Unregistering works
+U1|
+ERROR:  relation "remote_geom" does not exist at character 71
+f|remote_geom|||||[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+t|remote_geom2|cdb_fs_loopback.different_name|cartodb_id|the_geom_webmercator|the_geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+## Registering a table: Invalid server fails
+ERROR:  Server "Does not exist" does not exist
+## Registering a table: NULL server fails
+ERROR:  Server name cannot be NULL
+## Registering a table: Invalid schema fails
+ERROR:  Could not import schema "Does not exist" of server "loopback": schema "Does not exist" is not present on foreign server "cdb_fs_loopback"
+## Registering a table: NULL schema fails
+ERROR:  Schema name cannot be NULL
+## Registering a table: Invalid table fails
+ERROR:  Could not import table "remote_schema.Does not exist" of server "loopback"
+## Registering a table: NULL table fails
+ERROR:  Remote table name cannot be NULL
+## Registering a table: Invalid id fails
+ERROR:  non integer id_column "Does not exist"
+## Registering a table: NULL id fails
+ERROR:  non integer id_column "<NULL>"
+## Registering a table: Invalid geom_column fails
+ERROR:  non geometry column "Does not exists"
+## Registering a table: NULL geom_column is OK: Reuses geom_mercator
+
+t|remote_geom|cdb_fs_loopback.remote_geom|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+
+## Registering a table: Invalid webmercator_column fails
+ERROR:  non geometry column "Does not exists"
+## Registering a table: NULL webmercator_column is OK: Reuses geom
+
+t|remote_geom|cdb_fs_loopback.remote_geom|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+
+##Registering a table with extra columns show the correct information
+
+t|remote_geom3|cdb_fs_loopback.remote_geom3|id|geom|geom_mercator|[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+
+## Target conflict is handled nicely: Table
+CREATE TABLE
+ERROR:  Could not import table "remote_geom" as "cdb_fs_loopback.localtable" already exists
+## Target conflict is handled nicely: View
+CREATE VIEW
+ERROR:  Could not import table "remote_geom" as "cdb_fs_loopback.localtable2" already exists
+DROP VIEW
+DROP TABLE
+## Registering tables does not work without permissions
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to access the server "loopback"
+## Normal users can not write in the import schema
+ERROR:  permission denied for schema cdb_fs_loopback at character 14
+## Listing remote tables does not work without permissions
+ERROR:  Not enough permissions to access the server "loopback"
+## Registering tables works with granted permissions
+You are now connected to database "contrib_regression" as user "postgres".
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+
+## Listing remote tables works with granted permissions
+t|remote_geom|cdb_fs_loopback.localtable|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+t|remote_geom2|cdb_fs_loopback.different_name|cartodb_id|the_geom_webmercator|the_geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+## Selecting from a registered table with granted permissions works
+1|POINT(1 1)
+2|POINT(2 2)
+## Selecting from a registered table without permissions does not work
+You are now connected to database "contrib_regression" as user "cdb_fs_tester2".
+CREATE FUNCTION
+t
+DROP FUNCTION
+## Deleting a registered table without permissions does not work
+ERROR:  Not enough permissions to access the server "loopback"
+## Only the owner can grant permissions over the server
+ERROR:  You do not have rights to grant access on "loopback"
+## Everything works for a different user when granted permissions
+You are now connected to database "contrib_regression" as user "postgres".
+
+You are now connected to database "contrib_regression" as user "cdb_fs_tester2".
+t|remote_geom|cdb_fs_loopback.localtable|id|geom|geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+t|remote_geom2|cdb_fs_loopback.different_name|cartodb_id|the_geom_webmercator|the_geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+1|POINT(1 1)
+2|POINT(2 2)
+## A different user can unregister a table
+NOTICE:  drop cascades to view cdb_fs_loopback.localtable
+
+f|remote_geom|||||[{"Name" : "another_field", "Type" : "text"}, {"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "id", "Type" : "integer"}]
+t|remote_geom2|cdb_fs_loopback.different_name|cartodb_id|the_geom_webmercator|the_geom|[{"Name" : "another_field", "Type" : "text"}, {"Name" : "cartodb_id", "Type" : "bigint"}, {"Name" : "the_geom", "Type" : "GEOMETRY,4326"}, {"Name" : "the_geom_webmercator", "Type" : "GEOMETRY,3857"}]
+f|remote_geom3|||||[{"Name" : "geom", "Type" : "GEOMETRY,4326"}, {"Name" : "geom_mercator", "Type" : "GEOMETRY,3857"}, {"Name" : "id", "Type" : "bigint"}]
+f|remote_other|||||[{"Name" : "field", "Type" : "text"}, {"Name" : "field2", "Type" : "text"}, {"Name" : "id", "Type" : "bigint"}]
+## Only the owner can revoke permissions over the server
+ERROR:  You do not have rights to revoke access on "loopback"
+D1|

test/CDB_FederatedServer_expect

@@ -0,0 +1,69 @@
+## List empty servers shows nothing
+## List non-existent server shows nothing
+## Create and list a server works
+1.3|
+1.4|(myRemote,postgres_fdw,localhost,@@PGPORT@@,,read-only,fdw_user)
+## Create and list a second server works
+2.1|
+2.2|(myRemote,postgres_fdw,localhost,@@PGPORT@@,,read-only,fdw_user)
+2.2|(myRemote2,postgres_fdw,localhost,@@PGPORT@@,fdw_target,read-only,fdw_user)
+## List server by name works
+2.3|(myRemote,postgres_fdw,localhost,@@PGPORT@@,,read-only,fdw_user)
+## Re-register a second server works
+3.1|
+3.2|(myRemote,postgres_fdw,localhost,@@PGPORT@@,,read-only,fdw_user)
+3.2|(myRemote2,postgres_fdw,localhost,@@PGPORT@@,fdw_target,read-only,other_remote_user)
+## Unregister server 1 works
+4.1|
+4.2|(myRemote2,postgres_fdw,localhost,@@PGPORT@@,fdw_target,read-only,other_remote_user)
+## Unregistering a server that does not exist fails
+ERROR:  Server "doesNotExist" does not exist
+## Unregister the second server works
+6.1|
+## Create a server with NULL name fails
+ERROR:  Server name cannot be NULL
+## Create a server with NULL config fails
+7.01|
+## Create a server with empty config fails
+ERROR:  Server information is mandatory
+## Create a server without credentials fails
+ERROR:  Credentials are mandatory
+## Create a server with empty credentials works
+7.3|
+7.4|(empty,postgres_fdw,localhost,@@PGPORT@@,fdw_target,read-only,)
+7.5|
+## Create a server without options fails
+ERROR:  Server information is mandatory
+## Create a server with special characters works
+8.1|
+8.2|("myRemote"" or'not",postgres_fdw,localhost,@@PGPORT@@,"fdw target",read-only,"fdw user")
+8.3|
+9.1|
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+## All users are able to list servers
+9.2|(myRemote3,postgres_fdw,localhost,@@PGPORT@@,,read-only,)
+## Only superadmins can create servers
+ERROR:  Could not create server myRemote4: permission denied for foreign-data wrapper postgres_fdw
+You are now connected to database "contrib_regression" as user "postgres".
+## Granting access to a user works
+9.5|
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+9.55|(myRemote3,postgres_fdw,localhost,@@PGPORT@@,,read-only,fdw_user)
+You are now connected to database "contrib_regression" as user "postgres".
+ERROR:  Server "does not exist" does not exist
+ERROR:  Could not grant access on "myRemote3" to "does not exist": role "does not exist" does not exist
+## Granting access again raises a notice
+NOTICE:  role "cdb_fs_tester" is already a member of role "cdb_fs_role_95b63382aabca4433e7bd9cba6c30368"
+9.8|
+## Revoking access to a user works
+9.9|
+9.10|
+## Unregistering a server with active grants works
+9.11|
+## A user with granted access can not drop a server
+10.1|
+10.2|
+You are now connected to database "contrib_regression" as user "cdb_fs_tester".
+ERROR:  Not enough permissions to drop the server "myRemote4"
+You are now connected to database "contrib_regression" as user "postgres".
+10.4|

test/CDB_GhostTables.sql

@@ -1,6 +1,56 @@
 -- Create user and enable Ghost tables trigger
 \set QUIET on
 SET client_min_messages TO error;
+
+-- Recreate the function without extra error messages as it changes depending on the python-redis version
+CREATE OR REPLACE FUNCTION cartodb._CDB_LinkGhostTables(username text, db_name text, event_name text)
+RETURNS void
+AS $$
+  if not username:
+    return
+
+  if 'json' not in GD:
+    import json
+    GD['json'] = json
+  else:
+    json = GD['json']
+
+  tis_config = plpy.execute("select cartodb.CDB_Conf_GetConf('invalidation_service');")[0]['cdb_conf_getconf']
+  if not tis_config:
+    plpy.warning('Invalidation service configuration not found. Skipping Ghost Tables linking.')
+    return
+
+  tis_config_dict = json.loads(tis_config)
+  tis_host = tis_config_dict.get('host')
+  tis_port = tis_config_dict.get('port')
+  tis_timeout = tis_config_dict.get('timeout', 5)
+  tis_retry = tis_config_dict.get('retry', 5)
+
+  client = GD.get('invalidation', None)
+
+  while True:
+
+    if not client:
+        try:
+          import redis
+          client = redis.Redis(host=tis_host, port=tis_port, socket_timeout=tis_timeout)
+          GD['invalidation'] = client
+        except Exception as err:
+          # NOTE: no retries on connection error
+          plpy.warning('Error trying to connect to Invalidation Service to link Ghost Tables')
+          break
+
+    try:
+      client.execute_command('DBSCH', db_name, username, event_name)
+      break
+    except Exception as err:
+      client = GD['invalidation'] = None # force reconnect
+      if not tis_retry:
+        plpy.warning('Error calling Invalidation Service to link Ghost Tables')
+        break
+      tis_retry -= 1 # try reconnecting
+$$ LANGUAGE '@@plpythonu@@' VOLATILE PARALLEL UNSAFE;
+
 SELECT CDB_EnableGhostTablesTrigger();
 CREATE ROLE "fulano" LOGIN;
 GRANT ALL ON SCHEMA cartodb TO "fulano";

test/CDB_GhostTables_expect

@@ -1,19 +1,19 @@
 
 
 WARNING:  Invalidation service configuration not found. Skipping Ghost Tables linking.
-NOTICE:  _CDB_LinkGhostTables() called with username=fulanito, event_name=USER
+INFO:  _CDB_LinkGhostTables() called with username=fulanito, event_name=USER
 
 
-WARNING:  Error calling Invalidation Service to link Ghost Tables: Error -2 connecting fake-tis-host:3142. Name or service not known.
-NOTICE:  _CDB_LinkGhostTables() called with username=fulanito, event_name=USER
+WARNING:  Error calling Invalidation Service to link Ghost Tables
+INFO:  _CDB_LinkGhostTables() called with username=fulanito, event_name=USER
 
 BEGIN
 cdb_ddl_execution
 0
 CREATE TABLE
 1
-WARNING:  Error calling Invalidation Service to link Ghost Tables: Error -2 connecting fake-tis-host:3142. Name or service not known.
-NOTICE:  _CDB_LinkGhostTables() called with username=fulanito, event_name=CREATE TABLE
+WARNING:  Error calling Invalidation Service to link Ghost Tables
+INFO:  _CDB_LinkGhostTables() called with username=fulanito, event_name=CREATE TABLE
 COMMIT
 
 

test/CDB_OAuth.sql

@@ -0,0 +1,223 @@
+-- Create user and enable OAuth event trigger
+\set QUIET on
+SET client_min_messages TO error;
+
+-- The permission error changed between pre PG11 and post 11 (before everything was "relation", now it's "view", "table" and so on
+CREATE OR REPLACE FUNCTION catch_permission_error(query text)
+    RETURNS bool
+AS $$
+BEGIN
+    EXECUTE query;
+    RETURN FALSE;
+EXCEPTION
+    WHEN insufficient_privilege THEN
+        RETURN TRUE;
+    WHEN OTHERS THEN
+        RAISE WARNING 'Exception %', sqlstate;
+        RETURN FALSE;
+END
+$$ LANGUAGE 'plpgsql';
+
+DROP ROLE IF EXISTS "creator_role";
+CREATE ROLE "creator_role" LOGIN;
+DROP ROLE IF EXISTS "ownership_role";
+CREATE ROLE "ownership_role" LOGIN;
+GRANT ALL ON SCHEMA cartodb TO "creator_role";
+SELECT CDB_Conf_SetConf('api_keys_creator_role', '{"username": "creator_role", "permissions":[]}');
+SET SESSION AUTHORIZATION "creator_role";
+SET client_min_messages TO notice;
+\set QUIET off
+
+-- First part without event trigger
+
+CREATE TABLE test(id INT);
+INSERT INTO test VALUES(1);
+CREATE TABLE test_tablesas AS SELECT * FROM test;
+CREATE VIEW test_view AS SELECT * FROM test;
+CREATE MATERIALIZED VIEW test_mview AS SELECT * FROM test;
+SELECT * INTO test_selectinto FROM test;
+CREATE FUNCTION test_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+
+SELECT * FROM test;
+SELECT * FROM test_tablesas;
+SELECT * FROM test_view;
+SELECT * FROM test_mview;
+SELECT * FROM test_selectinto;
+SELECT test_function();
+-- Postgres grants default execute privilege on functions to PUBLIC. So in order to check the different permissions
+-- between creator and owner roles is not enough with performing a selection, we need to DROP the table (which only the owner can do)
+DROP FUNCTION test_function();
+
+\set QUIET on
+CREATE FUNCTION test_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+SET SESSION AUTHORIZATION "ownership_role";
+\set QUIET off
+
+SELECT 'denied_table', catch_permission_error($$SELECT * FROM test;$$);
+SELECT 'denied_tableas', catch_permission_error($$SELECT * FROM test_tablesas;$$);
+SELECT 'denied_view', catch_permission_error($$SELECT * FROM test_view;$$);
+SELECT 'denied_mview', catch_permission_error($$SELECT * FROM test_mview;$$);
+SELECT 'denied_selectinto', catch_permission_error($$SELECT * FROM test_selectinto;$$);
+SELECT test_function();
+SELECT 'denied_function', catch_permission_error($$DROP FUNCTION test_function();$$);
+
+\set QUIET on
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+DROP TABLE test_tablesas;
+DROP VIEW test_view;
+DROP MATERIALIZED VIEW test_mview;
+DROP TABLE test_selectinto;
+DROP TABLE test;
+DROP FUNCTION test_function();
+
+-- Second part with event trigger but without ownership_role_name in cdb_conf
+
+\set QUIET on
+SET SESSION AUTHORIZATION postgres;
+SELECT CDB_EnableOAuthReassignTablesTrigger();
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+CREATE TABLE test2(id INT);
+INSERT INTO test2 VALUES(1);
+CREATE TABLE test2_tablesas AS SELECT * FROM test2;
+CREATE VIEW test2_view AS SELECT * FROM test2;
+CREATE MATERIALIZED VIEW test2_mview AS SELECT * FROM test2;
+SELECT * INTO test2_selectinto FROM test2;
+CREATE FUNCTION test2_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+
+SELECT * FROM test2;
+SELECT * FROM test2_tablesas;
+SELECT * FROM test2_view;
+SELECT * FROM test2_mview;
+SELECT * FROM test2_selectinto;
+SELECT test2_function();
+DROP FUNCTION test2_function();
+
+\set QUIET on
+CREATE FUNCTION test2_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+SET SESSION AUTHORIZATION "ownership_role";
+\set QUIET off
+
+SELECT 'denied_table2', catch_permission_error($$SELECT * FROM test2;$$);
+SELECT 'denied_tableas2', catch_permission_error($$SELECT * FROM test2_tablesas;$$);
+SELECT 'denied_view2', catch_permission_error($$SELECT * FROM test2_view;$$);
+SELECT 'denied_mview2', catch_permission_error($$SELECT * FROM test2_mview;$$);
+SELECT 'denied_selectinto2', catch_permission_error($$SELECT * FROM test2_selectinto;$$);
+SELECT test2_function();
+SELECT 'denied_function2', catch_permission_error($$DROP FUNCTION test2_function();$$);
+
+\set QUIET on
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+DROP TABLE test2_tablesas;
+DROP VIEW test2_view;
+DROP MATERIALIZED VIEW test2_mview;
+DROP TABLE test2_selectinto;
+DROP TABLE test2;
+DROP FUNCTION test2_function();
+
+-- Third part with event trigger but with empty ownership_role_name in cdb_conf
+
+\set QUIET on
+SET SESSION AUTHORIZATION postgres;
+SELECT CDB_Conf_SetConf('api_keys_creator_role', '{"username": "creator_role", "permissions":[], "ownership_role_name": ""}');
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+CREATE TABLE test3(id INT);
+INSERT INTO test3 VALUES(1);
+CREATE TABLE test3_tablesas AS SELECT * FROM test3;
+CREATE VIEW test3_view AS SELECT * FROM test3;
+CREATE MATERIALIZED VIEW test3_mview AS SELECT * FROM test3;
+SELECT * INTO test3_selectinto FROM test3;
+CREATE FUNCTION test3_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+
+SELECT * FROM test3;
+SELECT * FROM test3_tablesas;
+SELECT * FROM test3_view;
+SELECT * FROM test3_mview;
+SELECT * FROM test3_selectinto;
+SELECT test3_function();
+DROP FUNCTION test3_function();
+
+\set QUIET on
+CREATE FUNCTION test3_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+SET SESSION AUTHORIZATION "ownership_role";
+\set QUIET off
+
+SELECT 'denied_table3', catch_permission_error($$SELECT * FROM test3;$$);
+SELECT 'denied_tableas3', catch_permission_error($$SELECT * FROM test3_tablesas;$$);
+SELECT 'denied_view3', catch_permission_error($$SELECT * FROM test3_view;$$);
+SELECT 'denied_mview3', catch_permission_error($$SELECT * FROM test3_mview;$$);
+SELECT 'denied_selectinto3', catch_permission_error($$SELECT * FROM test3_selectinto;$$);
+SELECT test3_function();
+SELECT 'denied_function3', catch_permission_error($$DROP FUNCTION test3_function();$$);
+
+\set QUIET on
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+DROP TABLE test3_tablesas;
+DROP VIEW test3_view;
+DROP MATERIALIZED VIEW test3_mview;
+DROP TABLE test3_selectinto;
+DROP TABLE test3;
+DROP FUNCTION test3_function();
+
+-- Fourth part with the event trigger active and configured
+
+\set QUIET on
+SET SESSION AUTHORIZATION postgres;
+SELECT CDB_Conf_SetConf('api_keys_creator_role', '{"username": "creator_role", "permissions":[], "ownership_role_name": "ownership_role"}');
+SET SESSION AUTHORIZATION "creator_role";
+\set QUIET off
+
+CREATE TABLE test4(id INT);
+INSERT INTO test4 VALUES(1);
+CREATE TABLE test4_tablesas AS SELECT * FROM test4;
+CREATE VIEW test4_view AS SELECT * FROM test4;
+CREATE MATERIALIZED VIEW test4_mview AS SELECT * FROM test4;
+SELECT * INTO test4_selectinto FROM test4;
+CREATE FUNCTION test4_function() RETURNS integer AS $$ BEGIN RETURN 1; END; $$ LANGUAGE PLPGSQL;
+
+SELECT * FROM test4;
+SELECT * FROM test4_tablesas;
+SELECT * FROM test4_view;
+SELECT * FROM test4_mview;
+SELECT * FROM test4_selectinto;
+SELECT test4_function();
+SELECT 'denied_function4', catch_permission_error($$DROP FUNCTION test4_function();$$);
+
+\set QUIET on
+SET SESSION AUTHORIZATION "ownership_role";
+\set QUIET off
+
+SELECT * FROM test4;
+SELECT * FROM test4_tablesas;
+SELECT * FROM test4_view;
+SELECT * FROM test4_mview;
+SELECT * FROM test4_selectinto;
+SELECT test4_function();
+
+-- Ownership role drops the tables
+DROP TABLE test4_tablesas;
+DROP VIEW test4_view;
+DROP MATERIALIZED VIEW test4_mview;
+DROP TABLE test4_selectinto;
+DROP TABLE test4;
+DROP FUNCTION test4_function();
+
+-- Cleanup
+\set QUIET on
+SET SESSION AUTHORIZATION postgres;
+SELECT CDB_DisableOAuthReassignTablesTrigger();
+DROP ROLE "ownership_role";
+REVOKE ALL ON SCHEMA cartodb FROM "creator_role";
+DROP ROLE "creator_role";
+DELETE FROM cdb_conf WHERE key = 'api_keys_creator_role';
+DROP FUNCTION catch_permission_error(text);
+\set QUIET off

test/CDB_OAuth_expect

@@ -0,0 +1,113 @@
+
+CREATE TABLE
+INSERT 0 1
+SELECT 1
+CREATE VIEW
+SELECT 1
+SELECT 1
+CREATE FUNCTION
+1
+1
+1
+1
+1
+1
+DROP FUNCTION
+denied_table|t
+denied_tableas|t
+denied_view|t
+denied_mview|t
+denied_selectinto|t
+1
+denied_function|t
+DROP TABLE
+DROP VIEW
+DROP MATERIALIZED VIEW
+DROP TABLE
+DROP TABLE
+DROP FUNCTION
+NOTICE:  event trigger "oauth_reassign_tables_trigger" does not exist, skipping
+
+CREATE TABLE
+INSERT 0 1
+SELECT 1
+CREATE VIEW
+SELECT 1
+SELECT 1
+CREATE FUNCTION
+1
+1
+1
+1
+1
+1
+DROP FUNCTION
+denied_table2|t
+denied_tableas2|t
+denied_view2|t
+denied_mview2|t
+denied_selectinto2|t
+1
+denied_function2|t
+DROP TABLE
+DROP VIEW
+DROP MATERIALIZED VIEW
+DROP TABLE
+DROP TABLE
+DROP FUNCTION
+
+CREATE TABLE
+INSERT 0 1
+SELECT 1
+CREATE VIEW
+SELECT 1
+SELECT 1
+CREATE FUNCTION
+1
+1
+1
+1
+1
+1
+DROP FUNCTION
+denied_table3|t
+denied_tableas3|t
+denied_view3|t
+denied_mview3|t
+denied_selectinto3|t
+1
+denied_function3|t
+DROP TABLE
+DROP VIEW
+DROP MATERIALIZED VIEW
+DROP TABLE
+DROP TABLE
+DROP FUNCTION
+
+CREATE TABLE
+INSERT 0 1
+SELECT 1
+CREATE VIEW
+SELECT 1
+SELECT 1
+CREATE FUNCTION
+1
+1
+1
+1
+1
+1
+denied_function4|t
+1
+1
+1
+1
+1
+1
+DROP TABLE
+DROP VIEW
+DROP MATERIALIZED VIEW
+DROP TABLE
+DROP TABLE
+DROP FUNCTION
+

test/CDB_QuotaTest.sql

@@ -1,30 +1,48 @@
 set client_min_messages to error;
 \set VERBOSITY TERSE
-
--- See the dice
-SELECT setseed(0.5);
+-- Runs a query and returns whether an error was thrown
+-- Useful when the error message depends on the execution plan or db settings
+-- The error message outputs the extra quota, and this might depend on the database setup and version
+CREATE OR REPLACE FUNCTION catch_error(query text)
+RETURNS bool
+AS $$
+BEGIN
+    EXECUTE query;
+    RETURN FALSE;
+EXCEPTION
+    WHEN OTHERS THEN
+        RETURN TRUE;
+END
+$$ LANGUAGE 'plpgsql';
 
 CREATE TABLE big(a int);
 -- Try the legacy interface
 -- See https://github.com/CartoDB/cartodb-postgresql/issues/13
 CREATE TRIGGER test_quota BEFORE UPDATE OR INSERT ON big
-      EXECUTE PROCEDURE CDB_CheckQuota(1, 1, 'public');
+      EXECUTE PROCEDURE cartodb.CDB_CheckQuota(2, 1, 'public');
 INSERT INTO big VALUES (1); -- allowed, check runs before
-INSERT INTO big VALUES (2); -- disallowed, quota exceeds before
-SELECT CDB_SetUserQuotaInBytes(0);
-SELECT CDB_CartodbfyTable('big');
+SELECT 'excess1', catch_error($$INSERT INTO big VALUES (2); $$); -- disallowed, quota exceeds before
+SELECT cartodb.CDB_SetUserQuotaInBytes(0);
+SELECT cartodb.CDB_CartodbfyTable('big');
+-- Creating the trigger should fail as it was created by CDB_CartodbfyTable
+CREATE TRIGGER test_quota BEFORE UPDATE OR INSERT ON big
+      EXECUTE PROCEDURE cartodb.CDB_CheckQuota(2, 1, 'public');
+-- Drop the trigger and recreate it forcing a 100% checks
+DROP TRIGGER test_quota ON big;
+CREATE TRIGGER test_quota BEFORE UPDATE OR INSERT ON big
+      EXECUTE PROCEDURE cartodb.CDB_CheckQuota(2, 1, 'public');
 INSERT INTO big SELECT generate_series(2049,4096);
 INSERT INTO big SELECT generate_series(4097,6144);
 INSERT INTO big SELECT generate_series(6145,8192);
 -- Test for #108: https://github.com/CartoDB/cartodb-postgresql/issues/108
-SELECT CDB_UserDataSize();
-SELECT cartodb._CDB_total_relation_size('public', 'big');
+SELECT cartodb.CDB_UserDataSize() < 500000 AND cartodb.CDB_UserDataSize() > 0;
+SELECT cartodb._CDB_total_relation_size('public', 'big') < 1000000;
 SELECT cartodb._CDB_total_relation_size('public', 'nonexistent_table_name');
 -- END Test for #108
-SELECT setseed(0.9);
-SELECT CDB_SetUserQuotaInBytes(2);
-INSERT INTO big VALUES (8193);
-SELECT CDB_SetUserQuotaInBytes(0);
+
+SELECT cartodb.CDB_SetUserQuotaInBytes(2);
+SELECT 'excess2', catch_error($$INSERT INTO big VALUES (8193);$$);
+SELECT cartodb.CDB_SetUserQuotaInBytes(0);
 INSERT INTO big VALUES (8194);
 DROP TABLE big;
 
@@ -32,16 +50,20 @@ DROP TABLE big;
 --analysis tables should be excluded from quota:
 CREATE TABLE big(a int);
 CREATE TRIGGER test_quota BEFORE UPDATE OR INSERT ON big
-      EXECUTE PROCEDURE CDB_CheckQuota(1, 1, 'public');
-SELECT CDB_SetUserQuotaInBytes(1);
+      EXECUTE PROCEDURE cartodb.CDB_CheckQuota(2, 1, 'public');
+SELECT cartodb.CDB_SetUserQuotaInBytes(1);
 CREATE TABLE analysis_2f13a3dbd7_41bd92976fc6dd97072afe4ee450054f4c0715d4(id int);
 INSERT INTO analysis_2f13a3dbd7_41bd92976fc6dd97072afe4ee450054f4c0715d4(id) VALUES (1),(2),(3),(4),(5);
 INSERT INTO big VALUES (1); -- allowed, check runs before
 DROP TABLE analysis_2f13a3dbd7_41bd92976fc6dd97072afe4ee450054f4c0715d4;
-INSERT INTO big VALUES (2); -- disallowed, quota exceeds before
+SELECT 'excess3', catch_error($$INSERT INTO big VALUES (3);$$); -- disallowed, quota exceeds before
 DROP TABLE big;
 SELECT CDB_SetUserQuotaInBytes(0);
 
+CREATE SCHEMA "complex-name%_with'quotes""";
+SELECT CDB_UserDataSize('"complex-name%_with''quotes"');
+DROP SCHEMA "complex-name%_with'quotes""";
 
 set client_min_messages to NOTICE;
+DROP FUNCTION catch_error(text);
 DROP FUNCTION _CDB_UserQuotaInBytes();

test/CDB_QuotaTest_expect

@@ -1,20 +1,22 @@
 SET
-
+CREATE FUNCTION
 CREATE TABLE
 CREATE TRIGGER
 INSERT 0 1
-ERROR:  Quota exceeded by 3.9990234375KB
+excess1|t
 0
 big
+ERROR:  trigger "test_quota" for relation "big" already exists
+DROP TRIGGER
+CREATE TRIGGER
 INSERT 0 2048
 INSERT 0 2048
 INSERT 0 2048
-454656
-909312
+t
+t
 0
-
 2
-ERROR:  Quota exceeded by 443.998046875KB
+excess2|t
 0
 INSERT 0 1
 DROP TABLE
@@ -25,8 +27,12 @@ CREATE TABLE
 INSERT 0 5
 INSERT 0 1
 DROP TABLE
-ERROR:  Quota exceeded by 3.9990234375KB
+excess3|t
 DROP TABLE
 0
+CREATE SCHEMA
+0
+DROP SCHEMA
 SET
 DROP FUNCTION
+DROP FUNCTION

test/CDB_SyncTableTest.sql

@@ -0,0 +1,94 @@
+-- Setup: create and populate a table to test the syncs
+\set QUIET on
+BEGIN;
+SET client_min_messages TO error;
+CREATE TABLE test_sync_source (
+  cartodb_id bigint,
+  lat double precision,
+  lon double precision,
+  name text
+);
+INSERT INTO test_sync_source VALUES
+  (1, 1.0, 1.0, 'foo'),
+  (2, 2.0, 2.0, 'bar'),
+  (3, 3.0, 3.0, 'patata'),
+  (4, 4.0, 4.0, 'melon');
+SET client_min_messages TO notice;
+\set QUIET off
+
+
+\echo 'First table sync: it should be simply just copied to the destination'
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest');
+
+\echo 'Next table sync: there shall be no changes'
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest');
+
+\echo 'Remove a row from the source and check it is deleted from the dest table'
+DELETE FROM test_sync_source WHERE cartodb_id = 3;
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest');
+
+\echo 'Insert a new row and check that it is inserted in the dest table'
+INSERT INTO test_sync_source VALUES (5, 5.0, 5.0, 'sandia');
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest');
+
+\echo 'Modify row and check that it is modified in the dest table'
+UPDATE test_sync_source SET name = 'cantaloupe' WHERE cartodb_id = 4;
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest');
+
+\echo 'Sanity check: the end result is the same source table'
+SELECT * FROM test_sync_source ORDER BY cartodb_id;
+SELECT * FROM test_sync_dest ORDER BY cartodb_id;
+
+
+\echo 'It shall exclude geom columns if instructed to do so'
+\set QUIET on
+SET client_min_messages TO error;
+SELECT cartodb.CDB_SetUserQuotaInBytes(0); -- Set user quota to infinite
+SELECT cartodb.CDB_CartodbfyTable('test_sync_source');
+SELECT cartodb.CDB_CartodbfyTable('test_sync_dest');
+UPDATE test_sync_dest SET the_geom = cartodb.CDB_LatLng(lat, lon); -- A "gecoding"
+\set QUIET off
+SET client_min_messages TO notice;
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest', '{the_geom, the_geom_webmercator}');
+SELECT * FROM test_sync_source ORDER BY cartodb_id;
+SELECT cartodb_id, the_geom, lat, lon, name FROM test_sync_dest ORDER BY cartodb_id;
+
+\echo 'It will work with schemas that need quoting'
+\set QUIET on
+SET client_min_messages TO error;
+CREATE SCHEMA "sch-ema";
+CREATE TABLE "test_sync_source2" AS SELECT * FROM test_sync_source;
+\set QUIET off
+SELECT cartodb.CDB_SyncTable('test_sync_source2', 'sch-ema', 'test_sync_dest');
+INSERT INTO test_sync_source2(cartodb_id, lat, lon, name) VALUES (6, 6.0, 6.0, 'papaya');
+DELETE FROM test_sync_source2 WHERE cartodb_id = 4;
+UPDATE test_sync_source2 SET lat = 2.5 WHERE cartodb_id = 2;
+SET client_min_messages TO notice;
+SELECT cartodb.CDB_SyncTable('test_sync_source2', 'sch-ema', 'test_sync_dest');
+
+\echo 'It will work with table names that need quoting'
+\set QUIET on
+SET client_min_messages TO error;
+CREATE TABLE "test-sync-source" AS SELECT * FROM test_sync_source;
+\set QUIET off
+SELECT cartodb.CDB_SyncTable('test-sync-source', 'public', 'test-sync-dest');
+INSERT INTO "test-sync-source"(cartodb_id, lat, lon, name) VALUES (6, 6.0, 6.0, 'papaya');
+DELETE FROM "test-sync-source" WHERE cartodb_id = 4;
+UPDATE "test-sync-source" SET lat = 2.5 WHERE cartodb_id = 2;
+SET client_min_messages TO notice;
+SELECT cartodb.CDB_SyncTable('test-sync-source', 'public', 'test-sync-dest');
+
+\echo 'It will work with column names that need quoting'
+\set QUIET on
+SET client_min_messages TO error;
+ALTER TABLE test_sync_source ADD COLUMN "a-column" int;
+\set QUIET off
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest2');
+INSERT INTO test_sync_source(cartodb_id, lat, lon, name) VALUES (6, 6.0, 6.0, 'papaya');
+DELETE FROM test_sync_source WHERE cartodb_id = 4;
+UPDATE test_sync_source SET lat = 2.5 WHERE cartodb_id = 2;
+SET client_min_messages TO notice;
+SELECT cartodb.CDB_SyncTable('test_sync_source', 'public', 'test_sync_dest2');
+
+-- Cleanup
+ROLLBACK;

test/CDB_SyncTableTest_expect

@@ -0,0 +1,94 @@
+First table sync: it should be simply just copied to the destination
+NOTICE:  INSERTED 4 row(s)
+
+Next table sync: there shall be no changes
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  DELETED 0 row(s)
+NOTICE:  INSERTED 0 row(s)
+NOTICE:  MODIFIED 0 row(s)
+
+Remove a row from the source and check it is deleted from the dest table
+DELETE 1
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  DELETED 1 row(s)
+NOTICE:  INSERTED 0 row(s)
+NOTICE:  MODIFIED 0 row(s)
+
+Insert a new row and check that it is inserted in the dest table
+INSERT 0 1
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  DELETED 0 row(s)
+NOTICE:  INSERTED 1 row(s)
+NOTICE:  MODIFIED 0 row(s)
+
+Modify row and check that it is modified in the dest table
+UPDATE 1
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  DELETED 0 row(s)
+NOTICE:  INSERTED 0 row(s)
+NOTICE:  MODIFIED 1 row(s)
+
+Sanity check: the end result is the same source table
+1|1|1|foo
+2|2|2|bar
+4|4|4|cantaloupe
+5|5|5|sandia
+1|1|1|foo
+2|2|2|bar
+4|4|4|cantaloupe
+5|5|5|sandia
+It shall exclude geom columns if instructed to do so
+0
+test_sync_source
+test_sync_dest
+SET
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  cdb_invalidate_varnish(public.test_sync_dest) called
+NOTICE:  DELETED 0 row(s)
+NOTICE:  cdb_invalidate_varnish(public.test_sync_dest) called
+NOTICE:  INSERTED 0 row(s)
+NOTICE:  cdb_invalidate_varnish(public.test_sync_dest) called
+NOTICE:  MODIFIED 0 row(s)
+
+1|||1|1|foo
+2|||2|2|bar
+4|||4|4|cantaloupe
+5|||5|5|sandia
+1|0101000020E6100000000000000000F03F000000000000F03F|1|1|foo
+2|0101000020E610000000000000000000400000000000000040|2|2|bar
+4|0101000020E610000000000000000010400000000000001040|4|4|cantaloupe
+5|0101000020E610000000000000000014400000000000001440|5|5|sandia
+It will work with schemas that need quoting
+
+INSERT 0 1
+DELETE 1
+UPDATE 1
+SET
+NOTICE:  relation "test_sync_dest" already exists, skipping
+NOTICE:  DELETED 1 row(s)
+NOTICE:  INSERTED 1 row(s)
+NOTICE:  MODIFIED 1 row(s)
+
+It will work with table names that need quoting
+
+INSERT 0 1
+DELETE 1
+UPDATE 1
+SET
+NOTICE:  relation "test-sync-dest" already exists, skipping
+NOTICE:  DELETED 1 row(s)
+NOTICE:  INSERTED 1 row(s)
+NOTICE:  MODIFIED 1 row(s)
+
+It will work with column names that need quoting
+
+INSERT 0 1
+DELETE 1
+UPDATE 1
+SET
+NOTICE:  relation "test_sync_dest2" already exists, skipping
+NOTICE:  DELETED 1 row(s)
+NOTICE:  INSERTED 1 row(s)
+NOTICE:  MODIFIED 1 row(s)
+
+ROLLBACK

test/CDB_UserTablesTest.sql

@@ -17,16 +17,16 @@ CREATE TABLE pub(a int);
 CREATE TABLE prv(a int);
 GRANT SELECT ON TABLE pub TO publicuser;
 REVOKE SELECT ON TABLE prv FROM publicuser;
-SELECT CDB_UserTables() ORDER BY 1;
-SELECT 'all',CDB_UserTables('all') ORDER BY 2;
-SELECT 'public',CDB_UserTables('public') ORDER BY 2;
-SELECT 'private',CDB_UserTables('private') ORDER BY 2;
-SELECT '--unsupported--',CDB_UserTables('--unsupported--') ORDER BY 2;
+SELECT cartodb.CDB_UserTables() ORDER BY 1;
+SELECT 'all', cartodb.CDB_UserTables('all') ORDER BY 2;
+SELECT 'public', cartodb.CDB_UserTables('public') ORDER BY 2;
+SELECT 'private', cartodb.CDB_UserTables('private') ORDER BY 2;
+SELECT '--unsupported--', cartodb.CDB_UserTables('--unsupported--') ORDER BY 2;
 -- now tests with public user
 \c contrib_regression publicuser
-SELECT 'all_publicuser',CDB_UserTables('all') ORDER BY 2;
-SELECT 'public_publicuser',CDB_UserTables('public') ORDER BY 2;
-SELECT 'private_publicuser',CDB_UserTables('private') ORDER BY 2;
+SELECT 'all_publicuser', cartodb.CDB_UserTables('all') ORDER BY 2;
+SELECT 'public_publicuser', cartodb.CDB_UserTables('public') ORDER BY 2;
+SELECT 'private_publicuser', cartodb.CDB_UserTables('private') ORDER BY 2;
 \c contrib_regression postgres
 DROP TABLE pub;
 DROP TABLE prv;

test/CDB_Username_expect

@@ -1,4 +1,4 @@
-postgres
+@@PGUSER@@
 
 fulano
 fulanito

test/README

@@ -6,6 +6,7 @@ Example, to add a test for CDB_Something function, you'd add:
  - CDB_SomethingTest.sql
  - CDB_SomethingTest_expect
 
+
 To easy the generation of the expected file you can initially omit it,
 then run "make -C .. installcheck" from the top-level dir and copy
 ../results/test/CDB_SomethingTest.out to CDB_SomethingTest_expect chopping

test/extension/test.sh

@@ -17,6 +17,10 @@ SED=sed
 OK=0
 PARTIALOK=0
 
+function reset_default_database() {
+    DATABASE=test_extension
+}
+
 function set_failed() {
     OK=1
     PARTIALOK=1
@@ -40,10 +44,10 @@ function sql() {
     fi
 
     if [ -n "${ROLE}" ]; then
-      log_debug "Executing query '${QUERY}' as ${ROLE}"
+      log_debug "Executing query '${QUERY}' as '${ROLE}' in '${DATABASE}'"
       RESULT=`${CMD} -U "${ROLE}" ${DATABASE} -c "${QUERY}" -A -t`
     else
-      log_debug "Executing query '${QUERY}'"
+      log_debug "Executing query '${QUERY}' in '${DATABASE}'"
       RESULT=`${CMD} ${DATABASE} -c "${QUERY}" -A -t`
     fi
     CODERESULT=$?
@@ -212,6 +216,8 @@ function tear_down_database() {
     ${CMD} -c "DROP DATABASE ${DATABASE}"
 }
 function tear_down() {
+    reset_default_database
+
     log_info "########################### USER TEAR DOWN ###########################"
     sql cdb_testmember_1 "SELECT * FROM cartodb.CDB_Organization_Remove_Access_Permission('cdb_testmember_1', 'foo', 'cdb_testmember_2');"
     sql cdb_testmember_2 "SELECT * FROM cartodb.CDB_Organization_Remove_Access_Permission('cdb_testmember_2', 'bar', 'cdb_testmember_1');"
@@ -362,7 +368,7 @@ function test_cdb_tablemetadatatouch_fails_from_user_without_permission() {
 
 function test_cdb_tablemetadatatouch_fully_qualifies_names() {
     sql postgres "CREATE TABLE touch_invalidations (table_name text);"
-    sql postgres "create or replace function cartodb.cdb_invalidate_varnish(table_name text) returns void as \$\$ begin insert into touch_invalidations select table_name; end; \$\$ language 'plpgsql';"
+    sql postgres "create or replace function cartodb.cdb_invalidate_varnish(table_name text) returns void as \$\$ begin insert into public.touch_invalidations select table_name; end; \$\$ language 'plpgsql';"
 
     #default schema
     sql "CREATE TABLE touch_example (a int);"
@@ -532,6 +538,8 @@ END
     DATABASE=fdw_target sql postgres "SELECT cdb_tablemetadatatouch('test_fdw.foo'::regclass);"
     DATABASE=fdw_target sql postgres "SELECT cdb_tablemetadatatouch('test_fdw.foo2'::regclass);"
 
+    reset_default_database
+
     # Add PGPORT to conf if it is set
     PORT_SPEC=""
     if [[ "$PGPORT" != "" ]] ; then
@@ -586,14 +594,21 @@ test_extension|public|"local-table-with-dashes"'
     sql postgres "SELECT cartodb.CDB_Last_Updated_Time(ARRAY['test_extension.public.\"local-table-with-dashes\"']::text[]) < now()" should 't'
     sql postgres "SELECT cartodb.CDB_Last_Updated_Time(ARRAY['test_extension.public.\"local-table-with-dashes\"']::text[]) > (now() - interval '1 minute')" should 't'
 
+    # Check CDB_Get_Foreign_Updated_At is robust to unimported CDB_TableMetadata
+    sql postgres "DROP FOREIGN TABLE IF EXISTS test_fdw.cdb_tablemetadata;"
+    sql postgres "SELECT cartodb.CDB_Get_Foreign_Updated_At('test_fdw.foo') IS NULL" should 't'
+
+    # Teardown
     DATABASE=fdw_target sql postgres 'REVOKE USAGE ON SCHEMA test_fdw FROM fdw_user;'
     DATABASE=fdw_target sql postgres 'REVOKE SELECT ON test_fdw.foo FROM fdw_user;'
     DATABASE=fdw_target sql postgres 'REVOKE SELECT ON test_fdw.foo2 FROM fdw_user;'
     DATABASE=fdw_target sql postgres 'REVOKE SELECT ON cdb_tablemetadata_text FROM fdw_user;'
     DATABASE=fdw_target sql postgres 'DROP ROLE fdw_user;'
 
+    reset_default_database
     sql postgres "select pg_terminate_backend(pid) from pg_stat_activity where datname='fdw_target';"
     DATABASE=fdw_target tear_down_database
+    reset_default_database
 }
 
 function test_cdb_catalog_basic_node() {

util/create_from_unpackaged.sh

@@ -10,6 +10,7 @@ echo "-- Script generated by $0 on `date`" > ${output}
 cat ${input} |
   grep '^ *CREATE OR REPLACE FUNCTION' |
   grep -v ' cartodb\.' | # should  only match DDL hooks
+  grep -v '.*\quit.*' | 
   sed 's/).*$/)/' |
   sed 's/DEFAULT [^ ,)]*//g' |
   sed 's/CREATE OR REPLACE FUNCTION /ALTER FUNCTION public./' |
@@ -19,59 +20,4 @@ cat ${input} |
   cat >> ${output}
 
 # Upgrade all functions
-cat ${input} | grep -v 'duplicated extension$' >> ${output}
-
-# Migrate CDB_TableMetadata
-cat >> ${output} <<'EOF'
-ALTER TABLE cartodb.CDB_TableMetadata DISABLE TRIGGER ALL;
-INSERT INTO cartodb.CDB_TableMetadata SELECT * FROM public.CDB_TableMetadata;
-ALTER TABLE cartodb.CDB_TableMetadata ENABLE TRIGGER ALL;
-DROP TABLE public.CDB_TableMetadata;
-
--- Set user quota
--- NOTE: will fail if user quota wasn't set at database level, see
---       http://github.com/CartoDB/cartodb-postgresql/issues/18
-DO $$
-DECLARE
-  qmax int8;
-BEGIN
-  BEGIN
-    qmax := public._CDB_UserQuotaInBytes();
-  EXCEPTION WHEN undefined_function THEN
-    RAISE EXCEPTION 'Please set user quota before switching to cartodb extension';
-  END;
-  PERFORM cartodb.CDB_SetUserQuotaInBytes(qmax);
-  DROP FUNCTION public._CDB_UserQuotaInBytes();
-END;
-$$ LANGUAGE 'plpgsql';
-EOF
-
-## Cartodbfy tables with a trigger using 'CDB_CheckQuota' or
-## 'CDB_TableMetadata_Trigger' from the 'public' schema
-#cat >> ${output} <<'EOF'
-#select cartodb.CDB_CartodbfyTable(relname::regclass) from ( 
-#  -- names of tables using public.CDB_CheckQuota or
-#  -- public.CDB_TableMetadata_Trigger in their triggers
-#  SELECT distinct c.relname
-#  FROM
-#    pg_trigger t,
-#    pg_class c,
-#    pg_proc p,
-#    pg_namespace n
-#  WHERE
-#    n.nspname = 'public' AND
-#    p.pronamespace = n.oid AND
-#    p.proname IN ( 'cdb_checkquota', 'cdb_tablemetadata_trigger' ) AND
-#    t.tgrelid = c.oid AND
-#    p.oid = t.tgfoid 
-#) as foo;
-#EOF
-
-## Drop any leftover function from public schema (there should be none)
-#cat ${input} |
-#  grep '^ *CREATE OR REPLACE FUNCTION' |
-#  grep -v ' cartodb\.' | # should  only match DDL hooks
-#  sed 's/).*$/);/' |
-#  sed 's/DEFAULT [^ ,)]*//g' |
-#  sed 's/CREATE OR REPLACE FUNCTION /DROP FUNCTION IF EXISTS public./' |
-#  cat >> ${output}
+cat ${input} | grep -v 'duplicated extension$' | grep -v '\quit$' | grep -v 'pg_extension_config_dump' >> ${output}