Added support of Foreign Tables to the Schema Diff. Fixes #5263

docs/en_US/release_notes_4_21.rst

@@ -12,6 +12,7 @@ New features
 | `Issue #2172 <https://redmine.postgresql.org/issues/2172>`_ -  Added search object functionality.
 | `Issue #2186 <https://redmine.postgresql.org/issues/2186>`_ -  Added LDAP authentication support.
 | `Issue #5184 <https://redmine.postgresql.org/issues/5184>`_ -  Added support for parameter toast_tuple_target and parallel_workers of the table.
+| `Issue #5263 <https://redmine.postgresql.org/issues/5263>`_ -  Added support of Foreign Tables to the Schema Diff.
 | `Issue #5264 <https://redmine.postgresql.org/issues/5264>`_ -  Added support of Packages, Sequences and Synonyms to the Schema Diff.
 | `Issue #5353 <https://redmine.postgresql.org/issues/5353>`_ -  Added an option to prevent a browser tab being opened at startup.
 

web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/__init__.py

@@ -223,6 +223,9 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
         'compare': [{'get': 'compare'}, {'get': 'compare'}]
     })
 
+    keys_to_ignore = ['oid', 'basensp', 'oid-2', 'attnum', 'strftoptions',
+                      'relacl']
+
     def validate_request(f):
         """
         Works as a decorator.
@@ -697,7 +700,7 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             return internal_server_error(errormsg=str(e))
 
     @check_precondition
-    def delete(self, gid, sid, did, scid, foid=None):
+    def delete(self, gid, sid, did, scid, foid=None, only_sql=False):
         """
         Drops the Foreign Table.
 
@@ -707,6 +710,7 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             did: Database Id
             scid: Schema Id
             foid: Foreign Table Id
+            only_sql: Return only sql if True
         """
         if foid is None:
             data = request.form if request.form else json.loads(
@@ -750,6 +754,11 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
                                       name=name,
                                       basensp=basensp,
                                       cascade=cascade)
+
+                # Used for schema diff tool
+                if only_sql:
+                    return SQL
+
                 status, res = self.conn.execute_scalar(SQL)
                 if not status:
                     return internal_server_error(errormsg=res)
@@ -808,7 +817,8 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             return internal_server_error(errormsg=str(e))
 
     @check_precondition
-    def sql(self, gid, sid, did, scid, foid=None):
+    def sql(self, gid, sid, did, scid, foid=None, diff_schema=None,
+            json_resp=True):
         """
         Returns the SQL for the Foreign Table object.
 
@@ -818,12 +828,17 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             did: Database Id
             scid: Schema Id
             foid: Foreign Table Id
+            diff_schema: Target Schema for schema diff
+            json_resp: True then return json response
         """
         status, data = self._fetch_properties(gid, sid, did, scid, foid,
                                               inherits=True)
         if not status:
             return data
 
+        if diff_schema:
+            data['basensp'] = diff_schema
+
         col_data = []
         for c in data['columns']:
             if ('inheritedfrom' not in c) or (c['inheritedfrom'] is None):
@@ -839,6 +854,9 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
         SQL = render_template("/".join([self.template_path,
                                         'create.sql']), data=data, is_sql=True)
 
+        if not json_resp:
+            return SQL.strip('\n')
+
         sql_header = u"""-- FOREIGN TABLE: {0}
 
 -- DROP FOREIGN TABLE {0};
@@ -883,7 +901,8 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
         except Exception as e:
             return internal_server_error(errormsg=str(e))
 
-    def get_sql(self, gid, sid, did, scid, data, foid=None):
+    def get_sql(self, gid, sid, did, scid, data, foid=None,
+                is_schema_diff=False):
         """
         Genrates the SQL statements to create/update the Foreign Table.
 
@@ -893,6 +912,7 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             did: Database Id
             scid: Schema Id
             foid: Foreign Table Id
+            is_schema_diff: True is function gets called from schema diff
         """
         if foid is not None:
             status, old_data = self._fetch_properties(gid, sid, did, scid,
@@ -900,6 +920,10 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             if not status:
                 return old_data
 
+            if is_schema_diff:
+                data['is_schema_diff'] = True
+                old_data['columns_for_schema_diff'] = old_data['columns']
+
             # Prepare dict of columns with key = column's attnum
             # Will use this in the update template when any column is
             # changed, to identify the columns.
@@ -960,10 +984,21 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
                 data['acl']['deleted'] = parse_priv_to_db(
                     data['acl']['deleted'], ["a", "r", "w", "x"])
 
-            SQL = render_template(
+            # If ftsrvname is changed while comparing two schemas
-                "/".join([self.template_path, 'update.sql']),
+            # then we need to drop foreign table and recreate it
-                data=data, o_data=old_data
+            if is_schema_diff and 'ftsrvname' in data:
-            )
+                # Modify the data required to recreate the foreign table.
+                self.modify_data_for_schema_diff(data, old_data)
+
+                SQL = render_template(
+                    "/".join([self.template_path,
+                              'foreign_table_schema_diff.sql']),
+                    data=data, o_data=old_data)
+            else:
+                SQL = render_template(
+                    "/".join([self.template_path, 'update.sql']),
+                    data=data, o_data=old_data
+                )
             return SQL, data['name'] if 'name' in data else old_data['name']
         else:
             data['columns'] = self._format_columns(data['columns'])
@@ -1328,7 +1363,7 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
         return ajax_response(response=sql)
 
     @check_precondition
-    def delete_sql(self, gid, sid, did, scid, foid):
+    def delete_sql(self, gid, sid, did, scid, foid, only_sql=False):
         """
         DELETE script sql for the object
 
@@ -1338,6 +1373,7 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             did: Database Id
             scid: Schema Id
             foid: Foreign Table Id
+            only_sql: Return only sql if True
 
         Returns:
             DELETE Script sql for the object
@@ -1350,6 +1386,10 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
             self.qtIdent(self.conn, data['basensp'], data['name'])
         )
 
+        # Used for schema diff tool
+        if only_sql:
+            return sql
+
         return ajax_response(response=sql)
 
     @check_precondition
@@ -1384,5 +1424,86 @@ class ForeignTableView(PGChildNodeView, DataTypeReader,
 
         return res
 
+    def get_sql_from_diff(self, gid, sid, did, scid, oid, data=None,
+                          diff_schema=None, drop_sql=False):
+        """
+        This function is used to get the DDL/DML statements.
+        :param gid: Group ID
+        :param sid: Serve ID
+        :param did: Database ID
+        :param scid: Schema ID
+        :param oid: Collation ID
+        :param data: Difference data
+        :param diff_schema: Target Schema
+        :param drop_sql: True if need to drop the domains
+        :return:
+        """
+        sql = ''
+        if data:
+            if diff_schema:
+                data['schema'] = diff_schema
+            sql, name = self.get_sql(gid=gid, sid=sid, did=did, scid=scid,
+                                     data=data, foid=oid,
+                                     is_schema_diff=True)
+        else:
+            if drop_sql:
+                sql = self.delete(gid=gid, sid=sid, did=did,
+                                  scid=scid, foid=oid, only_sql=True)
+            elif diff_schema:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, foid=oid,
+                               diff_schema=diff_schema, json_resp=False)
+            else:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, foid=oid,
+                               json_resp=False)
+        return sql
 
+    def modify_data_for_schema_diff(self, data, old_data):
+        """
+        This function modifies the data for columns, constraints, options
+        etc...
+        :param data:
+        :return:
+        """
+        tmp_columns = []
+        if 'columns_for_schema_diff' in old_data:
+            tmp_columns = old_data['columns_for_schema_diff']
+        if 'columns' in data:
+            if 'added' in data['columns']:
+                for item in data['columns']['added']:
+                    tmp_columns.append(item)
+            if 'changed' in data['columns']:
+                for item in data['columns']['changed']:
+                    tmp_columns.append(item)
+            if 'deleted' in data['columns']:
+                for item in data['columns']['deleted']:
+                    tmp_columns.remove(item)
+            data['columns'] = tmp_columns
+
+        tmp_constraints = []
+        if 'constraints' in data:
+            if 'added' in data['constraints']:
+                for item in data['constraints']['added']:
+                    tmp_constraints.append(item)
+            if 'changed' in data['constraints']:
+                for item in data['constraints']['changed']:
+                    tmp_constraints.append(item)
+            data['constraints'] = tmp_constraints
+
+        tmp_ftoptions = []
+        if 'ftoptions' in old_data:
+            tmp_ftoptions = old_data['ftoptions']
+        if 'ftoptions' in data:
+            if 'added' in data['ftoptions']:
+                for item in data['ftoptions']['added']:
+                    tmp_ftoptions.append(item)
+            if 'changed' in data['ftoptions']:
+                for item in data['ftoptions']['changed']:
+                    tmp_ftoptions.append(item)
+            if 'deleted' in data['ftoptions']:
+                for item in data['ftoptions']['deleted']:
+                    tmp_ftoptions.remove(item)
+            data['ftoptions'] = tmp_ftoptions
+
+
+SchemaDiffRegistry(blueprint.node_type, ForeignTableView)
 ForeignTableView.register_node_view(blueprint)

web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/templates/foreign_tables/sql/9.2_plus/get_columns.sql

@@ -16,7 +16,7 @@ LEFT OUTER JOIN
 LEFT OUTER JOIN
     pg_type b ON t.typelem=b.oid
 LEFT OUTER JOIN
-    pg_collation cl ON t.typcollation=cl.oid
+    pg_collation cl ON att.attcollation=cl.oid
 LEFT OUTER JOIN
     pg_namespace cn ON cl.collnamespace=cn.oid
 WHERE

web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/templates/foreign_tables/sql/9.5_plus/foreign_table_schema_diff.sql

@@ -0,0 +1,76 @@
+{% import 'macros/schemas/security.macros' as SECLABEL %}
+{% import 'macros/schemas/privilege.macros' as PRIVILEGE %}
+{% set is_columns = [] %}
+{% if data.columns %}{% set columns = data.columns %}{% elif o_data.columns %}{% set columns = o_data.columns %}{% endif %}
+{% if data.inherits %}{% set inherits = data.inherits %}{% elif o_data.columns %}{% set inherits = o_data.inherits %}{% endif %}
+{% if data.ftoptions %}{% set ftoptions = data.ftoptions %}{% elif o_data.ftoptions %}{% set ftoptions = o_data.ftoptions %}{% endif %}
+{% if data.constraints %}{% set constraints = data.constraints %}{% elif o_data.constraints %}{% set constraints = o_data.constraints %}{% endif %}
+{% if data.acl %}{% set acl = data.acl %}{% elif o_data.acl %}{% set acl = o_data.acl %}{% endif %}
+-- WARNING:
+-- We have found the difference in foreign server
+-- so we need to drop the existing foreign table first and re-create it.
+DROP FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }};
+
+CREATE FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }}(
+{% if columns %}
+{% for c in columns %}
+{% if (not c.inheritedfrom or c.inheritedfrom =='' or  c.inheritedfrom == None or  c.inheritedfrom == 'None' ) %}
+{% if is_columns.append('1') %}{% endif %}
+    {{conn|qtIdent(c.attname)}} {% if is_sql %}{{ c.fulltype }}{% else %}{{c.datatype }}{% if c.typlen %}({{c.typlen}}{% if c.precision %}, {{c.precision}}{% endif %}){% endif %}{% if c.isArrayType %}[]{% endif %}{% endif %}{% if c.coloptions %}
+{% for o in c.coloptions %}{% if o.option and o.value %}
+{% if loop.first %} OPTIONS ({% endif %}{% if not loop.first %}, {% endif %}{{o.option}} {{o.value|qtLiteral}}{% if loop.last %}){% endif %}{% endif %}
+{% endfor %}{% endif %}
+{% if c.attnotnull %} NOT NULL{% else %} NULL{% endif %}
+{% if c.typdefault is defined and c.typdefault is not none %} DEFAULT {{c.typdefault}}{% endif %}
+{% if c.collname %} COLLATE {{c.collname}}{% endif %}
+{% if not loop.last %},
+{% endif %}
+{% endif %}
+{% endfor %}
+{% endif %}
+
+)
+{% if inherits %}
+    INHERITS ({% for i in inherits %}{% if i %}{{i}}{% if not loop.last %}, {% endif %}{% endif %}{% endfor %})
+{% endif %}
+    SERVER {{ conn|qtIdent(data.ftsrvname) }}{% if ftoptions %}
+
+{% for o in ftoptions %}
+{% if o.option and o.value %}
+{% if loop.first %}    OPTIONS ({% endif %}{% if not loop.first %}, {% endif %}{{o.option}} {{o.value|qtLiteral}}{% if loop.last %}){% endif %}{% endif %}
+{% endfor %}{% endif %};
+{% if data.owner %}
+
+ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    OWNER TO {{ data.owner }};
+{% endif -%}
+{% if constraints %}
+{% for c in constraints %}
+
+ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% if c.connoinherit %} NO INHERIT{% endif %};
+{% endfor %}
+{% endif %}
+{% if data.description %}
+
+COMMENT ON FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    IS '{{ data.description }}';
+{ % elif o_data.description %}
+
+COMMENT ON FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    IS '{{ o_data.description }}';
+{% endif -%}
+{% if acl %}
+
+{% for priv in acl %}
+{{ PRIVILEGE.SET(conn, 'TABLE', priv.grantee, o_data.name, priv.without_grant, priv.with_grant, o_data.basensp) }}
+{% endfor -%}
+{% endif -%}
+{% if data.seclabels %}
+{% for r in data.seclabels %}
+{% if r.label and r.provider %}
+
+{{ SECLABEL.SET(conn, 'FOREIGN TABLE', o_data.name, r.provider, r.label, o_data.basensp) }}
+{% endif %}
+{% endfor %}
+{% endif %}

web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/templates/foreign_tables/sql/9.5_plus/get_columns.sql

@@ -34,7 +34,7 @@ LEFT OUTER JOIN
 LEFT OUTER JOIN
     pg_type b ON t.typelem=b.oid
 LEFT OUTER JOIN
-    pg_collation cl ON t.typcollation=cl.oid
+    pg_collation cl ON att.attcollation=cl.oid
 LEFT OUTER JOIN
     pg_namespace cn ON cl.collnamespace=cn.oid
 WHERE

web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/templates/foreign_tables/sql/9.5_plus/update.sql

@@ -121,6 +121,16 @@ ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, name) }}
     ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% if c.connoinherit %} NO INHERIT{% endif %};
 
 {% endfor %}
+{% if data.is_schema_diff is defined and data.is_schema_diff %}
+{% for c in data.constraints.changed %}
+ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, name) }}
+    DROP CONSTRAINT {{conn|qtIdent(c.conname)}};
+
+ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, name) }}
+    ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% if c.connoinherit %} NO INHERIT{% endif %};
+
+{% endfor %}
+{% else %}
 {% for c in data.constraints.changed %}
 {% if c.convalidated %}
 ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, name) }}
@@ -129,6 +139,7 @@ ALTER FOREIGN TABLE {{ conn|qtIdent(o_data.basensp, name) }}
 {% endif %}
 {% endfor %}
 {% endif %}
+{% endif %}
 {% if data.ftoptions %}
 {% for o in data.ftoptions.deleted %}
 {% if o.option and o.value %}

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/compound_triggers/__init__.py

@@ -30,7 +30,7 @@ from pgadmin.utils.compile_template_name import compile_template_path
 from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
 from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
 from pgadmin.tools.schema_diff.directory_compare import directory_diff,\
-    parce_acl
+    parse_acl
 
 
 # If we are in Python3
@@ -1012,7 +1012,7 @@ class CompoundTriggerView(PGChildNodeView, SchemaDiffObjectCompare):
                 source, target,
                 ignore_keys=self.keys_to_ignore, difference={}
             )
-            diff_dict.update(parce_acl(source, target))
+            parse_acl(source, target, diff_dict)
 
             diff = self.get_sql_from_diff(gid=tgt_params['gid'],
                                           sid=tgt_params['sid'],

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/rules/__init__.py

@@ -29,7 +29,7 @@ from pgadmin.utils import IS_PY2
 from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
 from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
 from pgadmin.tools.schema_diff.directory_compare import directory_diff,\
-    parce_acl
+    parse_acl
 
 # If we are in Python3
 if not IS_PY2:
@@ -680,7 +680,7 @@ class RuleView(PGChildNodeView, SchemaDiffObjectCompare):
                 source, target,
                 ignore_keys=self.keys_to_ignore, difference={}
             )
-            diff_dict.update(parce_acl(source, target))
+            parse_acl(source, target, diff_dict)
 
             diff = self.get_sql_from_diff(gid=tgt_params['gid'],
                                           sid=tgt_params['sid'],

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/triggers/__init__.py

@@ -30,7 +30,7 @@ from pgadmin.utils import IS_PY2
 from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
 from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
 from pgadmin.tools.schema_diff.directory_compare import directory_diff,\
-    parce_acl
+    parse_acl
 
 # If we are in Python3
 if not IS_PY2:
@@ -1007,7 +1007,7 @@ class TriggerView(PGChildNodeView, SchemaDiffObjectCompare):
                 source, target,
                 ignore_keys=self.keys_to_ignore, difference={}
             )
-            diff_dict.update(parce_acl(source, target))
+            parse_acl(source, target, diff_dict)
 
             diff = self.get_sql_from_diff(gid=tgt_params['gid'],
                                           sid=tgt_params['sid'],

web/pgadmin/tools/schema_diff/directory_compare.py

@@ -171,7 +171,7 @@ def compare_dictionaries(view_object, source_params, target_params,
                     ignore_keys=temp_ignore_keys,
                     difference={}
                 )
-                diff_dict.update(parce_acl(dict1[key], dict2[key]))
+                parse_acl(dict1[key], dict2[key], diff_dict)
 
                 temp_src_params['tid'] = source_object_id
                 temp_tgt_params['tid'] = target_object_id
@@ -192,7 +192,7 @@ def compare_dictionaries(view_object, source_params, target_params,
                     dict1[key], dict2[key],
                     ignore_keys=view_object.keys_to_ignore, difference={}
                 )
-                diff_dict.update(parce_acl(dict1[key], dict2[key]))
+                parse_acl(dict1[key], dict2[key], diff_dict)
 
                 temp_src_params['oid'] = source_object_id
                 temp_tgt_params['oid'] = target_object_id
@@ -351,7 +351,7 @@ def directory_diff(source_dict, target_dict, ignore_keys=[], difference={}):
                     elif type(source) is dict:
                         tmp_key_array = ['name', 'colname', 'argid', 'token',
                                          'option', 'conname', 'member_name',
-                                         'label']
+                                         'label', 'attname']
                         # Check the above keys are exist in the dictionary
                         tmp_key = is_key_exists(tmp_key_array, source)
                         if tmp_key is not None:
@@ -400,6 +400,9 @@ def directory_diff(source_dict, target_dict, ignore_keys=[], difference={}):
             elif tmp_target and type(tmp_target) is list:
                 difference[key]['deleted'] = tmp_target
 
+            # No point adding empty list into difference.
+            if key in difference and len(difference[key]) == 0:
+                difference.pop(key)
         else:
             if source_dict[key] != target_dict[key]:
                 if (key == 'comment' or key == 'description') and \
@@ -426,13 +429,13 @@ def is_key_exists(key_list, target_dict):
     return None
 
 
-def parce_acl(source, target):
+def parse_acl(source, target, diff_dict):
     """
     This function is used to parse acl.
 
-    :param source:
+    :param source: Source Dict
-    :param target:
+    :param target: Target Dict
-    :return:
+    :param diff_dict: Difference Dict
     """
     acl_keys = ['datacl', 'relacl', 'typacl', 'pkgacl']
     key = is_key_exists(acl_keys, source)
@@ -443,6 +446,8 @@ def parce_acl(source, target):
         key = is_key_exists(acl_keys, target)
         if key is None:
             key = 'acl'
+    elif key is not None and type(source[key]) != list:
+        key = 'acl'
 
     tmp_source = source[key] if\
         key in source and source[key] is not None else []
@@ -457,4 +462,9 @@ def parce_acl(source, target):
             diff['added'].append(acl)
     diff['deleted'] = tmp_target
 
-    return {key: diff}
+    # Update the key if there are some element in added or deleted
+    # else remove that key from diff dict
+    if len(diff['added']) > 0 or len(diff['deleted']) > 0:
+        diff_dict.update({key: diff})
+    elif key in diff_dict:
+        diff_dict.pop(key)

web/pgadmin/tools/schema_diff/tests/pg/10_plus/source.sql

@@ -735,3 +735,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO pg_monitor;
+GRANT ALL ON TABLE source.ft_src TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE source.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/10_plus/target.sql

@@ -686,3 +686,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO pg_monitor;
+GRANT ALL ON TABLE target.ft_tar TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_col TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/11_plus/source.sql

@@ -698,3 +698,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO pg_monitor;
+GRANT ALL ON TABLE source.ft_src TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE source.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/11_plus/target.sql

@@ -685,3 +685,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO pg_monitor;
+GRANT ALL ON TABLE target.ft_tar TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_col TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/12_plus/source.sql

@@ -699,3 +699,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO pg_monitor;
+GRANT ALL ON TABLE source.ft_src TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE source.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/12_plus/target.sql

@@ -674,3 +674,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO pg_monitor;
+GRANT ALL ON TABLE target.ft_tar TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_col TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO pg_monitor;
+GRANT ALL ON TABLE target.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/9.2_plus/source.sql

@@ -568,3 +568,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO PUBLIC;
+GRANT ALL ON TABLE source.ft_src TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE source.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/pg/9.2_plus/target.sql

@@ -592,3 +592,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO postgres;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO postgres;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO postgres;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO postgres;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to postgres;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO PUBLIC;
+GRANT ALL ON TABLE target.ft_tar TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_col TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO postgres;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_const TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO postgres;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO postgres;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/ppas/10_plus/source.sql

@@ -1,5 +1,5 @@
 --
--- PostgreSQL database dump
+-- enterprisedbQL database dump
 --
 
 -- Dumped from database version 10.7
@@ -519,11 +519,11 @@ CREATE TYPE source.typ_range_col_diff AS RANGE
     SUBTYPE_OPCLASS = text_ops
 );
 ALTER TYPE source.typ_range_col_diff
-    OWNER TO pg_monitor;
+    OWNER TO PUBLIC;
 COMMENT ON TYPE source.typ_range_col_diff
     IS 'Test Comment';
 GRANT USAGE ON TYPE source.typ_range_col_diff TO PUBLIC;
-GRANT USAGE ON TYPE source.typ_range_col_diff TO pg_monitor WITH GRANT OPTION;
+GRANT USAGE ON TYPE source.typ_range_col_diff TO PUBLIC WITH GRANT OPTION;
 
 CREATE TYPE source.typ_range_subtype_diff AS RANGE
 (
@@ -796,3 +796,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO enterprisedb;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO enterprisedb;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO PUBLIC;
+GRANT ALL ON TABLE source.ft_src TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO enterprisedb;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE source.ft_diff_const TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/ppas/10_plus/target.sql

@@ -1,5 +1,5 @@
 --
--- PostgreSQL database dump
+-- enterprisedbQL database dump
 --
 
 -- Dumped from database version 10.7
@@ -531,7 +531,7 @@ ALTER TYPE target.typ_shell_tar
 
 CREATE TYPE target.typ_shell_diff;
 ALTER TYPE target.typ_shell_diff
-    OWNER TO pg_monitor;
+    OWNER TO PUBLIC;
 
 -- Type script to test when Type is different
 CREATE TYPE target.typ_comp_range_diff AS RANGE
@@ -773,3 +773,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO enterprisedb;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO enterprisedb;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO PUBLIC;
+GRANT ALL ON TABLE target.ft_tar TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_col TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO enterprisedb;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_const TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/ppas/9.2_plus/source.sql

@@ -1,5 +1,5 @@
 --
--- PostgreSQL database dump
+-- enterprisedbQL database dump
 --
 
 -- Dumped from database version 10.7
@@ -728,3 +728,107 @@ CREATE SEQUENCE source.seq_diff
     CACHE 2;
 ALTER SEQUENCE source.seq_diff
     OWNER TO enterprisedb;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO enterprisedb;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_src(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_src
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_src
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_src
+    IS 'Test Comment';
+GRANT INSERT ON TABLE source.ft_src TO PUBLIC;
+GRANT ALL ON TABLE source.ft_src TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_col(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default",
+    fcity character varying(40) NULL COLLATE pg_catalog."POSIX"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_col
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE source.ft_diff_col
+    IS 'Test Comment';
+
+CREATE FOREIGN TABLE source.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_const
+    OWNER TO enterprisedb;
+
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 1000)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20));
+ALTER FOREIGN TABLE source.ft_diff_const
+    ADD CONSTRAINT fcheck_src CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE source.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE source.ft_diff_const TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val20', opt_src 'val_src');
+ALTER FOREIGN TABLE source.ft_diff_opt
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE source.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1');
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE source.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs1 CHECK ((fid > 200)) NO INHERIT;

web/pgadmin/tools/schema_diff/tests/ppas/9.2_plus/target.sql

@@ -1,5 +1,5 @@
 --
--- PostgreSQL database dump
+-- enterprisedbQL database dump
 --
 
 -- Dumped from database version 10.7
@@ -742,3 +742,109 @@ CREATE SEQUENCE target.seq_diff
 
 ALTER SEQUENCE target.seq_diff
     OWNER TO enterprisedb;
+
+-- Foreign Data Wrapper to test foreign table
+CREATE FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER FOREIGN DATA WRAPPER test_fdw_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Foreign Server to test foreign table
+CREATE SERVER test_fs_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs_for_foreign_table
+    OWNER TO enterprisedb;
+CREATE SERVER test_fs2_for_foreign_table
+    FOREIGN DATA WRAPPER test_fdw_for_foreign_table;
+ALTER SERVER test_fs2_for_foreign_table
+    OWNER TO enterprisedb;
+
+-- Table to test inheritance in foreign table
+CREATE TABLE public.test_table_for_foreign_table
+(
+    tid bigint NOT NULL,
+    tname text COLLATE pg_catalog."default",
+    CONSTRAINT test_table_for_foreign_table_pkey PRIMARY KEY (tid)
+)
+WITH (
+    OIDS = FALSE
+)
+TABLESPACE pg_default;
+ALTER TABLE public.test_table_for_foreign_table
+    OWNER to enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_tar(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_tar
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_tar
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_tar
+    IS 'Test Comment';
+GRANT INSERT ON TABLE target.ft_tar TO PUBLIC;
+GRANT ALL ON TABLE target.ft_tar TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_col(
+    fid bigint NULL,
+    fname text NOT NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_col
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_diff_col
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+COMMENT ON FOREIGN TABLE target.ft_diff_col
+    IS 'Comment';
+GRANT INSERT ON TABLE target.ft_diff_col TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_col TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_const(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_const
+    OWNER TO enterprisedb;
+
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck CHECK ((fid > 1000)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck1 CHECK ((fid > 50)) NO INHERIT NOT VALID;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck2 CHECK ((fid > 20)) NO INHERIT;
+ALTER FOREIGN TABLE target.ft_diff_const
+    ADD CONSTRAINT fcheck_tar CHECK ((fid > 50));
+
+GRANT INSERT ON TABLE target.ft_diff_const TO PUBLIC;
+GRANT ALL ON TABLE target.ft_diff_const TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_opt(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val30', opt_tar 'val_tar');
+
+ALTER FOREIGN TABLE target.ft_diff_opt
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server(
+    fid bigint NULL,
+    fname text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server
+    OWNER TO enterprisedb;
+
+CREATE FOREIGN TABLE target.ft_diff_foreign_server_1(
+    fid bigint NULL,
+    fcity text NULL COLLATE pg_catalog."default"
+)
+    SERVER test_fs2_for_foreign_table
+    OPTIONS (opt1 'val1', opt2 'val2');
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    OWNER TO enterprisedb;
+ALTER FOREIGN TABLE target.ft_diff_foreign_server_1
+    ADD CONSTRAINT cs2 CHECK ((fid > 200)) NO INHERIT;