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

2025-02-25 18:55:31 -06:00 · 2020-04-09 21:03:12 +05:30
parent fecf3915c5
commit 31f255b541
22 changed files with 1510 additions and 31 deletions
--- a/web/pgadmin/tools/schema_diff/directory_compare.py
+++ b/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 target:
-    :return:
+    :param source: Source Dict
+    :param target: Target Dict
+    :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)
--- a/web/pgadmin/tools/schema_diff/tests/pg/10_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/10_plus/target.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/11_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/11_plus/target.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/12_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/12_plus/target.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/9.2_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/pg/9.2_plus/target.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/ppas/10_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/ppas/10_plus/target.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/ppas/9.2_plus/source.sql
+++ b/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;
--- a/web/pgadmin/tools/schema_diff/tests/ppas/9.2_plus/target.sql
+++ b/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;