Add files using upload-large-folder tool

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/aggregates/__init__.py

@@ -0,0 +1,371 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+""" Implements Aggregate Node """
+
+from functools import wraps
+
+from flask import render_template
+from flask_babel import gettext
+
+import pgadmin.browser.server_groups.servers.databases as database
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.server_groups.servers.databases.schemas.utils \
+    import SchemaChildModule
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response, gone
+from pgadmin.utils.compile_template_name import compile_template_path
+from pgadmin.utils.driver import get_driver
+
+
+class AggregateModule(SchemaChildModule):
+    """
+     class AggregateModule(SchemaChildModule)
+
+        A module class for Aggregate node derived from SchemaChildModule.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Method is used to initialize the Aggregate and it's base module.
+
+    * get_nodes(gid, sid, did, scid, agid)
+      - Method is used to generate the browser collection node.
+
+    * node_inode()
+      - Method is overridden from its base class to make the node as leaf node.
+
+    * script_load()
+      - Load the module script for schema, when any of the server node is
+        initialized.
+    """
+
+    _NODE_TYPE = 'aggregate'
+    _COLLECTION_LABEL = gettext("Aggregates")
+
+    def __init__(self, *args, **kwargs):
+        """
+        Method is used to initialize the AggregateModule and it's base module.
+
+        Args:
+            *args:
+            **kwargs:
+        """
+
+        super().__init__(*args, **kwargs)
+        self.min_ver = 90100
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid):
+        """
+        Generate the collection node
+        """
+        if self.has_nodes(sid, did, scid=scid,
+                          base_template_path=AggregateView.BASE_TEMPLATE_PATH):
+            yield self.generate_browser_collection_node(scid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for database, when any of the database node is
+        initialized.
+        """
+        return database.DatabaseModule.node_type
+
+    @property
+    def node_inode(self):
+        return False
+
+
+blueprint = AggregateModule(__name__)
+
+
+class AggregateView(PGChildNodeView):
+    """
+    This class is responsible for generating routes for Aggregate node
+
+    Methods:
+    -------
+    * __init__(**kwargs)
+      - Method is used to initialize the AggregateView and it's base view.
+
+    * check_precondition()
+      - This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+
+    * list()
+      - This function is used to list all the Aggregate nodes within that
+      collection.
+
+    * nodes()
+      - This function will used to create all the child node within that
+        collection, Here it will create all the Aggregate node.
+
+    * properties(gid, sid, did, scid, agid)
+      - This function will show the properties of the selected Aggregate node
+
+
+    * sql(gid, sid, did, scid):
+      - This function will generate sql to show it in sql pane for the
+        selected Aggregate node.
+    """
+
+    node_type = blueprint.node_type
+    node_label = "Aggregate"
+    BASE_TEMPLATE_PATH = 'aggregates/sql/#{0}#'
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'agid'}
+    ]
+
+    operations = dict({
+        'obj': [
+            {'get': 'properties', 'delete': 'delete', 'put': 'update'},
+            {'get': 'list', 'post': 'create', 'delete': 'delete'}
+        ],
+        'delete': [{'delete': 'delete'}, {'delete': 'delete'}],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}]
+    })
+
+    def check_precondition(f):
+        """
+        This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            # Here args[0] will hold self & kwargs will hold gid,sid,did
+            self = args[0]
+            self.manager = get_driver(PG_DEFAULT_DRIVER).connection_manager(
+                kwargs['sid']
+            )
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.datistemplate = False
+            if (
+                self.manager.db_info is not None and
+                kwargs['did'] in self.manager.db_info and
+                'datistemplate' in self.manager.db_info[kwargs['did']]
+            ):
+                self.datistemplate = self.manager.db_info[
+                    kwargs['did']]['datistemplate']
+
+            # Set the template path for the SQL scripts
+            self.template_path = \
+                self.BASE_TEMPLATE_PATH.format(self.manager.version)
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid):
+        """
+        This function is used to list all the aggregate nodes within that
+        collection.
+
+        Args:
+            gid: Server group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available aggregate nodes
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), scid=scid)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid):
+        """
+        This function will used to create all the child node within that
+        collection.
+        Here it will create all the aggregate node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available aggregate child nodes
+        """
+
+        res = []
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), scid=scid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-aggregate",
+                    description=row['description']
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, agid):
+        """
+        This function will fetch properties of the aggregate node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            agid: Aggregate ID
+
+        Returns:
+            JSON of given aggregate node
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), agid=agid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-aggregate"
+                ),
+                status=200
+            )
+
+        return gone(self.not_found_error_msg())
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, agid):
+        """
+        This function will show the properties of the selected aggregate node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did:  Database ID
+            scid: Schema ID
+            scid: Schema ID
+            agid: Aggregate ID
+
+        Returns:
+            JSON of selected aggregate node
+        """
+
+        status, res = self._fetch_properties(scid, agid)
+        if not status:
+            return res
+
+        return ajax_response(
+            response=res,
+            status=200
+        )
+
+    def _fetch_properties(self, scid, agid):
+        """
+        This function fetch the properties for the specified object.
+
+        :param scid: Schema ID
+        :param agid: Aggregate ID
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, agid=agid,
+                              datlastsysoid=self._DATABASE_LAST_SYSTEM_OID)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return False, gone(self.not_found_error_msg())
+
+        res['rows'][0]['is_sys_obj'] = (
+            res['rows'][0]['oid'] <= self._DATABASE_LAST_SYSTEM_OID or
+            self.datistemplate)
+
+        return True, res['rows'][0]
+
+    @check_precondition
+    def sql(self, gid, sid, did, scid, agid, **kwargs):
+        """
+        This function will generates reverse engineered sql for aggregate
+        object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           agid: Aggregate ID
+           json_resp: True then return json response
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, agid=agid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+        if len(res['rows']) == 0:
+            return gone(self.not_found_error_msg())
+
+        data = res['rows'][0]
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._CREATE_SQL]),
+                              data=data)
+
+        sql_header = "-- Aggregate: {0};\n\n-- ".format(data['name'])
+
+        sql_header += render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]),
+                                      data=data)
+        SQL = sql_header + '\n' + SQL.strip('\n')
+
+        return ajax_response(response=SQL)
+
+
+AggregateView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/catalog_objects/__init__.py

@@ -0,0 +1,364 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+""" Implements Catalog objects Node."""
+
+from functools import wraps
+
+from flask import render_template
+from flask_babel import gettext
+
+import pgadmin.browser.server_groups.servers.databases as database
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.server_groups.servers.databases.schemas.utils \
+    import SchemaChildModule
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import gone
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response
+from pgadmin.utils.driver import get_driver
+
+
+class CatalogObjectModule(SchemaChildModule):
+    """
+     class CatalogObjectModule(SchemaChildModule)
+
+        A module class for Catalog objects node derived from SchemaChildModule.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Method is used to initialize the Catalog objects and it's base module.
+
+    * get_nodes(gid, sid, did, scid, coid)
+      - Method is used to generate the browser collection node.
+
+    * script_load()
+      - Load the module script for Catalog objects, when any of the server node
+        is initialized.
+    """
+    _NODE_TYPE = 'catalog_object'
+    _COLLECTION_LABEL = gettext("Catalog Objects")
+
+    # Flag for not to show node under Schema/Catalog node
+    # By default its set to True to display node in schema/catalog
+    # We do not want to display 'Catalog Objects' under Schema/Catalog
+    # but only in information_schema/sys
+    CATALOG_DB_SUPPORTED = False
+    SUPPORTED_SCHEMAS = ['information_schema', 'sys']
+
+    def __init__(self, *args, **kwargs):
+        """
+        Method is used to initialize the CatalogObjectModule and it's base
+        module.
+
+        Args:
+            *args:
+            **kwargs:
+        """
+        super().__init__(*args, **kwargs)
+        self.min_ver = None
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid):
+        """
+        Generate the collection node
+        """
+        yield self.generate_browser_collection_node(scid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for server, when any of the database node is
+        initialized.
+        """
+        return database.DatabaseModule.node_type
+
+    def register(self, app, options):
+        """
+        Override the default register function to automagically register
+        sub-modules at once.
+        """
+        super().register(app, options)
+
+        from .columns import blueprint as module
+        app.register_blueprint(module)
+
+
+blueprint = CatalogObjectModule(__name__)
+
+
+class CatalogObjectView(PGChildNodeView):
+    """
+    This class is responsible for generating routes for Catalog objects node.
+
+    Methods:
+    -------
+    * check_precondition()
+      - This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+
+    * list()
+      - Lists all the Catalog objects nodes within that collection.
+
+    * nodes()
+      - Creates all the nodes of type Catalog objects.
+
+    * properties(gid, sid, did, scid, coid)
+      - Shows the properties of the selected Catalog objects node.
+
+    * dependency(gid, sid, did, scid):
+      - Returns the dependencies list for the given catalog object node.
+
+    * dependent(gid, sid, did, scid):
+      - Returns the dependents list for the given Catalog objects node.
+    """
+    node_type = blueprint.node_type
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'coid'}
+    ]
+
+    operations = dict({
+        'obj': [{'get': 'properties'}, {'get': 'list'}],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}],
+        'dependency': [{'get': 'dependencies'}],
+        'dependent': [{'get': 'dependents'}]
+    })
+
+    def check_precondition(f):
+        """
+        This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            # Here args[0] will hold self & kwargs will hold gid,sid,did
+            self = args[0]
+            self.manager = get_driver(PG_DEFAULT_DRIVER).connection_manager(
+                kwargs['sid']
+            )
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.datistemplate = False
+            if (
+                self.manager.db_info is not None and
+                kwargs['did'] in self.manager.db_info and
+                'datistemplate' in self.manager.db_info[kwargs['did']]
+            ):
+                self.datistemplate = self.manager.db_info[
+                    kwargs['did']]['datistemplate']
+
+            self.template_path = 'catalog_object/sql/{0}/#{1}#'.format(
+                'ppas' if self.manager.server_type == 'ppas' else 'pg',
+                self.manager.version
+            )
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid):
+        """
+        This function is used to list all the catalog objects
+        nodes within that collection.
+
+        Args:
+            gid: Server group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available catalog objects nodes
+        """
+
+        SQL = render_template("/".join([
+            self.template_path, self._PROPERTIES_SQL
+        ]), scid=scid
+        )
+
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid):
+        """
+        This function will used to create all the child node within that
+        collection.
+        Here it will create all the catalog objects node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available catalog objects child nodes
+        """
+        res = []
+        SQL = render_template(
+            "/".join([self.template_path, self._NODES_SQL]), scid=scid
+        )
+
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-catalog_object",
+                    description=row['description']
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, coid):
+        """
+        This function will fetch properties of catalog objects node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: Catalog object ID
+
+        Returns:
+            JSON of given catalog objects child node
+        """
+        SQL = render_template(
+            "/".join([self.template_path, self._NODES_SQL]), coid=coid
+        )
+
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-catalog_object"
+                ),
+                status=200
+            )
+
+        return gone(
+            errormsg=gettext("Could not find the specified catalog object."))
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, coid):
+        """
+        This function will show the properties of the selected
+        catalog objects node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did:  Database ID
+            scid: Schema ID
+            scid: Schema ID
+            coid: Catalog object ID
+
+        Returns:
+            JSON of selected catalog objects node
+        """
+        SQL = render_template(
+            "/".join([self.template_path, self._PROPERTIES_SQL]),
+            scid=scid, coid=coid
+        )
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return gone(
+                gettext("""Could not find the specified catalog object."""))
+
+        res['rows'][0]['is_sys_obj'] = (
+            res['rows'][0]['oid'] <= self._DATABASE_LAST_SYSTEM_OID or
+            self.datistemplate)
+
+        return ajax_response(
+            response=res['rows'][0],
+            status=200
+        )
+
+    @check_precondition
+    def dependents(self, gid, sid, did, scid, coid):
+        """
+        This function get the dependents and return ajax response
+        for the catalog objects node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: catalog objects ID
+        """
+        dependents_result = self.get_dependents(self.conn, coid)
+
+        return ajax_response(
+            response=dependents_result,
+            status=200
+        )
+
+    @check_precondition
+    def dependencies(self, gid, sid, did, scid, coid):
+        """
+        This function get the dependencies and return ajax response
+        for the catalog objects node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: catalog objects ID
+        """
+        dependencies_result = self.get_dependencies(self.conn, coid)
+
+        return ajax_response(
+            response=dependencies_result,
+            status=200
+        )
+
+
+CatalogObjectView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/__init__.py

@@ -0,0 +1,853 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+""" Implements Collation Node """
+
+from functools import wraps
+
+import json
+from flask import render_template, request, jsonify
+from flask_babel import gettext
+
+import pgadmin.browser.server_groups.servers.databases as database
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.server_groups.servers.databases.schemas.utils \
+    import SchemaChildModule
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response, gone
+from pgadmin.utils.compile_template_name import compile_template_path
+from pgadmin.utils.driver import get_driver
+from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
+from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
+
+
+class CollationModule(SchemaChildModule):
+    """
+     class CollationModule(CollectionNodeModule)
+
+        A module class for Collation node derived from CollectionNodeModule.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Method is used to initialize the Collation and it's base module.
+
+    * get_nodes(gid, sid, did, scid, coid)
+      - Method is used to generate the browser collection node.
+
+    * node_inode()
+      - Method is overridden from its base class to make the node as leaf node.
+
+    * script_load()
+      - Load the module script for schema, when any of the server node is
+        initialized.
+    """
+
+    _NODE_TYPE = 'collation'
+    _COLLECTION_LABEL = gettext("Collations")
+
+    def __init__(self, *args, **kwargs):
+        """
+        Method is used to initialize the CollationModule and it's base module.
+
+        Args:
+            *args:
+            **kwargs:
+        """
+
+        super().__init__(*args, **kwargs)
+        self.min_ver = 90100
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid):
+        """
+        Generate the collection node
+        """
+        if self.has_nodes(sid, did, scid=scid,
+                          base_template_path=CollationView.BASE_TEMPLATE_PATH):
+            yield self.generate_browser_collection_node(scid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for database, when any of the database node is
+        initialized.
+        """
+        return database.DatabaseModule.node_type
+
+    @property
+    def node_inode(self):
+        return False
+
+
+blueprint = CollationModule(__name__)
+
+
+class CollationView(PGChildNodeView, SchemaDiffObjectCompare):
+    """
+    This class is responsible for generating routes for Collation node
+
+    Methods:
+    -------
+    * __init__(**kwargs)
+      - Method is used to initialize the CollationView and it's base view.
+
+    * check_precondition()
+      - This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+
+    * list()
+      - This function is used to list all the Collation nodes within that
+      collection.
+
+    * nodes()
+      - This function will used to create all the child node within that
+        collection, Here it will create all the Collation node.
+
+    * properties(gid, sid, did, scid, coid)
+      - This function will show the properties of the selected Collation node
+
+    * create(gid, sid, did, scid)
+      - This function will create the new Collation object
+
+    * update(gid, sid, did, scid, coid)
+      - This function will update the data for the selected Collation node
+
+    * delete(self, gid, sid, scid, coid):
+      - This function will drop the Collation object
+
+    * msql(gid, sid, did, scid, coid)
+      - This function is used to return modified SQL for the selected
+        Collation node
+
+    * get_sql(data, scid, coid)
+      - This function will generate sql from model data
+
+    * sql(gid, sid, did, scid):
+      - This function will generate sql to show it in sql pane for the
+        selected Collation node.
+
+    * dependency(gid, sid, did, scid):
+      - This function will generate dependency list show it in dependency
+        pane for the selected Collation node.
+
+    * dependent(gid, sid, did, scid):
+      - This function will generate dependent list to show it in dependent
+        pane for the selected Collation node.
+
+    * compare(**kwargs):
+      - This function will compare the collation nodes from two different
+        schemas.
+    """
+
+    node_type = blueprint.node_type
+    node_label = "Collation"
+    BASE_TEMPLATE_PATH = 'collations/sql/#{0}#'
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'coid'}
+    ]
+
+    operations = dict({
+        'obj': [
+            {'get': 'properties', 'delete': 'delete', 'put': 'update'},
+            {'get': 'list', 'post': 'create', 'delete': 'delete'}
+        ],
+        'delete': [{'delete': 'delete'}, {'delete': 'delete'}],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}],
+        'msql': [{'get': 'msql'}, {'get': 'msql'}],
+        'stats': [{'get': 'statistics'}],
+        'dependency': [{'get': 'dependencies'}],
+        'dependent': [{'get': 'dependents'}],
+        'get_collations': [{'get': 'get_collation'},
+                           {'get': 'get_collation'}],
+        'compare': [{'get': 'compare'}, {'get': 'compare'}]
+    })
+
+    def check_precondition(f):
+        """
+        This function will behave as a decorator which will checks
+        database connection before running view, it will also attaches
+        manager,conn & template_path properties to self
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            # Here args[0] will hold self & kwargs will hold gid,sid,did
+            self = args[0]
+            self.manager = get_driver(PG_DEFAULT_DRIVER).connection_manager(
+                kwargs['sid']
+            )
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.datistemplate = False
+            if (
+                self.manager.db_info is not None and
+                kwargs['did'] in self.manager.db_info and
+                'datistemplate' in self.manager.db_info[kwargs['did']]
+            ):
+                self.datistemplate = self.manager.db_info[
+                    kwargs['did']]['datistemplate']
+
+            # Set the template path for the SQL scripts
+            self.template_path = \
+                self.BASE_TEMPLATE_PATH.format(self.manager.version)
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid):
+        """
+        This function is used to list all the collation nodes within that
+        collection.
+
+        Args:
+            gid: Server group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available collation nodes
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]), scid=scid)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid):
+        """
+        This function will used to create all the child node within that
+        collection.
+        Here it will create all the collation node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+
+        Returns:
+            JSON of available collation child nodes
+        """
+
+        res = []
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), scid=scid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-collation",
+                    description=row['description']
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, coid):
+        """
+        This function will fetch properties of the collation node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: Collation ID
+
+        Returns:
+            JSON of given collation node
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), coid=coid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-collation"
+                ),
+                status=200
+            )
+
+        return gone(self.not_found_error_msg())
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, coid):
+        """
+        This function will show the properties of the selected collation node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did:  Database ID
+            scid: Schema ID
+            scid: Schema ID
+            coid: Collation ID
+
+        Returns:
+            JSON of selected collation node
+        """
+
+        status, res = self._fetch_properties(scid, coid)
+        if not status:
+            return res
+
+        return ajax_response(
+            response=res,
+            status=200
+        )
+
+    def _fetch_properties(self, scid, coid):
+        """
+        This function fetch the properties for the specified object.
+
+        :param scid: Schema ID
+        :param coid: Collation ID
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, coid=coid,
+                              datlastsysoid=self._DATABASE_LAST_SYSTEM_OID)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return False, gone(self.not_found_error_msg())
+
+        res['rows'][0]['is_sys_obj'] = (
+            res['rows'][0]['oid'] <= self._DATABASE_LAST_SYSTEM_OID or
+            self.datistemplate)
+
+        return True, res['rows'][0]
+
+    @check_precondition
+    def get_collation(self, gid, sid, did, scid, coid=None):
+        """
+        This function will return list of collation available
+        as AJAX response.
+        """
+
+        res = []
+        try:
+            SQL = render_template("/".join([self.template_path,
+                                            'get_collations.sql']))
+            status, rset = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            for row in rset['rows']:
+                res.append(
+                    {'label': row['copy_collation'],
+                     'value': row['copy_collation']}
+                )
+            return make_json_response(
+                data=res,
+                status=200
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    def _check_definition(self, data):
+        """
+        Args:
+            data: request data received from client
+
+        Returns:
+            True if defination is missing, False otherwise
+        """
+        definition_args = [
+            'locale',
+            'copy_collation',
+            'lc_collate',
+            'lc_type'
+        ]
+
+        # Additional server side validation to check if
+        # definition is sent properly from client side
+        missing_definition_flag = False
+
+        for arg in definition_args:
+            if (
+                arg == 'locale' and
+                (arg not in data or data[arg] == '') and
+                'copy_collation' not in data and
+                'lc_collate' not in data and 'lc_type' not in data
+            ):
+                missing_definition_flag = True
+
+            if (
+                arg == 'copy_collation' and
+                (arg not in data or data[arg] == '') and
+                'locale' not in data and
+                'lc_collate' not in data and 'lc_type' not in data
+            ):
+                missing_definition_flag = True
+
+            if (
+                (arg == 'lc_collate' or arg == 'lc_type') and
+                (arg not in data or data[arg] == '') and
+                'copy_collation' not in data and 'locale' not in data
+            ):
+                missing_definition_flag = True
+
+        return missing_definition_flag
+
+    @check_precondition
+    def create(self, gid, sid, did, scid):
+        """
+        This function will creates new the collation object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+        """
+
+        data = request.form if request.form else json.loads(
+            request.data
+        )
+
+        required_args = [
+            'schema',
+            'name'
+        ]
+
+        for arg in required_args:
+            if arg not in data:
+                return make_json_response(
+                    status=410,
+                    success=0,
+                    errormsg=gettext(
+                        "Could not find the required parameter ({})."
+                    ).format(arg)
+                )
+        if self._check_definition(data):
+            return make_json_response(
+                status=410,
+                success=0,
+                errormsg=gettext(
+                    "Definition incomplete. Please provide Locale OR Copy "
+                    "Collation OR LC_TYPE/LC_COLLATE."
+                )
+            )
+
+        SQL = render_template(
+            "/".join([self.template_path, self._CREATE_SQL]),
+            data=data, conn=self.conn
+        )
+        status, res = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        # We need oid to add object in tree at browser
+        SQL = render_template(
+            "/".join([self.template_path, self._OID_SQL]), data=data,
+            conn=self.conn
+        )
+        status, coid = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=coid)
+
+        # Get updated schema oid
+        SQL = render_template(
+            "/".join([self.template_path, self._OID_SQL]), coid=coid,
+            conn=self.conn
+        )
+
+        status, new_scid = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=coid)
+
+        return jsonify(
+            node=self.blueprint.generate_browser_node(
+                coid,
+                new_scid,
+                data['name'],
+                icon="icon-collation"
+            )
+        )
+
+    @check_precondition
+    def delete(self, gid, sid, did, scid, coid=None, only_sql=False):
+        """
+        This function will delete the existing collation object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           coid: Collation ID
+           only_sql: Return only sql if True
+        """
+        data = json.loads(request.data) if coid is None \
+            else {'ids': [coid]}
+
+        # Below will decide if it's simple drop or drop with cascade call
+
+        cascade = self._check_cascade_operation()
+
+        try:
+            for coid in data['ids']:
+                SQL = render_template("/".join([self.template_path,
+                                                'get_name.sql']),
+                                      scid=scid, coid=coid)
+                status, res = self.conn.execute_dict(SQL)
+                if not status:
+                    return internal_server_error(errormsg=res)
+
+                if len(res['rows']) == 0:
+                    return gone(self.not_found_error_msg())
+
+                data = res['rows'][0]
+
+                SQL = render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]),
+                                      name=data['name'],
+                                      nspname=data['schema'],
+                                      cascade=cascade,
+                                      conn=self.conn)
+
+                # 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)
+
+            return make_json_response(
+                success=1,
+                info=gettext("Collation dropped")
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def update(self, gid, sid, did, scid, coid):
+        """
+        This function will updates the existing collation object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           coid: Collation ID
+        """
+        data = request.form if request.form else json.loads(
+            request.data
+        )
+        SQL, name = self.get_sql(gid, sid, data, scid, coid)
+        # Most probably this is due to error
+        if not isinstance(SQL, str):
+            return SQL
+        SQL = SQL.strip('\n').strip(' ')
+        status, res = self.conn.execute_scalar(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        # We need oid to add object in tree at browser
+        SQL = render_template("/".join([self.template_path,
+                                        self._OID_SQL]), coid=coid)
+
+        status, res = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        scid = res['rows'][0]['scid']
+
+        other_node_info = {}
+        if 'description' in data:
+            other_node_info['description'] = data['description']
+
+        return jsonify(
+            node=self.blueprint.generate_browser_node(
+                coid,
+                scid,
+                name,
+                icon="icon-%s" % self.node_type,
+                **other_node_info
+            )
+        )
+
+    @check_precondition
+    def msql(self, gid, sid, did, scid, coid=None):
+        """
+        This function will generates modified sql for collation object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           coid: Collation ID
+        """
+        data = dict()
+        for k, v in request.args.items():
+            try:
+                # comments should be taken as is because if user enters a
+                # json comment it is parsed by loads which should not happen
+                if k in ('description',):
+                    data[k] = v
+                else:
+                    data[k] = json.loads(v)
+            except ValueError:
+                data[k] = v
+
+        try:
+            SQL, _ = self.get_sql(gid, sid, data, scid, coid)
+            # Most probably this is due to error
+            if not isinstance(SQL, str):
+                return SQL
+            if SQL == '':
+                SQL = "--modified SQL"
+
+            return make_json_response(
+                data=SQL,
+                status=200
+            )
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    def get_sql(self, gid, sid, data, scid, coid=None):
+        """
+        This function will genrate sql from model data
+        """
+        if coid is not None:
+            SQL = render_template("/".join([self.template_path,
+                                            self._PROPERTIES_SQL]),
+                                  scid=scid, coid=coid)
+            status, res = self.conn.execute_dict(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+            if len(res['rows']) == 0:
+                return gone(self.not_found_error_msg())
+
+            old_data = res['rows'][0]
+            SQL = render_template(
+                "/".join([self.template_path, self._UPDATE_SQL]),
+                data=data, o_data=old_data, conn=self.conn
+            )
+            return SQL.strip('\n'), data['name'] if 'name' in data else \
+                old_data['name']
+        else:
+            required_args = [
+                'name'
+            ]
+
+            for arg in required_args:
+                if arg not in data:
+                    return gettext("-- missing definition")
+
+            if self._check_definition(data):
+                return gettext("-- missing definition")
+
+            SQL = render_template("/".join([self.template_path,
+                                            self._CREATE_SQL]),
+                                  data=data, conn=self.conn)
+            return SQL.strip('\n'), data['name']
+
+    @check_precondition
+    def sql(self, gid, sid, did, scid, coid, **kwargs):
+        """
+        This function will generates reverse engineered sql for collation
+        object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           coid: Collation ID
+           json_resp: True then return json response
+        """
+        json_resp = kwargs.get('json_resp', True)
+        target_schema = kwargs.get('target_schema', None)
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, coid=coid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+        if len(res['rows']) == 0:
+            return gone(self.not_found_error_msg())
+
+        data = res['rows'][0]
+        if target_schema:
+            data['schema'] = target_schema
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._CREATE_SQL]),
+                              data=data, conn=self.conn,
+                              add_not_exists_clause=True
+                              )
+
+        sql_header = "-- Collation: {0};\n\n-- ".format(data['name'])
+
+        sql_header += render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]),
+                                      name=data['name'],
+                                      nspname=data['schema'])
+        SQL = sql_header + '\n\n' + SQL.strip('\n')
+
+        if not json_resp:
+            return SQL
+
+        return ajax_response(response=SQL)
+
+    @check_precondition
+    def dependents(self, gid, sid, did, scid, coid):
+        """
+        This function get the dependents and return ajax response
+        for the Collation node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: Collation ID
+        """
+        dependents_result = self.get_dependents(
+            self.conn, coid
+        )
+
+        return ajax_response(
+            response=dependents_result,
+            status=200
+        )
+
+    @check_precondition
+    def dependencies(self, gid, sid, did, scid, coid):
+        """
+        This function get the dependencies and return ajax response
+        for the Collation node.
+
+        Args:
+            gid: Server Group ID
+            sid: Server ID
+            did: Database ID
+            scid: Schema ID
+            coid: Collation ID
+        """
+        dependencies_result = self.get_dependencies(
+            self.conn, coid
+        )
+
+        return ajax_response(
+            response=dependencies_result,
+            status=200
+        )
+
+    @check_precondition
+    def fetch_objects_to_compare(self, sid, did, scid):
+        """
+        This function will fetch the list of all the collations for
+        specified schema id.
+
+        :param sid: Server Id
+        :param did: Database Id
+        :param scid: Schema Id
+        :return:
+        """
+        res = dict()
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODES_SQL]), scid=scid,
+                              schema_diff=True)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        for row in rset['rows']:
+            status, data = self._fetch_properties(scid, row['oid'])
+            if status:
+                res[row['name']] = data
+
+        return res
+
+    def get_sql_from_diff(self, **kwargs):
+        """
+        This function is used to get the DDL/DML statements.
+        :param kwargs
+        :return:
+        """
+        gid = kwargs.get('gid')
+        sid = kwargs.get('sid')
+        did = kwargs.get('did')
+        scid = kwargs.get('scid')
+        oid = kwargs.get('oid')
+        data = kwargs.get('data', None)
+        drop_sql = kwargs.get('drop_sql', False)
+        target_schema = kwargs.get('target_schema', None)
+
+        if data:
+            if target_schema:
+                data['schema'] = target_schema
+            sql, _ = self.get_sql(gid=gid, sid=sid, data=data, scid=scid,
+                                  coid=oid)
+        else:
+            if drop_sql:
+                sql = self.delete(gid=gid, sid=sid, did=did,
+                                  scid=scid, coid=oid, only_sql=True)
+            elif target_schema:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, coid=oid,
+                               target_schema=target_schema, json_resp=False)
+            else:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, coid=oid,
+                               json_resp=False)
+        return sql
+
+
+SchemaDiffRegistry(blueprint.node_type, CollationView)
+CollationView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/12_plus/create.sql

@@ -0,0 +1,59 @@
+{% if data %}
+CREATE COLLATION{% if add_not_exists_clause %} IF NOT EXISTS{% endif %} {{ conn|qtIdent(data.schema, data.name) }}
+{% if not data.copy_collation %}
+{% set options = [] %}
+{# if user has provided lc_collate & lc_type #}
+{% if data.lc_collate and data.lc_type %}
+{% if data.lc_collate and data.lc_type %}
+    {% set options = options + ['LC_COLLATE = ' ~ data.lc_collate|qtLiteral(conn), 'LC_CTYPE = ' ~ data.lc_type|qtLiteral(conn)] %}
+{% endif %}
+{% if data.provider %}
+{% set options = options + ['PROVIDER = ' ~ data.provider|qtLiteral(conn)] %}
+{% endif %}
+{% if data.is_deterministic is defined %}
+{% set options = options + ['DETERMINISTIC = ' ~ data.is_deterministic|qtLiteral(conn)] %}
+{% endif %}
+{% if data.rules %}
+{% set options = options + ['RULES = ' ~ data.rules|qtLiteral(conn)] %}
+{% endif %}
+{% if data.version %}
+{% set options = options + ['VERSION = ' ~ data.version|qtLiteral(conn)] %}
+{% endif %}
+{% endif %}
+{# if user has provided locale only  #}
+{% if data.locale %}
+{% if data.locale %}
+    {% set options = options + ['LOCALE = ' ~ data.locale|qtLiteral(conn)] %}
+{% endif %}
+{% if data.provider %}
+{% set options = options + ['PROVIDER = ' ~ data.provider|qtLiteral(conn)] %}
+{% endif %}
+{% if data.is_deterministic is defined %}
+{% set options = options + ['DETERMINISTIC = ' ~ data.is_deterministic|qtLiteral(conn)] %}
+{% endif %}
+{% if data.rules %}
+{% set options = options + ['RULES = ' ~ data.rules|qtLiteral(conn)] %}
+{% endif %}
+{% if data.version %}
+{% set options = options + ['VERSION = ' ~ data.version|qtLiteral(conn)] %}
+{% endif %}
+{% endif %}
+{% if options %}
+({{ options|join(', ') }});
+{% endif %}
+{% endif %}
+{# if user has choosed to copy from existing collation #}
+{% if data.copy_collation %}
+    FROM {{ data.copy_collation }};
+{% endif %}
+{% if data.owner %}
+
+ALTER COLLATION {{ conn|qtIdent(data.schema, data.name) }}
+    OWNER TO {{ conn|qtIdent(data.owner) }};
+{% endif %}
+{% if data.description %}
+
+COMMENT ON COLLATION {{ conn|qtIdent(data.schema, data.name) }}
+    IS {{ data.description|qtLiteral(conn) }};
+{% endif %}
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/12_plus/properties.sql

@@ -0,0 +1,10 @@
+SELECT c.oid, c.collname AS name, c.collcollate AS lc_collate, c.collctype AS lc_type,
+    pg_catalog.pg_get_userbyid(c.collowner) AS owner, c.collisdeterministic AS is_deterministic, c.collversion AS version,
+    c.collprovider AS provider, des.description, n.nspname AS schema
+
+FROM pg_catalog.pg_collation c
+    JOIN pg_catalog.pg_namespace n ON n.oid=c.collnamespace
+    LEFT OUTER JOIN pg_catalog.pg_description des ON (des.objoid=c.oid AND des.classoid='pg_collation'::regclass)
+WHERE c.collnamespace = {{scid}}::oid
+{% if coid %}    AND c.oid = {{coid}}::oid {% endif %}
+ORDER BY c.collname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/15_plus/properties.sql

@@ -0,0 +1,10 @@
+SELECT c.oid, c.collname AS name, COALESCE(c.collcollate, c.colliculocale) AS lc_collate,
+	COALESCE(c.collctype, c.colliculocale) AS lc_type, c.collisdeterministic AS is_deterministic, c.collversion AS version,
+    c.collprovider AS provider,
+    pg_catalog.pg_get_userbyid(c.collowner) AS owner, description, n.nspname AS schema
+FROM pg_catalog.pg_collation c
+    JOIN pg_catalog.pg_namespace n ON n.oid=c.collnamespace
+    LEFT OUTER JOIN pg_catalog.pg_description des ON (des.objoid=c.oid AND des.classoid='pg_collation'::regclass)
+WHERE c.collnamespace = {{scid}}::oid
+{% if coid %}    AND c.oid = {{coid}}::oid {% endif %}
+ORDER BY c.collname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/16_plus/properties.sql

@@ -0,0 +1,10 @@
+SELECT c.oid, c.collname AS name, COALESCE(c.collcollate, c.colliculocale) AS lc_collate,
+	COALESCE(c.collctype, c.colliculocale) AS lc_type, c.collisdeterministic AS is_deterministic, c.collversion AS version,
+    c.collprovider AS provider, c.collicurules AS rules,
+    pg_catalog.pg_get_userbyid(c.collowner) AS owner, description, n.nspname AS schema
+FROM pg_catalog.pg_collation c
+    JOIN pg_catalog.pg_namespace n ON n.oid=c.collnamespace
+    LEFT OUTER JOIN pg_catalog.pg_description des ON (des.objoid=c.oid AND des.classoid='pg_collation'::regclass)
+WHERE c.collnamespace = {{scid}}::oid
+{% if coid %}    AND c.oid = {{coid}}::oid {% endif %}
+ORDER BY c.collname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/backend_support.sql

@@ -0,0 +1,18 @@
+SELECT
+     CASE WHEN nsp.nspname IN ('sys', 'information_schema') THEN true ELSE false END AS dbSupport
+FROM pg_catalog.pg_namespace nsp
+WHERE nsp.oid={{scid}}::oid
+AND (
+    (nspname = 'pg_catalog' AND EXISTS
+        (SELECT 1 FROM pg_catalog.pg_class WHERE relname = 'pg_class' AND relnamespace = nsp.oid LIMIT 1))
+    OR (nspname = 'pgagent' AND EXISTS
+        (SELECT 1 FROM pg_catalog.pg_class WHERE relname = 'pga_job' AND relnamespace = nsp.oid LIMIT 1))
+    OR (nspname = 'information_schema' AND EXISTS
+        (SELECT 1 FROM pg_catalog.pg_class WHERE relname = 'tables' AND relnamespace = nsp.oid LIMIT 1))
+    OR (nspname LIKE '_%' AND EXISTS
+        (SELECT 1 FROM pg_catalog.pg_proc WHERE proname='slonyversion' AND pronamespace = nsp.oid LIMIT 1))
+)
+AND
+    nspname NOT LIKE E'pg\\temp\\%'
+AND
+    nspname NOT LIKE E'pg\\toast_temp\\%'

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/count.sql

@@ -0,0 +1,5 @@
+SELECT COUNT(*)
+FROM pg_catalog.pg_collation c
+{% if scid %}
+WHERE c.collnamespace = {{scid}}::oid
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/create.sql

@@ -0,0 +1,47 @@
+{% if data %}
+CREATE COLLATION{% if add_not_exists_clause %} IF NOT EXISTS{% endif %} {{ conn|qtIdent(data.schema, data.name) }}
+{% if not data.copy_collation %}
+{% set options = [] %}
+{# if user has provided lc_collate & lc_type #}
+{% if data.lc_collate and data.lc_type %}
+{% if data.lc_collate and data.lc_type %}
+    {% set options = options + ['LC_COLLATE = ' ~ data.lc_collate|qtLiteral(conn), 'LC_CTYPE = ' ~ data.lc_type|qtLiteral(conn)] %}
+{% endif %}
+{% if data.provider %}
+{% set options = options + ['PROVIDER = ' ~ data.provider|qtLiteral(conn)] %}
+{% endif %}
+{% if data.version %}
+{% set options = options + ['VERSION = ' ~ data.version|qtLiteral(conn)] %}
+{% endif %}
+{% endif %}
+{# if user has provided locale only  #}
+{% if data.locale %}
+{% if data.locale %}
+    {% set options = options + ['LOCALE = ' ~ data.locale|qtLiteral(conn)] %}
+{% endif %}
+{% if data.provider %}
+{% set options = options + ['PROVIDER = ' ~ data.provider|qtLiteral(conn)] %}
+{% endif %}
+{% if data.version %}
+{% set options = options + ['VERSION = ' ~ data.version|qtLiteral(conn)] %}
+{% endif %}
+{% endif %}
+{% if options %}
+({{ options|join(', ') }});
+{% endif %}
+{% endif %}
+{# if user has choosed to copy from existing collation #}
+{% if data.copy_collation %}
+    FROM {{ data.copy_collation }};
+{% endif %}
+{% if data.owner %}
+
+ALTER COLLATION {{ conn|qtIdent(data.schema, data.name) }}
+    OWNER TO {{ conn|qtIdent(data.owner) }};
+{% endif %}
+{% if data.description %}
+
+COMMENT ON COLLATION {{ conn|qtIdent(data.schema, data.name) }}
+    IS {{ data.description|qtLiteral(conn) }};
+{% endif %}
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/delete.sql

@@ -0,0 +1 @@
+DROP COLLATION IF EXISTS {{ conn|qtIdent(nspname, name) }}{% if cascade%} CASCADE{% endif %};

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/get_collations.sql

@@ -0,0 +1,7 @@
+SELECT --nspname, collname,
+    CASE WHEN length(nspname::text) > 0 AND length(collname::text) > 0  THEN
+        pg_catalog.concat(pg_catalog.quote_ident(nspname), '.', pg_catalog.quote_ident(collname))
+    ELSE '' END AS copy_collation
+FROM pg_catalog.pg_collation c, pg_catalog.pg_namespace n
+WHERE c.collnamespace=n.oid
+ORDER BY nspname, collname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/templates/collations/sql/default/get_name.sql

@@ -0,0 +1,5 @@
+SELECT nspname AS schema, collname AS name
+FROM pg_catalog.pg_collation c, pg_catalog.pg_namespace n
+WHERE c.collnamespace = n.oid AND
+    n.oid = {{ scid }}::oid AND
+    c.oid = {{ coid }}::oid;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/__init__.py

@@ -0,0 +1,1030 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+"""Implements the Domain Node."""
+
+from functools import wraps
+
+import json
+from flask import render_template, make_response, request, jsonify
+from flask_babel import gettext
+
+from pgadmin.browser.server_groups.servers import databases
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.server_groups.servers.databases.schemas.utils import \
+    SchemaChildModule, DataTypeReader
+from pgadmin.browser.server_groups.servers.databases.utils import \
+    parse_sec_labels_from_db
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response, gone
+from pgadmin.utils.compile_template_name import compile_template_path
+from pgadmin.utils.driver import get_driver
+from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
+from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
+
+
+class DomainModule(SchemaChildModule):
+    """
+    class DomainModule(SchemaChildModule):
+
+        This class represents The Domain Module.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Initialize the Domain Module.
+
+    * get_nodes(gid, sid, did, scid)
+      - Generate the domain collection node.
+
+    * script_load()
+      - Load the module script for domain, when schema node is
+        initialized.
+    """
+
+    _NODE_TYPE = 'domain'
+    _COLLECTION_LABEL = gettext("Domains")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_ver = None
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid):
+        """
+        Generate the domain collection node.
+        """
+        if self.has_nodes(sid, did, scid=scid,
+                          base_template_path=DomainView.BASE_TEMPLATE_PATH):
+            yield self.generate_browser_collection_node(scid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for domain, when schema node is
+        initialized.
+        """
+        return databases.DatabaseModule.node_type
+
+    def register(self, app, options):
+        """
+        Override the default register function to automagically register
+        sub-modules at once.
+        """
+        from .domain_constraints import blueprint as module
+        self.submodules.append(module)
+        super().register(app, options)
+
+
+blueprint = DomainModule(__name__)
+
+
+class DomainView(PGChildNodeView, DataTypeReader, SchemaDiffObjectCompare):
+    """
+    class DomainView
+
+    This class inherits PGChildNodeView to get the different routes for
+    the module. Also, inherits DataTypeReader to get data types.
+
+    The class is responsible to Create, Read, Update and Delete operations for
+    the Domain.
+
+    Methods:
+    -------
+    * validate_request(f):
+      - Works as a decorator.
+        Validating request on the request of create, update and modified SQL.
+
+    * check_precondition(f):
+      - Works as a decorator.
+      -  Checks database connection status.
+      -  Attach connection object and template path.
+
+    * list(gid, sid, did, scid, doid):
+      - List the Domains.
+
+    * nodes(gid, sid, did, scid):
+      - Returns all the Domains to generate Nodes in the browser.
+
+    * properties(gid, sid, did, scid, doid):
+      - Returns the Domain properties.
+
+    * get_collations(gid, sid, did, scid, doid=None):
+      - Returns Collations.
+
+    * create(gid, sid, did, scid):
+      - Creates a new Domain object.
+
+    * update(gid, sid, did, scid, doid):
+      - Updates the Domain object.
+
+    * delete(gid, sid, did, scid, doid):
+      - Drops the Domain object.
+
+    * sql(gid, sid, did, scid, doid=None):
+      - Returns the SQL for the Domain object.
+
+    * msql(gid, sid, did, scid, doid=None):
+      - Returns the modified SQL.
+
+    * get_sql(gid, sid, data, scid, doid=None):
+      - Generates the SQL statements to create/update the Domain object.
+
+    * dependents(gid, sid, did, scid, doid):
+      - Returns the dependents for the Domain object.
+
+    * dependencies(gid, sid, did, scid, doid):
+      - Returns the dependencies for the Domain object.
+
+    * types(gid, sid, did, scid, fnid=None):
+      - Returns Data Types.
+
+    * compare(**kwargs):
+      - This function will compare the domain nodes from two different
+        schemas.
+    """
+
+    node_type = blueprint.node_type
+    node_label = "Domain"
+    BASE_TEMPLATE_PATH = 'domains/sql/#{0}#'
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'doid'}
+    ]
+
+    operations = dict({
+        'obj': [
+            {'get': 'properties', 'delete': 'delete', 'put': 'update'},
+            {'get': 'list', 'post': 'create', 'delete': 'delete'}
+        ],
+        'delete': [{'delete': 'delete'}, {'delete': 'delete'}],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}],
+        'msql': [{'get': 'msql'}, {'get': 'msql'}],
+        'stats': [{'get': 'statistics'}],
+        'dependency': [{'get': 'dependencies'}],
+        'dependent': [{'get': 'dependents'}],
+        'get_types': [{'get': 'types'}, {'get': 'types'}],
+        'get_collations': [
+            {'get': 'get_collations'},
+            {'get': 'get_collations'}
+        ],
+        'compare': [{'get': 'compare'}, {'get': 'compare'}]
+    })
+
+    keys_to_ignore = ['oid', 'basensp', 'conoid', 'nspname', 'oid-2']
+
+    @staticmethod
+    def _get_req_data(kwargs):
+        """
+        Get req data from request.
+        :param kwargs: kwargs.
+        :return: if any error return error, else return req.
+        """
+        if request.data:
+            req = json.loads(request.data)
+        else:
+            req = request.args or request.form
+
+        if 'doid' not in kwargs:
+            required_args = [
+                'name',
+                'basetype'
+            ]
+
+            for arg in required_args:
+                if arg not in req or req[arg] == '':
+                    return req, True, make_json_response(
+                        status=410,
+                        success=0,
+                        errormsg=gettext(
+                            "Could not find the required parameter ({})."
+                        ).format(arg),
+                    )
+        return req, False, ''
+
+    @staticmethod
+    def _get_data(req):
+        """
+        Get data from request and update required values.
+        :param req: request object.
+        :return: data.
+        """
+        data = {}
+        list_params = []
+        if request.method == 'GET':
+            list_params = ['constraints', 'seclabels']
+
+        for key in req:
+            if (
+                key in list_params and req[key] != '' and
+                req[key] is not None
+            ):
+                # Coverts string into python list as expected.
+                data[key] = json.loads(req[key])
+            elif key == 'typnotnull':
+                if req[key] == 'true' or req[key] is True:
+                    data[key] = True
+                elif req[key] == 'false' or req[key] is False:
+                    data[key] = False
+                else:
+                    data[key] = ''
+            else:
+                data[key] = req[key]
+        return data
+
+    def validate_request(f):
+        """
+        Works as a decorator.
+        Validating request on the request of create, update and modified SQL.
+
+        Required Args:
+                    name: Name of the Domain
+                    owner: Domain Owner
+                    basensp: Schema Name
+                    basetype: Data Type of the Domain
+
+        Above both the arguments will not be validated in the update action.
+        """
+
+        @wraps(f)
+        def wrap(self, **kwargs):
+
+            req, is_error, errmsg = DomainView._get_req_data(kwargs)
+            if is_error:
+                return errmsg
+
+            try:
+                data = DomainView._get_data(req)
+
+            except Exception as e:
+                return internal_server_error(errormsg=str(e))
+
+            self.request = data
+            return f(self, **kwargs)
+
+        return wrap
+
+    def check_precondition(f):
+        """
+        Works as a decorator.
+        Checks database connection status.
+        Attach connection object and template path.
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            self = args[0]
+            driver = get_driver(PG_DEFAULT_DRIVER)
+            self.manager = driver.connection_manager(kwargs['sid'])
+            # Get database connection
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.qtIdent = driver.qtIdent
+            self.datistemplate = False
+            if (
+                self.manager.db_info is not None and
+                kwargs['did'] in self.manager.db_info and
+                'datistemplate' in self.manager.db_info[kwargs['did']]
+            ):
+                self.datistemplate = self.manager.db_info[
+                    kwargs['did']]['datistemplate']
+
+            # we will set template path for sql scripts
+            self.template_path = \
+                self.BASE_TEMPLATE_PATH.format(self.manager.version)
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid):
+        """
+        List the Domains.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+        """
+
+        SQL = render_template("/".join([self.template_path, self._NODE_SQL]),
+                              scid=scid)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid):
+        """
+        Returns all the Domains to generate Nodes in the browser.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+        """
+
+        res = []
+        SQL = render_template("/".join([self.template_path, self._NODE_SQL]),
+                              scid=scid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-domain",
+                    description=row['description']
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, doid):
+        """
+        This function will fetch the properties of the domain node.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+
+        SQL = render_template("/".join([self.template_path, self._NODE_SQL]),
+                              doid=doid)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-domain"
+                ),
+                status=200
+            )
+
+        return gone(self.not_found_error_msg())
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, doid):
+        """
+        Returns the Domain properties.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+        status, res = self._fetch_properties(did, scid, doid)
+        if not status:
+            return res
+
+        return ajax_response(
+            response=res,
+            status=200
+        )
+
+    def _fetch_properties(self, did, scid, doid):
+        """
+        This function is used to fecth the properties of specified object.
+        :param did:
+        :param scid:
+        :param doid:
+        :return:
+        """
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, doid=doid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return False, gone(gettext("""
+Could not find the domain in the database.
+It may have been removed by another user or moved to another schema.
+"""))
+
+        data = res['rows'][0]
+
+        # Get Type Length and Precision
+        data.update(self._parse_type(data['fulltype']))
+
+        # Get Domain Constraints
+        SQL = render_template("/".join([self.template_path,
+                                        self._GET_CONSTRAINTS_SQL]),
+                              doid=doid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        data['constraints'] = res['rows']
+
+        # Get formatted Security Labels
+        if 'seclabels' in data:
+            data.update(parse_sec_labels_from_db(data['seclabels']))
+
+        # Set System Domain Status
+        data['sysdomain'] = False
+        if doid <= self._DATABASE_LAST_SYSTEM_OID or \
+                self.datistemplate:
+            data['sysdomain'] = True
+
+        return True, data
+
+    def _parse_type(self, basetype):
+        """
+        Returns Type and Data Type from the basetype.
+        """
+        typ_len = ''
+        typ_precision = ''
+
+        # The Length and the precision of the Datatype should be separate.
+        # The Format we getting from database is: numeric(1,1)
+        # So, we need to separate Length: 1, Precision: 1
+
+        if basetype != '' and basetype.find("(") > 0:
+            substr = basetype[basetype.find("(") + 1:len(
+                basetype) - 1]
+            typlen = substr.split(",")
+            typ_len = typlen[0]
+            if len(typlen) > 1:
+                typ_precision = typlen[1]
+            else:
+                typ_precision = ''
+
+        return {'typlen': typ_len, 'precision': typ_precision}
+
+    @check_precondition
+    def get_collations(self, gid, sid, did, scid, doid=None):
+        """
+        Returns Collations.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+
+        res = [{'label': '', 'value': ''}]
+        try:
+            SQL = render_template("/".join([self.template_path,
+                                            'get_collations.sql']))
+            status, rset = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=rset)
+
+            for row in rset['rows']:
+                res.append({'label': row['copy_collation'],
+                            'value': row['copy_collation']}
+                           )
+
+            return make_json_response(
+                data=res,
+                status=200
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def types(self, gid, sid, did, scid, doid=None):
+        """
+        Returns the Data Types.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            fnid: Function Id
+        """
+
+        condition = """typisdefined AND typtype IN ('b', 'c', 'd', 'e', 'r')
+AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_class
+WHERE relnamespace=typnamespace AND relname = typname AND relkind != 'c') AND
+(typname NOT LIKE '_%' OR NOT EXISTS (SELECT 1 FROM pg_catalog.pg_class WHERE
+relnamespace=typnamespace AND relname = substring(typname FROM 2)::name
+AND relkind != 'c'))"""
+
+        # To show hidden objects
+        if not self.blueprint.show_system_objects:
+            condition += " AND nsp.nspname != 'information_schema'"
+
+        # Get Types
+        status, types = self.get_types(self.conn, condition)
+
+        if not status:
+            return internal_server_error(errormsg=types)
+
+        return make_json_response(
+            data=types,
+            status=200
+        )
+
+    @check_precondition
+    @validate_request
+    def create(self, gid, sid, did, scid):
+        """
+        Creates a new Domain object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+
+        Required Args:
+            name: Domain Name
+            owner: Owner Name
+            basensp: Schema Name
+            basetype: Domain Base Type
+
+        Returns:
+            Domain object in json format.
+        """
+
+        data = self.request
+        SQL, _ = self.get_sql(gid, sid, data, scid)
+        # Most probably this is due to error
+        if not isinstance(SQL, str):
+            return SQL
+
+        status, res = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        # We need oid to add object in tree at browser, below sql will
+        # gives the same
+        SQL = render_template("/".join([self.template_path,
+                                        self._OID_SQL]),
+                              basensp=data['basensp'],
+                              name=data['name'],
+                              conn=self.conn)
+        status, doid = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=doid)
+
+        # Get updated schema oid
+        SQL = render_template("/".join([self.template_path,
+                                        self._OID_SQL]),
+                              doid=doid,
+                              conn=self.conn)
+        status, scid = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=scid)
+
+        return jsonify(
+            node=self.blueprint.generate_browser_node(
+                doid,
+                scid,
+                data['name'],
+                icon="icon-domain"
+            )
+        )
+
+    @check_precondition
+    def delete(self, gid, sid, did, scid, doid=None, only_sql=False):
+        """
+        Drops the Domain object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            only_sql: Return only sql if True
+        """
+        if doid is None:
+            data = request.form if request.form else json.loads(
+                request.data
+            )
+        else:
+            data = {'ids': [doid]}
+
+        cascade = self._check_cascade_operation(only_sql)
+
+        for doid in data['ids']:
+            SQL = render_template("/".join([self.template_path,
+                                            self._DELETE_SQL]),
+                                  scid=scid, doid=doid)
+            status, res = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            if not res['rows']:
+                return make_json_response(
+                    status=410,
+                    success=0,
+                    errormsg=gettext(
+                        'Error: Object not found.'
+                    ),
+                    info=self.not_found_error_msg()
+                )
+
+            name = res['rows'][0]['name']
+            basensp = res['rows'][0]['basensp']
+
+            SQL = render_template("/".join([self.template_path,
+                                            self._DELETE_SQL]),
+                                  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)
+
+        return make_json_response(
+            success=1,
+            info=gettext("Domain dropped")
+        )
+
+    @check_precondition
+    @validate_request
+    def update(self, gid, sid, did, scid, doid):
+        """
+        Updates the Domain object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+
+        SQL, name = self.get_sql(gid, sid, self.request, scid, doid)
+        # Most probably this is due to error
+        if not isinstance(SQL, str):
+            return SQL
+
+        status, res = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        # Get Schema Id
+        SQL = render_template("/".join([self.template_path,
+                                        self._OID_SQL]),
+                              doid=doid,
+                              conn=self.conn)
+        status, scid = self.conn.execute_scalar(SQL)
+        if not status:
+            return internal_server_error(errormsg=scid)
+
+        other_node_info = {}
+        if 'description' in self.request:
+            other_node_info['description'] = self.request['description']
+
+        return jsonify(
+            node=self.blueprint.generate_browser_node(
+                doid,
+                scid,
+                name,
+                icon="icon-%s" % self.node_type,
+                **other_node_info
+            )
+        )
+
+    @check_precondition
+    def sql(self, gid, sid, did, scid, doid=None, **kwargs):
+        """
+        Returns the SQL for the Domain object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            json_resp: True then return json response
+        """
+        json_resp = kwargs.get('json_resp', True)
+        target_schema = kwargs.get('target_schema', None)
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, doid=doid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+        if len(res['rows']) == 0:
+            return gone(self.not_found_error_msg())
+
+        data = res['rows'][0]
+        if target_schema:
+            data['basensp'] = target_schema
+
+        # Get Type Length and Precision
+        data.update(self._parse_type(data['fulltype']))
+
+        # Get Domain Constraints
+        SQL = render_template("/".join([self.template_path,
+                                        self._GET_CONSTRAINTS_SQL]),
+                              doid=doid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        data['constraints'] = res['rows']
+
+        # Get formatted Security Labels
+        if 'seclabels' in data:
+            data.update(parse_sec_labels_from_db(data['seclabels']))
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._CREATE_SQL]), data=data)
+
+        sql_header = """-- DOMAIN: {0}.{1}\n\n""".format(
+            data['basensp'], data['name'])
+
+        sql_header += """-- DROP DOMAIN IF EXISTS {0};\n
+""".format(self.qtIdent(self.conn, data['basensp'], data['name']))
+        SQL = sql_header + SQL
+
+        if not json_resp:
+            return SQL.strip('\n')
+
+        return ajax_response(response=SQL.strip('\n'))
+
+    @check_precondition
+    @validate_request
+    def msql(self, gid, sid, did, scid, doid=None):
+        """
+        Returns the modified SQL.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+
+        Required Args:
+            name: Domain Name
+            owner: Owner Name
+            basensp: Schema Name
+            basetype: Domain Base Type
+
+        Returns:
+            SQL statements to create/update the Domain.
+        """
+
+        try:
+            SQL, _ = self.get_sql(gid, sid, self.request, scid, doid)
+            # Most probably this is due to error
+            if not isinstance(SQL, str):
+                return SQL
+            if SQL == '':
+                SQL = "--modified SQL"
+
+            return make_json_response(
+                data=SQL,
+                status=200
+            )
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    def check_domain_type(self, data, old_data, is_schema_diff):
+        """
+        Check domain type
+        :return:
+        """
+        # If fulltype or basetype or collname is changed while comparing
+        # two schemas then we need to drop domain and recreate it
+        if 'fulltype' in data or 'basetype' in data or 'collname' in data:
+            SQL = render_template(
+                "/".join([self.template_path, 'domain_schema_diff.sql']),
+                data=data, o_data=old_data)
+        else:
+            if is_schema_diff:
+                data['is_schema_diff'] = True
+
+            SQL = render_template(
+                "/".join([self.template_path, self._UPDATE_SQL]),
+                data=data, o_data=old_data, conn=self.conn)
+        return SQL, data
+
+    def get_sql(self, gid, sid, data, scid, doid=None, is_schema_diff=False):
+        """
+        Generates the SQL statements to create/update the Domain.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            is_schema_diff: True is function gets called from schema diff
+        """
+
+        if doid is not None:
+            SQL = render_template("/".join([self.template_path,
+                                            self._PROPERTIES_SQL]),
+                                  scid=scid, doid=doid)
+            status, res = self.conn.execute_dict(SQL)
+
+            if not status:
+                return False, internal_server_error(errormsg=res)
+            if len(res['rows']) == 0:
+                return gone(self.not_found_error_msg())
+
+            old_data = res['rows'][0]
+
+            # Get Domain Constraints
+            SQL = render_template("/".join([self.template_path,
+                                            self._GET_CONSTRAINTS_SQL]),
+                                  doid=doid)
+            status, res = self.conn.execute_dict(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            con_data = {}
+            for c in res['rows']:
+                con_data[c['conoid']] = c
+
+            old_data['constraints'] = con_data
+
+            SQL, data = self.check_domain_type(data, old_data, is_schema_diff)
+            return SQL.strip('\n'), data['name'] if 'name' in data else \
+                old_data['name']
+        else:
+            SQL = render_template("/".join([self.template_path,
+                                            self._CREATE_SQL]),
+                                  data=data)
+            return SQL.strip('\n'), data['name']
+
+    @check_precondition
+    def dependents(self, gid, sid, did, scid, doid):
+        """
+        This function get the dependents and return ajax response
+        for the Domain node.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+        dependents_result = self.get_dependents(self.conn, doid)
+        return ajax_response(
+            response=dependents_result,
+            status=200
+        )
+
+    @check_precondition
+    def dependencies(self, gid, sid, did, scid, doid):
+        """
+        This function get the dependencies and return ajax response
+        for the Domain node.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+        dependencies_result = self.get_dependencies(self.conn, doid)
+        return ajax_response(
+            response=dependencies_result,
+            status=200
+        )
+
+    @check_precondition
+    def fetch_objects_to_compare(self, sid, did, scid):
+        """
+        This function will fetch the list of all the domains for
+        specified schema id.
+
+        :param sid: Server Id
+        :param did: Database Id
+        :param scid: Schema Id
+        :return:
+        """
+        res = dict()
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODE_SQL]), scid=scid,
+                              schema_diff=True)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            status, data = self._fetch_properties(did, scid, row['oid'])
+
+            if status:
+                res[row['name']] = data
+
+        return res
+
+    def get_sql_from_diff(self, **kwargs):
+        """
+        This function is used to get the DDL/DML statements.
+        :param kwargs
+        :return:
+        """
+        gid = kwargs.get('gid')
+        sid = kwargs.get('sid')
+        did = kwargs.get('did')
+        scid = kwargs.get('scid')
+        oid = kwargs.get('oid')
+        data = kwargs.get('data', None)
+        drop_sql = kwargs.get('drop_sql', False)
+        target_schema = kwargs.get('target_schema', None)
+
+        if data:
+            if target_schema:
+                data['schema'] = target_schema
+            sql, _ = self.get_sql(gid=gid, sid=sid, scid=scid,
+                                  data=data, doid=oid, is_schema_diff=True)
+        else:
+            if drop_sql:
+                sql = self.delete(gid=gid, sid=sid, did=did,
+                                  scid=scid, doid=oid, only_sql=True)
+            elif target_schema:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, doid=oid,
+                               target_schema=target_schema, json_resp=False)
+            else:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, doid=oid,
+                               json_resp=False)
+        return sql
+
+    def get_dependencies(self, conn, object_id, where=None,
+                         show_system_objects=None, is_schema_diff=False):
+        """
+        This function is used to get dependencies of domain and it's
+        domain constraints.
+        """
+        domain_dependencies = []
+        domain_deps = super().get_dependencies(
+            conn, object_id, where=None, show_system_objects=None,
+            is_schema_diff=True)
+        if len(domain_deps) > 0:
+            domain_dependencies.extend(domain_deps)
+
+        # Get Domain Constraints
+        SQL = render_template("/".join([self.template_path,
+                                        self._GET_CONSTRAINTS_SQL]),
+                              doid=object_id)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        # Get the domain constraints dependencies.
+        for row in res['rows']:
+            constraint_deps = super().get_dependencies(
+                conn, row['conoid'], where=None, show_system_objects=None,
+                is_schema_diff=True)
+            if len(constraint_deps) > 0:
+                domain_dependencies.extend(constraint_deps)
+
+        return domain_dependencies
+
+
+SchemaDiffRegistry(blueprint.node_type, DomainView)
+DomainView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/__init__.py

@@ -0,0 +1,770 @@
+
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+"""Implements the Domain Constraint Module."""
+
+from functools import wraps
+
+import json
+from flask import render_template, request, jsonify
+from flask_babel import gettext
+
+from pgadmin.browser.server_groups.servers.databases.schemas import domains
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.collection import CollectionNodeModule
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response, gone
+from pgadmin.utils.driver import get_driver
+from pgadmin.utils.exception import ObjectGone
+
+
+class DomainConstraintModule(CollectionNodeModule):
+    """
+    class DomainConstraintModule(CollectionNodeModule):
+
+        This class represents The Domain Constraint Module.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Initialize the Domain Constraint Module.
+
+    * get_nodes(gid, sid, did, scid)
+      - Generate the Domain Constraint collection node.
+
+    * node_inode(gid, sid, did, scid)
+      - Returns Domain Constraint node as leaf node.
+
+    * script_load()
+      - Load the module script for the Domain Constraint, when any of the
+        Domain node is initialized.
+    """
+    _NODE_TYPE = 'domain_constraints'
+    _COLLECTION_LABEL = gettext("Domain Constraints")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_ver = None
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid, doid):
+        """
+        Generate the Domain Constraint collection node.
+        """
+        yield self.generate_browser_collection_node(doid)
+
+    @property
+    def node_inode(self):
+        """
+        Returns Domain Constraint node as leaf node.
+        """
+        return False
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for the Domain Constraint, when any of the
+        Domain node is initialized.
+        """
+        return domains.DomainModule.node_type
+
+    @property
+    def csssnippets(self):
+        """
+        Returns a snippet of css to include in the page
+        """
+        return [
+            render_template(
+                "domain_constraints/css/domain_constraints.css",
+                node_type=self.node_type
+            )
+        ]
+
+    @property
+    def module_use_template_javascript(self):
+        """
+        Returns whether Jinja2 template is used for generating the javascript
+        module.
+        """
+        return False
+
+
+blueprint = DomainConstraintModule(__name__)
+
+
+class DomainConstraintView(PGChildNodeView):
+    """
+    class DomainConstraintView(PGChildNodeView):
+
+    This class inherits PGChildNodeView to get the different routes for
+    the module.
+
+    The class is responsible to Create, Read, Update and Delete operations for
+    the Domain Constraint.
+
+    Methods:
+    -------
+
+    * check_precondition(f):
+      - Works as a decorator.
+      -  Checks database connection status.
+      -  Attach connection object and template path.
+
+    * list(gid, sid, did, scid, doid):
+      - List the Domain Constraints.
+
+    * nodes(gid, sid, did, scid):
+      - Returns all the Domain Constraints to generate Nodes in the browser.
+
+    * properties(gid, sid, did, scid, doid):
+      - Returns the Domain Constraint properties.
+
+    * create(gid, sid, did, scid):
+      - Creates a new Domain Constraint object.
+
+    * update(gid, sid, did, scid, doid):
+      - Updates the Domain Constraint object.
+
+    * delete(gid, sid, did, scid, doid):
+      - Drops the Domain Constraint object.
+
+    * sql(gid, sid, did, scid, doid=None):
+      - Returns the SQL for the Domain Constraint object.
+
+    * msql(gid, sid, did, scid, doid=None):
+      - Returns the modified SQL.
+
+    * get_sql(gid, sid, data, scid, doid=None):
+      - Generates the SQL statements to create/update the Domain Constraint.
+        object.
+
+    * dependents(gid, sid, did, scid, doid, coid):
+      - Returns the dependents for the Domain Constraint object.
+
+    * dependencies(gid, sid, did, scid, doid, coid):
+      - Returns the dependencies for the Domain Constraint object.
+    """
+    node_type = blueprint.node_type
+    node_label = "Domain Constraint"
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'},
+        {'type': 'int', 'id': 'doid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'coid'}
+    ]
+
+    operations = dict({
+        'obj': [
+            {'get': 'properties', 'delete': 'delete', 'put': 'update'},
+            {'get': 'list', 'post': 'create', 'delete': 'delete'}
+        ],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}],
+        'msql': [{'get': 'msql'}, {'get': 'msql'}],
+        'stats': [{'get': 'statistics'}],
+        'dependency': [{'get': 'dependencies'}],
+        'dependent': [{'get': 'dependents'}]
+    })
+
+    @staticmethod
+    def _get_req_data(kwargs):
+        """
+        Get data from request.
+        :param kwargs: kwargs for request.
+        :return: if any error return error with error msg else return req data
+        """
+        if request.data:
+            req = json.loads(request.data)
+        else:
+            req = request.args or request.form
+
+        if 'coid' not in kwargs:
+            required_args = [
+                'name',
+                'consrc'
+            ]
+
+            for arg in required_args:
+                if arg not in req or req[arg] == '':
+                    return True, make_json_response(
+                        status=410,
+                        success=0,
+                        errormsg=gettext(
+                            "Could not find the required parameter ({})."
+                        ).format(arg)
+                    ), req
+        return False, '', req
+
+    def validate_request(f):
+        """
+        Works as a decorator.
+        Validating request on the request of create, update and modified SQL.
+
+        Required Args:
+                    name: Name of the Domain Constraint
+                    consrc: Check Constraint Definition
+
+        Above both the arguments will not be validated in the update action.
+        """
+
+        @wraps(f)
+        def wrap(self, **kwargs):
+
+            data = {}
+            is_error, errmsg, req = DomainConstraintView._get_req_data(kwargs)
+            if is_error:
+                return errmsg
+
+            try:
+                for key in req:
+                    if key == 'convalidated':
+                        data[key] = True if (req[key] == 'true' or req[key] is
+                                             True) else False
+                    else:
+                        data[key] = req[key]
+
+            except Exception as e:
+                return internal_server_error(errormsg=str(e))
+
+            self.request = data
+            return f(self, **kwargs)
+
+        return wrap
+
+    def check_precondition(f):
+        """
+        Works as a decorator.
+        Checks database connection status.
+        Attach connection object and template path.
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            self = args[0]
+            driver = get_driver(PG_DEFAULT_DRIVER)
+            self.manager = driver.connection_manager(kwargs['sid'])
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.qtIdent = driver.qtIdent
+            self.datistemplate = False
+            if (
+                self.manager.db_info is not None and
+                kwargs['did'] in self.manager.db_info and
+                'datistemplate' in self.manager.db_info[kwargs['did']]
+            ):
+                self.datistemplate = self.manager.db_info[
+                    kwargs['did']]['datistemplate']
+
+            # Set the template path for the SQL scripts
+            self.template_path = 'domain_constraints/sql/#{0}#'.format(
+                self.manager.version)
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid, doid):
+        """
+        List the Domain Constraints.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              doid=doid)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid, doid):
+        """
+        Returns all the Domain Constraints.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+        """
+        res = []
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              doid=doid)
+        status, rset = self.conn.execute_2darray(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            if 'convalidated' not in row:
+                icon = 'icon-domain_constraints'
+            elif row['convalidated']:
+                icon = 'icon-domain_constraints'
+            else:
+                icon = 'icon-domain_constraints-bad'
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    doid,
+                    row['name'],
+                    icon=icon,
+                    description=row['description']
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, doid, coid):
+        """
+        Returns all the Domain Constraints.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              coid=coid)
+        status, rset = self.conn.execute_2darray(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            if 'convalidated' not in row:
+                icon = 'icon-domain_constraints'
+            elif row['convalidated']:
+                icon = 'icon-domain_constraints'
+            else:
+                icon = 'icon-domain_constraints-bad'
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    doid,
+                    row['name'],
+                    icon=icon
+                ),
+                status=200
+            )
+
+        return gone(self.not_found_error_msg())
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, doid, coid):
+        """
+        Returns the Domain Constraints property.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              doid=doid, coid=coid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return gone(self.not_found_error_msg())
+
+        data = res['rows'][0]
+        data['is_sys_obj'] = (
+            data['oid'] <= self._DATABASE_LAST_SYSTEM_OID or
+            self.datistemplate)
+        return ajax_response(
+            response=data,
+            status=200
+        )
+
+    @check_precondition
+    @validate_request
+    def create(self, gid, sid, did, scid, doid):
+        """
+        Creates a new Domain Constraint object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+
+        Returns:
+            Domain Constraint object in json format.
+        """
+        data = self.request
+        try:
+            status, SQL, _ = self.get_sql(gid, sid, data, scid, doid)
+            if not status:
+                return SQL
+
+            status, res = self.conn.execute_scalar(SQL)
+
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            # Get the recently added constraints oid
+            SQL = render_template("/".join([self.template_path,
+                                            self._OID_SQL]),
+                                  doid=doid, name=data['name'],
+                                  conn=self.conn)
+            status, coid = self.conn.execute_scalar(SQL)
+            if not status:
+                return internal_server_error(errormsg=coid)
+
+            if 'convalidated' not in data:
+                icon = 'icon-domain_constraints'
+            elif 'convalidated' in data and data['convalidated']:
+                icon = 'icon-domain_constraints'
+            else:
+                icon = 'icon-domain_constraints-bad'
+
+            return jsonify(
+                node=self.blueprint.generate_browser_node(
+                    coid,
+                    doid,
+                    data['name'],
+                    icon=icon
+                )
+            )
+        except ObjectGone:
+            raise
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def delete(self, gid, sid, did, scid, doid, coid=None):
+        """
+        Drops the Domain Constraint object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        if coid is None:
+            data = request.form if request.form else json.loads(
+                request.data
+            )
+        else:
+            data = {'ids': [coid]}
+
+        try:
+            for coid in data['ids']:
+                SQL = render_template("/".join([self.template_path,
+                                                self._PROPERTIES_SQL]),
+                                      doid=doid, coid=coid)
+                status, res = self.conn.execute_dict(SQL)
+
+                if not status:
+                    return internal_server_error(errormsg=res)
+
+                if not res['rows']:
+                    return make_json_response(
+                        status=410,
+                        success=0,
+                        errormsg=gettext(
+                            'Error: Object not found.'
+                        ),
+                        info=self.not_found_error_msg()
+                    )
+
+                data = res['rows'][0]
+
+                SQL = render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]),
+                                      data=data)
+                status, res = self.conn.execute_scalar(SQL)
+                if not status:
+                    return internal_server_error(errormsg=res)
+
+            return make_json_response(
+                success=1,
+                info=gettext("Domain Constraint dropped")
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    @validate_request
+    def update(self, gid, sid, did, scid, doid, coid):
+        """
+        Updates the Domain Constraint object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        data = self.request
+        status, SQL, name = self.get_sql(gid, sid, data, scid, doid, coid)
+        if not status:
+            return SQL
+
+        try:
+            if SQL and status:
+                status, res = self.conn.execute_scalar(SQL)
+                if not status:
+                    return internal_server_error(errormsg=res)
+
+                if 'convalidated' in data and data['convalidated']:
+                    icon = 'icon-domain_constraints'
+                elif 'convalidated' in data and not data['convalidated']:
+                    icon = 'icon-domain_constraints-bad'
+                else:
+                    icon = ''
+
+                other_node_info = {}
+                if 'description' in data:
+                    other_node_info['description'] = data['description']
+
+                return jsonify(
+                    node=self.blueprint.generate_browser_node(
+                        coid,
+                        doid,
+                        name,
+                        icon=icon,
+                        **other_node_info
+                    )
+                )
+            else:
+                return make_json_response(
+                    success=1,
+                    info="Nothing to update",
+                    data={
+                        'id': coid,
+                        'doid': doid,
+                        'scid': scid,
+                        'sid': sid,
+                        'gid': gid,
+                        'did': did
+                    }
+                )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def sql(self, gid, sid, did, scid, doid, coid=None):
+        """
+        Returns the SQL for the Domain Constraint object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+
+        # Get Schema and Domain.
+        schema, domain = self._get_domain(doid)
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              doid=doid, coid=coid)
+        status, res = self.conn.execute_dict(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+        if len(res['rows']) == 0:
+            return gone(self.not_found_error_msg())
+
+        data = res['rows'][0]
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._CREATE_SQL]),
+                              data=data, domain=domain, schema=schema)
+
+        sql_header = """-- CHECK: {1}.{0}
+
+-- ALTER DOMAIN {1} DROP CONSTRAINT {0};
+
+""".format(self.qtIdent(self.conn, data['name']),
+           self.qtIdent(self.conn, schema, domain))
+
+        SQL = sql_header + SQL
+
+        return ajax_response(response=SQL)
+
+    @check_precondition
+    @validate_request
+    def msql(self, gid, sid, did, scid, doid, coid=None):
+        """
+        Returns the modified SQL.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+
+        Returns:
+            Domain Constraint object in json format.
+        """
+        data = self.request
+
+        status, SQL, _ = self.get_sql(gid, sid, data, scid, doid, coid)
+        if status and SQL:
+            return make_json_response(
+                data=SQL,
+                status=200
+            )
+        else:
+            return SQL
+
+    def get_sql(self, gid, sid, data, scid, doid, coid=None):
+        """
+        Generates the SQL statements to create/update the Domain Constraint.
+
+         Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        try:
+            if coid is not None:
+                SQL = render_template("/".join([self.template_path,
+                                                self._PROPERTIES_SQL]),
+                                      doid=doid, coid=coid)
+                status, res = self.conn.execute_dict(SQL)
+
+                if not status:
+                    return False, internal_server_error(errormsg=res)
+                if len(res['rows']) == 0:
+                    return False, gone(self.not_found_error_msg())
+
+                old_data = res['rows'][0]
+
+                SQL = render_template(
+                    "/".join([self.template_path, self._UPDATE_SQL]),
+                    data=data, o_data=old_data, conn=self.conn
+                )
+            else:
+                schema, domain = self._get_domain(doid)
+
+                SQL = render_template("/".join([self.template_path,
+                                                self._CREATE_SQL]),
+                                      data=data, domain=domain, schema=schema)
+            if 'name' in data:
+                return True, SQL.strip('\n'), data['name']
+            else:
+                return True, SQL.strip('\n'), old_data['name']
+        except ObjectGone:
+            raise
+        except Exception as e:
+            return False, internal_server_error(errormsg=str(e)), None
+
+    def _get_domain(self, doid):
+        """
+        Returns Domain and Schema name.
+
+        Args:
+            doid: Domain Id
+
+        """
+        SQL = render_template("/".join([self.template_path,
+                                        'get_domain.sql']),
+                              doid=doid)
+        status, res = self.conn.execute_2darray(SQL)
+
+        if not status:
+            return False, internal_server_error(errormsg=res)
+        if len(res['rows']) == 0:
+            raise ObjectGone(self.not_found_error_msg('Domain'))
+
+        return res['rows'][0]['schema'], res['rows'][0]['domain']
+
+    @check_precondition
+    def dependents(self, gid, sid, did, scid, doid, coid):
+        """
+        This function get the dependents and return ajax response
+        for the Domain Constraint node.
+
+        Args:
+            gid:  Server Group Id
+            sid:  Server Id
+            did:  Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        dependents_result = self.get_dependents(self.conn, coid)
+        return ajax_response(
+            response=dependents_result,
+            status=200
+        )
+
+    @check_precondition
+    def dependencies(self, gid, sid, did, scid, doid, coid):
+        """
+        This function get the dependencies and return ajax response
+        for the Domain Constraint node.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            doid: Domain Id
+            coid: Domain Constraint Id
+        """
+        dependencies_result = self.get_dependencies(self.conn, coid)
+        return ajax_response(
+            response=dependencies_result,
+            status=200
+        )
+
+
+DomainConstraintView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/static/js/domain_constraints.js

@@ -0,0 +1,79 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2024, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+
+import DomainConstraintSchema from './domain_constraints.ui';
+
+// Domain Constraint Module: Collection and Node
+define('pgadmin.node.domain_constraints', [
+  'sources/gettext', 'sources/url_for',
+  'sources/pgadmin', 'pgadmin.browser',
+  'pgadmin.node.schema.dir/schema_child_tree_node', 'pgadmin.browser.collection',
+], function(gettext, url_for, pgAdmin, pgBrowser, schemaChildTreeNode) {
+
+  // Define Domain Constraint Collection Node
+  if (!pgBrowser.Nodes['coll-domain_constraints']) {
+    pgAdmin.Browser.Nodes['coll-domain_constraints'] =
+      pgAdmin.Browser.Collection.extend({
+        node: 'domain_constraints',
+        label: gettext('Domain Constraints'),
+        type: 'coll-domain_constraints',
+        columns: ['name', 'description'],
+        canDrop: schemaChildTreeNode.isTreeItemOfChildOfSchema,
+        canDropCascade: false,
+      });
+  }
+
+  // Domain Constraint Node
+  if (!pgBrowser.Nodes['domain_constraints']) {
+    pgAdmin.Browser.Nodes['domain_constraints'] = pgBrowser.Node.extend({
+      type: 'domain_constraints',
+      sqlAlterHelp: 'sql-alterdomain.html',
+      sqlCreateHelp: 'sql-alterdomain.html',
+      dialogHelp: url_for('help.static', {'filename': 'domain_constraint_dialog.html'}),
+      label: gettext('Domain Constraints'),
+      collection_type: 'coll-domain_constraints',
+      hasSQL: true,
+      hasDepends: true,
+      parent_type: ['domain'],
+      Init: function() {
+        // Avoid mulitple registration of menus
+        if (this.initialized)
+          return;
+
+        this.initialized = true;
+
+        pgBrowser.add_menus([{
+          name: 'create_domain_on_coll', node: 'coll-domain_constraints', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 5, label: gettext('Domain Constraint...'),
+          data: {action: 'create', check: true}, enable: 'canCreate',
+        },{
+          name: 'create_domain_constraints', node: 'domain_constraints', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 5, label: gettext('Domain Constraint...'),
+          data: {action: 'create', check: true}, enable: 'canCreate',
+        },{
+          name: 'create_domain_constraints', node: 'domain', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 5, label: gettext('Domain Constraint...'),
+          data: {action: 'create', check: false}, enable: 'canCreate',
+        },
+        ]);
+
+      },
+      canDrop: schemaChildTreeNode.isTreeItemOfChildOfSchema,
+
+      getSchema: function() {
+        return new DomainConstraintSchema();
+      },
+    });
+  }
+
+  return pgBrowser.Nodes['domain'];
+});

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/static/js/domain_constraints.ui.js

@@ -0,0 +1,59 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2024, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+
+import gettext from 'sources/gettext';
+import BaseUISchema from 'sources/SchemaView/base_schema.ui';
+
+export default class DomainConstraintSchema extends BaseUISchema {
+  constructor(initValues) {
+    super({
+      name: undefined,
+      oid: undefined,
+      description: undefined,
+      consrc: undefined,
+      convalidated: true,
+      ...initValues,
+    });
+  }
+
+  get idAttribute() {
+    return 'oid';
+  }
+
+  get baseFields() {
+    let obj = this;
+    return [
+      {
+        id: 'name', label: gettext('Name'), type:'text', cell:'text',
+        noEmpty: true,
+      }, {
+        id: 'oid', label: gettext('OID'), cell: 'text',
+        type: 'text' , mode: ['properties'],
+      }, {
+        id: 'is_sys_obj', label: gettext('System domain constraint?'),
+        cell:'boolean', type: 'switch', mode: ['properties'],
+      }, {
+        id: 'description', label: gettext('Comment'), type: 'multiline', cell:
+        'text', mode: ['properties', 'create', 'edit'], min_version: 90500,
+      }, {
+        id: 'consrc', label: gettext('Check'), type: 'multiline',
+        group: gettext('Definition'), mode: ['properties', 'create', 'edit'],
+        readonly: function(state) {return !obj.isNew(state); },
+        noEmpty: true,
+      }, {
+        id: 'convalidated', label: gettext('Validate?'), type: 'switch',
+        cell:'boolean', group: gettext('Definition'), min_version: 90200,
+        mode: ['properties', 'create', 'edit'],
+        readonly: function(state) {
+          return !obj.isNew(state) && obj._origData.convalidated;
+        }
+      }
+    ];
+  }
+}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/css/domain_constraints.css

@@ -0,0 +1,26 @@
+.icon-coll-domain_constraints {
+  background-image: url('{{ url_for('NODE-%s.static' % node_type, filename='img/coll-domain_constraints.svg' )}}') !important;
+  background-repeat: no-repeat;
+  background-size: 20px !important;
+  align-content: center;
+  vertical-align: middle;
+  height: 1.3em;
+}
+
+.icon-check-bad, .icon-domain_constraints-bad {
+  background-image: url('{{ url_for('NODE-%s.static' % node_type, filename='img/domain_constraints-bad.svg' )}}') !important;
+  background-repeat: no-repeat;
+  background-size: 20px !important;
+  align-content: center;
+  vertical-align: middle;
+  height: 1.3em;
+}
+
+.icon-check, .icon-domain_constraints {
+  background-image: url('{{ url_for('NODE-%s.static' % node_type, filename='img/domain_constraints.svg' )}}') !important;
+  background-repeat: no-repeat;
+  background-size: 20px !important;
+  align-content: center;
+  vertical-align: middle;
+  height: 1.3em;
+}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/create.sql

@@ -0,0 +1,10 @@
+{% if data and schema and domain %}
+ALTER DOMAIN {{ conn|qtIdent(schema, domain) }}
+    ADD CONSTRAINT {{ conn|qtIdent(data.name) }} CHECK ({{ data.consrc }}){% if not data.convalidated %}
+
+    NOT VALID{% endif %};{% if data.description %}
+
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(data.name) }} ON DOMAIN {{ conn|qtIdent(schema, domain) }}
+    IS '{{ data.description }}';{% endif %}
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/delete.sql

@@ -0,0 +1,4 @@
+{% if data %}
+ALTER DOMAIN {{ conn|qtIdent(data.nspname, data.relname) }}
+    DROP CONSTRAINT {{ conn|qtIdent(data.name) }};
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/get_domain.sql

@@ -0,0 +1,8 @@
+SELECT
+    d.typname as domain, bn.nspname as schema
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+WHERE
+    d.oid = {{doid}};

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/get_oid.sql

@@ -0,0 +1,7 @@
+SELECT
+    oid, conname as name
+FROM
+    pg_catalog.pg_constraint
+WHERE
+    contypid = {{doid}}::oid
+    AND conname={{ name|qtLiteral(conn) }};

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/get_type_category.sql

@@ -0,0 +1,5 @@
+SELECT
+    typcategory
+FROM
+    pg_catalog.pg_type
+WHERE typname = {{datatype}};

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/properties.sql

@@ -0,0 +1,22 @@
+SELECT
+    c.oid, conname AS name, typname AS relname, nspname, description,
+    pg_catalog.regexp_replace(pg_catalog.pg_get_constraintdef(c.oid, true), E'CHECK \\((.*)\\).*', E'\\1') AS consrc,
+    connoinherit, convalidated, convalidated AS convalidated_p
+FROM
+    pg_catalog.pg_constraint c
+JOIN
+    pg_catalog.pg_type t ON t.oid=contypid
+JOIN
+    pg_catalog.pg_namespace nl ON nl.oid=typnamespace
+LEFT OUTER JOIN
+    pg_catalog.pg_description des ON (des.objoid=c.oid AND des.classoid='pg_constraint'::regclass)
+{% if doid %}
+WHERE
+    contype = 'c' AND contypid =  {{doid}}::oid
+{% if coid %}
+    AND c.oid = {{ coid }}
+{% endif %}
+{% elif coid %}
+WHERE
+c.oid = {{ coid }}
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/domain_constraints/templates/domain_constraints/sql/default/update.sql

@@ -0,0 +1,13 @@
+{% set name = o_data.name %}
+{% if data.name %}
+{% set name = data.name %}
+ALTER DOMAIN {{ conn|qtIdent(o_data.nspname, o_data.relname) }}
+    RENAME CONSTRAINT {{ conn|qtIdent(o_data.name) }} TO {{ conn|qtIdent(data.name) }};{% endif -%}{% if data.convalidated %}
+
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.nspname, o_data.relname) }}
+    VALIDATE CONSTRAINT {{ conn|qtIdent(name) }};{% endif -%}{% if data.description is defined %}
+
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(name) }} ON DOMAIN {{ conn|qtIdent(o_data.nspname, o_data.relname) }}
+    IS {{ data.description|qtLiteral(conn) }};{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/static/js/domain.js

@@ -0,0 +1,100 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2024, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+
+import { getNodeAjaxOptions, getNodeListByName } from '../../../../../../../static/js/node_ajax';
+import DomainSchema from './domain.ui';
+
+// Domain Module: Collection and Node.
+define('pgadmin.node.domain', [
+  'sources/gettext', 'sources/url_for', 'pgadmin.browser',
+  'pgadmin.node.schema.dir/child', 'pgadmin.node.schema.dir/schema_child_tree_node',
+  'pgadmin.browser.collection',
+], function(
+  gettext, url_for, pgBrowser, schemaChild, schemaChildTreeNode
+) {
+
+  // Define Domain Collection Node
+  if (!pgBrowser.Nodes['coll-domain']) {
+    pgBrowser.Nodes['coll-domain'] =
+      pgBrowser.Collection.extend({
+        node: 'domain',
+        label: gettext('Domains'),
+        type: 'coll-domain',
+        columns: ['name', 'owner', 'description'],
+        canDrop: schemaChildTreeNode.isTreeItemOfChildOfSchema,
+        canDropCascade: schemaChildTreeNode.isTreeItemOfChildOfSchema,
+      });
+  }
+
+  // Domain Node
+  if (!pgBrowser.Nodes['domain']) {
+    pgBrowser.Nodes['domain'] = schemaChild.SchemaChildNode.extend({
+      type: 'domain',
+      sqlAlterHelp: 'sql-alterdomain.html',
+      sqlCreateHelp: 'sql-createdomain.html',
+      dialogHelp: url_for('help.static', {'filename': 'domain_dialog.html'}),
+      label: gettext('Domain'),
+      collection_type: 'coll-domain',
+      hasSQL: true,
+      hasDepends: true,
+      Init: function() {
+        // Avoid mulitple registration of menus
+        if (this.initialized)
+          return;
+
+        this.initialized = true;
+
+        pgBrowser.add_menus([{
+          name: 'create_domain_on_coll', node: 'coll-domain', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 4, label: gettext('Domain...'),
+          data: {action: 'create', check: true}, enable: 'canCreate',
+        },{
+          name: 'create_domain', node: 'domain', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 4, label: gettext('Domain...'),
+          data: {action: 'create', check: true}, enable: 'canCreate',
+        },{
+          name: 'create_domain', node: 'schema', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 4, label: gettext('Domain...'),
+          data: {action: 'create', check: false}, enable: 'canCreate',
+        },
+        ]);
+
+      },
+
+      getSchema: function(treeNodeInfo, itemNodeData) {
+        return new DomainSchema(
+          {
+            role: ()=>getNodeListByName('role', treeNodeInfo, itemNodeData),
+            schema: ()=>getNodeListByName('schema', treeNodeInfo, itemNodeData, {
+              cacheLevel: 'database'
+            }),
+            basetype: ()=>getNodeAjaxOptions('get_types', this, treeNodeInfo, itemNodeData, {
+              cacheNode: 'type'
+            }),
+            collation: ()=>getNodeAjaxOptions('get_collations', this, treeNodeInfo, itemNodeData, {
+              cacheLevel: 'database',
+              cacheNode: 'schema'
+            }),
+          },
+          {
+            owner: pgBrowser.serverInfo[treeNodeInfo.server._id].user.name,
+            schema: itemNodeData.label,
+            basensp: itemNodeData.label,
+          }
+        );
+      },
+    });
+
+  }
+
+  return pgBrowser.Nodes['domain'];
+});

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/static/js/domain.ui.js

@@ -0,0 +1,224 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2024, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+
+import gettext from 'sources/gettext';
+import BaseUISchema from 'sources/SchemaView/base_schema.ui';
+import SecLabelSchema from '../../../../../static/js/sec_label.ui';
+import { isEmptyString } from 'sources/validators';
+import _ from 'lodash';
+
+export class DomainConstSchema extends BaseUISchema {
+  constructor() {
+    super({
+      conoid: undefined,
+      conname: undefined,
+      consrc: undefined,
+      convalidated: true,
+    });
+  }
+
+  get idAttribute() {
+    return 'conoid';
+  }
+
+  get baseFields() {
+    let obj = this;
+    return [
+      {
+        id: 'conname', label: gettext('Name'), cell: 'text', type: 'text',
+      }, {
+        id: 'consrc', label: gettext('Check'), cell: 'text', type: 'text',
+        editable: function(state) {return obj.isNew(state);},
+      }, {
+        id: 'convalidated', label: gettext('Validate?'), cell: 'checkbox',
+        type: 'checkbox',
+        readonly: function(state) {
+          let currCon = _.find(obj.top.origData.constraints, (con)=>con.conoid == state.conoid);
+          return !obj.isNew(state) && currCon.convalidated;
+        },
+      }
+    ];
+  }
+
+  validate(state, setError) {
+    if (isEmptyString(state.conname)) {
+      setError('conname', 'Constraint Name cannot be empty.');
+      return true;
+    } else {
+      setError('conname', null);
+    }
+
+    if (isEmptyString(state.consrc)) {
+      setError('consrc', 'Constraint Check cannot be empty.');
+      return true;
+    } else {
+      setError('consrc', null);
+    }
+  }
+}
+
+export default class DomainSchema extends BaseUISchema {
+  constructor(fieldOptions={}, initValues={}) {
+    super({
+      name: undefined,
+      oid: undefined,
+      owner: undefined,
+      basensp: undefined,
+      description: undefined,
+      basetype: undefined,
+      typlen: undefined,
+      precision: undefined,
+      typdefault: undefined,
+      typnotnull: undefined,
+      sysdomain: undefined,
+      collname: undefined,
+      constraints: [],
+      seclabels: [],
+      ...initValues,
+    });
+    this.fieldOptions = {
+      role: [],
+      schema: [],
+      basetype: [],
+      collation: [],
+      ...fieldOptions,
+    };
+  }
+
+  get idAttribute() {
+    return 'oid';
+  }
+
+  get baseFields() {
+    let obj = this;
+    return [
+      {
+        id: 'name', label: gettext('Name'), cell: 'text',
+        type: 'text', mode: ['properties', 'create', 'edit'],
+        noEmpty: true,
+      }, {
+        id: 'oid', label: gettext('OID'), cell: 'text',
+        type: 'text' , mode: ['properties'],
+      }, {
+        id: 'owner', label: gettext('Owner'),
+        editable: false, type: 'select', options: this.fieldOptions.role,
+        controlProps: { allowClear: false },
+      }, {
+        id: 'basensp', label: gettext('Schema'),
+        editable: false, type: 'select', options: this.fieldOptions.schema,
+        controlProps: { allowClear: false },
+        mode: ['create', 'edit'],
+      }, {
+        id: 'sysdomain', label: gettext('System domain?'), cell: 'boolean',
+        type: 'switch', mode: ['properties'],
+      }, {
+        id: 'description', label: gettext('Comment'), cell: 'text',
+        type: 'multiline',
+      }, {
+        id: 'basetype', label: gettext('Base type'),
+        type: 'select', options: this.fieldOptions.basetype,
+        optionsLoaded: (options) => { obj.type_options = options; },
+        mode:['properties', 'create', 'edit'], group: gettext('Definition'),
+        readonly: function(state) {return !obj.isNew(state);}, noEmpty: true,
+      }, {
+        id: 'typlen', label: gettext('Length'), cell: 'text',
+        type: 'text', group: gettext('Definition'), deps: ['basetype'],
+        readonly: function(state) {return !obj.isNew(state);},
+        disabled: function(state) {
+          // We will store type from selected from combobox
+          let of_type = state.basetype;
+          if(obj.type_options) {
+            // iterating over all the types
+            _.each(obj.type_options, function(o) {
+              // if type from selected from combobox matches in options
+              if ( of_type == o.value ) {
+                // if length is allowed for selected type
+                if(o.length) {
+                  // set the values in model
+                  state.is_tlength = true;
+                  state.min_val = o.min_val;
+                  state.max_val = o.max_val;
+                }
+                else
+                  state.is_tlength = false;
+              }
+            });
+
+            if(!state.is_tlength) {
+              if(state.typlen) {
+                state.typlen = null;
+              }
+            }
+          }
+          return !state.is_tlength;
+        },
+      }, {
+        id: 'precision', label: gettext('Precision'), cell: 'text',
+        type: 'text', group: gettext('Definition'), deps: ['basetype'],
+        readonly: function(state) {return !obj.isNew(state);},
+        disabled: function(state) {
+          // We will store type from selected from combobox
+          let of_type = state.basetype;
+          if(obj.type_options) {
+            // iterating over all the types
+            _.each(obj.type_options, function(o) {
+              // if type from selected from combobox matches in options
+              if ( of_type == o.value ) {
+                // if precession is allowed for selected type
+                if(o.precision)
+                {
+                  // set the values in model
+                  state.is_precision = true;
+                  state.min_val = o.min_val;
+                  state.max_val = o.max_val;
+                }
+                else
+                  state.is_precision = false;
+              }
+            });
+
+            if (!state.is_precision) {
+              if(state.precision) {
+                state.precision = null;
+              }
+            }
+          }
+          return !state.is_precision;
+        },
+      }, {
+        id: 'typdefault', label: gettext('Default'), cell: 'text',
+        type: 'text', group: gettext('Definition'),
+        controlProps: {placeholder: gettext('Enter an expression or a value.')},
+      }, {
+        id: 'typnotnull', label: gettext('Not NULL?'), cell: 'boolean',
+        type: 'switch', group: gettext('Definition'),
+      }, {
+        id: 'collname', label: gettext('Collation'), cell: 'text',
+        type: 'select', group: gettext('Definition'),
+        options: this.fieldOptions.collation,
+        readonly: function(state) {return !obj.isNew(state);},
+      }, {
+        id: 'constraints', label: gettext('Constraints'), type: 'collection',
+        schema: new DomainConstSchema(),
+        editable: false, group: gettext('Constraints'),
+        mode: ['edit', 'create'],
+        canAdd: true, canEdit: false, canDelete: true,
+        uniqueCol : ['conname'],
+      }, {
+        id: 'seclabels', label: gettext('Security labels'), type: 'collection',
+        schema: new SecLabelSchema(),
+        editable: false, group: gettext('Security'),
+        mode: ['edit', 'create'],
+        canAdd: true, canEdit: false, canDelete: true,
+        uniqueCol : ['provider'],
+        min_version: 90200,
+      }
+    ];
+  }
+}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/count.sql

@@ -0,0 +1,9 @@
+SELECT COUNT(*)
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_type b ON b.oid = d.typbasetype
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+WHERE
+    d.typnamespace = {{scid}}::oid

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/create.sql

@@ -0,0 +1,41 @@
+{% import 'macros/schemas/security.macros' as SECLABEL %}
+{% if data %}
+CREATE DOMAIN {{ conn|qtIdent(data.basensp, data.name) }}
+    AS {{ conn|qtTypeIdent(data.basetype) }}{% if data.typlen %}({{data.typlen}}{% if data.precision %},{{data.precision}}{% endif %}){% endif %}{% if data.collname and data.collname != "pg_catalog.\"default\"" %}
+
+    COLLATE {{ data.collname }}{% endif %}{% if data.typdefault %}
+
+    DEFAULT {{ data.typdefault }}{% endif %}{% if data.typnotnull %}
+
+    NOT NULL{% endif %};
+
+{% if data.owner %}
+ALTER DOMAIN {{ conn|qtIdent(data.basensp, data.name) }} OWNER TO {{ conn|qtIdent(data.owner) }};{% endif %}
+
+{% if data.constraints %}
+{% for c in data.constraints %}{% if c.conname and c.consrc %}
+
+ALTER DOMAIN {{ conn|qtIdent(data.basensp, data.name) }}
+    ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% endif -%};
+{% if c.description %}
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(c.conname) }} ON DOMAIN {{ conn|qtIdent(data.basensp, data.name) }}
+    IS '{{ c.description }}';
+{% endif %}
+{% endfor -%}
+{% endif %}
+
+{% if data.description %}
+COMMENT ON DOMAIN {{ conn|qtIdent(data.basensp, data.name) }}
+    IS '{{ data.description }}';{% endif -%}
+
+{% if data.seclabels %}
+{% for r in data.seclabels %}
+{% if r.label and r.provider %}
+
+
+{{ SECLABEL.SET(conn, 'DOMAIN', data.name, r.provider, r.label, data.basensp) }}{% endif -%}
+{% endfor -%}
+{% endif -%}
+
+{% endif -%}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/delete.sql

@@ -0,0 +1,16 @@
+{% if scid and doid %}
+SELECT
+    d.typname as name, bn.nspname as basensp
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+WHERE
+    d.typnamespace = {{scid}}::oid
+AND
+    d.oid={{doid}}::oid;
+{% endif %}
+
+{% if name %}
+DROP DOMAIN IF EXISTS {{ conn|qtIdent(basensp, name) }}{% if cascade %} CASCADE{% endif %};
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/domain_schema_diff.sql

@@ -0,0 +1,54 @@
+{% import 'macros/schemas/security.macros' as SECLABEL %}
+
+-- WARNING:
+-- We have found the difference in either of datatype or collation,
+-- so we need to drop the existing domain first and re-create it.
+DROP DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }};
+
+CREATE DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    AS {% if data.fulltype %}{{ data.fulltype }}{% else %}{{ o_data.fulltype }}{% endif %}{% if data.collname and data.collname != "pg_catalog.\"default\"" %}
+
+    COLLATE {{ data.collname }}{% endif %}{% if data.typdefault %}
+
+    DEFAULT {{ data.typdefault }}{% endif %}{% if data.typnotnull %}
+
+    NOT NULL{% endif %};
+
+{% if data.owner or o_data.owner %}
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }} OWNER TO {% if data.owner %}{{ conn|qtIdent(data.owner) }}{% else %}{{ conn|qtIdent(o_data.owner) }}{% endif %};
+{% endif %}
+{% if data.constraints %}
+{% for c in data.constraints.added %}{% if c.conname and c.consrc %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% endif -%};
+{% if c.description %}
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(c.conname) }} ON DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    IS '{{ c.description }}';
+{% endif %}
+{% endfor -%}
+{% for c in data.constraints.changed %}{% if c.conname and c.consrc %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    ADD CONSTRAINT {{ conn|qtIdent(c.conname) }} CHECK ({{ c.consrc }}){% if not c.convalidated %} NOT VALID{% endif %}{% endif -%};
+{% if c.description %}
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(c.conname) }} ON DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    IS '{{ c.description }}';
+{% endif %}
+{% endfor -%}
+{% endif %}
+
+{% if data.description %}
+COMMENT ON DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    IS '{{ data.description }}';{% endif -%}
+
+{% if data.seclabels %}
+{% for r in data.seclabels %}
+{% if r.label and r.provider %}
+
+
+{{ SECLABEL.SET(conn, 'DOMAIN', data.name, r.provider, r.label, data.basensp) }}{% endif -%}
+{% endfor -%}
+{% endif -%}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/get_collations.sql

@@ -0,0 +1,10 @@
+SELECT --nspname, collname,
+    CASE WHEN length(nspname::text) > 0 AND length(collname::text) > 0  THEN
+    pg_catalog.concat(nspname, '."', collname,'"')
+    ELSE '' END AS copy_collation
+FROM
+    pg_catalog.pg_collation c, pg_catalog.pg_namespace n
+WHERE
+    c.collnamespace=n.oid
+ORDER BY
+    nspname, collname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/get_constraints.sql

@@ -0,0 +1,15 @@
+SELECT
+    'DOMAIN' AS objectkind, c.oid as conoid, conname, typname as relname, nspname, description,
+    pg_catalog.regexp_replace(pg_catalog.pg_get_constraintdef(c.oid, true), E'CHECK \\((.*)\\).*', E'\\1') as consrc, connoinherit, convalidated
+FROM
+    pg_catalog.pg_constraint c
+JOIN
+    pg_catalog.pg_type t ON t.oid=contypid
+JOIN
+    pg_catalog.pg_namespace nl ON nl.oid=typnamespace
+LEFT OUTER JOIN
+    pg_catalog.pg_description des ON (des.objoid=c.oid AND des.classoid='pg_constraint'::regclass)
+WHERE
+    contype = 'c' AND contypid =  {{doid}}::oid
+ORDER BY
+    conname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/get_oid.sql

@@ -0,0 +1,18 @@
+{% if doid %}
+SELECT
+    d.typnamespace as scid
+FROM
+    pg_catalog.pg_type d
+WHERE
+    d.oid={{ doid }}::oid;
+{% else %}
+SELECT
+    d.oid
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+WHERE
+    bn.nspname = {{ basensp|qtLiteral(conn) }}
+    AND d.typname={{ name|qtLiteral(conn) }};
+{% endif %}

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/node.sql

@@ -0,0 +1,23 @@
+SELECT
+    d.oid, d.typname as name, pg_catalog.pg_get_userbyid(d.typowner) as owner,
+    bn.nspname as basensp, des.description
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_type b ON b.oid = d.typbasetype
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+LEFT OUTER JOIN
+    pg_catalog.pg_description des ON (des.objoid=d.oid AND des.classoid='pg_type'::regclass)
+{% if scid is defined %}
+WHERE
+    d.typnamespace = {{scid}}::oid
+{% elif doid %}
+WHERE d.oid = {{doid}}::oid
+{% endif %}
+{% if schema_diff %}
+    AND CASE WHEN (SELECT COUNT(*) FROM pg_catalog.pg_depend
+        WHERE objid = d.oid AND deptype = 'e') > 0 THEN FALSE ELSE TRUE END
+{% endif %}
+ORDER BY
+    d.typname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/properties.sql

@@ -0,0 +1,34 @@
+SELECT
+    d.oid, d.typname as name, d.typbasetype, pg_catalog.format_type(b.oid,NULL) as basetype, pg_catalog.pg_get_userbyid(d.typowner) as owner,
+    c.oid AS colloid, pg_catalog.format_type(b.oid, d.typtypmod) AS fulltype,
+    CASE WHEN length(cn.nspname::text) > 0 AND length(c.collname::text) > 0 THEN
+    pg_catalog.concat(cn.nspname, '."', c.collname,'"')
+    ELSE '' END AS collname,
+    d.typtypmod, d.typnotnull, d.typdefault, d.typndims, d.typdelim, bn.nspname as basensp,
+    description, (SELECT COUNT(1) FROM pg_catalog.pg_type t2 WHERE t2.typname=d.typname) > 1 AS domisdup,
+    (SELECT COUNT(1) FROM pg_catalog.pg_type t3 WHERE t3.typname=b.typname) > 1 AS baseisdup,
+    (SELECT
+        pg_catalog.array_agg(provider || '=' || label)
+    FROM
+        pg_catalog.pg_seclabel sl1
+    WHERE
+        sl1.objoid=d.oid) AS seclabels
+FROM
+    pg_catalog.pg_type d
+JOIN
+    pg_catalog.pg_type b ON b.oid = d.typbasetype
+JOIN
+    pg_catalog.pg_namespace bn ON bn.oid=d.typnamespace
+LEFT OUTER JOIN
+    pg_catalog.pg_description des ON (des.objoid=d.oid AND des.classoid='pg_type'::regclass)
+LEFT OUTER JOIN
+    pg_catalog.pg_collation c ON d.typcollation=c.oid
+LEFT OUTER JOIN
+    pg_catalog.pg_namespace cn ON c.collnamespace=cn.oid
+WHERE
+    d.typnamespace = {{scid}}::oid
+{% if doid %}
+  AND d.oid={{doid}}::oid
+{% endif %}
+ORDER BY
+    d.typname;

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/templates/domains/sql/default/update.sql

@@ -0,0 +1,100 @@
+{% import 'macros/schemas/security.macros' as SECLABEL %}
+{% if data %}
+{% set name = o_data.name %}
+{% if data.name %}
+{% if data.name != o_data.name %}
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, o_data.name) }}
+    RENAME TO {{ conn|qtIdent(data.name) }};
+{% set name = data.name %}
+{% endif %}
+{% endif -%}
+{% if data.typnotnull and not o_data.typnotnull %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    SET NOT NULL;
+{% elif 'typnotnull' in data and not data.typnotnull and o_data.typnotnull%}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    DROP NOT NULL;
+{% endif -%}{% if data.typdefault %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    SET DEFAULT {{ data.typdefault }};
+{% elif (data.typdefault == '' or data.typdefault == None) and data.typdefault != o_data.typdefault %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    DROP DEFAULT;
+{% endif -%}{% if data.owner %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    OWNER TO {{ conn|qtIdent(data.owner) }};
+{% endif -%}{% if data.constraints %}
+{% for c in data.constraints.deleted %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    DROP CONSTRAINT {{ conn|qtIdent(o_data['constraints'][c.conoid]['conname']) }};
+{% endfor -%}
+{% if data.is_schema_diff is defined and data.is_schema_diff %}
+{% for c in data.constraints.changed %}
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    DROP CONSTRAINT {{ conn|qtIdent(c.conname) }};
+
+ALTER DOMAIN {{ 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 -%};
+
+{% if c.description is defined and c.description != '' %}
+COMMENT ON CONSTRAINT {{ conn|qtIdent(c.conname) }} ON DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    IS {{ c.description|qtLiteral(conn) }};{% endif %}
+{% endfor -%}
+{% else %}
+{% for c in data.constraints.changed %}
+{% if c.conname and c.conname !=o_data['constraints'][c.conoid]['conname'] %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+     RENAME CONSTRAINT {{ conn|qtIdent(o_data['constraints'][c.conoid]['conname']) }} TO {{ conn|qtIdent(c.conname) }};
+{% endif %}
+{% if c.convalidated and not o_data['constraints'][c.conoid]['convalidated'] %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+     VALIDATE CONSTRAINT {{ conn|qtIdent(c.conname) }};
+{% endif %}
+{% endfor -%}
+{% endif %}
+{% for c in data.constraints.added %}
+{% if c.conname and c.consrc %}
+
+ALTER DOMAIN {{ 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 -%};{% endif -%}
+
+{% if c.description %}
+
+COMMENT ON CONSTRAINT {{ conn|qtIdent(c.conname) }} ON DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    IS '{{ c.description }}';
+{% endif %}
+{% endfor -%}{% endif -%}
+{% set seclabels = data.seclabels %}
+{% if 'deleted' in seclabels and seclabels.deleted|length > 0 %}
+{% for r in seclabels.deleted %}
+{{ SECLABEL.UNSET(conn, 'DOMAIN', name, r.provider, o_data.basensp) }}
+
+{% endfor %}
+{% endif -%}
+{% if 'added' in seclabels and seclabels.added|length > 0 %}
+{% for r in seclabels.added %}
+
+{{ SECLABEL.SET(conn, 'DOMAIN', name, r.provider, r.label, o_data.basensp) }}
+{% endfor %}
+{% endif -%}{% if 'changed' in seclabels and seclabels.changed|length > 0 %}
+{% for r in seclabels.changed %}
+
+{{ SECLABEL.SET(conn, 'DOMAIN', name, r.provider, r.label, o_data.basensp) }}
+{% endfor %}
+{% endif -%}{% if data.description is defined and data.description != o_data.description %}
+
+COMMENT ON DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    IS {{ data.description|qtLiteral(conn) }};
+{% endif -%}{% if data.basensp %}
+
+ALTER DOMAIN {{ conn|qtIdent(o_data.basensp, name) }}
+    SET SCHEMA {{ conn|qtIdent(data.basensp) }};{% endif -%}
+{% endif -%}

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

@@ -0,0 +1,1942 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+"""Implements the Foreign Table Module."""
+
+import sys
+import re
+from functools import wraps
+
+import json
+from flask import render_template, request, jsonify, \
+    current_app
+from flask_babel import gettext
+
+from pgadmin.browser.server_groups.servers import databases
+from config import PG_DEFAULT_DRIVER
+from pgadmin.browser.server_groups.servers.databases.schemas.utils import \
+    SchemaChildModule, DataTypeReader
+from pgadmin.browser.server_groups.servers.databases.utils import \
+    parse_sec_labels_from_db
+from pgadmin.browser.server_groups.servers.utils import parse_priv_from_db, \
+    parse_priv_to_db
+from pgadmin.browser.utils import PGChildNodeView
+from pgadmin.utils.ajax import make_json_response, internal_server_error, \
+    make_response as ajax_response, gone
+from pgadmin.utils.compile_template_name import compile_template_path
+from pgadmin.utils.driver import get_driver
+from pgadmin.tools.schema_diff.node_registry import SchemaDiffRegistry
+from pgadmin.tools.schema_diff.compare import SchemaDiffObjectCompare
+from pgadmin.browser.server_groups.servers.databases.schemas.tables.\
+    columns import utils as column_utils
+from pgadmin.browser.server_groups.servers.databases.schemas.tables.\
+    triggers import utils as trigger_utils
+
+
+class ForeignTableModule(SchemaChildModule):
+    """
+    class ForeignTableModule(CollectionNodeModule):
+
+        This class represents The Foreign Table Module.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Initialize the Foreign Table Module.
+
+    * get_nodes(gid, sid, did, scid)
+      - Generate the Foreign Table collection node.
+
+    * node_inode():
+      - Override this property to make the Foreign Table node as leaf node.
+
+    * script_load()
+      - Load the module script for Foreign Table, when schema node is
+        initialized.
+    """
+    _NODE_TYPE = 'foreign_table'
+    _COLLECTION_LABEL = gettext("Foreign Tables")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.min_ver = None
+        self.max_ver = None
+
+    def get_nodes(self, gid, sid, did, scid):
+        """
+        Generate the Foreign Table collection node.
+        """
+        if self.has_nodes(
+            sid, did, scid,
+                base_template_path=ForeignTableView.BASE_TEMPLATE_PATH):
+            yield self.generate_browser_collection_node(scid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for foreign table, when the
+        schema node is initialized.
+        """
+        return databases.DatabaseModule.node_type
+
+    def register(self, app, options):
+        from pgadmin.browser.server_groups.servers.databases.schemas.\
+            tables.triggers import blueprint as module
+        self.submodules.append(module)
+        from pgadmin.browser.server_groups.servers.databases.schemas.tables.\
+            constraints import blueprint as module
+        self.submodules.append(module)
+        from pgadmin.browser.server_groups.servers.databases.schemas. \
+            foreign_tables.foreign_table_columns import \
+            foreign_table_column_blueprint as module
+        self.submodules.append(module)
+        super().register(app, options)
+
+
+blueprint = ForeignTableModule(__name__)
+
+
+class ForeignTableView(PGChildNodeView, DataTypeReader,
+                       SchemaDiffObjectCompare):
+    """
+    class ForeignTableView(PGChildNodeView)
+
+    This class inherits PGChildNodeView to get the different routes for
+    the module.
+
+    The class is responsible to Create, Read, Update and Delete operations for
+    the Foreign Table.
+
+    Methods:
+    -------
+    * validate_request(f):
+      - Works as a decorator.
+        Validating request on the request of create, update and modified SQL.
+
+    * check_precondition(f):
+      - Works as a decorator.
+      - Checks database connection status.
+      - Attach connection object and template path.
+
+    * list(gid, sid, did, scid):
+      - List the Foreign Table.
+
+    * nodes(gid, sid, did, scid):
+      - Returns all the Foreign Table to generate Nodes in the browser.
+
+    * properties(gid, sid, did, scid, foid):
+      - Returns the Foreign Table properties.
+
+    * get_collations(gid, sid, did, scid, foid=None):
+      - Returns Collations.
+
+    * get_types(gid, sid, did, scid, foid=None):
+      - Returns Data Types.
+
+    * get_foreign_servers(gid, sid, did, scid, foid=None):
+      - Returns the Foreign Servers.
+
+    * get_tables(gid, sid, did, scid, foid=None):
+      - Returns the Foreign Tables as well as Plain Tables.
+
+    * get_columns(gid, sid, did, scid, foid=None):
+      - Returns the Table Columns.
+
+    * create(gid, sid, did, scid):
+      - Creates a new Foreign Table object.
+
+    * update(gid, sid, did, scid, foid):
+      - Updates the Foreign Table object.
+
+    * delete(gid, sid, did, scid, foid):
+      - Drops the Foreign Table object.
+
+    * sql(gid, sid, did, scid, foid):
+      - Returns the SQL for the Foreign Table object.
+
+    * msql(gid, sid, did, scid, foid=None):
+      - Returns the modified SQL.
+
+    * get_sql(gid, sid, data, scid, foid=None):
+      - Generates the SQL statements to create/update the Foreign Table object.
+
+    * dependents(gid, sid, did, scid, foid):
+      - Returns the dependents for the Foreign Table object.
+
+    * dependencies(gid, sid, did, scid, foid):
+      - Returns the dependencies for the Foreign Table object.
+
+    * select_sql(gid, sid, did, scid, foid):
+      - Returns sql for Script
+
+    * insert_sql(gid, sid, did, scid, foid):
+      - Returns sql for Script
+
+    * update_sql(gid, sid, did, scid, foid):
+      - Returns sql for Script
+
+    * delete_sql(gid, sid, did, scid, foid):
+      - Returns sql for Script
+
+    * compare(**kwargs):
+      - This function will compare the foreign table nodes from two different
+        schemas.
+    """
+
+    node_type = blueprint.node_type
+    node_label = "Foreign Table"
+    BASE_TEMPLATE_PATH = 'foreign_tables/sql/#{0}#'
+    double_newline = '\n\n'
+    pattern = '\n{2,}'
+
+    parent_ids = [
+        {'type': 'int', 'id': 'gid'},
+        {'type': 'int', 'id': 'sid'},
+        {'type': 'int', 'id': 'did'},
+        {'type': 'int', 'id': 'scid'}
+    ]
+    ids = [
+        {'type': 'int', 'id': 'foid'}
+    ]
+
+    operations = dict({
+        'obj': [
+            {'get': 'properties', 'delete': 'delete', 'put': 'update'},
+            {'get': 'list', 'post': 'create', 'delete': 'delete'}
+        ],
+        'delete': [{'delete': 'delete'}, {'delete': 'delete'}],
+        'children': [{'get': 'children'}],
+        'nodes': [{'get': 'node'}, {'get': 'nodes'}],
+        'sql': [{'get': 'sql'}],
+        'msql': [{'get': 'msql'}, {'get': 'msql'}],
+        'stats': [{'get': 'statistics'}],
+        'dependency': [{'get': 'dependencies'}],
+        'dependent': [{'get': 'dependents'}],
+        'get_collations': [
+            {'get': 'get_collations'},
+            {'get': 'get_collations'}
+        ],
+        'get_types': [{'get': 'types'}, {'get': 'types'}],
+        'get_foreign_servers': [{'get': 'get_foreign_servers'},
+                                {'get': 'get_foreign_servers'}],
+        'get_tables': [{'get': 'get_tables'}, {'get': 'get_tables'}],
+        'set_trigger': [{'put': 'enable_disable_triggers'}],
+        'get_columns': [{'get': 'get_columns'}, {'get': 'get_columns'}],
+        'select_sql': [{'get': 'select_sql'}],
+        'insert_sql': [{'get': 'insert_sql'}],
+        'update_sql': [{'get': 'update_sql'}],
+        'delete_sql': [{'get': 'delete_sql'}],
+        'compare': [{'get': 'compare'}, {'get': 'compare'}]
+    })
+
+    keys_to_ignore = ['oid', 'basensp', 'oid-2', 'attnum', 'strftoptions']
+
+    def validate_request(f):
+        """
+        Works as a decorator.
+        Validating request on the request of create, update and modified SQL.
+
+        Required Args:
+                    name: Name of the Foreign Table
+                    ftsrvname: Foreign Server Name
+
+        Above both the arguments will not be validated in the update action.
+        """
+
+        @wraps(f)
+        def wrap(self, **kwargs):
+
+            if request.data:
+                req = json.loads(request.data)
+            else:
+                req = request.args or request.form
+
+            invalid, arg = self._check_valid_foid_input(kwargs, req)
+
+            if invalid:
+                return make_json_response(
+                    status=410,
+                    success=0,
+                    errormsg=gettext(
+                        "Could not find the required parameter ({})."
+                    ).format(arg)
+                )
+
+            try:
+                if request.method == 'GET':
+                    list_params = ['constraints', 'columns', 'ftoptions',
+                                   'seclabels', 'inherits', 'acl']
+                else:
+                    list_params = ['inherits']
+
+                data = self._validate_req(req, list_params)
+
+            except Exception as e:
+                return internal_server_error(errormsg=str(e))
+
+            self.request = data
+            return f(self, **kwargs)
+
+        return wrap
+
+    @staticmethod
+    def _check_valid_foid_input(kwargs, req):
+
+        """
+        check for valid Foreign Table id
+        :param kwargs: user input
+        :param req: request object
+        """
+
+        if 'foid' not in kwargs:
+            required_args = [
+                'name',
+                'ftsrvname'
+            ]
+
+            for arg in required_args:
+                if arg not in req or req[arg] == '':
+                    return True, arg
+        return False, ''
+
+    def _validate_req(self, req, list_params):
+
+        """
+        Validate & convert the string to desired output format
+        :param req: request data
+        :param list_params: prepared list of inherit, constraints, etc.
+        :return: data
+        """
+
+        data = {}
+
+        try:
+            for key in req:
+                if (
+                    key in list_params and req[key] != '' and
+                    req[key] is not None
+                ):
+                    # Coverts string into python list as expected.
+                    data[key] = []
+                    self._convert_string_to_list(req, data, key)
+
+                elif key == 'typnotnull':
+                    if req[key] == 'true' or req[key] is True:
+                        data[key] = True
+                    elif req[key] == 'false' or req[key] is False:
+                        data[key] = False
+                    else:
+                        data[key] = ''
+                else:
+                    data[key] = req[key]
+
+        except Exception as e:
+            current_app.logger.exception(e)
+            raise e
+
+        return data
+
+    def _convert_string_to_list(self, req, data, key):
+
+        """
+        Convert the string with utf-8 base to list
+        :param req: request data
+        :param data: output
+        :param key: index for data
+        """
+
+        if not isinstance(req[key], list) and req[key]:
+            data[key] = json.loads(req[key])
+        elif req[key]:
+            data[key] = req[key]
+
+        if key == 'inherits':
+            # Convert Table ids from unicode/string to int
+            # and make tuple for 'IN' query.
+            inherits = tuple([int(x) for x in data[key]])
+
+            if len(inherits) == 1:
+                # Python tupple has , after the first param
+                # in case of single parameter.
+                # So, we need to make it tuple explicitly.
+                inherits = "(" + str(inherits[0]) + ")"
+            if inherits:
+                # Fetch Table Names from their respective Ids,
+                # as we need Table names to generate the SQL.
+                SQL = render_template(
+                    "/".join([self.template_path,
+                              self._GET_TABLES_SQL]),
+                    attrelid=inherits)
+                status, res = self.conn.execute_dict(SQL)
+
+                if not status:
+                    return internal_server_error(errormsg=res)
+
+                if 'inherits' in res['rows'][0]:
+                    data[key] = res['rows'][0]['inherits']
+                else:
+                    data[key] = []
+
+    def check_precondition(f):
+        """
+        Works as a decorator.
+        Checks the database connection status.
+        Attaches the connection object and template path to the class object.
+        """
+
+        @wraps(f)
+        def wrap(*args, **kwargs):
+            self = args[0]
+            driver = get_driver(PG_DEFAULT_DRIVER)
+            self.manager = driver.connection_manager(kwargs['sid'])
+
+            # Get database connection
+            self.conn = self.manager.connection(did=kwargs['did'])
+            self.qtIdent = driver.qtIdent
+            self.datistemplate = \
+                self.manager.db_info[kwargs['did']]['datistemplate'] \
+                if self.manager.db_info is not None and \
+                kwargs['did'] in self.manager.db_info else False
+
+            # Set template path for sql scripts depending
+            # on the server version.
+            self.template_path = \
+                self.BASE_TEMPLATE_PATH.format(self.manager.version)
+
+            self.foreign_table_column_template_path = compile_template_path(
+                'foreign_table_columns/sql', self.manager.version)
+
+            self.column_template_path = compile_template_path(
+                'columns/sql', self.manager.version)
+
+            # Template for trigger node
+            self.trigger_template_path = \
+                'triggers/sql/{0}/#{1}#'.format(self.manager.server_type,
+                                                self.manager.version)
+
+            return f(*args, **kwargs)
+
+        return wrap
+
+    @check_precondition
+    def list(self, gid, sid, did, scid):
+        """
+        List all the Foreign Tables.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+        """
+        SQL = render_template("/".join([self.template_path, self._NODE_SQL]),
+                              scid=scid)
+        status, res = self.conn.execute_dict(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=res)
+        return ajax_response(
+            response=res['rows'],
+            status=200
+        )
+
+    @check_precondition
+    def nodes(self, gid, sid, did, scid):
+        """
+        Returns the Foreign Tables to generate the Nodes.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+        """
+
+        res = []
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODE_SQL]), scid=scid)
+        status, rset = self.conn.execute_2darray(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            res.append(
+                self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-foreign_table",
+                    description=row['description'],
+                    tigger_count=row['triggercount'],
+                    has_enable_triggers=row['has_enable_triggers'],
+                ))
+
+        return make_json_response(
+            data=res,
+            status=200
+        )
+
+    @check_precondition
+    def node(self, gid, sid, did, scid, foid):
+        """
+        Returns the Foreign Tables to generate the Nodes.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODE_SQL]), foid=foid)
+        status, rset = self.conn.execute_2darray(SQL)
+
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        for row in rset['rows']:
+            return make_json_response(
+                data=self.blueprint.generate_browser_node(
+                    row['oid'],
+                    scid,
+                    row['name'],
+                    icon="icon-foreign_table"
+                ),
+                status=200
+            )
+
+        return gone(self.not_found_error_msg())
+
+    @check_precondition
+    def properties(self, gid, sid, did, scid, foid):
+        """
+        Returns the Foreign Table properties.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+        status, data = self._fetch_properties(gid, sid, did, scid, foid)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        return ajax_response(
+            response=data,
+            status=200
+        )
+
+    @check_precondition
+    def get_collations(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the Collations.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+
+        res = [{'label': '', 'value': ''}]
+        try:
+            SQL = render_template("/".join([self.template_path,
+                                            'get_collations.sql']))
+            status, rset = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            for row in rset['rows']:
+                res.append(
+                    {'label': row['copy_collation'],
+                     'value': row['copy_collation']}
+                )
+
+            return make_json_response(
+                data=res,
+                status=200
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def types(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the Data Types.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+
+        condition = render_template("/".join(
+            [self.template_path, 'types_condition.sql']),
+            server_type=self.manager.server_type,
+            show_sys_objects=self.blueprint.show_system_objects)
+
+        # Get Types
+        status, types = self.get_types(self.conn, condition)
+
+        if not status:
+            return internal_server_error(errormsg=types)
+
+        return make_json_response(
+            data=types,
+            status=200
+        )
+
+    @check_precondition
+    def get_foreign_servers(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the Foreign Servers.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+        res = [{'label': '', 'value': ''}]
+        try:
+            SQL = render_template("/".join([self.template_path,
+                                            'get_foreign_servers.sql']))
+            status, rset = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            for row in rset['rows']:
+                res.append(
+                    {'label': row['srvname'], 'value': row['srvname']}
+                )
+            return make_json_response(
+                data=res,
+                status=200
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def get_tables(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the Foreign Tables as well as Plain Tables.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+        res = []
+        try:
+            SQL = render_template("/".join(
+                [self.template_path, self._GET_TABLES_SQL]),
+                foid=foid, server_type=self.manager.server_type,
+                show_sys_objects=self.blueprint.show_system_objects)
+            status, rset = self.conn.execute_dict(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            return make_json_response(
+                data=rset['rows'],
+                status=200
+            )
+
+        except Exception:
+            _, exc_value, _ = sys.exc_info()
+            return internal_server_error(errormsg=str(exc_value))
+
+    @check_precondition
+    def get_columns(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the Table Columns.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            attrelid: Table oid
+
+        Returns:
+              JSON Array with below parameters.
+              attname: Column Name
+              datatype: Column Data Type
+              inherited_from: Parent Table from which the related column
+                              is inheritted.
+        """
+        res = []
+        data = request.args if request.args else None
+        try:
+            if data and 'attrelid' in data:
+                SQL = render_template("/".join([self.template_path,
+                                                'get_table_columns.sql']),
+                                      attrelid=data['attrelid'])
+                status, res = self.conn.execute_dict(SQL)
+
+                if not status:
+                    return internal_server_error(errormsg=res)
+                return make_json_response(
+                    data=res['rows'],
+                    status=200
+                )
+        except Exception:
+            _, exc_value, _ = sys.exc_info()
+            return internal_server_error(errormsg=str(exc_value))
+
+    @check_precondition
+    @validate_request
+    def create(self, gid, sid, did, scid):
+        """
+        Creates a new Foreign Table object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            name: Foreign Table Name
+            basensp: Schema Name
+            ftsrvname: Foreign Server Name
+
+        Returns:
+            Foreign Table object in json format.
+        """
+        try:
+            # Get SQL to create Foreign Table
+            SQL, _ = self.get_sql(gid=gid, sid=sid, did=did, scid=scid,
+                                  data=self.request)
+            # Most probably this is due to error
+            if not isinstance(SQL, str):
+                return SQL
+
+            status, res = self.conn.execute_scalar(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            # Need oid to add object in the tree at browser.
+            basensp = self.request['basensp'] if ('basensp' in self.request) \
+                else None
+            SQL = render_template("/".join([self.template_path,
+                                            self._OID_SQL]),
+                                  basensp=basensp,
+                                  name=self.request['name'],
+                                  conn=self.conn)
+            status, res = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            foid = res['rows'][0]['oid']
+            scid = res['rows'][0]['scid']
+
+            return jsonify(
+                node=self.blueprint.generate_browser_node(
+                    foid,
+                    scid,
+                    self.request['name'],
+                    icon="icon-foreign_table"
+                )
+            )
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def delete(self, gid, sid, did, scid, foid=None, only_sql=False):
+        """
+        Drops the Foreign Table.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            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(
+                request.data
+            )
+        else:
+            data = {'ids': [foid]}
+
+        cascade = self._check_cascade_operation()
+
+        try:
+            for foid in data['ids']:
+                # Fetch Name and Schema Name to delete the foreign table.
+                SQL = render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]), scid=scid,
+                                      foid=foid)
+                status, res = self.conn.execute_2darray(SQL)
+                if not status:
+                    return internal_server_error(errormsg=res)
+                elif not res['rows']:
+                    return make_json_response(
+                        success=0,
+                        errormsg=gettext(
+                            'Error: Object not found.'
+                        ),
+                        info=self.not_found_error_msg()
+                    )
+
+                name = res['rows'][0]['name']
+                basensp = res['rows'][0]['basensp']
+
+                SQL = render_template("/".join([self.template_path,
+                                                self._DELETE_SQL]),
+                                      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)
+
+            return make_json_response(
+                success=1,
+                info=gettext("Foreign Table dropped")
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    @validate_request
+    def update(self, gid, sid, did, scid, foid):
+        """
+        Updates the Foreign Table.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+
+        try:
+            SQL, name = self.get_sql(gid=gid, sid=sid, did=did, scid=scid,
+                                     data=self.request, foid=foid)
+            # Most probably this is due to error
+            if not isinstance(SQL, str):
+                return SQL
+
+            SQL = SQL.strip('\n').strip(' ')
+            status, res = self.conn.execute_scalar(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            SQL = render_template("/".join([self.template_path,
+                                            self._OID_SQL]),
+                                  foid=foid,
+                                  conn=self.conn)
+            status, res = self.conn.execute_2darray(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            scid = res['rows'][0]['scid']
+
+            other_node_info = {}
+            if 'description' in self.request:
+                other_node_info['description'] = self.request['description']
+
+            return jsonify(
+                node=self.blueprint.generate_browser_node(
+                    foid,
+                    scid,
+                    name,
+                    icon="icon-%s" % self.node_type,
+                    **other_node_info
+                )
+            )
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @check_precondition
+    def sql(self, gid, sid, did, scid, foid=None, **kwargs):
+        """
+        Returns the SQL for the Foreign Table object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            json_resp: True then return json response
+        """
+        json_resp = kwargs.get('json_resp', True)
+        target_schema = kwargs.get('target_schema', None)
+
+        status, data = self._fetch_properties(gid, sid, did, scid, foid,
+                                              inherits=True)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        col_data = []
+        for c in data['columns']:
+            if c.get('inheritedfrom', None) is None:
+                col_data.append(c)
+
+        data['columns'] = col_data
+        if target_schema:
+            data['basensp'] = target_schema
+
+        # Parse Privileges
+        if 'relacl' in data:
+            data['relacl'] = parse_priv_to_db(data['relacl'],
+                                              ["a", "r", "w", "x"])
+
+        SQL = render_template("/".join([self.template_path,
+                                        self._CREATE_SQL]),
+                              data=data, is_sql=True,
+                              add_not_exists_clause=True,
+                              conn=self.conn
+                              )
+
+        if not json_resp:
+            return SQL.strip('\n')
+
+        sql_header = """-- FOREIGN TABLE: {0}.{1}\n\n""".format(
+            data['basensp'], data['name'])
+
+        sql_header += """-- DROP FOREIGN TABLE IF EXISTS {0};
+
+""".format(self.qtIdent(self.conn, data['basensp'], data['name']))
+
+        SQL = sql_header + SQL
+
+        trigger_sql = self._get_resql_for_triggers(
+            foid, data['basensp'], data['name'])
+
+        SQL = SQL + trigger_sql
+
+        return ajax_response(response=SQL.strip('\n'))
+
+    @check_precondition
+    @validate_request
+    def msql(self, gid, sid, did, scid, foid=None):
+        """
+        Returns the modified SQL.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            name: Foreign Table Name
+            ftsrvname: Foreign Server Name
+
+        Returns:
+            SQL statements to create/update the Foreign Table.
+        """
+        data = {}
+        for k, v in self.request.items():
+            try:
+                # comments should be taken as is because if user enters a
+                # json comment it is parsed by loads which should not happen
+                if k in ('description',):
+                    data[k] = v
+                else:
+                    data[k] = json.loads(v)
+            except ValueError:
+                data[k] = v
+            except TypeError:
+                data[k] = v
+        try:
+            SQL, _ = self.get_sql(gid=gid, sid=sid, did=did, scid=scid,
+                                  data=data, foid=foid)
+            # Most probably this is due to error
+            if not isinstance(SQL, str):
+                return SQL
+
+            if SQL == '':
+                SQL = "--modified SQL"
+
+            return make_json_response(
+                data=SQL,
+                status=200
+            )
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    @staticmethod
+    def _parse_privileges(data):
+        """
+        Parser privilege data as per type.
+        :param data: Data.
+        :return:
+        """
+        if 'relacl' in data and 'added' in data['relacl']:
+            data['relacl']['added'] = parse_priv_to_db(
+                data['relacl']['added'], ["a", "r", "w", "x"])
+        if 'relacl' in data and 'changed' in data['relacl']:
+            data['relacl']['changed'] = parse_priv_to_db(
+                data['relacl']['changed'], ["a", "r", "w", "x"])
+        if 'relacl' in data and 'deleted' in data['relacl']:
+            data['relacl']['deleted'] = parse_priv_to_db(
+                data['relacl']['deleted'], ["a", "r", "w", "x"])
+
+    @staticmethod
+    def _check_old_col_ops(old_col_frmt_options, option, col):
+        """
+        check old column options.
+        :param old_col_frmt_options: old column option data.
+        :param option: option data.
+        :param col: column data.
+        :return:
+        """
+        if (
+            option['option'] in old_col_frmt_options and
+            option['value'] != old_col_frmt_options[option['option']]
+        ):
+            col['coloptions_updated']['changed'].append(option)
+        elif option['option'] not in old_col_frmt_options:
+            col['coloptions_updated']['added'].append(option)
+        if option['option'] in old_col_frmt_options:
+            del old_col_frmt_options[option['option']]
+
+    @staticmethod
+    def _parse_column_options(data):
+        """
+        Parse columns data.
+        :param data: Data.
+        :return:
+        """
+        for c in data['columns']['changed']:
+            old_col_options = []
+            if 'coloptions' in c and c['coloptions']:
+                old_col_options = c['coloptions']
+
+            old_col_frmt_options = {}
+
+            for o in old_col_options:
+                col_opt = o.split("=")
+                old_col_frmt_options[col_opt[0]] = col_opt[1]
+
+            c['coloptions_updated'] = {'added': [],
+                                       'changed': [],
+                                       'deleted': []}
+
+            if 'coloptions' in c and len(c['coloptions']) > 0:
+                for o in c['coloptions']:
+                    ForeignTableView._check_old_col_ops(old_col_frmt_options,
+                                                        o, c)
+
+            for o in old_col_frmt_options:
+                c['coloptions_updated']['deleted'].append(
+                    {'option': o})
+
+    def _format_columns_data(self, data, old_data):
+        """
+        Format columns.
+        :param data: data.
+        :param old_data: old data for compare.
+        :return:
+        """
+        col_data = {}
+        # 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.
+        for c in old_data['columns']:
+            col_data[c['attnum']] = c
+
+        old_data['columns'] = col_data
+
+        if 'columns' in data and 'added' in data['columns']:
+            data['columns']['added'] = self._format_columns(
+                data['columns']['added'])
+
+        if 'columns' in data and 'changed' in data['columns']:
+            data['columns']['changed'] = self._format_columns(
+                data['columns']['changed'])
+
+            # Parse Column Options
+            ForeignTableView._parse_column_options(data)
+
+    def get_sql(self, **kwargs):
+        """
+        Generates the SQL statements to create/update the Foreign Table.
+
+        Args:
+            kwargs: Server Group Id
+        """
+        gid = kwargs.get('gid')
+        sid = kwargs.get('sid')
+        did = kwargs.get('did')
+        scid = kwargs.get('scid')
+        data = kwargs.get('data')
+        foid = kwargs.get('foid', None)
+        is_schema_diff = kwargs.get('is_schema_diff', False)
+
+        if foid is not None:
+            status, old_data = self._fetch_properties(gid, sid, did, scid,
+                                                      foid, inherits=True)
+            if not status:
+                return old_data
+            elif not old_data:
+                return gone(self.not_found_error_msg())
+
+            if is_schema_diff:
+                data['is_schema_diff'] = True
+                old_data['columns_for_schema_diff'] = old_data['columns']
+
+            # If name is not present in request data
+            if 'name' not in data:
+                data['name'] = old_data['name']
+
+            # If name if not present
+            if 'schema' not in data:
+                data['schema'] = old_data['basensp']
+
+            # Parse Privileges
+            ForeignTableView._parse_privileges(data)
+
+            # If ftsrvname is changed while comparing two schemas
+            # then we need to drop foreign table and recreate it
+            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, conn=self.conn)
+            else:
+                sql = render_template(
+                    "/".join([self.template_path, self._UPDATE_SQL]),
+                    data=data, o_data=old_data, conn=self.conn
+                )
+
+            # Removes trailing new lines
+            if sql:
+                sql = sql.strip('\n') + self.double_newline
+
+            # Parse/Format columns & create sql
+            if 'columns' in data:
+                # Parse the data coming from client
+                data = column_utils.parse_format_columns(data, mode='edit')
+
+                columns = data['columns']
+                column_sql = '\n'
+
+                # If column(s) is/are deleted
+                column_sql = self._check_for_column_delete(columns, data,
+                                                           column_sql)
+
+                # If column(s) is/are changed
+                column_sql = self._check_for_column_update(columns, data,
+                                                           column_sql, foid)
+
+                # If column(s) is/are added
+                column_sql = self._check_for_column_add(columns, data,
+                                                        column_sql)
+
+                # Combine all the SQL together
+                sql += column_sql.strip('\n')
+
+            sql = re.sub(self.pattern, self.double_newline, sql)
+            sql = sql.strip('\n')
+
+            return sql, data['name'] if 'name' in data else old_data['name']
+        else:
+            data['columns'] = self._format_columns(data['columns'])
+
+            # Parse Privileges
+            if 'relacl' in data:
+                data['relacl'] = parse_priv_to_db(data['relacl'],
+                                                  ["a", "r", "w", "x"])
+
+            sql = render_template("/".join([self.template_path,
+                                            self._CREATE_SQL]), data=data,
+                                  conn=self.conn)
+            return sql, data['name']
+
+    def _check_for_column_delete(self, columns, data, column_sql):
+        # If column(s) is/are deleted
+        if 'deleted' in columns:
+            for c in columns['deleted']:
+                c['schema'] = data['schema']
+                c['table'] = data['name']
+                # Sql for drop column
+                if c.get('inheritedfrom', None) is None:
+                    column_sql += render_template("/".join(
+                        [self.foreign_table_column_template_path,
+                         self._DELETE_SQL]),
+                        data=c, conn=self.conn).strip('\n') + \
+                        self.double_newline
+        return column_sql
+
+    def _check_for_column_update(self, columns, data, column_sql, tid):
+        # Here we will be needing previous properties of column
+        # so that we can compare & update it
+        if 'changed' in columns:
+            for c in columns['changed']:
+                c['schema'] = data['schema']
+                c['table'] = data['name']
+
+                properties_sql = render_template(
+                    "/".join([self.column_template_path,
+                              self._PROPERTIES_SQL]),
+                    tid=tid,
+                    clid=c['attnum'] if 'attnum' in c else None,
+                    show_sys_objects=self.blueprint.show_system_objects
+                )
+
+                status, res = self.conn.execute_dict(properties_sql)
+                if not status:
+                    return internal_server_error(errormsg=res)
+                old_col_data = res['rows'][0]
+
+                old_col_data['cltype'], \
+                    old_col_data['hasSqrBracket'] = \
+                    column_utils.type_formatter(old_col_data['cltype'])
+                old_col_data = \
+                    column_utils.convert_length_precision_to_string(
+                        old_col_data)
+                old_col_data = column_utils.fetch_length_precision(
+                    old_col_data)
+
+                old_col_data['cltype'] = \
+                    DataTypeReader.parse_type_name(
+                        old_col_data['cltype'])
+
+                # Sql for alter column
+                if c.get('inheritedfrom', None) is None and \
+                        c.get('inheritedfromtable', None) is None:
+                    column_sql += render_template("/".join(
+                        [self.foreign_table_column_template_path,
+                         self._UPDATE_SQL]),
+                        data=c, o_data=old_col_data, conn=self.conn
+                    ).strip('\n') + self.double_newline
+        return column_sql
+
+    def _check_for_column_add(self, columns, data, column_sql):
+        # If column(s) is/are added
+        if 'added' in columns:
+            for c in columns['added']:
+                c['schema'] = data['schema']
+                c['table'] = data['name']
+
+                c = column_utils.convert_length_precision_to_string(c)
+
+                if c.get('inheritedfrom', None) is None and \
+                        c.get('inheritedfromtable', None) is None:
+                    column_sql += render_template("/".join(
+                        [self.foreign_table_column_template_path,
+                         self._CREATE_SQL]),
+                        data=c, conn=self.conn).strip('\n') + \
+                        self.double_newline
+        return column_sql
+
+    @check_precondition
+    def dependents(self, gid, sid, did, scid, foid):
+        """
+        This function get the dependents and return ajax response
+        for the Foreign Table object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+        dependents_result = self.get_dependents(self.conn, foid)
+        return ajax_response(
+            response=dependents_result,
+            status=200
+        )
+
+    @check_precondition
+    def dependencies(self, gid, sid, did, scid, foid):
+        """
+        This function get the dependencies and return ajax response
+        for the  Foreign Table object.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+        """
+        dependencies_result = self.get_dependencies(self.conn, foid)
+        return ajax_response(
+            response=dependencies_result,
+            status=200
+        )
+
+    def _format_columns(self, columns):
+        """
+        Format Table Columns.
+        """
+        cols = []
+        for c in columns:
+            if len(c) > 0 and 'cltype' in c:
+                if '[]' in c['cltype']:
+                    c['cltype'] = c['cltype'].replace('[]', '')
+                    c['isArrayType'] = True
+                else:
+                    c['isArrayType'] = False
+                cols.append(c)
+        return cols if cols else columns
+
+    def _fetch_properties(self, gid, sid, did, scid, foid, inherits=False, ):
+        """
+        Returns the Foreign Table properties which will be used in
+        properties, sql and get_sql functions.
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            inherits: If True then inherited table will be fetched from
+                      database
+
+        Returns:
+
+        """
+        sql = render_template("/".join([self.template_path,
+                                        self._PROPERTIES_SQL]),
+                              scid=scid, foid=foid)
+        status, res = self.conn.execute_dict(sql)
+        if not status:
+            return False, internal_server_error(errormsg=res)
+
+        if len(res['rows']) == 0:
+            return True, False
+
+        data = res['rows'][0]
+        data['is_sys_obj'] = (
+            data['oid'] <= self._DATABASE_LAST_SYSTEM_OID or
+            self.datistemplate)
+
+        if self.manager.version >= 90200:
+            # Fetch privileges
+            sql = render_template("/".join([self.template_path,
+                                            self._ACL_SQL]),
+                                  foid=foid)
+            status, aclres = self.conn.execute_dict(sql)
+            if not status:
+                return False, internal_server_error(errormsg=aclres)
+
+            # Get Formatted Privileges
+            data.update(self._format_proacl_from_db(aclres['rows']))
+
+        # Get formatted Security Labels
+        if 'seclabels' in data:
+            data.update(parse_sec_labels_from_db(data['seclabels']))
+
+        # Get formatted Options
+        if 'ftoptions' in data:
+            data.update({'strftoptions': data['ftoptions']})
+            data.update(self._parse_variables_from_db(data['ftoptions']))
+
+        sql = render_template("/".join([self.template_path,
+                                        self._GET_CONSTRAINTS_SQL]), foid=foid)
+        status, cons = self.conn.execute_dict(sql)
+        if not status:
+            return False, internal_server_error(errormsg=cons)
+
+        if cons and 'rows' in cons:
+            data['constraints'] = cons['rows']
+
+        sql = render_template("/".join([self.template_path,
+                                        self._GET_COLUMNS_SQL]), foid=foid)
+        status, cols = self.conn.execute_dict(sql)
+        if not status:
+            return False, internal_server_error(errormsg=cols)
+
+        # Fetch length and precision data
+        for col in cols['rows']:
+            column_utils.fetch_length_precision(col)
+
+            if 'attoptions' in col and col['attoptions'] != '':
+                col['attoptions'] = column_utils.parse_column_variables(
+                    col['attoptions'])
+
+            if 'attfdwoptions' in col and col['attfdwoptions'] != '':
+                col['coloptions'] = column_utils.parse_options_for_column(
+                    col['attfdwoptions'])
+
+        self._get_edit_types(cols['rows'])
+
+        if cols and 'rows' in cols:
+            data['columns'] = cols['rows']
+
+        # Get Inherited table names from their OID
+        is_error, errmsg = self._get_inherited_table_name(data, inherits)
+
+        if is_error:
+            return False, internal_server_error(errormsg=errmsg)
+
+        return True, data
+
+    def _get_edit_types(self, cols):
+        edit_types = {}
+        for col in cols:
+            edit_types[col['atttypid']] = []
+
+        if len(cols) > 0:
+            SQL = render_template("/".join([self.template_path,
+                                            'edit_mode_types_multi.sql']),
+                                  type_ids=",".join(map(lambda x: str(x),
+                                                        edit_types.keys())))
+            _, res = self.conn.execute_2darray(SQL)
+            for row in res['rows']:
+                edit_types[row['main_oid']] = sorted(row['edit_types'])
+
+            for column in cols:
+                edit_type_list = edit_types[column['atttypid']]
+                edit_type_list.append(column['cltype'])
+                column['edit_types'] = sorted(edit_type_list)
+                column['cltype'] = \
+                    DataTypeReader.parse_type_name(column['cltype'])
+
+    def _get_datatype_precision(self, cols):
+        """
+        The Length and the precision of the Datatype should be separated.
+        The Format we getting from database is: numeric(1,1)
+        So, we need to separate it as Length: 1, Precision: 1
+        :param cols: list of columns.
+        """
+        for c in cols['rows']:
+            if c['fulltype'] != '' and c['fulltype'].find("(") > 0:
+                substr = self.extract_type_length_precision(c)
+                typlen = substr.split(",")
+                if len(typlen) > 1:
+                    c['attlen'] = self.convert_typlen_to_int(typlen)
+                    c['attprecision'] = self.convert_precision_to_int(typlen)
+                else:
+                    c['attlen'] = self.convert_typlen_to_int(typlen)
+                    c['attprecision'] = None
+
+            # Get formatted Column Options
+            if 'attfdwoptions' in c and c['attfdwoptions'] != '':
+                att_opt = self._parse_variables_from_db(c['attfdwoptions'])
+                c['coloptions'] = att_opt['ftoptions']
+
+    def _get_inherited_table_name(self, data, inherits):
+        """
+        Get inherited table name.
+        :param data: Data.
+        :param inherits: flag which is used If True then inherited table
+        will be fetched from database.
+        """
+        if inherits and 'inherits' in data and data['inherits']:
+            inherits = tuple([int(x) for x in data['inherits']])
+            if len(inherits) == 1:
+                inherits = "(" + str(inherits[0]) + ")"
+
+            sql = render_template("/".join([self.template_path,
+                                            self._GET_TABLES_SQL]),
+                                  attrelid=inherits)
+            status, res = self.conn.execute_dict(sql)
+
+            if not status:
+                return True, res
+
+            if 'inherits' in res['rows'][0]:
+                data['inherits'] = res['rows'][0]['inherits']
+
+        return False, ''
+
+    @staticmethod
+    def convert_precision_to_int(typlen):
+        return int(typlen[1]) if typlen[1].isdigit() else \
+            typlen[1]
+
+    @staticmethod
+    def convert_typlen_to_int(typlen):
+        return int(typlen[0]) if typlen[0].isdigit() else \
+            typlen[0]
+
+    def extract_type_length_precision(self, column):
+        full_type = column['fulltype']
+        return full_type[self.type_start_position(column):
+                         self.type_end_position(column)]
+
+    @staticmethod
+    def type_end_position(column):
+        return column['fulltype'].find(")")
+
+    @staticmethod
+    def type_start_position(column):
+        return column['fulltype'].find("(") + 1
+
+    def _format_proacl_from_db(self, proacl):
+        """
+        Returns privileges.
+        Args:
+            proacl: Privileges Dict
+        """
+        privileges = []
+        for row in proacl:
+            priv = parse_priv_from_db(row)
+            privileges.append(priv)
+
+        return {"relacl": privileges}
+
+    def _parse_variables_from_db(self, db_variables):
+        """
+        Function to format the output for variables.
+
+        Args:
+            db_variables: Variable object
+
+                Expected Object Format:
+                    ['option1=value1', ..]
+                where:
+                    user_name and database are optional
+        Returns:
+            Variable Object in below format:
+                {
+                'variables': [
+                    {'name': 'var_name', 'value': 'var_value',
+                    'user_name': 'user_name', 'database': 'database_name'},
+                    ...]
+                }
+                where:
+                    user_name and database are optional
+        """
+        variables_lst = []
+
+        if db_variables is not None:
+            for row in db_variables:
+                # The value may contain equals in string, split on
+                # first equals only
+                var_name, var_value = row.split("=", 1)
+
+                var_dict = {'option': var_name, 'value': var_value}
+
+                variables_lst.append(var_dict)
+
+        return {"ftoptions": variables_lst}
+
+    @check_precondition
+    def select_sql(self, gid, sid, did, scid, foid):
+        """
+        SELECT script sql for the object
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+
+        Returns:
+            SELECT Script sql for the object
+        """
+        status, data = self._fetch_properties(gid, sid, did, scid, foid)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        columns = []
+        for c in data['columns']:
+            columns.append(self.qtIdent(self.conn, c['name']))
+
+        if len(columns) > 0:
+            columns = ", ".join(columns)
+        else:
+            columns = '*'
+
+        sql = "SELECT {0}\n\tFROM {1};".format(
+            columns,
+            self.qtIdent(self.conn, data['basensp'], data['name'])
+        )
+
+        return ajax_response(response=sql)
+
+    @check_precondition
+    def insert_sql(self, gid, sid, did, scid, foid):
+        """
+        INSERT script sql for the object
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+
+        Returns:
+            INSERT Script sql for the object
+        """
+        status, data = self._fetch_properties(gid, sid, did, scid, foid)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        columns = []
+        values = []
+
+        # Now we have all list of columns which we need
+        if 'columns' in data:
+            for c in data['columns']:
+                columns.append(self.qtIdent(self.conn, c['name']))
+                values.append('?')
+
+        if len(columns) > 0:
+            columns = ", ".join(columns)
+            values = ", ".join(values)
+            sql = "INSERT INTO {0}(\n\t{1})\n\tVALUES ({2});".format(
+                self.qtIdent(self.conn, data['basensp'], data['name']),
+                columns, values
+            )
+        else:
+            sql = gettext('-- Please create column(s) first...')
+
+        return ajax_response(response=sql)
+
+    @check_precondition
+    def update_sql(self, gid, sid, did, scid, foid):
+        """
+        UPDATE script sql for the object
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+
+        Returns:
+            UPDATE Script sql for the object
+        """
+        status, data = self._fetch_properties(gid, sid, did, scid, foid)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        columns = []
+
+        # Now we have all list of columns which we need
+        if 'columns' in data:
+            for c in data['columns']:
+                columns.append(self.qtIdent(self.conn, c['name']))
+
+        if len(columns) > 0:
+            if len(columns) == 1:
+                columns = columns[0]
+                columns += "=?"
+            else:
+                columns = "=?, ".join(columns)
+                columns += "=?"
+
+            sql = "UPDATE {0}\n\tSET {1}\n\tWHERE <condition>;".format(
+                self.qtIdent(self.conn, data['basensp'], data['name']),
+                columns
+            )
+        else:
+            sql = gettext('-- Please create column(s) first...')
+
+        return ajax_response(response=sql)
+
+    @check_precondition
+    def delete_sql(self, gid, sid, did, scid, foid, only_sql=False):
+        """
+        DELETE script sql for the object
+
+        Args:
+            gid: Server Group Id
+            sid: Server Id
+            did: Database Id
+            scid: Schema Id
+            foid: Foreign Table Id
+            only_sql: Return only sql if True
+
+        Returns:
+            DELETE Script sql for the object
+        """
+        status, data = self._fetch_properties(gid, sid, did, scid, foid)
+        if not status:
+            return data
+        if not data:
+            return gone(self.not_found_error_msg())
+
+        sql = "DELETE FROM {0}\n\tWHERE <condition>;".format(
+            self.qtIdent(self.conn, data['basensp'], data['name'])
+        )
+
+        # Used for schema diff tool
+        if only_sql:
+            return sql
+
+        return ajax_response(response=sql)
+
+    @staticmethod
+    def _check_const_for_obj_compare(data):
+        """
+        Check for constraint in fetched objects for compare.
+        :param data: Data.
+        """
+        if 'constraints' in data and data['constraints'] is not None \
+                and len(data['constraints']) > 0:
+            for item in data['constraints']:
+                if 'conoid' in item:
+                    item.pop('conoid')
+
+    @check_precondition
+    def fetch_objects_to_compare(self, sid, did, scid):
+        """
+        This function will fetch the list of all the foreign tables for
+        specified schema id.
+
+        :param sid: Server Id
+        :param did: Database Id
+        :param scid: Schema Id
+        :return:
+        """
+        res = dict()
+        SQL = render_template("/".join([self.template_path,
+                                        self._NODE_SQL]), scid=scid,
+                              schema_diff=True)
+        status, rset = self.conn.execute_2darray(SQL)
+        if not status:
+            return internal_server_error(errormsg=res)
+
+        for row in rset['rows']:
+            status, data = self._fetch_properties(0, sid, did, scid,
+                                                  row['oid'])
+            if status:
+                ForeignTableView._check_const_for_obj_compare(data)
+                res[row['name']] = data
+
+        return res
+
+    def get_sql_from_diff(self, **kwargs):
+        """
+        This function is used to get the DDL/DML statements.
+        :param kwargs
+        :return:
+        """
+        gid = kwargs.get('gid')
+        sid = kwargs.get('sid')
+        did = kwargs.get('did')
+        scid = kwargs.get('scid')
+        oid = kwargs.get('oid')
+        data = kwargs.get('data', None)
+        drop_sql = kwargs.get('drop_sql', False)
+        target_schema = kwargs.get('target_schema', None)
+
+        if data:
+            sql, _ = 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 target_schema:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, foid=oid,
+                               target_schema=target_schema, json_resp=False)
+            else:
+                sql = self.sql(gid=gid, sid=sid, did=did, scid=scid, foid=oid,
+                               json_resp=False)
+        return sql
+
+    @staticmethod
+    def _modify_column_data(data, tmp_columns):
+        """
+        Modifies data for column.
+        :param data: Data for columns.
+        :param tmp_columns: tmp_columns list.
+        """
+        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)
+
+    @staticmethod
+    def _modify_constraints_data(data):
+        """
+        Modifies data for constraints.
+        :param data: Data for constraints.
+        :return: tmp_constraints list.
+        """
+        tmp_constraints = []
+        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)
+
+        return tmp_constraints
+
+    @staticmethod
+    def _modify_options_data(data, tmp_ftoptions):
+        """
+        Modifies data for options.
+        :param data: Data for options.
+        :param tmp_ftoptions: tmp_ftoptions list.
+        """
+        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)
+
+    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:
+            ForeignTableView._modify_column_data(data, tmp_columns)
+
+        data['columns'] = tmp_columns
+
+        if 'constraints' in data:
+            tmp_constraints = ForeignTableView._modify_constraints_data(data)
+            data['constraints'] = tmp_constraints
+
+        tmp_ftoptions = []
+        if 'ftoptions' in old_data:
+            tmp_ftoptions = old_data['ftoptions']
+        if 'ftoptions' in data:
+            ForeignTableView._modify_options_data(data, tmp_ftoptions)
+
+        data['ftoptions'] = tmp_ftoptions
+
+    @check_precondition
+    def enable_disable_triggers(self, gid, sid, did, scid, foid):
+        """
+        This function will enable/disable trigger(s) on the table object
+
+         Args:
+           gid: Server Group ID
+           sid: Server ID
+           did: Database ID
+           scid: Schema ID
+           tid: Table ID
+        """
+        # Below will decide if it's simple drop or drop with cascade call
+        data = request.form if request.form else json.loads(
+            request.data
+        )
+        # Convert str 'true' to boolean type
+        is_enable_trigger = data['is_enable_trigger']
+
+        try:
+            if foid is not None:
+                status, data = self._fetch_properties(
+                    gid, sid, did, scid, foid, inherits=True)
+                if not status:
+                    return data
+                elif not data:
+                    return gone(self.not_found_error_msg())
+
+            SQL = render_template(
+                "/".join([self.template_path, 'enable_disable_trigger.sql']),
+                data=data, is_enable_trigger=is_enable_trigger
+            )
+            status, res = self.conn.execute_scalar(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            SQL = render_template(
+                "/".join([self.template_path, 'get_enabled_triggers.sql']),
+                tid=foid
+            )
+
+            status, trigger_res = self.conn.execute_scalar(SQL)
+            if not status:
+                return internal_server_error(errormsg=res)
+
+            return make_json_response(
+                success=1,
+                info=gettext("Trigger(s) have been disabled")
+                if is_enable_trigger == 'D'
+                else gettext("Trigger(s) have been enabled"),
+                data={
+                    'id': foid,
+                    'scid': scid,
+                    'has_enable_triggers': trigger_res
+                }
+            )
+
+        except Exception as e:
+            return internal_server_error(errormsg=str(e))
+
+    def _get_resql_for_triggers(self, tid, schema,
+                                table):
+        """
+        ########################################
+        # Reverse engineered sql for TRIGGERS
+        ########################################
+        """
+        sql = render_template("/".join([self.trigger_template_path,
+                                        self._NODES_SQL]), tid=tid)
+        status, rset = self.conn.execute_2darray(sql)
+        if not status:
+            return internal_server_error(errormsg=rset)
+
+        trigger_sql = ''
+        for row in rset['rows']:
+            trigger_sql = trigger_utils.get_reverse_engineered_sql(
+                self.conn, schema=schema, table=table, tid=tid,
+                trid=row['oid'], datlastsysoid=self._DATABASE_LAST_SYSTEM_OID,
+                show_system_objects=self.blueprint.show_system_objects,
+                template_path=None)
+            trigger_sql = "\n" + trigger_sql
+
+            trigger_sql = re.sub(self.pattern, self.double_newline,
+                                 trigger_sql)
+        return trigger_sql
+
+
+SchemaDiffRegistry(blueprint.node_type, ForeignTableView)
+ForeignTableView.register_node_view(blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/children/__init__.py

@@ -0,0 +1,14 @@
+"""
+We will use the existing modules for creating children module under
+foreign tables.
+
+Do not remove these imports as they will be automatically imported by the view
+module as its children
+"""
+from pgadmin.browser.server_groups.servers.databases.schemas.tables.triggers \
+    import blueprint as triggers_modules
+from pgadmin.browser.server_groups.servers.databases.schemas.tables.\
+    constraints import blueprint as constraints_modules
+from pgadmin.browser.server_groups.servers.databases.schemas.\
+    foreign_tables.foreign_table_columns import foreign_table_column_blueprint\
+    as foreign_tables_columns_modules

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/foreign_table_columns/__init__.py

@@ -0,0 +1,97 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2024, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+""" Implements Column Node for foreign table """
+import pgadmin.browser.server_groups.servers.databases as database
+from flask_babel import gettext
+from pgadmin.browser.collection import CollectionNodeModule
+
+from pgadmin.browser.server_groups.servers.databases.schemas.tables.columns \
+    import ColumnsView
+
+
+class ForeignTableColumnsModule(CollectionNodeModule):
+    """
+     class ColumnsModule(CollectionNodeModule)
+
+        A module class for Column node derived from CollectionNodeModule.
+
+    Methods:
+    -------
+    * __init__(*args, **kwargs)
+      - Method is used to initialize the Column and it's base module.
+
+    * get_nodes(gid, sid, did, scid, tid)
+      - Method is used to generate the browser collection node.
+
+    * node_inode()
+      - Method is overridden from its base class to make the node as leaf node.
+
+    * script_load()
+      - Load the module script for schema, when any of the server node is
+        initialized.
+    """
+
+    _NODE_TYPE = 'foreign_table_column'
+    _COLLECTION_LABEL = gettext("Columns")
+
+    def __init__(self, *args, **kwargs):
+        """
+        Method is used to initialize the ColumnModule and it's base module.
+
+        Args:
+            *args:
+            **kwargs:
+        """
+        self.min_ver = None
+        self.max_ver = None
+        super().__init__(*args, **kwargs)
+
+    def get_nodes(self, gid, sid, did, scid, foid, **kwargs):
+        """
+        Generate the collection node
+        """
+        if self.has_nodes(
+                sid, did, scid=scid, tid=foid,
+                base_template_path=ForeignTableColumnsView.BASE_TEMPLATE_PATH):
+            yield self.generate_browser_collection_node(foid)
+
+    @property
+    def script_load(self):
+        """
+        Load the module script for server, when any of the server-group node is
+        initialized.
+        """
+        return database.DatabaseModule.node_type
+
+    @property
+    def node_inode(self):
+        """
+        Load the module node as a leaf node
+        """
+        return False
+
+    @property
+    def module_use_template_javascript(self):
+        """
+        Returns whether Jinja2 template is used for generating the javascript
+        module.
+        """
+        return False
+
+
+foreign_table_column_blueprint = ForeignTableColumnsModule(__name__)
+
+
+class ForeignTableColumnsView(ColumnsView):
+    node_type = foreign_table_column_blueprint.node_type
+    node_label = "Column"
+
+
+ForeignTableColumnsView.register_node_view(foreign_table_column_blueprint)

pgsql/pgAdmin 4/web/pgadmin/browser/server_groups/servers/databases/schemas/foreign_tables/foreign_table_columns/static/js/foreign_table_column.js

@@ -0,0 +1,70 @@
+/////////////////////////////////////////////////////////////
+//
+// pgAdmin 4 - PostgreSQL Tools
+//
+// Copyright (C) 2013 - 2024, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+//////////////////////////////////////////////////////////////
+import { getNodeColumnSchema } from '../../../static/js/foreign_table.ui';
+
+define('pgadmin.node.foreign_table_column', [
+  'sources/gettext', 'sources/url_for', 'pgadmin.browser',
+  'pgadmin.node.schema.dir/schema_child_tree_node', 'pgadmin.browser.collection',
+], function(
+  gettext, url_for, pgBrowser
+) {
+
+  if (!pgBrowser.Nodes['coll-foreign_table_column']) {
+    pgBrowser.Nodes['coll-foreign_table_column'] =
+      pgBrowser.Collection.extend({
+        node: 'foreign_table_column',
+        label: gettext('Columns'),
+        type: 'coll-foreign_table_column',
+        columns: ['name', 'cltype', 'description']
+      });
+  }
+
+  if (!pgBrowser.Nodes['foreign_table_column']) {
+    pgBrowser.Nodes['foreign_table_column'] = pgBrowser.Node.extend({
+      // Foreign table is added in parent_type to support triggers on
+      // foreign table where we need column information.
+      parent_type: ['foreign_table'],
+      collection_type: ['coll-foreign_table'],
+      type: 'foreign_table_column',
+      label: gettext('Column'),
+      hasSQL:  true,
+      sqlAlterHelp: 'sql-altertable.html',
+      sqlCreateHelp: 'sql-altertable.html',
+      dialogHelp: url_for('help.static', {'filename': 'column_dialog.html'}),
+      canDrop: true,
+      canDropCascade: false,
+      hasDepends: true,
+      hasStatistics: true,
+      Init: function() {
+        /* Avoid multiple registration of menus */
+        if (this.initialized)
+          return;
+
+        this.initialized = true;
+        pgBrowser.add_menus([{
+          name: 'create_column_on_coll', node: 'coll-foreign_table_column', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 4, label: gettext('Column...'),
+          data: {action: 'create'}, enable: 'canCreate',
+        },{
+          name: 'create_column_onTable', node: 'foreign_table', module: this,
+          applies: ['object', 'context'], callback: 'show_obj_properties',
+          category: 'create', priority: 4, label: gettext('Column...'),
+          data: {action: 'create'}, enable: 'canCreate',
+        },
+        ]);
+      },
+      getSchema: function(treeNodeInfo, itemNodeData) {
+        return getNodeColumnSchema(treeNodeInfo, itemNodeData, pgBrowser);
+      },
+    });
+  }
+
+  return pgBrowser.Nodes['foreign_table_column'];
+});