diff --git a/doc/sql.extensions/README.MED.md b/doc/sql.extensions/README.MED.md
new file mode 100644
index 00000000000..a88b30909f9
--- /dev/null
+++ b/doc/sql.extensions/README.MED.md
@@ -0,0 +1,334 @@
+# Management of External Data \(FB 6.0\)
+
+## Concept
+
+Firebird 6.0 allows to managing external data \(distributed or heterogeneous queries\). Distributed queries allow managing data stored in other databases. Those databases can be located on the same or different servers and use the same or different DBMS. Distributed queries allow to integrate and process data from different sources, providing developers with the ability to work with them as a single logical unit.
+
+External data management is defined by ISO/IEC 9075\-9:2023\(E\) \(SQL/MED\) standard. External data management implies both read and write access to external data. Access to foreign data is implemented using 4 objects: foreign-data wrapper, foreign server, user mapping, and foreign table.
+
+## Syntax
+
+### Foreign-data wrapper
+
+In Firebird, the foreign-data wrapper can be implemented as a provider \(plugin\). To use a foreign-data wrapper, it should be defined in `plugins.conf`, for example:
+```
+Plugin = JDBC {
+    Module = $(dir_plugins)/jdbc_provider
+    Config = JDBC_config
+}
+
+Config = JDBC_config {
+    Dir = $(this)/jdbc
+}
+```
+To connect to Firebird databases, the Engine and Remote providers are available by default and require no additional definition in `plugins.conf`.
+
+### Foreign server
+
+A foreign server is a logical representation of a remote data source inside the DBMS. The DBMS connects to the foreign server to execute queries. The foreign server provides metadata and connection information about the remote data source. Usually, the external server stores the connection parameters such as connection string, port, database type, etc.
+
+#### CREATE SERVER definition
+
+```sql
+CREATE SERVER [IF NOT EXISTS] <foreign server name>
+        [{FOREIGN DATA WRAPPER | USING PLUGIN} <provider (plugin)>] [OPTIONS (<option> [,<option> ...] )]
+    <option> ::= {
+        CONNECTION_STRING = '<connection string>'
+        | USER = '<user name>'
+        | PASSWORD = '<password>'
+        | ROLE = '<role>'
+        | <option name> = 'value'
+        | <option name> [{FILE | ENV}] 'value' }
+```
+The `SERVER` clause specifies the name of the server.
+The `FOREIGN DATA WRAPPER` or `USING PLUGIN` clause specifies the provider to use to access foreign data. If no clause is specified, the providers specified in the Providers parameter of the `firebird.conf` configuration file will be tried for connection. The clause `USING PLUGIN` is not specified in the standard, but it is familiar to Firebird developers and users, so it is proposed as an extension to the standard definition of a foreign server.
+The optional `OPTIONS` clause defines additional connection parameters to the foreign server. The required connection parameters depend on the provider \(plugin\) used to access the data. The option value can be read from a file or an environment variable. If it is necessary to read the value from a file, then `FILE` is specified after the option name or `ENV` is specified to read from the environment variable. The server should have the permissions to read the specified file. General options are:
+* `CONNECTION_STRING` - connection string to the foreign server \(depends on the foreign server specification\), if the option is not specified, an attempt will be made to connect to the current database;
+* `USER` - the user on whose name the connection will be established;
+* `PASSWORD` - user password;
+* `ROLE` - the role with which the specified user will connect to the foreign server.
+
+The `CREATE SERVER` statement can be executed by administrators or users with the `CREATE SERVER` privilege.
+
+#### ALTER SERVER definition
+
+```sql
+ALTER SERVER <foreign server name>
+        [[DROP] FOREIGN DATA WRAPPER | [DROP] USING PLUGIN <provider(plugin)>] [OPTIONS(<option> [, <option> ...] )]
+    <option> ::= {
+        [DROP] <option name> [= 'value']
+        | [DROP] <option name> [{FILE | ENV}] ['value'] }
+```
+If existing server options are specified, they will be updated and the others will not be affected.
+The `ALTER SERVER` statement can be executed by administrators, owner or users with the `ALTER SERVER` privilege.
+
+#### DROP SERVER definition
+
+```sql
+DROP SERVER <foreign server name>
+```
+The `DROP SERVER` statement can be executed by administrators, owner or users with the `DROP SERVER` privilege. If the server has dependencies, the `DROP SERVER` statement will fail with an execution error.
+
+### User mappings
+
+User mappings for foreign connections define the connection parameters to be used by the specified user when accessing a foreign server. The user mapping provides security and access control by specifying the credentials to connect to the foreign server. User mapping maps local user accounts to remote server credentials and defines the login and password for the connection.
+
+#### CREATE USER MAPPING FOR definition
+
+```sql
+CREATE USER MAPPING FOR <user name> SERVER <server name> [OPTIONS (<option> [, <option> ...] )]
+    <option> ::= {
+        CONNECTION_STRING = '<connection string>'
+        | USER = '<user name>'
+        | PASSWORD = '<password>'
+        | ROLE = '<role>'
+        | <option name> = 'value'
+        | <option name> [{FILE | ENV}] 'value' }
+```
+The general options are the same as for the `CREATE SERVER` statement. When connecting to a foreign server, the option values specified in the user mapping will be used. The connection parameters specified in the user mapping have a higher priority than those specified for the foreign server.
+
+The `CREATE USER MAPPING FOR` statement can be executed by administrators and database owner.
+
+#### ALTER USER MAPPING FOR definition
+
+```sql
+ALTER USER MAPPING FOR <user name> SERVER <server name> [OPTIONS (<option> [, <option> ...] )]
+    <option> ::= {
+        [DROP] <option name> [= 'value']
+        | [DROP] <option name> [{FILE | ENV}] ['value'] }
+```
+If existing server options are specified, they will be updated and the others will not be affected.
+The `ALTER USER MAPPING FOR` statement can be executed by administrators and database owner.
+
+#### DROP USER MAPPING FOR definition
+
+```sql
+DROP USER MAPPING FOR <user name> SERVER <server name>
+```
+The `DROP USER MAPPING FOR` statement can be executed by administrators and database owner.
+
+### Access to foreign data
+
+Foreign server data can be managed in two ways: using the `EXECUTE STATEMENT` statement or via a foreign table.
+
+### Foreign table
+
+A foreign table is a table that is physically stored on a foreign server but is accessible by the local DBMS. The foreign table allows executing SQL queries to the data contained in the table as local ones. The foreign table includes the table structure description and column mapping between the foreign and local table.
+
+#### CREATE FOREIGN TABLE definition
+
+```sql
+CREATE FOREIGN TABLE [ IF NOT EXISTS ] <table name>
+            (<foreign column definition> [, {<foreign column definition> | <table constraint>}...])
+            SERVER <server name> [OPTIONS (<option> [, <option> ...] )]
+    <foreign column definition> ::=
+        <regular column definition>
+        | <identity column definition>
+        [OPTIONS (<option> [, <option> ...] )]
+    <regular column definition> ::=
+        <column name> { <data type> | <domain name>}
+        [DEFAULT {<literal> | NULL | <context variable>}]
+        [NOT NULL]
+        [<column constraint>]
+        [COLLATE <collation name>]
+    <identity column definition> ::=
+        <column name> [<data type>]
+        GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [(<identity column option> [<identity column option>])]
+        [<column constraint>]
+    <identity column option> ::= START WITH <start value>
+        | INCREMENT [BY] <increment value>
+    <column constraint> ::=
+        [CONSTRAINT <constraint name>] CHECK (<check condition>)
+    <table constraint> ::=
+        [CONSTRAINT <constraint name>] CHECK (<check condition>)
+    <option> ::= {
+        <option name> [= 'value']
+        | <option name> ['value'] }
+```
+Rules:
+* The name of the foreign table must be unique;
+* The required parameter is the name of the foreign server;
+* If the specified foreign server does not exist, the creation of the foreign table will fail;
+* The table name and column names should be the same as the object names on the foreign server. Can be remapped using the `OPTIONS` clause;
+* A foreign column cannot be `UNIQUE`, `PRIMARY KEY`, or `FOREIGN KEY`;
+* A foreign column cannot be computed \(`COMPUTED [BY] | GENERATED ALWAYS AS`\);
+* Foreign columns can have `NOT NULL` and `CHECK` integrity constraints, but this does not guarantee that the foreign server will check these constraints;
+* Otherwise, the rules for creating a foreign table are the same as for a regular table.
+
+The optional `OPTIONS` clause specifies additional foreign column options and table options. The required foreign column and table options depend on the provider \(plugin\) used to access table data. General table options are:
+* SCHEMA_NAME - the schema name where the table is located on the foreign server;
+* TABLE_NAME - name of the table on the foreign server.
+General column options are:
+* COLUMN_NAME - the name of the column in the foreign table;
+* PRIMARY_KEY - an identifier explicitly specifying that the column is used in the primary key.
+
+The table name should include the full schema name and the table name on the foreign server \(if not specified in the options\). The table names should match. Column names should match \(if not specified in the options\). The number of defined columns should be less than or equal to the columns in the table on the foreign server.
+
+The `CREATE FOREIGN TABLE` statement can be executed by administrators and users with the `CREATE FOREIGN TABLE` privilege and. The user executing the `CREATE FOREIGN TABLE` statement becomes the owner of the foreign table.
+
+#### ALTER FOREIGN TABLE definition
+
+```sql
+ALTER FOREIGN TABLE <table name> <modification operation> [, <modification operation>...]
+      [OPTIONS (<option> [, <option> ...] )]
+    <modification operation> ::=
+        ADD <foreign column definition>
+        | ADD <table constraint>
+        | DROP <column name>
+        | DROP CONSTRAINT <column or table constraint>
+        | ALTER [COLUMN] <column name> <foreign column modification>
+        | [OPTIONS (<option> [, <option> ...] )]
+    <foreign column definition> ::=
+        <regular column definition>
+        | <identity column definition>
+        [OPTIONS (<option> [, <option> ...] )]
+    <regular column definition> ::=
+        <column name> { <data type> | <domain name>}
+        [DEFAULT {<literal> | NULL | <context variable>}]
+        [NOT NULL]
+        [<column constraint>]
+        [COLLATE <collation name>]
+    <identity column definition> ::=
+        <column name> [<data type>]
+        GENERATED {ALWAYS|BY DEFAULT} AS IDENTITY [(<identity column option> [<identity column option>])]
+    [<column constraint>]
+    <foreign column modification> ::=
+        TO <new column name>
+        | POSITION <new position>
+        | <regular column modification>
+        | <identity column definition>
+    <regular column modification> ::=
+        TYPE { <data type> | <domain name> }
+        | SET DEFAULT { <literal> | NULL | <context variable>}
+        | DROP DEFAULT
+        | SET NOT NULL
+        | DROP NOT NULL
+    <identity column definition> ::=
+        <identity column option>
+        | SET GENERATED {ALWAYS|BY DEFAULT} [ <identity column option> ...]
+        | DROP IDENTITY
+    <identity column option> ::= {
+        RESTART [ WITH <start value> ]
+        | SET INCREMENT [BY] <increment value> }
+    <option> ::=
+        [DROP] <option name> [= 'value']
+        | [DROP] <option name> ['value']
+```
+The mandatory parameters are the table name and the modification operation definition. If new values of existing options of a foreign column or foreign table are specified, they will be updated and the others will not be affected. Otherwise, the rules for altering a foreign table are the same as for a regular table.
+
+The `ALTER FOREIGN TABLE` statement can be executed by administrators, the owner of the table and users with the `ALTER FOREIGN TABLE` privilege.
+
+#### DROP FOREIGN TABLE definition
+
+```sql
+DROP FOREIGN TABLE <table name>
+```
+
+A foreign table that is referenced in triggers cannot be deleted, except for triggers written by the user specifically for this table. Also, a foreign table that is used in a stored procedure or view cannot be deleted. When a foreign table is dropped, all its triggers and options \(include column options\) will be deleted as well.
+
+The `DROP TABLE` statement can be executed by administrators, the owner of the table and users with the `DROP FOREIGN TABLE` privilege.
+
+### EXECUTE STATEMENT changes
+
+```sql
+<execute_statement> ::= EXECUTE STATEMENT <argument>
+      [<option> ...]
+      [INTO <variables>];
+    <argument> ::= <paramless_stmt>
+                | (<paramless_stmt>)
+                | (<stmt_with_params>) (<param_values>)
+    <param_values> ::= <named_values> | <positional_values>
+    <named_values> ::= <named_value> [, <named_value> ...]
+    <named_value> ::= [EXCESS] paramname := <value_expr>
+    <positional_values> ::= <value_expr> [, <value_expr> ...]
+    <option> ::=
+        WITH {AUTONOMOUS | COMMON} TRANSACTION
+      | WITH CALLER PRIVILEGES
+      | AS USER user
+      | PASSWORD password
+      | ROLE role
+      | ON EXTERNAL { [DATA SOURCE] <connection_string> | SERVER <server name> }
+    <connection_string> ::=
+      !! See <filespec> in the CREATE DATABASE syntax !!
+    <variables> ::= [:]varname [, [:]varname ...]
+```
+
+The mandatory option for the `ON EXTERNAL SERVER` clause is the name of the foreign server. If the specified foreign server does not exist, creating an object with this `EXECUTE STATEMENT` will fail. The connection parameters specified in the `EXECUTE STATEMENT` statement have a higher priority than those specified in the user mapping or specified for the foreign server.
+
+## System metadata changes
+
+A new field is added for the `RDB$RELATIONS` table that stores the foreign server name:
+| Field                      | Type              | Description                                                |
+|----------------------------|-------------------|------------------------------------------------------------|
+| RDB$FOREIGN_SERVER_NAME    | CHAR \(63\)         | The foreign server name                                    |
+
+If the `RDB$FOREIGN_SERVER_NAME` field contains a value other than NULL, the metadata is considered to match the foreign table.
+
+The following system tables have been added:
+
+`RDB$FOREIGN_SERVERS` - contains a description of all foreign servers defined in the database:
+
+| Field                      | Type                 | Description                                                |
+|----------------------------|----------------------|------------------------------------------------------------|
+| RDB$FOREIGN_SERVER_NAME    | CHAR \(63\)          | The foreign server name                                    |
+| RDB$FOREIGN_SERVER_WRAPPER | CHAR \(63\)          | Provider (plugin) used to connect to a foreign server      |
+| RDB$SECURITY_CLASS         | CHAR \(63\)          | Security class                                             |
+| RDB$OWNER_NAME             | CHAR \(63\)          | The username of the user who created the server originally |
+
+`RDB$FOREIGN_SERVER_OPTIONS` - contains a description of all options defined for the foreign servers in the database:
+
+| Field                      | Type                 | Description                                                |
+|----------------------------|----------------------|------------------------------------------------------------|
+| RDB$FOREIGN_SERVER_NAME    | CHAR \(63\)          | The foreign server name                                    |
+| RDB$FOREIGN_OPTION_NAME    | CHAR \(63\)          | Option name                                                |
+| RDB$FOREIGN_OPTION_VALUE   | VARCHAR \(32765\)    | Option value                                               |
+| RDB$FOREIGN_OPTION_TYPE    | SHORT                | Option type                                                |
+
+`RDB$FOREIGN_USER_MAPPINGS` - contains a description of all user mappings defined in the database:
+
+| Field                      | Type                 | Description                                                |
+|----------------------------|----------------------|------------------------------------------------------------|
+| RDB$USER                   | CHAR \(63\)          | The user name to map                                       |
+| RDB$FOREIGN_SERVER_NAME    | CHAR \(63\)          | The foreign server name to map                             |
+
+`RDB$FOREIGN_MAPPING_OPTIONS` - contains a description of all options defined for user mappings to foreign servers in the database:
+
+| Field                      | Type                 | Description                                                |
+|----------------------------|----------------------|------------------------------------------------------------|
+| RDB$USER                   | CHAR \(63\)          | The user name to map                                       |
+| RDB$FOREIGN_SERVER_NAME    | CHAR \(63\)          | The foreign server name                                    |
+| RDB$FOREIGN_OPTION_NAME    | CHAR \(63\)          | Option name                                                |
+| RDB$FOREIGN_OPTION_VALUE   | VARCHAR \(32765\)    | Option value                                               |
+| RDB$FOREIGN_OPTION_TYPE    | SHORT                | Option type                                                |
+
+This table completely absorbs table `RDB$FOREIGN_USER_MAPPINGS`, but the ISO/IEC 9075\-9:2023\(E\) \(SQL/MED\) standard requires a separate table for user mappings and user mapping options.
+
+`RDB$FOREIGN_TABLE_FIELD_OPTIONS` - contains a description of all options defined for foreign table columns in the database:
+
+| Field                      | Type                 | Description                                                |
+|----------------------------|----------------------|------------------------------------------------------------|
+| RDB$SCHEMA_NAME            | CHAR \(63\)          | The schema name                                            |
+| RDB$TABLE_NAME             | CHAR \(63\)          | The table name                                             |
+| RDB$FIELD_NAME             | CHAR \(63\)          | The field name                                             |
+| RDB$FOREIGN_OPTION_NAME    | CHAR \(63\)          | Option name                                                |
+| RDB$FOREIGN_OPTION_VALUE   | VARCHAR \(32765\)    | Option value                                               |
+
+`RDB$FOREIGN_TABLE_OPTIONS` - contains a description of all options defined for foreign tables in the database:
+
+| Field                      | Type                | Description                                                |
+|----------------------------|---------------------|------------------------------------------------------------|
+| RDB$SCHEMA_NAME            | CHAR \(63\)         | The schema name                                            |
+| RDB$TABLE_NAME             | CHAR \(63\)         | The table name                                             |
+| RDB$FOREIGN_OPTION_NAME    | CHAR \(63\)         | Option name                                                |
+| RDB$FOREIGN_OPTION_VALUE   | VARCHAR \(32765\)   | Option value                                               |
+
+For `RDB$FOREIGN_SERVERS` a unique index is created on the field `RDB$FOREIGN_SERVER_NAME`.
+For `RDB$FOREIGN_SERVERS_OPTIONS` creates a unique index on the fields `RDB$FOREIGN_SERVER_NAME` and `RDB$FOREIGN_OPTION_NAME`.
+For `RDB$FOREIGN_TABLE_OPTIONS` a unique index is created on the `RDB$SCHEMA_NAME`, `RDB$TABLE_NAME` and `RDB$FOREIGN_OPTION_NAME` fields.
+For `RDB$FOREIGN_USER_MAPPINGS` a unique index is created for the fields `RDB$USER` and `RDB$FOREIGN_SERVER_NAME`.
+For `RDB$FOREIGN_MAPPING_OPTIONS` a unique index is created on the `RDB$USER`, `RDB$FOREIGN_SERVER_NAME`, and `RDB$FOREIGN_OPTION_NAME` fields.
+For `RDB$FOREIGN_TABLE_FIELD_OPTIONS` a unique index is created for the `RDB$SCHEMA_NAME`, `RDB$TABLE_NAME`, `RDB$FIELD_NAME`, and `RDB$FOREIGN_OPTION_NAME` fields.
+
+Connections to foreign servers are created using the external data source \(EDS\) subsystem.
+
+*This documentation will be updated.*
diff --git a/src/burp/OdsDetection.epp b/src/burp/OdsDetection.epp
index 2ca60361336..79e66f2d596 100644
--- a/src/burp/OdsDetection.epp
+++ b/src/burp/OdsDetection.epp
@@ -46,6 +46,7 @@ namespace
 		{"RDB$PACKAGES",		0,	DB_VERSION_DDL12},	// FB3
 		{"RDB$PUBLICATIONS",	0,	DB_VERSION_DDL13},	// FB4
 		{"RDB$SCHEMAS",			0,	DB_VERSION_DDL14},	// FB6
+		{"RDB$FOREIGN_SERVERS",	0,	DB_VERSION_DDL14},	// FB6
 		{0, 0, 0}
 	};
 
diff --git a/src/burp/backup.epp b/src/burp/backup.epp
index 2cbb866d51d..1504a5d9f94 100644
--- a/src/burp/backup.epp
+++ b/src/burp/backup.epp
@@ -134,6 +134,10 @@ void write_database(const TEXT*);
 void write_exceptions();
 void write_field_dimensions();
 void write_filters();
+void write_foreign_mapping_options(const MetaString& userName, const MetaString& serverName);
+void write_foreign_table_options(const QualifiedMetaString& table);
+void write_foreign_table_field_options(const QualifiedMetaString& table, const MetaString& fieldName);
+void write_foreign_user_mappings();
 void write_functions();
 void write_function_args(const QualifiedMetaString& name);
 void write_global_fields();
@@ -151,6 +155,8 @@ void write_rel_constraints();
 void write_relations();
 void write_schemas();
 void write_secclasses();
+void write_foreign_servers();
+void write_foreign_server_options(const MetaString& serverName);
 void write_shadow_files();
 void write_triggers();
 void write_trigger_messages();
@@ -345,6 +351,14 @@ int BACKUP_backup(const TEXT* dbb_file, const TEXT* file_name)
 		// Write schemas
 		BURP_verbose(412);	// msg 412 writing schemas
 		write_schemas();
+
+		// Write foreign servers
+		BURP_verbose(423);	// msg 423 writing foreign servers
+		write_foreign_servers();
+
+		// Write foreign user mappings
+		BURP_verbose(436);	// msg 436 writing foreign user mappings
+		write_foreign_user_mappings();
 	}
 
 	// Write global fields
@@ -428,7 +442,8 @@ int BACKUP_backup(const TEXT* dbb_file, const TEXT* file_name)
 
 		put(tdgbl, att_end);
 
-		if (!(relation->rel_flags & REL_view) && !(relation->rel_flags & REL_external))
+		if (!(relation->rel_flags & REL_view) && !(relation->rel_flags & REL_external)
+			&& !(relation->rel_flags & REL_foreign))
 		{
 			put_index(relation);
 			if (!(tdgbl->gbl_sw_meta || tdgbl->skipRelation(relation->rel_name)))
@@ -2076,6 +2091,9 @@ void put_relation( burp_rel* relation)
 		}
 
 		put(tdgbl, att_end);
+
+		if (relation->rel_flags & REL_foreign)
+			write_foreign_table_field_options(relation->rel_name, field->fld_name);
 	}
 
 	// Write out view relations (if a view, of course)
@@ -2898,6 +2916,189 @@ void write_filters()
 }
 
 
+void write_foreign_mapping_options(const MetaString& userName, const MetaString& serverName)
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ m a p p i n g _ o p t i o n s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for each foreign user mapping option.
+ *
+ **************************************/
+	IRequest* req_handle = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE req_handle)
+		X IN RDB$FOREIGN_MAPPING_OPTIONS
+			WITH X.RDB$USER EQ userName.c_str() AND
+			X.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+	{
+		put(tdgbl, rec_foreign_mapping_option);
+
+		PUT_TEXT(att_foreign_mapping_option_user, X.RDB$USER);
+
+		PUT_TEXT(att_foreign_mapping_option_server_name, X.RDB$FOREIGN_SERVER_NAME);
+
+		PUT_TEXT(att_foreign_mapping_option_name, X.RDB$FOREIGN_OPTION_NAME);
+
+		// msg 440 writing foreign user mapping option %s
+		BURP_verbose(440, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+
+		PUT_TEXT(att_foreign_mapping_option_value, X.RDB$FOREIGN_OPTION_VALUE);
+
+		if (!X.RDB$FOREIGN_OPTION_TYPE.NULL)
+			put_int32(att_foreign_mapping_option_type, X.RDB$FOREIGN_OPTION_TYPE);
+
+		put(tdgbl, att_end);
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(req_handle);
+}
+
+
+void write_foreign_table_options(const QualifiedMetaString& table)
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ t a b l e _ o p t i o n s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for foreign table option.
+ *
+ **************************************/
+	IRequest* req_handle = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE req_handle)
+		X IN RDB$FOREIGN_TABLE_OPTIONS
+			WITH X.RDB$SCHEMA_NAME EQ table.schema.c_str() AND
+			X.RDB$TABLE_NAME EQ table.object.c_str()
+	{
+		QualifiedMetaString tableName;
+
+		put(tdgbl, rec_foreign_table_option);
+
+		PUT_TEXT(att_foreign_table_option_schema_name, X.RDB$SCHEMA_NAME);
+		tableName.schema = X.RDB$SCHEMA_NAME;
+
+		PUT_TEXT(att_foreign_table_option_table_name, X.RDB$TABLE_NAME);
+		tableName.object = X.RDB$TABLE_NAME;
+
+		PUT_TEXT(att_foreign_table_option_name, X.RDB$FOREIGN_OPTION_NAME);
+
+		PUT_TEXT(att_foreign_table_option_value, X.RDB$FOREIGN_OPTION_VALUE);
+
+		// msg 430 writing foreign table option %s
+		BURP_verbose(430, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+
+		put(tdgbl, att_end);
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(req_handle);
+}
+
+
+void write_foreign_table_field_options(const QualifiedMetaString& table, const MetaString& fieldName)
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ t a b l e _ f i e l d _ o p t i o n s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for each foreign table field option.
+ *
+ **************************************/
+	IRequest* req_handle = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE req_handle)
+		X IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+			WITH X.RDB$SCHEMA_NAME EQ table.schema.c_str() AND
+			X.RDB$TABLE_NAME EQ table.object.c_str() AND
+			X.RDB$FIELD_NAME EQ fieldName.c_str()
+	{
+		put(tdgbl, rec_foreign_table_field_option);
+
+		PUT_TEXT(att_foreign_table_field_option_schema_name, X.RDB$SCHEMA_NAME);
+
+		PUT_TEXT(att_foreign_table_field_option_table_name, X.RDB$TABLE_NAME);
+
+		PUT_TEXT(att_foreign_table_field_option_field_name, X.RDB$FIELD_NAME);
+
+		PUT_TEXT(att_foreign_table_field_option_name, X.RDB$FOREIGN_OPTION_NAME);
+
+		PUT_TEXT(att_foreign_table_field_option_value, X.RDB$FOREIGN_OPTION_VALUE);
+
+		// msg 433 writing foreign table column option %s
+		BURP_verbose(433, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+
+		put(tdgbl, att_end);
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(req_handle);
+}
+
+
+void write_foreign_user_mappings()
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ u s e r _ m a p p i n g s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for each user mapping.
+ *
+ **************************************/
+	IRequest* reqForeignUserMappings = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE reqForeignUserMappings)
+		X IN RDB$FOREIGN_USER_MAPPINGS
+	{
+		put(tdgbl, rec_foreign_user_mapping);
+
+		// msg 437 writing foreign user mapping options for user %s and server %s
+		BURP_verbose(437, SafeArg() << MetaString(X.RDB$USER).toQuotedString().c_str() <<
+			MetaString(X.RDB$FOREIGN_SERVER_NAME).toQuotedString().c_str());
+
+		PUT_TEXT(att_foreign_user_mapping_user, X.RDB$USER);
+
+		PUT_TEXT(att_foreign_user_mapping_server_name, X.RDB$FOREIGN_SERVER_NAME);
+
+		put(tdgbl, att_end);
+
+		write_foreign_mapping_options(MetaString(X.RDB$USER), MetaString(X.RDB$FOREIGN_SERVER_NAME));
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(reqForeignUserMappings);
+}
+
+
 void write_functions()
 {
 /**************************************
@@ -4134,6 +4335,12 @@ void write_relations()
 				}
 			}
 
+			if (!X.RDB$FOREIGN_SERVER_NAME.NULL)
+			{
+				PUT_TEXT(att_relation_foreign_server_name, X.RDB$FOREIGN_SERVER_NAME);
+				flags |= REL_foreign;
+			}
+
 			if (!X.RDB$RELATION_TYPE.NULL)
 				put_int32 (att_relation_type, X.RDB$RELATION_TYPE);
 
@@ -4152,6 +4359,9 @@ void write_relations()
 			relation->rel_name = name;
 			relation->rel_flags |= flags;
 			put_relation (relation);
+
+			if (relation->rel_flags & REL_foreign)
+				write_foreign_table_options(relation->rel_name);
 		}
 		END_FOR
 		ON_ERROR
@@ -4289,6 +4499,97 @@ void write_secclasses()
 }
 
 
+void write_foreign_servers()
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ s e r v e r s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for each foreign server.
+ *
+ **************************************/
+	IRequest* req_handle = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE req_handle)
+		X IN RDB$FOREIGN_SERVERS
+	{
+		put(tdgbl, rec_foreign_server);
+
+		PUT_TEXT(att_foreign_server_name, X.RDB$FOREIGN_SERVER_NAME);
+
+		// msg 424 writing foreign server %s
+		BURP_verbose(424, MetaString(X.RDB$FOREIGN_SERVER_NAME).toQuotedString());
+
+		if (!X.RDB$FOREIGN_SERVER_WRAPPER.NULL)
+			PUT_TEXT(att_foreign_server_data_wrapper_name, X.RDB$FOREIGN_SERVER_WRAPPER);
+
+		if (!X.RDB$SECURITY_CLASS.NULL)
+			PUT_TEXT(att_foreign_server_security_class, X.RDB$SECURITY_CLASS);
+
+		if (!X.RDB$OWNER_NAME.NULL)
+			PUT_TEXT(att_foreign_server_owner_name, X.RDB$OWNER_NAME);
+
+		put(tdgbl, att_end);
+
+		write_foreign_server_options(MetaString(X.RDB$FOREIGN_SERVER_NAME));
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(req_handle);
+}
+
+
+void write_foreign_server_options(const MetaString& serverName)
+{
+/**************************************
+ *
+ *	w r i t e _ f o r e i g n _ s e r v e r _ o p t i o n s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Write a record in the burp file for each foreign server option.
+ *
+ **************************************/
+	IRequest* req_handle = nullptr;
+	BurpGlobals* tdgbl = BurpGlobals::getSpecific();
+
+	FOR (REQUEST_HANDLE req_handle)
+		X IN RDB$FOREIGN_SERVER_OPTIONS
+			WITH X.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+	{
+		put(tdgbl, rec_foreign_server_option);
+
+		PUT_TEXT(att_foreign_server_option_server_name, X.RDB$FOREIGN_SERVER_NAME);
+
+		PUT_TEXT(att_foreign_server_option_name, X.RDB$FOREIGN_OPTION_NAME);
+
+		// msg 427 writing foreign server option %s
+		BURP_verbose(427, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+
+		PUT_TEXT(att_foreign_server_option_value, X.RDB$FOREIGN_OPTION_VALUE);
+
+		if (!X.RDB$FOREIGN_OPTION_TYPE.NULL)
+			put_int32(att_foreign_server_option_type, X.RDB$FOREIGN_OPTION_TYPE);
+
+		put(tdgbl, att_end);
+	}
+	END_FOR
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	MISC_release_request_silent(req_handle);
+}
+
+
 void write_shadow_files()
 {
 /**************************************
diff --git a/src/burp/burp.h b/src/burp/burp.h
index d21317e0b18..d4090cd2b03 100644
--- a/src/burp/burp.h
+++ b/src/burp/burp.h
@@ -123,7 +123,13 @@ enum rec_type {
 	rec_db_creator,			// Database creator
 	rec_publication,		// Publication
 	rec_pub_table,			// Publication table
-	rec_schema				// Schema
+	rec_schema,				// Schema
+	rec_foreign_server,		// Foreign server
+	rec_foreign_server_option,	// Foreign server option
+	rec_foreign_table_option,	// Foreign table option
+	rec_foreign_table_field_option,	// Foreign table field option
+	rec_foreign_user_mapping,	// Foreign user mapping
+	rec_foreign_mapping_option	// Foreign user mapping option
 };
 
 
@@ -290,6 +296,7 @@ enum att_type {
 	att_relation_sql_security_deprecated,	// can be removed later
 	att_relation_sql_security,
 	att_relation_schema_name,
+	att_relation_foreign_server_name,	// table is foreign
 
 	// Field attributes (used for both global and local fields)
 
@@ -700,6 +707,46 @@ enum att_type {
 	att_schema_security_class,
 	att_schema_owner_name,
 	att_schema_description,
+
+	// Foreign server attributes
+	att_foreign_server_name = SERIES,
+	att_foreign_server_data_wrapper_name,
+	att_foreign_server_security_class,
+	att_foreign_server_owner_name,
+
+	// Foreign server option attributes
+	att_foreign_server_option_server_name = SERIES,
+	att_foreign_server_option_name,
+	att_foreign_server_option_value,
+	att_foreign_server_option_type,
+
+	// Foreign table option attributes
+
+	att_foreign_table_option_schema_name = SERIES,
+	att_foreign_table_option_table_name,
+	att_foreign_table_option_name,
+	att_foreign_table_option_value,
+
+	// Foreign table field option attributes
+
+	att_foreign_table_field_option_schema_name = SERIES,
+	att_foreign_table_field_option_table_name,
+	att_foreign_table_field_option_field_name,
+	att_foreign_table_field_option_name,
+	att_foreign_table_field_option_value,
+
+	// Foreign user mapping attributes
+
+	att_foreign_user_mapping_user = SERIES,
+	att_foreign_user_mapping_server_name,
+
+	// Foreign mapping option attributes
+
+	att_foreign_mapping_option_user = SERIES,
+	att_foreign_mapping_option_server_name,
+	att_foreign_mapping_option_name,
+	att_foreign_mapping_option_value,
+	att_foreign_mapping_option_type,
 };
 
 
@@ -792,13 +839,15 @@ struct burp_rel
 	SSHORT		rel_flags;
 	SSHORT		rel_id;
 	Firebird::QualifiedMetaString rel_name;
+	Firebird::QualifiedMetaString rel_foreign_server;
 	GDS_NAME	rel_owner;		// relation owner, if not us
 	ULONG		rel_max_pp;		// max pointer page sequence number
 };
 
 enum burp_rel_flags_vals {
 	REL_view		= 1,
-	REL_external	= 2
+	REL_external	= 2,
+	REL_foreign		= 4
 };
 
 // package definition
@@ -1173,6 +1222,12 @@ class BurpGlobals : public Firebird::ThreadData, public GblPool
 	Firebird::IRequest*	handles_get_fields_req_handle6;
 	Firebird::IRequest*	handles_get_files_req_handle1;
 	Firebird::IRequest*	handles_get_filter_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_mapping_option_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_server_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_server_option_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_table_option_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_table_field_option_req_handle1;
+	Firebird::IRequest*	handles_get_foreign_user_mapping_req_handle1;
 	Firebird::IRequest*	handles_get_function_arg_req_handle1;
 	Firebird::IRequest*	handles_get_function_req_handle1;
 	Firebird::IRequest*	handles_get_global_field_req_handle1;
diff --git a/src/burp/restore.epp b/src/burp/restore.epp
index 1aecf4f1cb0..fd2260e4b7a 100644
--- a/src/burp/restore.epp
+++ b/src/burp/restore.epp
@@ -167,6 +167,12 @@ bool	get_trigger_old (BurpGlobals* tdgbl, burp_rel*);
 bool	get_type(BurpGlobals* tdgbl);
 bool	get_user_privilege(BurpGlobals* tdgbl);
 bool	get_view(BurpGlobals* tdgbl, burp_rel*);
+bool	get_foreign_server(BurpGlobals* tdgbl);
+bool	get_foreign_server_option(BurpGlobals* tdgbl);
+bool	get_foreign_table_option(BurpGlobals* tdgbl);
+bool	get_foreign_table_field_option(BurpGlobals* tdgbl);
+bool	get_foreign_user_mapping(BurpGlobals* tdgbl);
+bool	get_foreign_mapping_option(BurpGlobals* tdgbl);
 void	ignore_array(BurpGlobals* tdgbl, burp_rel*);
 void	ignore_blob(BurpGlobals* tdgbl);
 rec_type	ignore_data(BurpGlobals* tdgbl, burp_rel*);
@@ -8072,6 +8078,11 @@ bool get_relation(BurpGlobals* tdgbl, Coordinator* coord, RestoreRelationTask* t
 			relation->rel_name.schema = temp;
 			break;
 
+		case att_relation_foreign_server_name:
+			GET_TEXT(temp);
+			relation->rel_foreign_server.object = temp;
+			break;
+
 		case att_relation_name:
 			{
 				GET_TEXT(temp);
@@ -8176,6 +8187,7 @@ bool get_relation(BurpGlobals* tdgbl, Coordinator* coord, RestoreRelationTask* t
 			X IN RDB$RELATIONS
 		{
 			X.RDB$SCHEMA_NAME.NULL = TRUE;
+			X.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
 			X.RDB$SYSTEM_FLAG.NULL = FALSE;
 			X.RDB$FLAGS.NULL = rel_flags_null;
 			X.RDB$SECURITY_CLASS.NULL = sec_class_null;
@@ -8201,6 +8213,12 @@ bool get_relation(BurpGlobals* tdgbl, Coordinator* coord, RestoreRelationTask* t
 				X.RDB$SCHEMA_NAME.NULL = FALSE;
 			}
 
+			if (relation->rel_foreign_server.object.hasData())
+			{
+				strcpy(X.RDB$FOREIGN_SERVER_NAME, relation->rel_foreign_server.object.c_str());
+				X.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+			}
+
 			strcpy(X.RDB$SECURITY_CLASS, sec_class);
 			strcpy(X.RDB$RELATION_NAME, relation->rel_name.object.c_str());
 			strcpy(X.RDB$EXTERNAL_FILE, ext_file_name);
@@ -8287,6 +8305,10 @@ bool get_relation(BurpGlobals* tdgbl, Coordinator* coord, RestoreRelationTask* t
 			get_view(tdgbl, relation);
 			break;
 
+		case rec_foreign_table_field_option:
+			get_foreign_table_field_option(tdgbl);
+			break;
+
 		default:
 			BURP_error(43, true, SafeArg() << record);
 			// msg 43 don't recognize record type %ld
@@ -10522,6 +10544,643 @@ bool get_view(BurpGlobals* tdgbl, burp_rel* relation)
 	return true;
 }
 
+bool get_foreign_server(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ s e r v e r
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_SERVERS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_server_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_data_wrapper_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_security_class:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_owner_name:
+					eat_text(tdgbl);
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 426);	// msg 426 foreign server
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString name;
+	bool securityClass = false;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_server_req_handle1)
+		X IN RDB$FOREIGN_SERVERS
+	{
+		X.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_SERVER_WRAPPER.NULL = TRUE;
+		X.RDB$SECURITY_CLASS.NULL = TRUE;
+		X.RDB$OWNER_NAME.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_server_name:
+					GET_TEXT(X.RDB$FOREIGN_SERVER_NAME);
+					X.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+					name.object = X.RDB$FOREIGN_SERVER_NAME;
+					BURP_verbose(425, name.object.toQuotedString());	// msg 425 restoring foreign server %s
+					break;
+
+				case att_foreign_server_data_wrapper_name:
+					GET_TEXT(X.RDB$FOREIGN_SERVER_WRAPPER);
+					X.RDB$FOREIGN_SERVER_WRAPPER.NULL = FALSE;
+					break;
+
+				case att_foreign_server_security_class:
+					GET_TEXT(X.RDB$SECURITY_CLASS);
+					fix_security_class_name(tdgbl, X.RDB$SECURITY_CLASS, false);
+					X.RDB$SECURITY_CLASS.NULL = FALSE;
+					securityClass = true;
+					break;
+
+				case att_foreign_server_owner_name:
+					GET_TEXT(X.RDB$OWNER_NAME);
+					X.RDB$OWNER_NAME.NULL = FALSE;
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 426);	// msg 426 foreign server
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	collect_missing_privs(tdgbl, obj_foreign_servers, name, securityClass);
+
+	return true;
+}
+
+bool get_foreign_server_option(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ s e r v e r _ o p t i o n
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_SERVER_OPTIONS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_server_option_server_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_option_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_option_value:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_server_option_type:
+					get_int32(tdgbl);
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 429);	// msg 429 foreign server option
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString name;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_server_option_req_handle1)
+		X IN RDB$FOREIGN_SERVER_OPTIONS
+	{
+		X.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_VALUE.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_TYPE.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_server_option_server_name:
+					GET_TEXT(X.RDB$FOREIGN_SERVER_NAME);
+					X.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+					name.object = X.RDB$FOREIGN_SERVER_NAME;
+					break;
+
+				case att_foreign_server_option_name:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_NAME);
+					X.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+					// msg 428 restoring foreign server option %s
+					BURP_verbose(428, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+					break;
+
+				case att_foreign_server_option_value:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_VALUE);
+					X.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+					break;
+
+				case att_foreign_server_option_type:
+					X.RDB$FOREIGN_OPTION_TYPE = get_int32(tdgbl);
+					X.RDB$FOREIGN_OPTION_TYPE.NULL = FALSE;
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 429);	// msg 429 foreign server option
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	return true;
+}
+
+bool get_foreign_table_option(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ t a b l e _ o p t i o n
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_TABLE_OPTIONS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case rec_foreign_table_option:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_option_schema_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_option_table_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_option_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_option_value:
+					eat_text(tdgbl);
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 432);	// msg 432 foreign table option
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString name;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_table_option_req_handle1)
+		X IN RDB$FOREIGN_TABLE_OPTIONS
+	{
+		X.RDB$SCHEMA_NAME.NULL = TRUE;
+		X.RDB$TABLE_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_VALUE.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_table_option_schema_name:
+					GET_TEXT(X.RDB$SCHEMA_NAME);
+					X.RDB$SCHEMA_NAME.NULL = FALSE;
+					name.schema = X.RDB$SCHEMA_NAME;
+					break;
+
+				case att_foreign_table_option_table_name:
+					GET_TEXT(X.RDB$TABLE_NAME);
+					X.RDB$TABLE_NAME.NULL = FALSE;
+					name.object = X.RDB$TABLE_NAME;
+					break;
+
+				case att_foreign_table_option_name:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_NAME);
+					X.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+					// msg 431 restoring foreign table option %s
+					BURP_verbose(431, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+					break;
+
+				case att_foreign_table_option_value:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_VALUE);
+					X.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 432);	// msg 432 foreign table option
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	return true;
+}
+
+bool get_foreign_table_field_option(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ t a b l e _ f i e l d _ o p t i o n
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_TABLE_FIELD_OPTIONS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_table_field_option_schema_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_field_option_table_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_field_option_field_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_field_option_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_table_field_option_value:
+					eat_text(tdgbl);
+					break;
+
+				default:
+					// msg 435 foreign table column option
+					bad_attribute(scan_next_attr, attribute, 435);
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString tableName;
+	QualifiedMetaString fieldName;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_table_field_option_req_handle1)
+		X IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+	{
+		X.RDB$SCHEMA_NAME.NULL = TRUE;
+		X.RDB$TABLE_NAME.NULL = TRUE;
+		X.RDB$FIELD_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_VALUE.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_table_field_option_schema_name:
+					GET_TEXT(X.RDB$SCHEMA_NAME);
+					X.RDB$SCHEMA_NAME.NULL = FALSE;
+					tableName.schema = X.RDB$SCHEMA_NAME;
+					break;
+
+				case att_foreign_table_field_option_table_name:
+					GET_TEXT(X.RDB$TABLE_NAME);
+					X.RDB$TABLE_NAME.NULL = FALSE;
+					tableName.object = X.RDB$TABLE_NAME;
+					break;
+
+				case att_foreign_table_field_option_field_name:
+					GET_TEXT(X.RDB$FIELD_NAME);
+					X.RDB$FIELD_NAME.NULL = FALSE;
+					fieldName.object = X.RDB$FIELD_NAME;
+					break;
+
+				case att_foreign_table_field_option_name:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_NAME);
+					X.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+					// msg 434 restoring foreign table column option %s
+					BURP_verbose(434, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+					break;
+
+				case att_foreign_table_field_option_value:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_VALUE);
+					X.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+					break;
+
+				default:
+					// msg 435 foreign table column option
+					bad_attribute(scan_next_attr, attribute, 435);
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	return true;
+}
+
+bool get_foreign_user_mapping(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ u s e r _ m a p p i n g
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_USER_MAPPINGS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_user_mapping_user:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_user_mapping_server_name:
+					eat_text(tdgbl);
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 439);	// msg 439 foreign user mapping
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString user;
+	QualifiedMetaString server;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_user_mapping_req_handle1)
+		X IN RDB$FOREIGN_USER_MAPPINGS
+	{
+		X.RDB$USER.NULL = TRUE;
+		X.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_user_mapping_user:
+					GET_TEXT(X.RDB$USER);
+					X.RDB$USER.NULL = FALSE;
+					user.object = X.RDB$USER;
+					break;
+
+				case att_foreign_user_mapping_server_name:
+					GET_TEXT(X.RDB$FOREIGN_SERVER_NAME);
+					X.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+					server.object = X.RDB$FOREIGN_SERVER_NAME;
+					// msg 438 restoring foreign user mapping for user %s and server %s
+					BURP_verbose(438, SafeArg() << user.object.toQuotedString().c_str() <<
+						server.object.toQuotedString().c_str());
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 439);	// msg 439 foreign user mapping
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	return true;
+}
+
+bool get_foreign_mapping_option(BurpGlobals* tdgbl)
+{
+/**************************************
+ *
+ *	g e t _ f o r e i g n _ m a p p i n g _ o p t i o n
+ *
+ **************************************
+ *
+ * Functional description
+ *	Store a record in RDB$FOREIGN_MAPPING_OPTIONS.
+ *
+ **************************************/
+
+	att_type attribute;
+	scan_attr_t scan_next_attr;
+
+	if (tdgbl->runtimeODS < DB_VERSION_DDL14)
+	{
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_mapping_option_user:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_mapping_option_server_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_mapping_option_name:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_mapping_option_value:
+					eat_text(tdgbl);
+					break;
+
+				case att_foreign_mapping_option_type:
+					get_int32(tdgbl);
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 442);	// msg 442 foreign user mapping option
+					break;
+			}
+		}
+
+		return true;
+	}
+
+	QualifiedMetaString user;
+	QualifiedMetaString server;
+	ITransaction* local_trans = tdgbl->global_trans ? tdgbl->global_trans : gds_trans;
+
+	STORE (TRANSACTION_HANDLE local_trans REQUEST_HANDLE tdgbl->handles_get_foreign_mapping_option_req_handle1)
+		X IN RDB$FOREIGN_MAPPING_OPTIONS
+	{
+		X.RDB$USER.NULL = TRUE;
+		X.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_NAME.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_VALUE.NULL = TRUE;
+		X.RDB$FOREIGN_OPTION_TYPE.NULL = TRUE;
+
+		skip_init(&scan_next_attr);
+
+		while (skip_scan(&scan_next_attr), get_attribute(&attribute, tdgbl) != att_end)
+		{
+			switch (attribute)
+			{
+				case att_foreign_mapping_option_user:
+					GET_TEXT(X.RDB$USER);
+					X.RDB$USER.NULL = FALSE;
+					user.object = X.RDB$USER;
+					break;
+
+				case att_foreign_mapping_option_server_name:
+					GET_TEXT(X.RDB$FOREIGN_SERVER_NAME);
+					X.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+					server.object = X.RDB$FOREIGN_SERVER_NAME;
+					break;
+
+				case att_foreign_mapping_option_name:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_NAME);
+					X.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+					// msg 441 restoring foreign user mapping option %s
+					BURP_verbose(441, MetaString(X.RDB$FOREIGN_OPTION_NAME).toQuotedString());
+					break;
+
+				case att_foreign_mapping_option_value:
+					GET_TEXT(X.RDB$FOREIGN_OPTION_VALUE);
+					X.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+					break;
+
+				case att_foreign_mapping_option_type:
+					X.RDB$FOREIGN_OPTION_TYPE = get_int32(tdgbl);
+					X.RDB$FOREIGN_OPTION_TYPE.NULL = FALSE;
+					break;
+
+				default:
+					bad_attribute(scan_next_attr, attribute, 442);	// msg 442 foreign user mapping option
+					break;
+			}
+		}
+	}
+	END_STORE
+	ON_ERROR
+		general_on_error();
+	END_ERROR
+
+	return true;
+}
+
 void ignore_array(BurpGlobals* tdgbl, burp_rel* relation)
 {
 /**************************************
@@ -11355,6 +12014,36 @@ bool restore(BurpGlobals* tdgbl, Firebird::IProvider* provider, const TEXT* file
 			flag = true;
 			break;
 
+		case rec_foreign_server:
+			if (!get_foreign_server(tdgbl))
+				return false;
+			flag = true;
+			break;
+
+		case rec_foreign_server_option:
+			if (!get_foreign_server_option(tdgbl))
+				return false;
+			flag = true;
+			break;
+
+		case rec_foreign_table_option:
+			if (!get_foreign_table_option(tdgbl))
+				return false;
+			flag = true;
+			break;
+
+		case rec_foreign_user_mapping:
+			if (!get_foreign_user_mapping(tdgbl))
+				return false;
+			flag = true;
+			break;
+
+		case rec_foreign_mapping_option:
+			if (!get_foreign_mapping_option(tdgbl))
+				return false;
+			flag = true;
+			break;
+
 		default:
 			BURP_error(43, true, SafeArg() << record);
 			// msg 43 don't recognize record type %ld
diff --git a/src/common/ParserTokens.h b/src/common/ParserTokens.h
index 3abce408f92..247586db1df 100644
--- a/src/common/ParserTokens.h
+++ b/src/common/ParserTokens.h
@@ -202,6 +202,7 @@ PARSER_TOKEN(TOK_ENCRYPT, "ENCRYPT", true)
 PARSER_TOKEN(TOK_END, "END", false)
 PARSER_TOKEN(TOK_ENGINE, "ENGINE", true)
 PARSER_TOKEN(TOK_ENTRY_POINT, "ENTRY_POINT", true)
+PARSER_TOKEN(TOK_ENV, "ENV", true)
 PARSER_TOKEN(TOK_ESCAPE, "ESCAPE", false)
 PARSER_TOKEN(TOK_EXCEPTION, "EXCEPTION", true)
 PARSER_TOKEN(TOK_EXCESS, "EXCESS", true)
@@ -347,6 +348,7 @@ PARSER_TOKEN(TOK_ONLY, "ONLY", false)
 PARSER_TOKEN(TOK_OPEN, "OPEN", false)
 PARSER_TOKEN(TOK_OPTIMIZE, "OPTIMIZE", true)
 PARSER_TOKEN(TOK_OPTION, "OPTION", true)
+PARSER_TOKEN(TOK_OPTIONS, "OPTIONS", true)
 PARSER_TOKEN(TOK_OR, "OR", false)
 PARSER_TOKEN(TOK_ORDER, "ORDER", false)
 PARSER_TOKEN(TOK_OS_NAME, "OS_NAME", true)
@@ -459,6 +461,7 @@ PARSER_TOKEN(TOK_SEGMENT, "SEGMENT", true)
 PARSER_TOKEN(TOK_SELECT, "SELECT", false)
 PARSER_TOKEN(TOK_SENSITIVE, "SENSITIVE", false)
 PARSER_TOKEN(TOK_SEQUENCE, "SEQUENCE", true)
+PARSER_TOKEN(TOK_SERVER, "SERVER", true)
 PARSER_TOKEN(TOK_SERVERWIDE, "SERVERWIDE", true)
 PARSER_TOKEN(TOK_SESSION, "SESSION", true)
 PARSER_TOKEN(TOK_SET, "SET", false)
@@ -557,6 +560,7 @@ PARSER_TOKEN(TOK_WINDOW, "WINDOW", false)
 PARSER_TOKEN(TOK_WITH, "WITH", false)
 PARSER_TOKEN(TOK_WITHOUT, "WITHOUT", false)
 PARSER_TOKEN(TOK_WORK, "WORK", true)
+PARSER_TOKEN(TOK_WRAPPER, "WRAPPER", true)
 PARSER_TOKEN(TOK_WRITE, "WRITE", true)
 PARSER_TOKEN(TOK_YEAR, "YEAR", false)
 PARSER_TOKEN(TOK_YEARDAY, "YEARDAY", true)
diff --git a/src/dsql/DdlNodes.epp b/src/dsql/DdlNodes.epp
index 4e8c5c9f4cf..c7d40c01fca 100644
--- a/src/dsql/DdlNodes.epp
+++ b/src/dsql/DdlNodes.epp
@@ -64,6 +64,7 @@
 #include "../auth/SecureRemotePassword/Message.h"
 #include "../jrd/Mapping.h"
 #include "../jrd/extds/ExtDS.h"
+#include "../jrd/ForeignServer.h"
 
 namespace Jrd {
 
@@ -110,6 +111,8 @@ static void updateRdbFields(const TypeClause* type,
 	SSHORT& collationIdNull, SSHORT& collationId,
 	SSHORT& segmentLengthNull, SSHORT& segmentLength);
 
+static bool checkObjectExist(thread_db* tdbb, jrd_tra* transaction, const QualifiedName& name, int type);
+
 static constexpr const char* CHECK_CONSTRAINT_EXCEPTION = "check_constraint";
 
 DATABASE DB = STATIC "ODS.RDB";
@@ -609,6 +612,8 @@ static const char* getRelationScopeName(const rel_t type)
 		return REL_SCOPE_VIEW;
 	case rel_virtual:
 		return REL_SCOPE_VIRTUAL;
+	case rel_foreign:
+		return REL_SCOPE_FOREIGN;
 	case rel_persistent:
 		return REL_SCOPE_PERSISTENT;
 	default:
@@ -1502,6 +1507,10 @@ void CommentOnNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
 			SCL_check_package(tdbb, name, SCL_alter);
 			break;
 
+		case obj_foreign_server:
+			SCL_check_foreign_server(tdbb, name.object, SCL_alter);
+			break;
+
 		default:
 			fb_assert(false);
 	}
@@ -6219,11 +6228,13 @@ void DropSequenceNode::deleteIdentity(thread_db* tdbb, jrd_tra* transaction, con
 //----------------------
 
 
-RelationNode::RelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode)
+RelationNode::RelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode, bool aForeign)
 	: DdlNode(p),
 	  dsqlNode(aDsqlNode),
 	  name(p, dsqlNode->dsqlName),
-	  clauses(p)
+	  clauses(p),
+	  options(p),
+	  foreign(aForeign)
 {
 }
 
@@ -6448,6 +6459,8 @@ DdlNode* RelationNode::dsqlPass(DsqlCompilerScratch* dsqlScratch)
 			case Clause::TYPE_DROP_CONSTRAINT:
 			case Clause::TYPE_ALTER_SQL_SECURITY:
 			case Clause::TYPE_ALTER_PUBLICATION:
+			case Clause::TYPE_ALTER_FOREIGN_COL:
+			case Clause::TYPE_ALTER_OPTIONS:
 				break;
 
 			default:
@@ -6651,6 +6664,17 @@ bool RelationNode::deleteLocalField(thread_db* tdbb, jrd_tra* transaction,
 	}
 	END_FOR
 
+	request.reset(tdbb, drq_drop_f_tbl_opt, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+		FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+		WITH FTFOPT.RDB$TABLE_NAME EQ relationName.object.c_str() AND
+			FTFOPT.RDB$FIELD_NAME EQ fieldName.c_str()
+	{
+		ERASE FTFOPT;
+	}
+	END_FOR
+
 	if (!found && !silent)
 	{
 		// msg 176: "column %s does not exist in table/view %s"
@@ -6840,6 +6864,36 @@ void RelationNode::defineField(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch
 				constraint->create->columns.add(field->fld_name);
 			defineConstraint(tdbb, dsqlScratch, transaction, constraint->name, *constraint->create);
 		}
+
+		// Store foreign field options
+		for (unsigned cnt = 0; cnt < clause->options.getCount(); ++cnt)
+		{
+			const Option* option = &clause->options[cnt];
+			if (option->value.hasData())
+			{
+				AutoCacheRequest request(tdbb, drq_s_f_tbl_f_opt, DYN_REQUESTS);
+
+				STORE (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+					FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+				{
+					FTFOPT.RDB$SCHEMA_NAME.NULL = FALSE;
+					strcpy(FTFOPT.RDB$SCHEMA_NAME, relation->rel_name.schema.c_str());
+
+					FTFOPT.RDB$TABLE_NAME.NULL = FALSE;
+					strcpy(FTFOPT.RDB$TABLE_NAME, relation->rel_name.object.c_str());
+
+					FTFOPT.RDB$FIELD_NAME.NULL = FALSE;
+					strcpy(FTFOPT.RDB$FIELD_NAME, field->fld_name.c_str());
+
+					FTFOPT.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+					strcpy(FTFOPT.RDB$FOREIGN_OPTION_NAME, option->name.c_str());
+
+					FTFOPT.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+					strcpy(FTFOPT.RDB$FOREIGN_OPTION_VALUE, option->value.c_str());
+				}
+				END_STORE
+			}
+		}
 	}
 	catch (const Exception&)
 	{
@@ -7804,6 +7858,31 @@ void RelationNode::dropFromPublication(thread_db* tdbb,
 }
 
 
+void RelationNode::storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option)
+{
+	Attachment* const attachment = transaction->getAttachment();
+
+	AutoCacheRequest requestHandle(tdbb, drq_s_f_tbl_opt, DYN_REQUESTS);
+
+	STORE (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FTOPT IN RDB$FOREIGN_TABLE_OPTIONS
+	{
+		FTOPT.RDB$SCHEMA_NAME.NULL = FALSE;
+		strcpy(FTOPT.RDB$SCHEMA_NAME, name.schema.c_str());
+
+		FTOPT.RDB$TABLE_NAME.NULL = FALSE;
+		strcpy(FTOPT.RDB$TABLE_NAME, name.object.c_str());
+
+		FTOPT.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+		strcpy(FTOPT.RDB$FOREIGN_OPTION_NAME, option->name.c_str());
+
+		FTOPT.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+		strcpy(FTOPT.RDB$FOREIGN_OPTION_VALUE, option->value.c_str());
+	}
+	END_STORE
+}
+
+
 //----------------------
 
 
@@ -7813,6 +7892,7 @@ string CreateRelationNode::internalPrint(NodePrinter& printer) const
 
 	NODE_PRINT(printer, externalFile);
 	NODE_PRINT(printer, relationType);
+	NODE_PRINT(printer, foreignServer);
 
 	return "CreateRelationNode";
 }
@@ -7820,6 +7900,9 @@ string CreateRelationNode::internalPrint(NodePrinter& printer) const
 void CreateRelationNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
 {
 	SCL_check_create_access(tdbb, obj_relations, name.schema);
+
+	if (foreignServer.hasData())
+		SCL_check_foreign_server(tdbb, foreignServer, SCL_usage);
 }
 
 void CreateRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
@@ -7836,6 +7919,12 @@ void CreateRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScrat
 		dsqlScratch->relation->rel_flags |= REL_external;
 	}
 
+	if (foreignServer.hasData())
+	{
+		fb_assert(dsqlScratch->relation);
+		dsqlScratch->relation->rel_flags |= REL_foreign;
+	}
+
 	// run all statements under savepoint control
 	AutoSavePoint savePoint(tdbb, transaction);
 
@@ -7885,9 +7974,30 @@ void CreateRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScrat
 			strcpy(REL.RDB$EXTERNAL_FILE, externalFile->c_str());
 			REL.RDB$RELATION_TYPE = rel_external;
 		}
+
+		if (foreignServer.hasData())
+		{
+			if (!checkObjectExist(tdbb, transaction, QualifiedName(foreignServer), obj_foreign_server))
+				status_exception::raise(Arg::Gds(isc_dyn_foreign_server_not_found) << foreignServer.c_str());
+
+			REL.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+			strcpy(REL.RDB$FOREIGN_SERVER_NAME, foreignServer.c_str());
+			REL.RDB$RELATION_TYPE = rel_foreign;
+		}
+		else
+			REL.RDB$FOREIGN_SERVER_NAME.NULL = TRUE;
 	}
 	END_STORE
 
+	// Store foreign table options
+	for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+	{
+		if (options[cnt].value.hasData())
+		{
+			storeOption(tdbb, transaction, &options[cnt]);
+		}
+	}
+
 	bool replicationEnabled = false;
 
 	if (replicationState.isAssigned())
@@ -7999,12 +8109,24 @@ void AlterRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratc
 	dsql_rel* relation;
 	relation = METD_get_relation(dsqlScratch->getTransaction(), dsqlScratch, name);
 
-	if (!relation || (relation->rel_flags & REL_view))
+	ISC_STATUS dsqlError = 0;
+	if (foreign)
+	{
+		if (!relation || !(relation->rel_flags & REL_foreign))
+			dsqlError = isc_dsql_foreign_table_not_found;
+	}
+	else
+	{
+		if (!relation || (relation->rel_flags & (REL_view | REL_foreign)))
+			dsqlError = isc_dsql_table_not_found;
+	}
+
+	if (dsqlError)
 	{
 		status_exception::raise(
 			Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
 			Arg::Gds(isc_dsql_command_err) <<
-			Arg::Gds(isc_dsql_table_not_found) << name.toQuotedString());
+			Arg::Gds(dsqlError) << name.toQuotedString());
 	}
 
 	if (!dsqlScratch->relation)
@@ -8142,6 +8264,21 @@ void AlterRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratc
 					}
 					END_FOR
 
+					// if it's a column of the foreign table, update its name in the column options
+					AutoRequest request3;
+
+					FOR(REQUEST_HANDLE request3 TRANSACTION_HANDLE transaction)
+						FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+							WITH FTFOPT.RDB$SCHEMA_NAME EQ name.schema.c_str() AND
+								FTFOPT.RDB$TABLE_NAME EQ name.object.c_str() AND
+								FTFOPT.RDB$FIELD_NAME EQ clause->fromName.c_str()
+					{
+						MODIFY FTFOPT
+							strcpy(FTFOPT.RDB$FIELD_NAME, clause->toName.c_str());
+						END_MODIFY
+					}
+					END_FOR
+
 					break;
 				}
 
@@ -8233,6 +8370,55 @@ void AlterRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratc
 					break;
 				}
 
+				case Clause::TYPE_ALTER_FOREIGN_COL:
+				{
+					const AlterForeignColumnClause* clause =
+						static_cast<const AlterForeignColumnClause*>(i->getObject());
+
+					// Drop old options and insert the new ones
+					for (unsigned cnt = 0; cnt < clause->options.getCount(); ++cnt)
+					{
+						const Option* option = &clause->options[cnt];
+						AutoCacheRequest request(tdbb, drq_drop_f_tbl_opt, DYN_REQUESTS);
+
+						FOR (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+							FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+							WITH FTFOPT.RDB$SCHEMA_NAME EQ name.schema.c_str() AND
+								FTFOPT.RDB$TABLE_NAME EQ name.object.c_str() AND
+								FTFOPT.RDB$FIELD_NAME EQ clause->name.c_str() AND
+								FTFOPT.RDB$FOREIGN_OPTION_NAME EQ option->name.c_str()
+						{
+							ERASE FTFOPT;
+						}
+						END_FOR
+
+						if (option->value.hasData())
+						{
+							request.reset(tdbb, drq_s_f_tbl_f_opt, DYN_REQUESTS);
+							STORE (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+								FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+							{
+								FTFOPT.RDB$SCHEMA_NAME.NULL = FALSE;
+								strcpy(FTFOPT.RDB$SCHEMA_NAME, name.schema.c_str());
+
+								FTFOPT.RDB$TABLE_NAME.NULL = FALSE;
+								strcpy(FTFOPT.RDB$TABLE_NAME, name.object.c_str());
+
+								FTFOPT.RDB$FIELD_NAME.NULL = FALSE;
+								strcpy(FTFOPT.RDB$FIELD_NAME, clause->name.c_str());
+
+								FTFOPT.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+								strcpy(FTFOPT.RDB$FOREIGN_OPTION_NAME, option->name.c_str());
+
+								FTFOPT.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+								strcpy(FTFOPT.RDB$FOREIGN_OPTION_VALUE, option->value.c_str());
+							}
+							END_STORE
+						}
+					}
+					break;
+				}
+
 				case Clause::TYPE_DROP_COLUMN:
 				{
 					// Fix for bug 8054:
@@ -8366,6 +8552,19 @@ void AlterRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratc
 					break;
 				}
 
+				case Clause::TYPE_ALTER_OPTIONS:
+				{
+					// Drop old options and insert the new ones
+					for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+					{
+						DropRelationNode::dropOption(tdbb, transaction, name, options[cnt].name);
+
+						if (options[cnt].value.hasData())
+							storeOption(tdbb, transaction, &options[cnt]);
+					}
+					break;
+				}
+
 				default:
 					fb_assert(false);
 					break;
@@ -8978,26 +9177,34 @@ void DropRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch
 	if (!relation && silent)
 		return;
 
-	// Check that DROP TABLE is dropping a table and that DROP VIEW is dropping a view.
+	// Check that DROP TABLE is dropping a table, that DROP FOREIGN TABLE is dropping a foreign table
+	// and that DROP VIEW is dropping a view.
+	ISC_STATUS dsqlError = 0;
 	if (view)
 	{
-		if (!relation || (relation && !(relation->rel_flags & REL_view)))
-		{
-			status_exception::raise(
-				Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
-				Arg::Gds(isc_dsql_command_err) <<
-				Arg::Gds(isc_dsql_view_not_found) << name.toQuotedString());
-		}
+		if (!relation || !(relation->rel_flags & REL_view))
+			dsqlError = isc_dsql_view_not_found;
+	}
+	else if (foreign)
+	{
+		if (!relation || !(relation->rel_flags & REL_foreign))
+			dsqlError = isc_dsql_foreign_table_not_found;
 	}
 	else
 	{
-		if (!relation || (relation && (relation->rel_flags & REL_view)))
-		{
-			status_exception::raise(
-				Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
-				Arg::Gds(isc_dsql_command_err) <<
-				Arg::Gds(isc_dsql_table_not_found) << name.toQuotedString());
-		}
+		if (!relation || (relation->rel_flags & (REL_view | REL_foreign)))
+			dsqlError = isc_dsql_table_not_found;
+	}
+
+	if (dsqlError)
+	{
+		if (silent)
+			return;
+
+		status_exception::raise(
+			Arg::Gds(isc_sqlerr) << Arg::Num(-607) <<
+			Arg::Gds(isc_dsql_command_err) <<
+			Arg::Gds(dsqlError) << name.toQuotedString());
 	}
 
 	const int ddlTriggerAction = (view ? DDL_TRIGGER_DROP_VIEW : DDL_TRIGGER_DROP_TABLE);
@@ -9189,6 +9396,32 @@ void DropRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch
 	}
 	END_FOR
 
+	// Drop foreign table options
+
+	request.reset(tdbb, drq_drop_f_tbl_opts, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+		FTOPT IN RDB$FOREIGN_TABLE_OPTIONS
+		WITH FTOPT.RDB$SCHEMA_NAME EQ name.schema.c_str() AND
+			FTOPT.RDB$TABLE_NAME EQ name.object.c_str()
+	{
+		ERASE FTOPT;
+	}
+	END_FOR
+
+	// Drop foreign field options
+
+	request.reset(tdbb, drq_drop_f_tbl_f_opt, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+		FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+		WITH FTFOPT.RDB$SCHEMA_NAME EQ name.schema.c_str() AND
+			FTFOPT.RDB$TABLE_NAME EQ name.object.c_str()
+	{
+		ERASE FTFOPT;
+	}
+	END_FOR
+
 	if (found)
 		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, ddlTriggerAction, name, {});
 	else
@@ -9204,6 +9437,28 @@ void DropRelationNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch
 }
 
 
+bool DropRelationNode::dropOption(thread_db* tdbb, jrd_tra* transaction,
+	const QualifiedName& relation, const MetaName& optionName)
+{
+	AutoCacheRequest requestHandle(tdbb, drq_drop_f_tbl_opt, DYN_REQUESTS);
+	bool found = false;
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FTOPT IN RDB$FOREIGN_TABLE_OPTIONS
+		WITH FTOPT.RDB$SCHEMA_NAME EQ relation.schema.c_str() AND
+			FTOPT.RDB$TABLE_NAME EQ relation.object.c_str() AND
+			FTOPT.RDB$FOREIGN_OPTION_NAME EQ optionName.c_str()
+	{
+		found = true;
+
+		ERASE FTOPT;
+	}
+	END_FOR
+
+	return found;
+}
+
+
 //----------------------
 
 
@@ -11916,108 +12171,674 @@ void DropUserNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jr
 //----------------------
 
 
-string GrantRevokeNode::internalPrint(NodePrinter& printer) const
+string CreateAlterForeignServerNode::internalPrint(NodePrinter& printer) const
 {
 	DdlNode::internalPrint(printer);
 
-	NODE_PRINT(printer, isGrant);
-	NODE_PRINT(printer, privileges);
-	NODE_PRINT(printer, roles);
-	NODE_PRINT(printer, object);
-	NODE_PRINT(printer, users);
-	NODE_PRINT(printer, grantAdminOption);
-	NODE_PRINT(printer, grantor);
-	NODE_PRINT(printer, isDdl);
+	NODE_PRINT(printer, name);
+	NODE_PRINT(printer, create);
+	NODE_PRINT(printer, alter);
+	NODE_PRINT(printer, plugin);
+	// NODE_PRINT(printer, options);
 
-	return "GrantRevokeNode";
+	return "CreateAlterForeignServerNode";
 }
 
-void GrantRevokeNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
+
+void CreateAlterForeignServerNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
 {
-	// GRANT OPTION will be checked in grantRevoke method
+	if (alter)
+	{
+		if (SCL_check_foreign_server(tdbb, name, SCL_alter) || !create)
+			return;
+	}
+
+	SCL_check_create_access(tdbb, obj_foreign_servers, {});
 }
 
-void GrantRevokeNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
+
+void CreateAlterForeignServerNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
 {
+	fb_assert(create || alter);
+
 	// run all statements under savepoint control
 	AutoSavePoint savePoint(tdbb, transaction);
 
-	createDbJobs.clear();
-
-	const GranteeClause* usersPtr;
-	const GranteeClause* usersEnd;
-
-	if (!isGrant && roles.isEmpty() && privileges.isEmpty() && !object)	// REVOKE ALL ON ALL
+	if (alter)
 	{
-		usersEnd = users.end();
-		for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
-			grantRevoke(tdbb, transaction, NULL, usersPtr, NULL, NULL, 0);
+		if (!executeAlter(tdbb, dsqlScratch, transaction))
+		{
+			if (create)	// create or alter
+				executeCreate(tdbb, dsqlScratch, transaction);
+			else
+				status_exception::raise(Arg::Gds(isc_dyn_foreign_server_not_found) << Arg::Str(name));
+		}
 	}
 	else
+		executeCreate(tdbb, dsqlScratch, transaction);
+
+	savePoint.release();	// everything is ok
+}
+
+
+void CreateAlterForeignServerNode::executeCreate(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
+	jrd_tra* transaction)
+{
+	Attachment* const attachment = transaction->getAttachment();
+	const MetaString& ownerName = attachment->getEffectiveUserName();
+	const QualifiedName qualifiedName(name);
+
+	if (createIfNotExistsOnly && !DYN_UTIL_check_unique_name_nothrow(tdbb, transaction, qualifiedName,
+		obj_foreign_server))
+		return;
+
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE,
+		DDL_TRIGGER_CREATE_FOREIGN_SERVER, qualifiedName, {});
+
+	DYN_UTIL_check_unique_name(tdbb, transaction, qualifiedName, obj_foreign_server);
+
+	AutoCacheRequest requestHandle(tdbb, drq_s_f_server, DYN_REQUESTS);
+
+	STORE (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSERV IN RDB$FOREIGN_SERVERS
 	{
-		SSHORT option = 0; // no grant/admin option
+		strcpy(FSERV.RDB$FOREIGN_SERVER_NAME, name.c_str());
 
-		if (roles.isEmpty())
+		if (plugin.hasData())
 		{
-			if (grantAdminOption)
-				option = 1; // with grant option
-
-			usersEnd = users.end();
-			for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
-				modifyPrivileges(tdbb, transaction, option, usersPtr);
+			FSERV.RDB$FOREIGN_SERVER_WRAPPER.NULL = FALSE;
+			strcpy(FSERV.RDB$FOREIGN_SERVER_WRAPPER, plugin.c_str());
 		}
 		else
 		{
-			if (grantAdminOption)
-				option = 2; // with admin option
+			FSERV.RDB$FOREIGN_SERVER_WRAPPER.NULL = TRUE;
+		}
 
-			const GranteeClause* rolesPtr = roles.begin();
-			const GranteeClause* rolesEnd = roles.end();
-			const bool* defaultRolesPtr = defaultRoles.begin();
-			for (; rolesPtr != rolesEnd; ++rolesPtr, ++defaultRolesPtr)
+		FSERV.RDB$OWNER_NAME.NULL = FALSE;
+		strcpy(FSERV.RDB$OWNER_NAME, ownerName.c_str());
+	}
+	END_STORE
+
+	if (options.hasData())
+	{
+		for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+		{
+			if (options[cnt].value.hasData())
 			{
-				usersEnd = users.end();
-				const bool defaultRole = *defaultRolesPtr;
-				for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
-					grantRevoke(tdbb, transaction, rolesPtr, usersPtr, "M", defaultRole ? "D" : NULL, option);
+				storeOption(tdbb, transaction, &options[cnt]);
 			}
-
-			// Invalidate system privileges cache
-			DFW_post_work(transaction, dfw_clear_cache, {}, {}, Mapping::SYSTEM_PRIVILEGES_CACHE);
 		}
+
 	}
 
-	if (createDbJobs.hasData())
-		executeInSecurityDb(transaction);
+	storePrivileges(tdbb, transaction, qualifiedName, obj_foreign_server, USAGE_PRIVILEGES);
 
-	savePoint.release();	// everything is ok
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_CREATE_FOREIGN_SERVER,
+		qualifiedName, {});
 }
 
-void GrantRevokeNode::runInSecurityDb(SecDbContext* secDbContext)
+
+bool CreateAlterForeignServerNode::executeAlter(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
+	jrd_tra* transaction)
 {
-	for (unsigned n = 0; n < createDbJobs.getCount(); ++n)
-	{
-		CreateDbJob& j = createDbJobs[n];
-		LocalStatus st;
-		CheckStatusWrapper statusWrapper(&st);
+	Attachment* const attachment = transaction->getAttachment();
+	QualifiedName qualifiedName(name);
 
-		Message result;
-		Field<ISC_INT64> cnt(result);
+	bool found = false;
 
-		if (j.userType == obj_sql_role && (!j.allOnAll))
-		{
-			Message isRole;
-			Field<Varying> u(isRole, MAX_SQL_IDENTIFIER_LEN);
-			u = j.user.c_str();
+	AutoCacheRequest requestHandle(tdbb, drq_m_f_server, DYN_REQUESTS);
 
-			const char* isRoleSql = "select count(*) from SYSTEM.RDB$ROLES where RDB$ROLE_NAME = ?";
-			secDbContext->att->execute(&statusWrapper, secDbContext->tra, 0, isRoleSql, SQL_DIALECT_V6,
-				isRole.getMetadata(), isRole.getBuffer(), result.getMetadata(), result.getBuffer());
-			check(&statusWrapper);
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSERV IN RDB$FOREIGN_SERVERS
+		WITH FSERV.RDB$FOREIGN_SERVER_NAME EQ name.c_str()
+	{
+		found = true;
 
-			if (cnt == 0)
-			{
-				// msg 188: Role doesn't exist.
+		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE,
+			DDL_TRIGGER_ALTER_FOREIGN_SERVER, qualifiedName, {});
+
+		MODIFY FSERV
+
+			if (plugin.hasData())
+			{
+				FSERV.RDB$FOREIGN_SERVER_WRAPPER.NULL = FALSE;
+				strcpy(FSERV.RDB$FOREIGN_SERVER_WRAPPER, plugin.c_str());
+			}
+
+			if (dropPlugin)
+				FSERV.RDB$FOREIGN_SERVER_WRAPPER.NULL = TRUE;
+
+		END_MODIFY
+	}
+	END_FOR
+
+
+	if (!found)
+		return found;
+
+	// Drop old options and insert the new ones
+	for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+	{
+		DropForeignServerNode::dropOption(tdbb, transaction, name, options[cnt].name);
+
+		if (options[cnt].value.hasData())
+			storeOption(tdbb, transaction, &options[cnt]);
+	}
+
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_ALTER_FOREIGN_SERVER,
+		qualifiedName, {});
+
+	return found;
+}
+
+
+void CreateAlterForeignServerNode::storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option)
+{
+	Attachment* const attachment = transaction->getAttachment();
+
+	AutoCacheRequest requestHandle(tdbb, drq_s_f_server_opt, DYN_REQUESTS);
+
+	STORE (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSOPT IN RDB$FOREIGN_SERVER_OPTIONS
+	{
+		FSOPT.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+		strcpy(FSOPT.RDB$FOREIGN_SERVER_NAME, name.c_str());
+
+		FSOPT.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+		strcpy(FSOPT.RDB$FOREIGN_OPTION_NAME, option->name.c_str());
+
+		FSOPT.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+		strcpy(FSOPT.RDB$FOREIGN_OPTION_VALUE, option->value.c_str());
+
+		if (option->type == ExternalValueType::TYPE_STRING)
+			FSOPT.RDB$FOREIGN_OPTION_TYPE.NULL = TRUE;
+		else
+		{
+			FSOPT.RDB$FOREIGN_OPTION_TYPE.NULL = FALSE;
+			FSOPT.RDB$FOREIGN_OPTION_TYPE = option->type;
+		}
+	}
+	END_STORE
+}
+
+//----------------------
+
+
+string DropForeignServerNode::internalPrint(NodePrinter& printer) const
+{
+	DdlNode::internalPrint(printer);
+
+	NODE_PRINT(printer, name);
+	NODE_PRINT(printer, plugin);
+	NODE_PRINT(printer, silent);
+
+	return "DropForeignServerNode";
+}
+
+void DropForeignServerNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
+{
+	SCL_check_foreign_server(tdbb, name, SCL_drop);
+}
+
+void DropForeignServerNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
+{
+	// run all statements under savepoint control
+	AutoSavePoint savePoint(tdbb, transaction);
+	bool found = false;
+	QualifiedName qualifiedName(name);
+
+	dropOptions(tdbb, transaction, name);
+
+	AutoCacheRequest requestHandle(tdbb, drq_drop_f_server, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSERV IN RDB$FOREIGN_SERVERS
+		WITH FSERV.RDB$FOREIGN_SERVER_NAME EQ name.c_str()
+	{
+		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE,
+			DDL_TRIGGER_DROP_FOREIGN_SERVER, qualifiedName, {});
+
+		ERASE FSERV;
+
+		if (!FSERV.RDB$SECURITY_CLASS.NULL)
+			deleteSecurityClass(tdbb, transaction, FSERV.RDB$SECURITY_CLASS);
+
+		found = true;
+	}
+	END_FOR
+
+	if (found)
+	{
+		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_DROP_FOREIGN_SERVER,
+			qualifiedName, {});
+	}
+	else if (!silent)
+		status_exception::raise(Arg::Gds(isc_dyn_foreign_server_not_found) << Arg::Str(name));
+
+	savePoint.release();	// everything is ok
+}
+
+
+bool DropForeignServerNode::dropOption(thread_db* tdbb, jrd_tra* transaction,
+	const MetaName& serverName, const MetaName& optionName)
+{
+	AutoCacheRequest requestHandle(tdbb, drq_drop_f_server_opt, DYN_REQUESTS);
+	bool found = false;
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSOPT IN RDB$FOREIGN_SERVER_OPTIONS
+		WITH FSOPT.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str() AND
+			FSOPT.RDB$FOREIGN_OPTION_NAME EQ optionName.c_str()
+	{
+		found = true;
+
+		ERASE FSOPT;
+	}
+	END_FOR
+
+	return found;
+}
+
+
+void DropForeignServerNode::dropOptions(thread_db* tdbb, jrd_tra* transaction,
+	const MetaName& serverName)
+{
+	AutoCacheRequest requestHandle(tdbb, drq_drop_f_server_opts, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FSOPT IN RDB$FOREIGN_SERVER_OPTIONS
+		WITH FSOPT.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+	{
+		ERASE FSOPT;
+	}
+	END_FOR
+}
+
+
+//----------------------
+
+
+string CreateAlterUserMappingNode::internalPrint(NodePrinter& printer) const
+{
+	DdlNode::internalPrint(printer);
+
+	NODE_PRINT(printer, user);
+	NODE_PRINT(printer, server);
+	NODE_PRINT(printer, create);
+	NODE_PRINT(printer, alter);
+	// NODE_PRINT(printer, options);
+
+	return "CreateAlterUserMappingNode";
+}
+
+
+void CreateAlterUserMappingNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
+{
+	SCL_check_foreign_server(tdbb, server, SCL_usage);
+}
+
+
+void CreateAlterUserMappingNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
+{
+	fb_assert(create || alter);
+
+	// run all statements under savepoint control
+	AutoSavePoint savePoint(tdbb, transaction);
+
+	if (alter)
+	{
+		if (!executeAlter(tdbb, dsqlScratch, transaction))
+		{
+			if (create)	// create or alter
+				executeCreate(tdbb, dsqlScratch, transaction);
+			else
+				status_exception::raise(Arg::Gds(isc_dyn_user_mapping_not_found) << Arg::Str(user) << Arg::Str(server));
+		}
+	}
+	else
+		executeCreate(tdbb, dsqlScratch, transaction);
+
+	savePoint.release();	// everything is ok
+}
+
+
+void CreateAlterUserMappingNode::executeCreate(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
+	jrd_tra* transaction)
+{
+	Attachment* const attachment = transaction->getAttachment();
+	const MetaString& ownerName = attachment->getEffectiveUserName();
+
+	// User mapping to external servers by MED specification does not have a name,
+	// make a unique name from the user and server.
+	const QualifiedName name(getUniqueName());
+
+	if (!checkObjectExist(tdbb, transaction, QualifiedName(server), obj_foreign_server))
+		status_exception::raise(Arg::Gds(isc_dyn_foreign_server_not_found) << server.c_str());
+
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE, DDL_TRIGGER_CREATE_USER_MAPPING,
+		name, {});
+
+	AutoCacheRequest requestHandle(tdbb, drq_s_u_mapping, DYN_REQUESTS);
+
+	STORE (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		UM IN RDB$FOREIGN_USER_MAPPINGS
+	{
+		strcpy(UM.RDB$USER, user.c_str());
+		strcpy(UM.RDB$FOREIGN_SERVER_NAME, server.c_str());
+	}
+	END_STORE
+
+	if (options.hasData())
+	{
+		for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+		{
+			if (options[cnt].value.hasData())
+			{
+				storeOption(tdbb, transaction, &options[cnt]);
+			}
+		}
+	}
+
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_CREATE_USER_MAPPING,
+		name, {});
+
+	DFW_post_work(transaction, dfw_clear_cache, {}, {}, Mapping::SYSTEM_PRIVILEGES_CACHE);
+}
+
+
+bool CreateAlterUserMappingNode::executeAlter(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch,
+	jrd_tra* transaction)
+{
+	Attachment* const attachment = transaction->getAttachment();
+
+	// User mapping to external servers by MED specification does not have a name,
+	// make a unique name from the user and server.
+	const QualifiedName name(getUniqueName());
+
+	bool found = false;
+	bool modified = false;
+
+	AutoCacheRequest requestHandle(tdbb, drq_m_u_mapping, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FUM IN RDB$FOREIGN_USER_MAPPINGS
+		WITH FUM.RDB$USER EQ user.c_str() AND
+		FUM.RDB$FOREIGN_SERVER_NAME EQ server.c_str()
+	{
+		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE, DDL_TRIGGER_ALTER_USER_MAPPING,
+			name, {});
+
+		found = true;
+	}
+	END_FOR
+
+	if (!found)
+		return found;
+
+	// Drop old options and insert the new ones
+	for (unsigned cnt = 0; cnt < options.getCount(); ++cnt)
+	{
+		if (DropUserMappingNode::dropOption(tdbb, transaction, user, server, options[cnt].name))
+			modified = true;
+
+		if (options[cnt].value.hasData())
+		{
+			storeOption(tdbb, transaction, &options[cnt]);
+
+			modified = true;
+		}
+	}
+
+	if (modified)
+	{
+		executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_ALTER_USER_MAPPING,
+			name, {});
+
+		DFW_post_work(transaction, dfw_clear_cache, {}, {}, Mapping::SYSTEM_PRIVILEGES_CACHE);
+	}
+
+	return found;
+}
+
+
+void CreateAlterUserMappingNode::storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option)
+{
+	Attachment* const attachment = transaction->getAttachment();
+
+	AutoCacheRequest requestHandle(tdbb, drq_s_u_mapping_opt, DYN_REQUESTS);
+
+	STORE (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FMO IN RDB$FOREIGN_MAPPING_OPTIONS
+	{
+		FMO.RDB$USER.NULL = FALSE;
+		strcpy(FMO.RDB$USER, user.c_str());
+
+		FMO.RDB$FOREIGN_SERVER_NAME.NULL = FALSE;
+		strcpy(FMO.RDB$FOREIGN_SERVER_NAME, server.c_str());
+
+		FMO.RDB$FOREIGN_OPTION_NAME.NULL = FALSE;
+		strcpy(FMO.RDB$FOREIGN_OPTION_NAME, option->name.c_str());
+
+		FMO.RDB$FOREIGN_OPTION_VALUE.NULL = FALSE;
+		strcpy(FMO.RDB$FOREIGN_OPTION_VALUE, option->value.c_str());
+
+		if (option->type == ExternalValueType::TYPE_STRING)
+			FMO.RDB$FOREIGN_OPTION_TYPE.NULL = TRUE;
+		else
+		{
+			FMO.RDB$FOREIGN_OPTION_TYPE.NULL = FALSE;
+			FMO.RDB$FOREIGN_OPTION_TYPE = option->type;
+		}
+	}
+	END_STORE
+}
+
+//----------------------
+
+
+string DropUserMappingNode::internalPrint(NodePrinter& printer) const
+{
+	DdlNode::internalPrint(printer);
+
+	NODE_PRINT(printer, user);
+	NODE_PRINT(printer, server);
+	NODE_PRINT(printer, silent);
+
+	return "DropUserMappingNode";
+}
+
+void DropUserMappingNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
+{
+	SCL_check_foreign_server(tdbb, server, SCL_usage);
+}
+
+void DropUserMappingNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
+{
+	// run all statements under savepoint control
+	AutoSavePoint savePoint(tdbb, transaction);
+	bool found = false;
+
+	// User mapping to external servers by MED specification does not have a name,
+	// make a unique name from the user and server.
+	const QualifiedName name(getUniqueName());
+
+	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_BEFORE, DDL_TRIGGER_DROP_USER_MAPPING,
+		name, {});
+
+	dropOptions(tdbb, transaction, user, server);
+
+	AutoCacheRequest requestHandle(tdbb, drq_drop_u_mapping, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FUM IN RDB$FOREIGN_USER_MAPPINGS
+		WITH FUM.RDB$USER EQ user.c_str() AND
+		FUM.RDB$FOREIGN_SERVER_NAME EQ server.c_str()
+	{
+
+		ERASE FUM;
+
+		found = true;
+	}
+	END_FOR
+
+	if (found)
+	{
+	 	executeDdlTrigger(tdbb, dsqlScratch, transaction, DTW_AFTER, DDL_TRIGGER_DROP_USER_MAPPING,
+			QualifiedName(user), {});
+	}
+
+	if (!found && !silent)
+		status_exception::raise(Arg::Gds(isc_dyn_user_mapping_not_found) << Arg::Str(user) << Arg::Str(server));
+
+	DFW_post_work(transaction, dfw_clear_cache, {}, {}, Mapping::SYSTEM_PRIVILEGES_CACHE);
+
+	savePoint.release();	// everything is ok
+}
+
+
+bool DropUserMappingNode::dropOption(thread_db* tdbb, jrd_tra* transaction, const MetaName& user,
+	const MetaName& server, const MetaName& optionName)
+{
+	AutoCacheRequest requestHandle(tdbb, drq_drop_u_mapping_opt, DYN_REQUESTS);
+	bool found = false;
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FMO IN RDB$FOREIGN_MAPPING_OPTIONS
+		WITH FMO.RDB$USER EQ user.c_str() AND
+		FMO.RDB$FOREIGN_SERVER_NAME EQ server.c_str() AND
+		FMO.RDB$FOREIGN_OPTION_NAME EQ optionName.c_str()
+	{
+		found = true;
+
+		ERASE FMO;
+	}
+	END_FOR
+
+	return found;
+}
+
+
+void DropUserMappingNode::dropOptions(thread_db* tdbb, jrd_tra* transaction, const MetaName& user,
+	const MetaName& server)
+{
+	AutoCacheRequest requestHandle(tdbb, drq_drop_u_m_opts, DYN_REQUESTS);
+
+	FOR (REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+		FMO IN RDB$FOREIGN_MAPPING_OPTIONS
+		WITH FMO.RDB$USER EQ user.c_str() AND
+		FMO.RDB$FOREIGN_SERVER_NAME EQ server.c_str()
+	{
+		ERASE FMO;
+	}
+	END_FOR
+}
+
+
+//----------------------
+
+
+string GrantRevokeNode::internalPrint(NodePrinter& printer) const
+{
+	DdlNode::internalPrint(printer);
+
+	NODE_PRINT(printer, isGrant);
+	NODE_PRINT(printer, privileges);
+	NODE_PRINT(printer, roles);
+	NODE_PRINT(printer, object);
+	NODE_PRINT(printer, users);
+	NODE_PRINT(printer, grantAdminOption);
+	NODE_PRINT(printer, grantor);
+	NODE_PRINT(printer, isDdl);
+
+	return "GrantRevokeNode";
+}
+
+void GrantRevokeNode::checkPermission(thread_db* tdbb, jrd_tra* transaction)
+{
+	// GRANT OPTION will be checked in grantRevoke method
+}
+
+void GrantRevokeNode::execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction)
+{
+	// run all statements under savepoint control
+	AutoSavePoint savePoint(tdbb, transaction);
+
+	createDbJobs.clear();
+
+	const GranteeClause* usersPtr;
+	const GranteeClause* usersEnd;
+
+	if (!isGrant && roles.isEmpty() && privileges.isEmpty() && !object)	// REVOKE ALL ON ALL
+	{
+		usersEnd = users.end();
+		for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
+			grantRevoke(tdbb, transaction, NULL, usersPtr, NULL, NULL, 0);
+	}
+	else
+	{
+		SSHORT option = 0; // no grant/admin option
+
+		if (roles.isEmpty())
+		{
+			if (grantAdminOption)
+				option = 1; // with grant option
+
+			usersEnd = users.end();
+			for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
+				modifyPrivileges(tdbb, transaction, option, usersPtr);
+		}
+		else
+		{
+			if (grantAdminOption)
+				option = 2; // with admin option
+
+			const GranteeClause* rolesPtr = roles.begin();
+			const GranteeClause* rolesEnd = roles.end();
+			const bool* defaultRolesPtr = defaultRoles.begin();
+			for (; rolesPtr != rolesEnd; ++rolesPtr, ++defaultRolesPtr)
+			{
+				usersEnd = users.end();
+				const bool defaultRole = *defaultRolesPtr;
+				for (usersPtr = users.begin(); usersPtr != usersEnd; ++usersPtr)
+					grantRevoke(tdbb, transaction, rolesPtr, usersPtr, "M", defaultRole ? "D" : NULL, option);
+			}
+
+			// Invalidate system privileges cache
+			DFW_post_work(transaction, dfw_clear_cache, {}, {}, Mapping::SYSTEM_PRIVILEGES_CACHE);
+		}
+	}
+
+	if (createDbJobs.hasData())
+		executeInSecurityDb(transaction);
+
+	savePoint.release();	// everything is ok
+}
+
+void GrantRevokeNode::runInSecurityDb(SecDbContext* secDbContext)
+{
+	for (unsigned n = 0; n < createDbJobs.getCount(); ++n)
+	{
+		CreateDbJob& j = createDbJobs[n];
+		LocalStatus st;
+		CheckStatusWrapper statusWrapper(&st);
+
+		Message result;
+		Field<ISC_INT64> cnt(result);
+
+		if (j.userType == obj_sql_role && (!j.allOnAll))
+		{
+			Message isRole;
+			Field<Varying> u(isRole, MAX_SQL_IDENTIFIER_LEN);
+			u = j.user.c_str();
+
+			const char* isRoleSql = "select count(*) from SYSTEM.RDB$ROLES where RDB$ROLE_NAME = ?";
+			secDbContext->att->execute(&statusWrapper, secDbContext->tra, 0, isRoleSql, SQL_DIALECT_V6,
+				isRole.getMetadata(), isRole.getBuffer(), result.getMetadata(), result.getBuffer());
+			check(&statusWrapper);
+
+			if (cnt == 0)
+			{
+				// msg 188: Role doesn't exist.
 				status_exception::raise(Arg::PrivateDyn(188) << j.user <<
 					Arg::Gds(isc_random) << "in security database");
 			}
@@ -12231,6 +13052,19 @@ static bool checkObjectExist(thread_db* tdbb, jrd_tra* transaction, const Qualif
 			END_FOR
 			break;
 		}
+
+		case obj_foreign_server:
+		{
+			AutoCacheRequest request(tdbb, drq_f_server_exist, DYN_REQUESTS);
+			FOR(REQUEST_HANDLE request TRANSACTION_HANDLE transaction)
+				X IN RDB$FOREIGN_SERVERS
+				WITH X.RDB$FOREIGN_SERVER_NAME EQ name.object.c_str()
+			{
+				rc = true;
+			}
+			END_FOR
+			break;
+		}
 	}
 
 	return rc;
@@ -12423,6 +13257,11 @@ void GrantRevokeNode::grantRevoke(thread_db* tdbb, jrd_tra* transaction, const G
 				status_exception::raise(Arg::PrivateDyn(188) << objName.toQuotedString());	// Role doesn't exist.
 			break;
 
+		case obj_foreign_server:
+			if (!checkObjectExist(tdbb, transaction, objName, objType))
+				status_exception::raise(Arg::PrivateDyn(326) << objName.toQuotedString());	// Foreign server @1 does not exist
+			break;
+
 		case obj_relations:
 		case obj_views:
 		case obj_procedures:
@@ -12643,6 +13482,7 @@ void GrantRevokeNode::grantRevoke(thread_db* tdbb, jrd_tra* transaction, const G
 					case obj_generator:
 					case obj_package_header:
 					case obj_schema:
+					case obj_foreign_server:
 					{
 						checkGrantorCanGrantObject(tdbb, transaction, currentUser.c_str(), priv, objName, objType);
 						break;
diff --git a/src/dsql/DdlNodes.h b/src/dsql/DdlNodes.h
index ab73673a487..5914c75413d 100644
--- a/src/dsql/DdlNodes.h
+++ b/src/dsql/DdlNodes.h
@@ -38,6 +38,7 @@
 #include "../common/classes/TriState.h"
 #include "../jrd/Savepoint.h"
 #include "../dsql/errd_proto.h"
+#include "../jrd/ForeignServer.h"
 
 namespace Jrd {
 
@@ -1316,6 +1317,17 @@ class RelationNode : public DdlNode
 		MetaName baseField;
 	};
 
+	class Option
+	{
+	public:
+		explicit Option(MemoryPool& p)
+			: value(p)
+		{}
+
+		MetaName name;
+		Firebird::string value;
+	};
+
 	struct IndexConstraintClause
 	{
 		explicit IndexConstraintClause(MemoryPool& p)
@@ -1405,10 +1417,12 @@ class RelationNode : public DdlNode
 			TYPE_ALTER_COL_NULL,
 			TYPE_ALTER_COL_POS,
 			TYPE_ALTER_COL_TYPE,
+			TYPE_ALTER_FOREIGN_COL,
 			TYPE_DROP_COLUMN,
 			TYPE_DROP_CONSTRAINT,
 			TYPE_ALTER_SQL_SECURITY,
-			TYPE_ALTER_PUBLICATION
+			TYPE_ALTER_PUBLICATION,
+			TYPE_ALTER_OPTIONS
 		};
 
 		explicit Clause(MemoryPool& p, Type aType) noexcept
@@ -1500,8 +1514,21 @@ class RelationNode : public DdlNode
 			  collate(p),
 			  computed(NULL),
 			  identityOptions(NULL),
-			  notNullSpecified(false)
+			  notNullSpecified(false),
+			  options(p)
+		{
+		}
+
+		void addOption(MetaName* name, Firebird::string* value = NULL)
 		{
+			fb_assert(name);
+
+			Option& option = options.add();
+			option.name = *name;
+			if (value)
+			{
+				option.value = *value;
+			}
 		}
 
 		dsql_fld* field;
@@ -1512,6 +1539,32 @@ class RelationNode : public DdlNode
 		NestConst<IdentityOptions> identityOptions;
 		bool notNullSpecified;
 		bool createIfNotExistsOnly = false;
+		Firebird::ObjectsArray<Option> options;
+	};
+
+	struct AlterForeignColumnClause : public Clause
+	{
+		explicit AlterForeignColumnClause(MemoryPool& p)
+			: Clause(p, TYPE_ALTER_FOREIGN_COL),
+			name(p),
+			options(p)
+		{
+		}
+
+		void addOption(MetaName* name, Firebird::string* value = NULL)
+		{
+			fb_assert(name);
+
+			Option& option = options.add();
+			option.name = *name;
+			if (value)
+			{
+				option.value = *value;
+			}
+		}
+
+		MetaName name;
+		Firebird::ObjectsArray<Option> options;
 	};
 
 	struct AlterColNameClause : public Clause
@@ -1599,7 +1652,7 @@ class RelationNode : public DdlNode
 		bool silent = false;
 	};
 
-	RelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode);
+	RelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode, bool aForeign = false);
 
 	static bool deleteLocalField(thread_db* tdbb, jrd_tra* transaction,
 		const QualifiedName& relationName, const MetaName& fieldName, bool silent,
@@ -1650,23 +1703,40 @@ class RelationNode : public DdlNode
 	void stuffDefaultBlr(const Firebird::ByteChunk& defaultBlr, BlrDebugWriter& blrWriter);
 	void stuffMatchingBlr(Constraint& constraint, BlrDebugWriter& blrWriter);
 	void stuffTriggerFiringCondition(const Constraint& constraint, BlrDebugWriter& blrWriter);
+	void storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option);
 
 public:
+	void addOption(MetaName* name, Firebird::string* value = NULL)
+	{
+		fb_assert(name);
+
+		Option& option = options.add();
+		option.name = *name;
+		if (value)
+		{
+			option.value = *value;
+		}
+	}
+
 	NestConst<RelationSourceNode> dsqlNode;
 	QualifiedName name;
 	Firebird::Array<NestConst<Clause> > clauses;
 	Firebird::TriState ssDefiner;
 	Firebird::TriState replicationState;
+	Firebird::ObjectsArray<Option> options;
+	bool foreign;
 };
 
 
-class CreateRelationNode final : public RelationNode
+class CreateRelationNode : public RelationNode
 {
 public:
 	CreateRelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode,
-				const Firebird::string* aExternalFile = NULL)
-		: RelationNode(p, aDsqlNode),
-		  externalFile(aExternalFile)
+				const Firebird::string* aExternalFile = NULL,
+				bool aForeign = false)
+		: RelationNode(p, aDsqlNode, aForeign),
+		  externalFile(aExternalFile),
+		  foreignServer(p)
 	{
 	}
 
@@ -1695,6 +1765,7 @@ class CreateRelationNode final : public RelationNode
 
 public:
 	const Firebird::string* externalFile;
+	MetaName foreignServer;
 	std::optional<rel_t> relationType = rel_persistent;
 	bool preserveRowsOpt = false;
 	bool deleteRowsOpt = false;
@@ -1702,11 +1773,27 @@ class CreateRelationNode final : public RelationNode
 };
 
 
-class AlterRelationNode final : public RelationNode
+class CreateForeignRelationNode final : public CreateRelationNode
+{
+public:
+	CreateForeignRelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode)
+		: CreateRelationNode(p, aDsqlNode, NULL, true)
+	{
+	}
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector << Firebird::Arg::Gds(isc_dsql_create_foreign_table_failed) << name.toQuotedString();
+	}
+};
+
+
+class AlterRelationNode : public RelationNode
 {
 public:
-	AlterRelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode)
-		: RelationNode(p, aDsqlNode)
+	AlterRelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode, bool aForeign = false)
+		: RelationNode(p, aDsqlNode, aForeign)
 	{
 	}
 
@@ -1736,19 +1823,39 @@ class AlterRelationNode final : public RelationNode
 };
 
 
-class DropRelationNode final : public DdlNode
+class AlterForeignRelationNode final : public AlterRelationNode
+{
+public:
+	AlterForeignRelationNode(MemoryPool& p, RelationSourceNode* aDsqlNode)
+		: AlterRelationNode(p, aDsqlNode, true)
+	{
+	}
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector << Firebird::Arg::Gds(isc_dsql_alter_foreign_table_failed) << name.toQuotedString();
+	}
+};
+
+
+class DropRelationNode : public DdlNode
 {
 public:
-	DropRelationNode(MemoryPool& p, const QualifiedName& aName, bool aView = false)
+	DropRelationNode(MemoryPool& p, const QualifiedName& aName, bool aView = false, bool aForeign = false)
 		: DdlNode(p),
 		  name(p, aName),
 		  view(aView),
-		  silent(false)
+		  silent(false),
+		  foreign(aForeign)
 	{
 	}
 
 	static void deleteGlobalField(thread_db* tdbb, jrd_tra* transaction, const QualifiedName& globalName);
 
+	static bool dropOption(thread_db* tdbb, jrd_tra* transaction, const QualifiedName& relation,
+		const MetaName& optionName);
+
 public:
 	Firebird::string internalPrint(NodePrinter& printer) const override;
 	void checkPermission(thread_db* tdbb, jrd_tra* transaction) override;
@@ -1779,12 +1886,43 @@ class DropRelationNode final : public DdlNode
 	bool view;
 	bool silent;
 	bool recreate = false;
+	bool foreign;
+};
+
+
+class DropForeignRelationNode final : public DropRelationNode
+{
+public:
+	DropForeignRelationNode(MemoryPool& p, const QualifiedName& aName)
+		: DropRelationNode(p, aName, false, true)
+	{
+	}
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector << Firebird::Arg::Gds(isc_dsql_drop_foreign_table_failed) << name.toQuotedString();
+	}
 };
 
 
 typedef RecreateNode<CreateRelationNode, DropRelationNode, isc_dsql_recreate_table_failed>
 	RecreateTableNode;
 
+template <>
+inline RecreateNode<CreateRelationNode, DropForeignRelationNode, isc_dsql_recreate_foreign_table_failed>::
+	RecreateNode(MemoryPool& p, CreateRelationNode* aCreateNode)
+		: DdlNode(p),
+			createNode(aCreateNode),
+			dropNode(p, createNode->name)
+	{
+		createNode->foreign = true;
+		dropNode.silent = true;
+	}
+
+typedef RecreateNode<CreateRelationNode, DropForeignRelationNode, isc_dsql_recreate_foreign_table_failed>
+	RecreateForeignTableNode;
+
 
 class CreateAlterViewNode final : public RelationNode
 {
@@ -2451,6 +2589,235 @@ typedef RecreateNode<CreateAlterUserNode, DropUserNode, isc_dsql_recreate_user_f
 	RecreateUserNode;
 
 
+class Option
+{
+public:
+	explicit Option(MemoryPool& p)
+		: value(p), type(ExternalValueType::TYPE_STRING)
+	{}
+
+	MetaName name;
+	Firebird::string value;
+	SSHORT type;
+};
+
+
+class CreateAlterForeignServerNode : public DdlNode
+{
+public:
+
+	CreateAlterForeignServerNode(MemoryPool& p, const MetaName& aName)
+		: DdlNode(p),
+		  name(p, aName),
+		  create(true),
+		  alter(false),
+		  plugin(p),
+		  options(p),
+		  dropType(false),
+		  dropVersion(false),
+		  dropPlugin(false)
+	{ }
+
+public:
+	virtual Firebird::string internalPrint(NodePrinter& printer) const;
+	virtual void checkPermission(thread_db* tdbb, jrd_tra* transaction);
+	virtual void execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector <<
+			Firebird::Arg::Gds(createAlterCode(create, alter,
+					isc_dsql_create_foreign_server_failed, isc_dsql_alter_foreign_server_failed,
+					isc_dsql_create_alter_foreign_server_failed)) <<
+				name.toQuotedString();
+	}
+
+public:
+	const MetaName name;
+	bool create;
+	bool alter;
+	bool createIfNotExistsOnly = false;
+	MetaName plugin;
+	Firebird::ObjectsArray<Option> options;
+	bool dropType;
+	bool dropVersion;
+	bool dropPlugin;
+
+	void addOption(MetaName* name, Firebird::string* value = NULL,
+		SSHORT type = ExternalValueType::TYPE_STRING)
+	{
+		fb_assert(name);
+
+		Option& option = options.add();
+		option.name = *name;
+		option.type = type;
+		if (value)
+		{
+			option.value = *value;
+		}
+	}
+
+private:
+	void executeCreate(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+	bool executeAlter(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+	void storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option);
+};
+
+
+class DropForeignServerNode : public DdlNode
+{
+public:
+	DropForeignServerNode(MemoryPool& p, const MetaName& aName, const MetaName* aPlugin = NULL)
+		: DdlNode(p),
+		  name(p, aName),
+		  plugin(p),
+		  silent(false),
+		  recreate(false)
+
+	{
+		if (aPlugin)
+			plugin = *aPlugin;
+	}
+
+public:
+	static bool dropOption(thread_db* tdbb, jrd_tra* transaction, const MetaName& serverName,
+		const MetaName& optionName);
+
+public:
+	virtual Firebird::string internalPrint(NodePrinter& printer) const;
+	virtual void checkPermission(thread_db* tdbb, jrd_tra* transaction);
+	virtual void execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+	void dropOptions(thread_db* tdbb, jrd_tra* transaction, const MetaName& serverName);
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector << Firebird::Arg::Gds(isc_dsql_drop_foreign_server_failed) << name;
+	}
+
+public:
+	const MetaName name;
+	MetaName plugin;
+	bool silent;
+	bool recreate;
+};
+
+
+typedef RecreateNode<CreateAlterForeignServerNode, DropForeignServerNode, isc_dsql_recreate_foreign_server_failed>
+	RecreateForeignServerNode;
+
+
+class CreateAlterUserMappingNode : public DdlNode
+{
+public:
+
+	CreateAlterUserMappingNode(MemoryPool& p, const MetaName& aUser, const MetaName& aServer)
+		: DdlNode(p),
+		  user(p, aUser),
+		  server(p, aServer),
+		  create(true),
+		  alter(false),
+		  options(p)
+	{ }
+
+public:
+	virtual Firebird::string internalPrint(NodePrinter& printer) const;
+	virtual void checkPermission(thread_db* tdbb, jrd_tra* transaction);
+	virtual void execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector <<
+			Firebird::Arg::Gds(createAlterCode(create, alter,
+					isc_dsql_create_user_mapping_failed, isc_dsql_alter_user_mapping_failed,
+					isc_dsql_create_alter_user_mapping_failed)) <<
+				user << server;
+	}
+
+public:
+	const MetaName user;
+	const MetaName server;
+	bool create;
+	bool alter;
+	Firebird::ObjectsArray<Option> options;
+
+	void addOption(MetaName* name, Firebird::string* value = NULL,
+		SSHORT type = ExternalValueType::TYPE_STRING)
+	{
+		fb_assert(name);
+
+		Option& option = options.add();
+		option.name = *name;
+		option.type = type;
+		if (value)
+		{
+			option.value = *value;
+		}
+	}
+
+private:
+	void executeCreate(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+	bool executeAlter(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+	void storeOption(thread_db* tdbb, jrd_tra* transaction, Option* option);
+
+	const MetaName getUniqueName() const
+	{
+		MetaName s;
+		s.printf("%s%s", user.c_str(), server.c_str());
+		return s;
+	};
+};
+
+
+class DropUserMappingNode : public DdlNode
+{
+public:
+	DropUserMappingNode(MemoryPool& p, const MetaName& aUser, const MetaName& aServer)
+		: DdlNode(p),
+		  user(p, aUser),
+		  server(p, aServer),
+		  silent(false)
+
+	{ }
+
+public:
+	static bool dropOption(thread_db* tdbb, jrd_tra* transaction, const MetaName& user, const MetaName& server,
+		const MetaName& optionName);
+
+public:
+	virtual Firebird::string internalPrint(NodePrinter& printer) const;
+	virtual void checkPermission(thread_db* tdbb, jrd_tra* transaction);
+	virtual void execute(thread_db* tdbb, DsqlCompilerScratch* dsqlScratch, jrd_tra* transaction);
+
+	void dropOptions(thread_db* tdbb, jrd_tra* transaction, const MetaName& user, const MetaName& server);
+
+protected:
+	virtual void putErrorPrefix(Firebird::Arg::StatusVector& statusVector)
+	{
+		statusVector << Firebird::Arg::Gds(isc_dsql_drop_user_mapping_failed) << user << server;
+	}
+
+public:
+	const MetaName user;
+	const MetaName server;
+	bool silent;
+
+private:
+	const Firebird::string getUniqueName() const
+	{
+		Firebird::string s;
+		s.append(user.c_str());
+		s.append(server.c_str());
+		return s;
+	};
+};
+
+
 typedef Firebird::NonPooledPair<char, Firebird::ObjectsArray<MetaName>*> PrivilegeClause;
 typedef Firebird::NonPooledPair<ObjectType, QualifiedName> GranteeClause;
 
@@ -2517,6 +2884,8 @@ class GrantRevokeNode final : public PrivilegesNode, private ExecInSecurityDb
 				case obj_jobs:
 				case obj_tablespaces:
 				case obj_schemas:
+				case obj_foreign_server:
+				case obj_foreign_servers:
 					break;
 
 				case obj_relations:
diff --git a/src/dsql/ExprNodes.cpp b/src/dsql/ExprNodes.cpp
index 85424f0e100..e1ba904ccf1 100644
--- a/src/dsql/ExprNodes.cpp
+++ b/src/dsql/ExprNodes.cpp
@@ -10660,7 +10660,8 @@ dsc* RecordKeyNode::execute(thread_db* /*tdbb*/, Request* request) const
 		const jrd_rel* relation = rpb->rpb_relation;
 
 		// If it doesn't point to a valid record, return NULL.
-		if (!rpb->rpb_number.isValid() || !relation || relation->isVirtual() || relation->rel_file)
+		if (!rpb->rpb_number.isValid() || !relation || relation->isVirtual() || relation->rel_file
+			|| relation->rel_foreign_adapter)
 		{
 			request->req_flags |= req_null;
 			return NULL;
diff --git a/src/dsql/StmtNodes.cpp b/src/dsql/StmtNodes.cpp
index 57026cc41d5..eb4b7901574 100644
--- a/src/dsql/StmtNodes.cpp
+++ b/src/dsql/StmtNodes.cpp
@@ -64,6 +64,8 @@
 #include "../dsql/make_proto.h"
 #include "../dsql/pass1_proto.h"
 #include "../dsql/DsqlStatementCache.h"
+#include "../jrd/ForeignServer.h"
+#include "../jrd/Mapping.h"
 
 using namespace Firebird;
 using namespace Jrd;
@@ -2604,6 +2606,8 @@ EraseNode* EraseNode::pass2(thread_db* tdbb, CompilerScratch* csb)
 
 	csb->csb_rpt[stream].csb_flags |= csb_update;
 
+	impureOffset = csb->allocImpure<Impure>();
+
 	return this;
 }
 
@@ -2654,7 +2658,8 @@ const StmtNode* EraseNode::execute(thread_db* tdbb, Request* request, ExeState*
 // Perform erase operation.
 const StmtNode* EraseNode::erase(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const
 {
-	impure_state* impure = request->getImpure<impure_state>(impureOffset);
+	Impure* impure = request->getImpure<Impure>(impureOffset);
+	impure_state* state = &impure->state;
 
 	jrd_tra* transaction = request->req_transaction;
 	record_param* rpb = &request->req_rpb[stream];
@@ -2681,9 +2686,9 @@ const StmtNode* EraseNode::erase(thread_db* tdbb, Request* request, WhichTrigger
 		}
 
 		case Request::req_return:
-			if (impure->sta_state == 1)
+			if (state->sta_state == 1)
 			{
-				impure->sta_state = 0;
+				state->sta_state = 0;
 				rpb->rpb_number.setValid(false);
 				return parentStmt;
 			}
@@ -2738,6 +2743,15 @@ const StmtNode* EraseNode::erase(thread_db* tdbb, Request* request, WhichTrigger
 		EXT_erase(rpb, transaction);
 	else if (relation->isVirtual())
 		VirtualTable::erase(tdbb, rpb);
+	else if (relation->rel_foreign_adapter)
+	{
+		if (!impure->statement)
+		{
+			impure->statement = relation->rel_foreign_adapter->createStatement(tdbb, rpb);
+			impure->statement->bindToRequest(request, &impure->statement);
+		}
+		relation->rel_foreign_adapter->execute(tdbb, impure->statement, rpb);
+	}
 	else if (!relation->rel_view_rse)
 	{
 		// VIO_erase returns false if:
@@ -2786,7 +2800,7 @@ const StmtNode* EraseNode::erase(thread_db* tdbb, Request* request, WhichTrigger
 
 	if (!relation->rel_view_rse)
 	{
-		if (!relation->rel_file && !relation->isVirtual())
+		if (!relation->rel_file && !relation->isVirtual() && !relation->rel_foreign_adapter)
 			IDX_erase(tdbb, rpb, transaction);
 
 		// Mark this rpb as already deleted to skip the subsequent attempts
@@ -2804,7 +2818,7 @@ const StmtNode* EraseNode::erase(thread_db* tdbb, Request* request, WhichTrigger
 
 	if (returningStatement)
 	{
-		impure->sta_state = 1;
+		state->sta_state = 1;
 		request->req_operation = Request::req_evaluate;
 		return returningStatement;
 	}
@@ -4116,6 +4130,18 @@ DmlNode* ExecStatementNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScr
 						node->role = PAR_parse_value(tdbb, csb);
 						break;
 
+					case blr_exec_stmt_ext_server:
+					{
+						csb->csb_blr_reader.getMetaName(node->server);
+						if (csb->collectingDependencies())
+						{
+							CompilerScratch::Dependency dependency(obj_foreign_server);
+							dependency.name = FB_NEW_POOL(pool) QualifiedName(pool, node->server);
+							csb->addDependency(dependency);
+						}
+						break;
+					}
+
 					case blr_exec_stmt_tran:
 						PAR_syntax_error(csb, "external transaction parameters");
 						break;
@@ -4259,6 +4285,7 @@ StmtNode* ExecStatementNode::dsqlPass(DsqlCompilerScratch* dsqlScratch)
 	node->role = doDsqlPass(dsqlScratch, role);
 	node->traScope = traScope;
 	node->useCallerPrivs = useCallerPrivs;
+	node->server = server;
 
 	return SavepointEncloseNode::make(dsqlScratch->getPool(), dsqlScratch, node);
 }
@@ -4271,6 +4298,7 @@ string ExecStatementNode::internalPrint(NodePrinter& printer) const
 	NODE_PRINT(printer, dsqlLabelNumber);
 	NODE_PRINT(printer, sql);
 	NODE_PRINT(printer, dataSource);
+	NODE_PRINT(printer, server);
 	NODE_PRINT(printer, userName);
 	NODE_PRINT(printer, password);
 	NODE_PRINT(printer, role);
@@ -4294,7 +4322,7 @@ void ExecStatementNode::genBlr(DsqlCompilerScratch* dsqlScratch)
 
 	// If no new features of EXECUTE STATEMENT are used, lets generate old BLR.
 	if (!dataSource && !userName && !password && !role && !useCallerPrivs && !inputs &&
-		 traScope == EDS::traNotSet)
+		 traScope == EDS::traNotSet && server.isEmpty())
 	{
 		if (outputs)
 		{
@@ -4354,6 +4382,13 @@ void ExecStatementNode::genBlr(DsqlCompilerScratch* dsqlScratch)
 		genOptionalExpr(dsqlScratch, blr_exec_stmt_pwd, password);
 		genOptionalExpr(dsqlScratch, blr_exec_stmt_role, role);
 
+		// Server
+		if (server.hasData())
+		{
+			dsqlScratch->appendUChar(blr_exec_stmt_ext_server);
+			dsqlScratch->appendMetaString(server.c_str());
+		}
+
 		// dsqlScratch's transaction behavior.
 		if (traScope != EDS::traNotSet)
 		{
@@ -4428,6 +4463,14 @@ ExecStatementNode* ExecStatementNode::pass1(thread_db* tdbb, CompilerScratch* cs
 	doPass1(tdbb, csb, innerStmt.getAddress());
 	doPass1(tdbb, csb, inputs.getAddress());
 	doPass1(tdbb, csb, outputs.getAddress());
+
+	if (server.hasData())
+	{
+		AutoPtr<ForeignServer> foreignServer = MET_get_foreign_server(tdbb, server);
+		CMP_post_access(tdbb, csb, foreignServer->getSecurityClass(), 0, SCL_usage, obj_foreign_servers,
+			QualifiedName(server));
+	}
+
 	return this;
 }
 
@@ -4466,6 +4509,7 @@ const StmtNode* ExecStatementNode::execute(thread_db* tdbb, Request* request, Ex
 	{
 		fb_assert(!*stmtPtr);
 
+		// Explicitly specified connection properties have the highest priority.
 		string sSql;
 		getString(tdbb, request, sql, sSql, true);
 
@@ -4481,7 +4525,59 @@ const StmtNode* ExecStatementNode::execute(thread_db* tdbb, Request* request, Ex
 		string sRole;
 		getString(tdbb, request, role, sRole);
 
-		EDS::Connection* conn = EDS::Manager::getConnection(tdbb, sDataSrc, sUser, sPwd, sRole, traScope);
+		PathName sProviders;
+
+		if (server.hasData())
+		{
+			AutoPtr<ForeignServer> foreignServer = MET_get_foreign_server(tdbb, server);
+
+			Database* const dbb = tdbb->getDatabase();
+			Jrd::Attachment* attachment = tdbb->getAttachment();
+			const string currentUser = attachment->getUserName();
+			const string fServer = server.c_str();
+			Mapping mapping(Mapping::MAP_NO_FLAGS, NULL);
+
+			// If there is mapping for user and foreign server,
+			// get a map of the connection parameters, skipping the explicitly specified properties earlier.
+			GenericMap<MetaStringOptionPair>* foreignMap;
+			ForeignOption option(*getDefaultMemoryPool());
+			if (mapping.getForeignUserMap(attachment, currentUser, fServer, foreignMap))
+			{
+				if (sDataSrc.isEmpty() && foreignMap->get(FOREIGN_SERVER_CONNECTION_STRING, option))
+					sDataSrc = option.getActualValue();
+
+				if (sUser.isEmpty() && foreignMap->get(FOREIGN_SERVER_USER, option))
+					sUser = option.getActualValue();
+
+				if (sPwd.isEmpty() && foreignMap->get(FOREIGN_SERVER_PASSWORD, option))
+					sPwd = option.getActualValue();
+
+				if (sRole.isEmpty() && foreignMap->get(FOREIGN_SERVER_ROLE, option))
+					sRole = option.getActualValue();
+			}
+
+			// The connection properties specified in foreign server options have the lowest priority.
+			const auto& options = foreignServer.get()->getOptions();
+			if (sDataSrc.isEmpty() && options.get(MetaName(FOREIGN_SERVER_CONNECTION_STRING), option))
+				sDataSrc = option.getActualValue();
+
+			if (sUser.isEmpty() && options.get(MetaName(FOREIGN_SERVER_USER), option))
+				sUser = option.getActualValue();
+
+			if (sPwd.isEmpty() && options.get(MetaName(FOREIGN_SERVER_PASSWORD), option))
+				sPwd = option.getActualValue();
+
+			if (sRole.isEmpty() && options.get(MetaName(FOREIGN_SERVER_ROLE), option))
+				sRole = option.getActualValue();
+
+			if (!foreignServer.get()->getPluginName().isEmpty())
+			{
+				sProviders = foreignServer.get()->getPluginName().c_str();
+				sProviders.insert(0, "Providers=");
+			}
+		}
+
+		EDS::Connection* conn = EDS::Manager::getConnection(tdbb, sDataSrc, sUser, sPwd, sRole, sProviders, traScope);
 
 		stmt = conn->createStatement(sSql);
 		stmt->bindToRequest(request, stmtPtr);
@@ -5977,7 +6073,7 @@ void ForNode::setWriteLockMode(Request* request) const
 void ForNode::checkRecordUpdated(thread_db* tdbb, Request* request, record_param* rpb) const
 {
 	jrd_rel* relation = rpb->rpb_relation;
-	if (!(marks & MARK_MERGE) || relation->isVirtual() || relation->rel_file || relation->rel_view_rse)
+	if (!(marks & MARK_MERGE) || !relation->isPageBased())
 		return;
 
 	ImpureMerge* impure = request->getImpure<ImpureMerge>(impureOffset);
@@ -5992,7 +6088,7 @@ void ForNode::checkRecordUpdated(thread_db* tdbb, Request* request, record_param
 void ForNode::setRecordUpdated(thread_db* tdbb, Request* request, record_param* rpb) const
 {
 	jrd_rel* relation = rpb->rpb_relation;
-	if (!(marks & MARK_MERGE) || relation->isVirtual() || relation->rel_file || relation->rel_view_rse)
+	if (!(marks & MARK_MERGE) || !relation->isPageBased())
 		return;
 
 	ImpureMerge* impure = request->getImpure<ImpureMerge>(impureOffset);
@@ -8150,20 +8246,21 @@ ModifyNode* ModifyNode::pass2(thread_db* tdbb, CompilerScratch* csb)
 	if (!(marks & StmtNode::MARK_POSITIONED))
 		forNode = pass2FindForNode(parentStmt, orgStream);
 
-	impureOffset = csb->allocImpure<impure_state>();
+	impureOffset = csb->allocImpure<Impure>();
 
 	return this;
 }
 
 const StmtNode* ModifyNode::execute(thread_db* tdbb, Request* request, ExeState* exeState) const
 {
-	impure_state* impure = request->getImpure<impure_state>(impureOffset);
+	Impure* impure = request->getImpure<Impure>(impureOffset);
+	impure_state* state = &impure->state;
 	const StmtNode* retNode;
 
 	if (request->req_operation == Request::req_unwind)
 		return parentStmt;
 
-	if (request->req_operation == Request::req_return && !impure->sta_state && subMod)
+	if (request->req_operation == Request::req_return && !state->sta_state && subMod)
 	{
 		if (!exeState->topNode)
 		{
@@ -8205,7 +8302,8 @@ const StmtNode* ModifyNode::execute(thread_db* tdbb, Request* request, ExeState*
 const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const
 {
 	jrd_tra* transaction = request->req_transaction;
-	impure_state* impure = request->getImpure<impure_state>(impureOffset);
+	Impure* impure = request->getImpure<Impure>(impureOffset);
+	impure_state* state = &impure->state;
 
 	record_param* orgRpb = &request->req_rpb[orgStream];
 	jrd_rel* relation = orgRpb->rpb_relation;
@@ -8218,16 +8316,16 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 			if (!(marks & MARK_AVOID_COUNTERS))
 				request->req_records_affected.bumpModified(false);
 
-			if (impure->sta_state == 0 && forNode && forNode->isWriteLockMode(request))
+			if (state->sta_state == 0 && forNode && forNode->isWriteLockMode(request))
 				request->req_operation = Request::req_return;
 			else
 				break;
 			[[fallthrough]];
 
 		case Request::req_return:
-			if (impure->sta_state == 1)
+			if (state->sta_state == 1)
 			{
-				impure->sta_state = 0;
+				state->sta_state = 0;
 				Record* orgRecord = orgRpb->rpb_record;
 				const Record* newRecord = newRpb->rpb_record;
 				orgRecord->copyDataFrom(newRecord, true);
@@ -8235,7 +8333,7 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 				return statement;
 			}
 
-			if (impure->sta_state == 0)
+			if (state->sta_state == 0)
 			{
 				if (forNode && forNode->isWriteLockMode(request))
 				{
@@ -8265,6 +8363,15 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 					EXT_modify(orgRpb, newRpb, transaction);
 				else if (relation->isVirtual())
 					VirtualTable::modify(tdbb, orgRpb, newRpb);
+				else if (relation->rel_foreign_adapter)
+				{
+					if (!impure->statement)
+					{
+						impure->statement = relation->rel_foreign_adapter->createStatement(tdbb, orgRpb, newRpb);
+						impure->statement->bindToRequest(request, &impure->statement);
+					}
+					relation->rel_foreign_adapter->execute(tdbb, impure->statement, orgRpb, newRpb);
+				}
 				else if (!relation->rel_view_rse)
 				{
 					// VIO_modify returns false if:
@@ -8309,7 +8416,7 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 				// have fired.  This is required for cascading referential integrity,
 				// which can be implemented as post_erase triggers.
 
-				if (!relation->rel_file && !relation->rel_view_rse && !relation->isVirtual())
+				if (relation->isPageBased())
 					IDX_modify_check_constraints(tdbb, orgRpb, newRpb, transaction);
 
 				if (!relation->rel_view_rse ||
@@ -8324,7 +8431,7 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 
 				if (statement2)
 				{
-					impure->sta_state = 2;
+					state->sta_state = 2;
 					request->req_operation = Request::req_evaluate;
 					return statement2;
 				}
@@ -8342,7 +8449,7 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 			return parentStmt;
 	}
 
-	impure->sta_state = 0;
+	state->sta_state = 0;
 	RLCK_reserve_relation(tdbb, transaction, relation, true);
 
 	if (orgRpb->rpb_runtime_flags & RPB_just_deleted)
@@ -8403,7 +8510,7 @@ const StmtNode* ModifyNode::modify(thread_db* tdbb, Request* request, WhichTrigg
 
 	if (mapView)
 	{
-		impure->sta_state = 1;
+		state->sta_state = 1;
 		return mapView;
 	}
 
@@ -9234,17 +9341,18 @@ StoreNode* StoreNode::pass2(thread_db* tdbb, CompilerScratch* csb)
 		ExprNode::doPass2(tdbb, csb, i->value.getAddress());
 	}
 
-	impureOffset = csb->allocImpure<impure_state>();
+	impureOffset = csb->allocImpure<Impure>();
 
 	return this;
 }
 
 const StmtNode* StoreNode::execute(thread_db* tdbb, Request* request, ExeState* exeState) const
 {
-	impure_state* impure = request->getImpure<impure_state>(impureOffset);
+	Impure* impure = request->getImpure<Impure>(impureOffset);
+	impure_state* state = &impure->state;
 	const StmtNode* retNode;
 
-	if (request->req_operation == Request::req_return && !impure->sta_state && subStore)
+	if (request->req_operation == Request::req_return && !state->sta_state && subStore)
 	{
 		if (!exeState->topNode)
 		{
@@ -9286,7 +9394,8 @@ const StmtNode* StoreNode::execute(thread_db* tdbb, Request* request, ExeState*
 const StmtNode* StoreNode::store(thread_db* tdbb, Request* request, WhichTrigger whichTrig) const
 {
 	jrd_tra* transaction = request->req_transaction;
-	impure_state* impure = request->getImpure<impure_state>(impureOffset);
+	Impure* impure = request->getImpure<Impure>(impureOffset);
+	impure_state* state = &impure->state;
 
 	const StreamType stream = target->getStream();
 	record_param* rpb = &request->req_rpb[stream];
@@ -9312,13 +9421,13 @@ const StmtNode* StoreNode::store(thread_db* tdbb, Request* request, WhichTrigger
 				request->req_records_affected.bumpModified(false);
 			}
 
-			impure->sta_state = 0;
+			state->sta_state = 0;
 			if (relation)
 				RLCK_reserve_relation(tdbb, transaction, relation, true);
 			break;
 
 		case Request::req_return:
-			if (!impure->sta_state)
+			if (!state->sta_state)
 			{
 				SavepointChangeMarker scMarker(transaction);
 
@@ -9346,6 +9455,15 @@ const StmtNode* StoreNode::store(thread_db* tdbb, Request* request, WhichTrigger
 					EXT_store(tdbb, rpb);
 				else if (relation->isVirtual())
 					VirtualTable::store(tdbb, rpb);
+				else if (relation->rel_foreign_adapter)
+				{
+					if (!impure->statement)
+					{
+						impure->statement = relation->rel_foreign_adapter->createStatement(tdbb, NULL, rpb);
+						impure->statement->bindToRequest(request, &impure->statement);
+					}
+					relation->rel_foreign_adapter->execute(tdbb, impure->statement, NULL, rpb);
+				}
 				else if (!relation->rel_view_rse)
 				{
 					VIO_store(tdbb, rpb, transaction);
@@ -9374,7 +9492,7 @@ const StmtNode* StoreNode::store(thread_db* tdbb, Request* request, WhichTrigger
 
 				if (statement2)
 				{
-					impure->sta_state = 1;
+					state->sta_state = 1;
 					request->req_operation = Request::req_evaluate;
 					return statement2;
 				}
diff --git a/src/dsql/StmtNodes.h b/src/dsql/StmtNodes.h
index 4d1d4936a02..664bb639900 100644
--- a/src/dsql/StmtNodes.h
+++ b/src/dsql/StmtNodes.h
@@ -515,6 +515,13 @@ class DeclareVariableNode final : public TypedNode<StmtNode, StmtNode::TYPE_DECL
 
 class EraseNode final : public TypedNode<StmtNode, StmtNode::TYPE_ERASE>
 {
+private:
+	struct Impure
+	{
+		impure_state state;
+		EDS::Statement* statement;
+	};
+
 public:
 	explicit EraseNode(MemoryPool& pool)
 		: TypedNode<StmtNode, StmtNode::TYPE_ERASE>(pool),
@@ -646,7 +653,8 @@ class ExecStatementNode final : public TypedNode<StmtNode, StmtNode::TYPE_EXEC_S
 		  excessInputs(NULL),
 		  dsqlLabelNumber(0),
 		  useCallerPrivs(false),
-		  traScope(EDS::traNotSet)	// not defined
+		  traScope(EDS::traNotSet),	// not defined
+		  server(pool)
 	{
 	}
 
@@ -681,6 +689,7 @@ class ExecStatementNode final : public TypedNode<StmtNode, StmtNode::TYPE_EXEC_S
 	USHORT dsqlLabelNumber;
 	bool useCallerPrivs;
 	EDS::TraScope traScope;
+	MetaName server;
 };
 
 
@@ -1208,6 +1217,13 @@ class MessageNode : public TypedNode<StmtNode, StmtNode::TYPE_MESSAGE>
 
 class ModifyNode final : public TypedNode<StmtNode, StmtNode::TYPE_MODIFY>
 {
+private:
+	struct Impure
+	{
+		impure_state state;
+		EDS::Statement* statement;
+	};
+
 public:
 	explicit ModifyNode(MemoryPool& pool)
 		: TypedNode<StmtNode, StmtNode::TYPE_MODIFY>(pool),
@@ -1343,6 +1359,13 @@ class ReceiveNode final : public TypedNode<StmtNode, StmtNode::TYPE_RECEIVE>
 
 class StoreNode final : public TypedNode<StmtNode, StmtNode::TYPE_STORE>
 {
+private:
+	struct Impure
+	{
+		impure_state state;
+		EDS::Statement* statement;
+	};
+
 public:
 	explicit StoreNode(MemoryPool& pool)
 		: TypedNode<StmtNode, StmtNode::TYPE_STORE>(pool),
diff --git a/src/dsql/dsql.h b/src/dsql/dsql.h
index 1a9c9b90181..2fef7a8151f 100644
--- a/src/dsql/dsql.h
+++ b/src/dsql/dsql.h
@@ -167,11 +167,12 @@ class dsql_rel : public pool_alloc<dsql_type_rel>
 
 // rel_flags bits
 enum rel_flags_vals {
-	REL_new_relation	= 1, // relation exists in sys tables, not committed yet
-	REL_dropped			= 2, // relation has been dropped
-	REL_view			= 4, // relation is a view
-	REL_external		= 8, // relation is an external table
-	REL_creating		= 16 // we are creating the bare relation in memory
+	REL_new_relation	= 1,  // relation exists in sys tables, not committed yet
+	REL_dropped			= 2,  // relation has been dropped
+	REL_view			= 4,  // relation is a view
+	REL_external		= 8,  // relation is an external table
+	REL_creating		= 16, // we are creating the bare relation in memory
+	REL_foreign		= 32  // relation is a foreign table
 };
 
 class TypeClause
diff --git a/src/dsql/metd.epp b/src/dsql/metd.epp
index b6ff06615ea..1274252e5e5 100644
--- a/src/dsql/metd.epp
+++ b/src/dsql/metd.epp
@@ -1272,6 +1272,8 @@ dsql_rel* METD_get_relation(jrd_tra* transaction, DsqlCompilerScratch* dsqlScrat
 				relation->rel_flags |= REL_view;
 			if (!X.RDB$EXTERNAL_FILE.NULL)
 				relation->rel_flags |= REL_external;
+			if (!X.RDB$FOREIGN_SERVER_NAME.NULL)
+				relation->rel_flags |= REL_foreign;
 		}
 	}
 	END_FOR
diff --git a/src/dsql/parse-conflicts.txt b/src/dsql/parse-conflicts.txt
index dea420bc00c..eb657237c98 100644
--- a/src/dsql/parse-conflicts.txt
+++ b/src/dsql/parse-conflicts.txt
@@ -1 +1 @@
-133 shift/reduce conflicts, 13 reduce/reduce conflicts.
+145 shift/reduce conflicts, 13 reduce/reduce conflicts.
diff --git a/src/dsql/parse.y b/src/dsql/parse.y
index beb79abf85c..c25982a3f4b 100644
--- a/src/dsql/parse.y
+++ b/src/dsql/parse.y
@@ -715,6 +715,10 @@ using namespace Firebird;
 %token <metaNamePtr> SCHEMA
 %token <metaNamePtr> SEARCH_PATH
 %token <metaNamePtr> UNLIST
+%token <metaNamePtr> SERVER
+%token <metaNamePtr> OPTIONS
+%token <metaNamePtr> ENV
+%token <metaNamePtr> WRAPPER
 
 // precedence declarations for expression evaluation
 
@@ -836,6 +840,7 @@ using namespace Firebird;
 	Jrd::RelationNode::RefActionClause* refActionClause;
 	Jrd::RelationNode::IndexConstraintClause* indexConstraintClause;
 	Jrd::RelationNode::IdentityOptions* identityOptions;
+	Jrd::RelationNode::AlterForeignColumnClause* alterForeignColumnClause;
 	IdentityType identityType;
 	Jrd::CreateRelationNode* createRelationNode;
 	Jrd::CreateAlterViewNode* createAlterViewNode;
@@ -874,6 +879,9 @@ using namespace Firebird;
 	Jrd::SetBindNode* setBindNode;
 	Jrd::SessionResetNode* sessionResetNode;
 	Jrd::ForRangeNode::Direction forRangeDirection;
+	Jrd::CreateAlterForeignServerNode* createAlterForeignServerNode;
+	Jrd::CreateAlterUserMappingNode* createAlterUserMappingNode;
+	ExternalValueType extValueType;
 }
 
 %include types.y
@@ -1027,6 +1035,13 @@ grant0($node)
 			$node->grantAdminOption = $7;
 			$node->grantor = $8;
 		}
+	| usage_privilege(NOTRIAL(&$node->privileges)) ON FOREIGN SERVER symbol_foreign_server_name
+			TO non_role_grantee_list(NOTRIAL(&$node->users)) grant_option granted_by
+		{
+			$node->object = newNode<GranteeClause>(obj_foreign_server, QualifiedName(*$5));
+			$node->grantAdminOption = $8;
+			$node->grantor = $9;
+		}
 	/***
 	| usage_privilege(NOTRIAL(&$node->privileges)) ON DOMAIN symbol_domain_name
 			TO non_role_grantee_list(NOTRIAL(&$node->users)) grant_option granted_by
@@ -1111,6 +1126,8 @@ schemaless_object
 		{ $$ = newNode<GranteeClause>(obj_filters, QualifiedName(getDdlSecurityName(obj_filters))); }
 	| SCHEMA
 		{ $$ = newNode<GranteeClause>(obj_schemas, QualifiedName(getDdlSecurityName(obj_schemas))); }
+	| SERVER
+		{ $$ = newNode<GranteeClause>(obj_foreign_servers, QualifiedName(getDdlSecurityName(obj_foreign_servers))); }
 	;
 
 table_noise
@@ -1321,6 +1338,13 @@ revoke0($node)
 			$node->grantAdminOption = $1;
 			$node->grantor = $8;
 		}
+	| rev_grant_option usage_privilege(NOTRIAL(&$node->privileges)) ON FOREIGN SERVER symbol_foreign_server_name
+			FROM non_role_grantee_list(NOTRIAL(&$node->users)) granted_by
+		{
+			$node->object = newNode<GranteeClause>(obj_foreign_server, QualifiedName(*$6));
+			$node->grantAdminOption = $1;
+			$node->grantor = $9;
+		}
 	/***
 	| rev_grant_option usage_privilege(NOTRIAL(&$node->privileges)) ON DOMAIN symbol_domain_name
 			FROM non_role_grantee_list(NOTRIAL(&$node->users)) granted_by
@@ -1653,6 +1677,12 @@ create_clause
 			node->createIfNotExistsOnly = $4;
 			$$ = node;
 		}
+	| FOREIGN TABLE if_not_exists_opt foreign_table_clause
+		{
+			const auto node = $4;
+			node->createIfNotExistsOnly = $3;
+			$$ = node;
+		}
 	| TRIGGER if_not_exists_opt trigger_clause
 		{
 			const auto node = $3;
@@ -1739,6 +1769,13 @@ create_clause
 			node->createIfNotExistsOnly = $2;
 			$$ = node;
 		}
+	| SERVER if_not_exists_opt create_foreign_server_clause
+		{
+			const auto node = $3;
+			node->createIfNotExistsOnly = $2;
+			$$ = node;
+		}
+	| USER MAPPING FOR create_foreign_user_mapping_clause	{ $$ = $4; }
 	;
 
 
@@ -1757,6 +1794,8 @@ recreate_clause
 		{ $$ = newNode<RecreateTableNode>($2); }
 	| GLOBAL TEMPORARY TABLE gtt_table_clause
 		{ $$ = newNode<RecreateTableNode>($4); }
+	| FOREIGN TABLE foreign_table_clause
+		{ $$ = newNode<RecreateForeignTableNode>($3); }
 	| VIEW view_clause
 		{ $$ = newNode<RecreateViewNode>($2); }
 	| TRIGGER trigger_clause
@@ -1775,6 +1814,8 @@ recreate_clause
 		{ $$ = newNode<RecreateUserNode>($2); }
 	| SCHEMA schema_clause
 		{ $$ = newNode<RecreateSchemaNode>($2); }
+	| SERVER create_foreign_server_clause
+		{ $$ = newNode<RecreateForeignServerNode>($2); }
 	;
 
 %type <ddlNode> create_or_alter
@@ -2432,6 +2473,23 @@ gtt_op($createRelationNode)
 		{ setClause($createRelationNode->relationType, "ON COMMIT PRESERVE ROWS", rel_global_temp_preserve); }
 	;
 
+%type <createRelationNode> foreign_table_clause
+foreign_table_clause
+	: simple_table_name
+			{
+				$<createRelationNode>$ = newNode<CreateForeignRelationNode>($1);
+			}
+		'(' foreign_table_elements($2) ')' SERVER valid_symbol_name
+			{
+				$$ = $2;
+				$$->foreignServer = *$7;
+			}
+		create_foreign_table_fixed_list_opt($8)
+			{
+				$$ = $8;
+			}
+	;
+
 %type <stringPtr> external_file
 external_file
 	: /* nothing */					{ $$ = NULL; }
@@ -2451,10 +2509,28 @@ table_element($createRelationNode)
 	| table_constraint_definition($createRelationNode)
 	;
 
+%type foreign_table_elements(<createRelationNode>)
+foreign_table_elements($createRelationNode)
+	: foreign_table_element($createRelationNode)
+	| foreign_table_elements ',' foreign_table_element($createRelationNode)
+	;
+
+%type foreign_table_element(<createRelationNode>)
+foreign_table_element($createRelationNode)
+	: basic_column_def($createRelationNode) create_foreign_column_fixed_list_opt($1)
+	| table_constraint_definition($createRelationNode)
+	;
+
 // column definition
 
 %type <addColumnClause> column_def(<relationNode>)
 column_def($relationNode)
+	: basic_column_def($relationNode) { $$ = $1; }
+	| computed_column_def($relationNode) { $$ = $1; }
+	;
+
+%type <addColumnClause> basic_column_def(<relationNode>)
+basic_column_def($relationNode)
 	: symbol_column_name data_type_or_domain domain_default_opt
 			{
 				RelationNode::AddColumnClause* clause = $<addColumnClause>$ =
@@ -2483,7 +2559,11 @@ column_def($relationNode)
 				setCollate($2, $6);
 				$$ = $<addColumnClause>4;
 			}
-	| symbol_column_name non_array_type def_computed
+	;
+
+%type <addColumnClause> computed_column_def(<relationNode>)
+computed_column_def($relationNode)
+	: symbol_column_name non_array_type def_computed
 		{
 			RelationNode::AddColumnClause* clause = newNode<RelationNode::AddColumnClause>();
 			clause->field = $2;
@@ -2670,6 +2750,80 @@ column_constraint($addColumnClause)
 		}
 	;
 
+%type create_foreign_column_fixed_list_opt(<addColumnClause>)
+create_foreign_column_fixed_list_opt($addColumnClause)
+	: // nothing
+	| create_foreign_column_fixed_list($addColumnClause)
+	;
+
+%type create_foreign_column_fixed_list(<addColumnClause>)
+create_foreign_column_fixed_list($addColumnClause)
+	: create_foreign_column_fixed_option($addColumnClause)
+	| create_foreign_column_fixed_list create_foreign_column_fixed_option($addColumnClause)
+	;
+
+%type create_foreign_column_fixed_option(<addColumnClause>)
+create_foreign_column_fixed_option($addColumnClause)
+	: OPTIONS '(' create_foreign_column_var_list($addColumnClause) ')'
+	;
+
+%type create_foreign_column_var_list(<addColumnClause>)
+create_foreign_column_var_list($addColumnClause)
+	: create_foreign_column_var_option($addColumnClause)
+	| create_foreign_column_var_list ',' create_foreign_column_var_option($addColumnClause)
+	;
+
+%type create_foreign_column_var_option(<addColumnClause>)
+create_foreign_column_var_option($addColumnClause)
+	: symbol_foreign_option_name '=' utf_string
+		{
+			$addColumnClause->addOption($1, $3);
+		}
+	| symbol_foreign_option_name utf_string
+		{
+			$addColumnClause->addOption($1, $2);
+		}
+	;
+
+%type alter_foreign_column_fixed_list_opt(<alterForeignColumnClause>)
+alter_foreign_column_fixed_list_opt($alterForeignColumnClause)
+	: // nothing
+	| alter_foreign_column_fixed_list($alterForeignColumnClause)
+	;
+
+%type alter_foreign_column_fixed_list(<alterForeignColumnClause>)
+alter_foreign_column_fixed_list($alterForeignColumnClause)
+	: alter_foreign_column_fixed_option($alterForeignColumnClause)
+	| alter_foreign_column_fixed_list alter_foreign_column_fixed_option($alterForeignColumnClause)
+	;
+
+%type alter_foreign_column_fixed_option(<alterForeignColumnClause>)
+alter_foreign_column_fixed_option($alterForeignColumnClause)
+	: OPTIONS '(' alter_foreign_column_var_list($alterForeignColumnClause) ')'
+	;
+
+%type alter_foreign_column_var_list(<alterForeignColumnClause>)
+alter_foreign_column_var_list($alterForeignColumnClause)
+	: alter_foreign_column_var_option($alterForeignColumnClause)
+	| alter_foreign_column_var_list ',' alter_foreign_column_var_option($alterForeignColumnClause)
+	;
+
+%type alter_foreign_column_var_option(<alterForeignColumnClause>)
+alter_foreign_column_var_option($alterForeignColumnClause)
+	: symbol_foreign_option_name '=' utf_string
+		{
+			$alterForeignColumnClause->addOption($1, $3);
+		}
+	| symbol_foreign_option_name utf_string
+		{
+			$alterForeignColumnClause->addOption($1, $2);
+		}
+	| DROP symbol_foreign_option_name
+		{
+			$alterForeignColumnClause->addOption($2);
+		}
+	;
+
 
 // table constraints
 
@@ -2806,6 +2960,72 @@ referential_action
 	| NO ACTION		{ $$ = RelationNode::RefActionClause::ACTION_NONE; }
 	;
 
+%type create_foreign_table_fixed_list_opt(<relationNode>)
+create_foreign_table_fixed_list_opt($node)
+	: // nothing
+	| create_foreign_table_fixed_list($node)
+	;
+
+%type create_foreign_table_fixed_list(<relationNode>)
+create_foreign_table_fixed_list($node)
+	: create_foreign_table_fixed_option($node)
+	| create_foreign_table_fixed_list create_foreign_table_fixed_option($node)
+	;
+
+%type create_foreign_table_fixed_option(<relationNode>)
+create_foreign_table_fixed_option($node)
+	: OPTIONS '(' create_foreign_table_var_list($node) ')'
+	;
+
+%type create_foreign_table_var_list(<relationNode>)
+create_foreign_table_var_list($node)
+	: foreign_table_var_option($node)
+	| create_foreign_table_var_list ',' foreign_table_var_option($node)
+	;
+
+%type foreign_table_var_option(<relationNode>)
+foreign_table_var_option($node)
+	: symbol_foreign_option_name '=' utf_string
+		{
+			$node->addOption($1, $3);
+		}
+	| symbol_foreign_option_name utf_string
+		{
+			$node->addOption($1, $2);
+		}
+	;
+
+%type alter_foreign_table_fixed_list_opt(<relationNode>)
+alter_foreign_table_fixed_list_opt($node)
+	: // nothing
+	| alter_foreign_table_fixed_list($node)
+	;
+
+%type alter_foreign_table_fixed_list(<relationNode>)
+alter_foreign_table_fixed_list($node)
+	: alter_foreign_table_fixed_option($node)
+	| alter_foreign_table_fixed_list alter_foreign_table_fixed_option($node)
+	;
+
+%type alter_foreign_table_fixed_option(<relationNode>)
+alter_foreign_table_fixed_option($node)
+	: OPTIONS '(' alter_foreign_table_var_list($node) ')'
+	;
+
+%type alter_foreign_table_var_list(<relationNode>)
+alter_foreign_table_var_list($node)
+	: alter_foreign_table_var_option($node)
+	| alter_foreign_table_var_list ',' alter_foreign_table_var_option($node)
+	;
+
+%type alter_foreign_table_var_option(<relationNode>)
+alter_foreign_table_var_option($node)
+	: foreign_table_var_option($node)
+	| DROP symbol_foreign_option_name
+		{
+			$node->addOption($2);
+		}
+	;
 
 // PROCEDURE
 
@@ -3793,6 +4013,8 @@ exec_stmt_option($execStatementNode)
 		{ setClause($execStatementNode->dataSource, "EXTERNAL DATA SOURCE", $5); }
 	| ON EXTERNAL value
 		{ setClause($execStatementNode->dataSource, "EXTERNAL DATA SOURCE", $3); }
+	| ON EXTERNAL SERVER symbol_foreign_server_name
+		{ setClause($execStatementNode->server, "SERVER", *$4); }
 	| AS USER value
 		{ setClause($execStatementNode->userName, "USER", $3); }
 	| PASSWORD value
@@ -4325,6 +4547,12 @@ trigger_ddl_type_items
 	| CREATE MAPPING		{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_CREATE_MAPPING); }
 	| ALTER MAPPING			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_ALTER_MAPPING); }
 	| DROP MAPPING			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_DROP_MAPPING); }
+	| CREATE SERVER			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_CREATE_FOREIGN_SERVER); }
+	| ALTER SERVER			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_ALTER_FOREIGN_SERVER); }
+	| DROP SERVER			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_DROP_FOREIGN_SERVER); }
+	| CREATE USER MAPPING FOR		{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_CREATE_USER_MAPPING); }
+	| ALTER USER MAPPING FOR		{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_ALTER_USER_MAPPING); }
+	| DROP USER MAPPING FOR			{ $$ = TRIGGER_TYPE_DDL | (1LL << DDL_TRIGGER_DROP_USER_MAPPING); }
 	| trigger_ddl_type OR
 		trigger_ddl_type	{ $$ = $1 | $3; }
 	;
@@ -4375,6 +4603,10 @@ alter_clause
 			{ $$ = newNode<AlterRelationNode>($2); }
 		alter_ops($<relationNode>3)
 			{ $$ = $<relationNode>3; }
+	| FOREIGN TABLE simple_table_name
+			{ $$ = newNode<AlterForeignRelationNode>($3); }
+		foreign_alter_ops($<relationNode>4)
+			{ $$ = $<relationNode>4; }
 	| VIEW alter_view_clause				{ $$ = $2; }
 	| TRIGGER alter_trigger_clause			{ $$ = $2; }
 	| PROCEDURE alter_procedure_clause		{ $$ = $2; }
@@ -4398,6 +4630,8 @@ alter_clause
 	| GLOBAL MAPPING alter_map_clause(true)	{ $$ = $3; }
 	| EXTERNAL CONNECTIONS POOL alter_eds_conn_pool_clause	{ $$ = $4; }
 	| SCHEMA alter_schema_clause			{ $$ = $2; }
+	| SERVER alter_foreign_server_clause	{ $$ = $2; }
+	| USER MAPPING FOR alter_foreign_user_mapping_clause	{ $$ = $4; }
 	;
 
 %type <alterDomainNode> alter_domain
@@ -4606,6 +4840,42 @@ alter_op($relationNode)
 		}
 	;
 
+%type foreign_alter_ops(<relationNode>)
+foreign_alter_ops($relationNode)
+	: foreign_alter_op($relationNode)
+	| foreign_alter_ops ',' foreign_alter_op($relationNode)
+	;
+
+%type <alterForeignColumnClause> foreign_alter_op(<relationNode>)
+foreign_alter_op($relationNode)
+	: alter_op($relationNode)
+		{
+			$$ = NULL;
+		}
+	| alter_foreign_table_fixed_list_opt($relationNode)
+		{
+			RelationNode::Clause* clause =
+				newNode<RelationNode::Clause>(RelationNode::Clause::TYPE_ALTER_OPTIONS);
+			$relationNode->clauses.add(clause);
+		}
+	| ADD if_not_exists_opt column_def($relationNode) create_foreign_column_fixed_list_opt($3)
+		{
+			const auto node = $3;
+			node->createIfNotExistsOnly = $2;
+		}
+	| col_opt symbol_column_name
+		{
+			RelationNode::AlterForeignColumnClause* clause = newNode<RelationNode::AlterForeignColumnClause>();
+			clause->name = *$2;
+			$relationNode->clauses.add(clause);
+			$$ = clause;
+		}
+		alter_foreign_column_fixed_list_opt(NOTRIAL($<alterForeignColumnClause>3))
+		{
+			$$ = $<alterForeignColumnClause>3;
+		}
+	;
+
 %type <metaNamePtr> alter_column_name
 alter_column_name
 	: keyword_or_column
@@ -5030,6 +5300,12 @@ drop_clause
 			node->silent = $2;
 			$$ = node;
 		}
+	| FOREIGN TABLE if_exists_opt symbol_table_name
+		{
+			const auto node = newNode<DropForeignRelationNode>(*$4);
+			node->silent = $3;
+			$$ = node;
+		}
 	| TRIGGER if_exists_opt symbol_trigger_name
 		{
 			const auto node = newNode<DropTriggerNode>(*$3);
@@ -5138,6 +5414,18 @@ drop_clause
 			node->silent = $2;
 			$$ = node;
 		}
+	| SERVER if_exists_opt symbol_foreign_server_name
+		{
+			const auto node = newNode<DropForeignServerNode>(*$3);
+			node->silent = $2;
+			$$ = node;
+		}
+	| USER MAPPING FOR if_exists_opt symbol_user_name SERVER symbol_foreign_server_name
+		{
+			const auto node = newNode<DropUserMappingNode>(*$5, *$7);
+			node->silent = $4;
+			$$ = node;
+		}
 	;
 
 %type <boolVal> if_exists_opt
@@ -6226,6 +6514,7 @@ ddl_type1_noschema
 	: FILTER				{ $$ = obj_blob_filter; }
 	| ROLE					{ $$ = obj_sql_role; }
 	| SCHEMA				{ $$ = obj_schema; }
+	| SERVER				{ $$ = obj_foreign_server; }
 	;
 
 %type <intVal> ddl_type3
@@ -8049,6 +8338,238 @@ map_role
 	;
 
 
+// SERVER
+
+%type <createAlterForeignServerNode> create_foreign_server_clause
+create_foreign_server_clause
+	: symbol_foreign_server_name
+ 		{
+			$$ = newNode<CreateAlterForeignServerNode>(*$1);
+			$$->create = true;
+			$$->alter = false;
+		}
+	create_foreign_server_fixed_list_opt($2)
+		{
+			$$ = $2;
+		}
+	;
+
+%type <createAlterForeignServerNode> alter_foreign_server_clause
+alter_foreign_server_clause
+	: symbol_foreign_server_name
+		{
+			$$ = newNode<CreateAlterForeignServerNode>(*$1);
+			$$->create = false;
+			$$->alter = true;
+		}
+	alter_foreign_server_fixed_list_opt($2)
+		{
+			$$ = $2;
+		}
+	;
+
+%type create_foreign_server_fixed_list_opt(<createAlterForeignServerNode>)
+create_foreign_server_fixed_list_opt($node)
+	: // nothing
+	| create_foreign_server_fixed_list($node)
+	;
+
+%type create_foreign_server_fixed_list(<createAlterForeignServerNode>)
+create_foreign_server_fixed_list($node)
+	: create_foreign_server_fixed_option($node)
+	| create_foreign_server_fixed_list create_foreign_server_fixed_option($node)
+	;
+
+%type create_foreign_server_fixed_option(<createAlterForeignServerNode>)
+create_foreign_server_fixed_option($node)
+	: create_foreign_server_plugin($node)
+	| OPTIONS '(' create_foreign_server_var_list($node) ')'
+	;
+
+%type create_foreign_server_plugin(<createAlterForeignServerNode>)
+create_foreign_server_plugin($node)
+	: USING PLUGIN valid_symbol_name
+							{ setClause($node->plugin, "USING PLUGIN", *$3); }
+	| FOREIGN DATA WRAPPER valid_symbol_name
+							{ setClause($node->plugin, "FOREIGN DATA WRAPPER", *$4); }
+	;
+
+%type create_foreign_server_var_list(<createAlterForeignServerNode>)
+create_foreign_server_var_list($node)
+	: foreign_server_var_option($node)
+	| create_foreign_server_var_list ',' foreign_server_var_option($node)
+	;
+
+%type foreign_server_var_option(<createAlterForeignServerNode>)
+foreign_server_var_option($node)
+	: symbol_foreign_option_name '=' utf_string
+		{
+			$node->addOption($1, $3);
+		}
+	| symbol_foreign_option_name value_storage_type_opt utf_string
+		{
+			$node->addOption($1, $3, $2);
+		}
+	;
+
+%type alter_foreign_server_fixed_list_opt(<createAlterForeignServerNode>)
+alter_foreign_server_fixed_list_opt($node)
+	: // nothing
+	| alter_foreign_server_fixed_list($node)
+	;
+
+%type alter_foreign_server_fixed_list(<createAlterForeignServerNode>)
+alter_foreign_server_fixed_list($node)
+	: alter_foreign_server_fixed_option($node)
+	| alter_foreign_server_fixed_list alter_foreign_server_fixed_option($node)
+	;
+
+%type alter_foreign_server_fixed_option(<createAlterForeignServerNode>)
+alter_foreign_server_fixed_option($node)
+	: alter_foreign_server_plugin($node)
+	| OPTIONS '(' alter_foreign_server_var_list($node) ')'
+	;
+
+%type alter_foreign_server_plugin(<createAlterForeignServerNode>)
+alter_foreign_server_plugin($node)
+	: USING PLUGIN valid_symbol_name
+							{ setClause($node->plugin, "USING PLUGIN", *$3); }
+	| DROP USING PLUGIN { setClause($node->dropPlugin, "DROP USING PLUGIN"); }
+	| FOREIGN DATA WRAPPER valid_symbol_name
+							{ setClause($node->plugin, "FOREIGN DATA WRAPPER", *$4); }
+	| DROP FOREIGN DATA WRAPPER
+							{ setClause($node->dropPlugin, "DROP FOREIGN DATA WRAPPER"); }
+	;
+
+%type alter_foreign_server_var_list(<createAlterForeignServerNode>)
+alter_foreign_server_var_list($node)
+	: alter_foreign_server_var_option($node)
+	| alter_foreign_server_var_list ',' alter_foreign_server_var_option($node)
+	;
+
+%type alter_foreign_server_var_option(<createAlterForeignServerNode>)
+alter_foreign_server_var_option($node)
+	: foreign_server_var_option($node)
+	| DROP symbol_foreign_option_name
+		{
+			$node->addOption($2);
+		}
+	;
+
+
+// USER MAPPING
+
+%type <createAlterUserMappingNode> foreign_user_mapping_clause
+foreign_user_mapping_clause
+	: symbol_user_name SERVER symbol_foreign_server_name
+ 		{
+			$$ = newNode<CreateAlterUserMappingNode>(*$1, *$3);
+		}
+	;
+
+%type <createAlterUserMappingNode> create_foreign_user_mapping_clause
+create_foreign_user_mapping_clause
+	: foreign_user_mapping_clause
+ 		{
+			$$ = $1;
+			$$->create = true;
+			$$->alter = false;
+		}
+	create_user_mapping_fixed_list_opt($2)
+		{
+			$$ = $2;
+		}
+	;
+
+%type <createAlterUserMappingNode> alter_foreign_user_mapping_clause
+alter_foreign_user_mapping_clause
+	: foreign_user_mapping_clause
+		{
+			$$ = $1;
+			$$->create = false;
+			$$->alter = true;
+		}
+	alter_user_mapping_fixed_list_opt($2)
+		{
+			$$ = $2;
+		}
+	;
+
+%type create_user_mapping_fixed_list_opt(<createAlterUserMappingNode>)
+create_user_mapping_fixed_list_opt($node)
+	: // nothing
+	| create_user_mapping_fixed_list($node)
+	;
+
+%type create_user_mapping_fixed_list(<createAlterUserMappingNode>)
+create_user_mapping_fixed_list($node)
+	: create_user_mapping_fixed_option($node)
+	| create_user_mapping_fixed_list create_user_mapping_fixed_option($node)
+	;
+
+%type create_user_mapping_fixed_option(<createAlterUserMappingNode>)
+create_user_mapping_fixed_option($node)
+	: OPTIONS '(' create_user_mapping_var_list($node) ')'
+	;
+
+%type create_user_mapping_var_list(<createAlterUserMappingNode>)
+create_user_mapping_var_list($node)
+	: user_mapping_var_option($node)
+	| create_user_mapping_var_list ',' user_mapping_var_option($node)
+	;
+
+%type user_mapping_var_option(<createAlterUserMappingNode>)
+user_mapping_var_option($node)
+	: symbol_foreign_option_name '=' utf_string
+		{
+			$node->addOption($1, $3);
+		}
+	| symbol_foreign_option_name value_storage_type_opt utf_string
+		{
+			$node->addOption($1, $3, $2);
+		}
+	;
+
+%type alter_user_mapping_fixed_list_opt(<createAlterUserMappingNode>)
+alter_user_mapping_fixed_list_opt($node)
+	: // nothing
+	| alter_user_mapping_fixed_list($node)
+	;
+
+%type alter_user_mapping_fixed_list(<createAlterUserMappingNode>)
+alter_user_mapping_fixed_list($node)
+	: alter_user_mapping_fixed_option($node)
+	| alter_user_mapping_fixed_list alter_user_mapping_fixed_option($node)
+	;
+
+%type alter_user_mapping_fixed_option(<createAlterUserMappingNode>)
+alter_user_mapping_fixed_option($node)
+	: OPTIONS '(' alter_user_mapping_var_list($node) ')'
+	;
+
+%type alter_user_mapping_var_list(<createAlterUserMappingNode>)
+alter_user_mapping_var_list($node)
+	: alter_user_mapping_var_option($node)
+	| alter_user_mapping_var_list ',' alter_user_mapping_var_option($node)
+	;
+
+%type alter_user_mapping_var_option(<createAlterUserMappingNode>)
+alter_user_mapping_var_option($node)
+	: user_mapping_var_option($node)
+	| DROP symbol_foreign_option_name
+		{
+			$node->addOption($2);
+		}
+	;
+
+%type <extValueType> value_storage_type_opt
+value_storage_type_opt
+	: { $$ = ExternalValueType::TYPE_STRING; }
+	| ENV { $$ = ExternalValueType::TYPE_ENV; }
+	| FILE { $$ = ExternalValueType::TYPE_FILE; }
+	;
+
+
 // value types
 
 %type <valueExprNode> value
@@ -9642,6 +10163,18 @@ symbol_window_name
 	: valid_symbol_name
 	;
 
+%type <metaNamePtr> symbol_foreign_server_name
+symbol_foreign_server_name
+	: valid_symbol_name
+	;
+
+%type <metaNamePtr> symbol_foreign_option_name
+symbol_foreign_option_name
+	: keyword_or_column
+	| USER
+	;
+
+
 // symbols
 
 %type <qualifiedNamePtr> schema_opt_qualified_name
@@ -9783,6 +10316,7 @@ non_reserved_word
 	| DO
 	| DOMAIN
 	| ENTRY_POINT
+	| ENV
 	| EXCEPTION
 	| EXIT
 	| FILE
@@ -9957,6 +10491,7 @@ non_reserved_word
 	| SEARCH_PATH
 	| SCHEMA
 	| UNLIST
+	| WRAPPER
 	;
 
 %%
diff --git a/src/dsql/pass1.cpp b/src/dsql/pass1.cpp
index eef4683975e..8a433f03556 100644
--- a/src/dsql/pass1.cpp
+++ b/src/dsql/pass1.cpp
@@ -1906,7 +1906,7 @@ static RseNode* pass1_rse_impl(DsqlCompilerScratch* dsqlScratch, RecordSourceNod
 			(streamList->items.getCount() != 1 ||
 				!(relNode = nodeAs<RelationSourceNode>(streamList->items[0])) ||
 				!(relation = relNode->dsqlContext->ctx_relation) ||
-				(relation->rel_flags & (REL_view | REL_external))))
+				(relation->rel_flags & (REL_view | REL_external | REL_foreign))))
 		{
 			ERRD_post(Arg::Gds(isc_sqlerr) << Arg::Num(-104) <<
 					  Arg::Gds(isc_dsql_wlock_simple));
diff --git a/src/gpre/pat.cpp b/src/gpre/pat.cpp
index 817ae409765..aabbed01908 100644
--- a/src/gpre/pat.cpp
+++ b/src/gpre/pat.cpp
@@ -179,7 +179,7 @@ void PATTERN_expand( USHORT column, const TEXT* pattern, PAT* args)
 	bool sw_gen = true;
 	p += align(p, column);
 
-	SSHORT value;				// value needs to be signed since some of the
+	int value;				// value needs to be signed since some of the
 								// values printed out are signed.
 	SLONG long_value;
 	TEXT c;
diff --git a/src/include/firebird/impl/blr.h b/src/include/firebird/impl/blr.h
index 6c4c9573aae..8e8faaf6e68 100644
--- a/src/include/firebird/impl/blr.h
+++ b/src/include/firebird/impl/blr.h
@@ -396,6 +396,7 @@
 #define blr_exec_stmt_out_params	(unsigned char) 13	// output parameters
 #define blr_exec_stmt_role			(unsigned char) 14
 #define blr_exec_stmt_in_excess		(unsigned char) 15  // excess input params numbers
+#define blr_exec_stmt_ext_server	(unsigned char) 16  // external server
 
 #define blr_stmt_expr				(unsigned char) 190
 #define blr_derived_expr			(unsigned char) 191
diff --git a/src/include/firebird/impl/consts_pub.h b/src/include/firebird/impl/consts_pub.h
index b10250b0822..0743ac36a33 100644
--- a/src/include/firebird/impl/consts_pub.h
+++ b/src/include/firebird/impl/consts_pub.h
@@ -138,6 +138,7 @@
 #define isc_dpb_search_path				 105
 #define isc_dpb_blr_request_search_path	 106
 #define isc_dpb_gbak_restore_has_schema	 107
+#define isc_dpb_foreign_options			 108
 
 
 /**************************************************/
diff --git a/src/include/firebird/impl/inf_pub.h b/src/include/firebird/impl/inf_pub.h
index 8d75871539e..e0da037fd0b 100644
--- a/src/include/firebird/impl/inf_pub.h
+++ b/src/include/firebird/impl/inf_pub.h
@@ -192,6 +192,9 @@ enum db_info_types
 	fb_info_max_blob_cache_size = 159,
 	fb_info_max_inline_blob_size = 160,
 
+	// Return list of SQL features supported by engine of external connection
+	fb_info_sql_features = 161,
+
 	isc_info_db_last_value   /* Leave this LAST! */
 };
 
@@ -210,10 +213,20 @@ enum info_features // response to fb_info_features
 	fb_feature_read_consistency		= 5,	// Read consistency TIL is supported
 	fb_feature_statement_timeout	= 6,	// Statement timeout is supported
 	fb_feature_statement_long_life  = 7,    // Prepared statements are not dropped on transaction end
+	fb_feature_prepared_input_types = 8,    // Provider can return parameter types in input statement metadata
 
 	fb_feature_max      // Not really a feature. Keep this last.
 };
 
+enum info_sql_features // response to fb_info_sql_features
+{
+	fb_feature_sql_op_concatenate	= 1,	// Statement supports concatenation `||` operation
+	fb_feature_sql_op_equiv			= 2,	// Statement supports NULL-aware comparison `IS [NOT] DISTINCT FROM` operation
+	fb_feature_sql_op_null_ordering	= 3,	// Statement supports places the rows with the NULL column above/after the ordered rows
+
+	fb_feature_sql_max	// Not really a feature. Keep this last.
+};
+
 enum replica_mode // response to fb_info_replica_mode
 {
 	fb_info_replica_none = 0,
diff --git a/src/include/firebird/impl/msg/dyn.h b/src/include/firebird/impl/msg/dyn.h
index 598b1da1e64..7ce6097b24f 100644
--- a/src/include/firebird/impl/msg/dyn.h
+++ b/src/include/firebird/impl/msg/dyn.h
@@ -312,3 +312,7 @@ FB_IMPL_MSG(DYN, 319, dyn_cannot_mod_obj_sys_schema, -607, "28", "000", "Cannot
 FB_IMPL_MSG(DYN, 320, dyn_cannot_create_reserved_schema, -607, "HY", "000", "Schema name @1 is reserved and cannot be created")
 FB_IMPL_MSG(DYN, 321, dyn_cannot_infer_schema, -901, "42", "000", "Cannot infer schema name as there is no valid schema in the search path")
 FB_IMPL_MSG_SYMBOL(DYN, 322, dyn_dup_blob_filter, "Blob filter @1 already exists")
+FB_IMPL_MSG(DYN, 323, dyn_foreign_server_not_found, -901, "42", "000", "Foreign server @1 not found")
+FB_IMPL_MSG(DYN, 324, dyn_user_mapping_not_found, -901, "42", "000", "User mapping for user @1 and server @2 not found")
+FB_IMPL_MSG(DYN, 325, dyn_foreign_server_already_exists, -901, "42", "000", "Foreign server @1 already exists")
+FB_IMPL_MSG(DYN, 326, dyn_foreign_server_not_exist, -901, "42", "000", "Foreign server @1 does not exist")
diff --git a/src/include/firebird/impl/msg/gbak.h b/src/include/firebird/impl/msg/gbak.h
index fb5a173b540..8a9affbb054 100644
--- a/src/include/firebird/impl/msg/gbak.h
+++ b/src/include/firebird/impl/msg/gbak.h
@@ -418,3 +418,23 @@ FB_IMPL_MSG_NO_SYMBOL(GBAK, 419, "regular expression to skip schemas was already
 FB_IMPL_MSG_NO_SYMBOL(GBAK, 420, "regular expression to include schemas was already set")
 FB_IMPL_MSG_SYMBOL(GBAK, 421, gbak_plugin_schema_migration, "migrating @1 plugin objects to schema @2")
 FB_IMPL_MSG_SYMBOL(GBAK, 422, gbak_plugin_schema_migration_err, "error migrating @1 plugin objects to schema @2. Plugin objects will be in inconsistent state:")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 423, "writing foreign servers")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 424, "    writing foreign server @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 425, "restoring foreign server @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 426, "foreign server")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 427, "         writing foreign server option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 428, "    restoring foreign server option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 429, "foreign server option")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 430, "         writing foreign table option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 431, "    restoring foreign table option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 432, "foreign table option")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 433, "              writing foreign table column option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 434, "         restoring foreign table column option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 435, "foreign table column option")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 436, "writing foreign user mappings")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 437, "    writing foreign user mapping for user @1 and server @2")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 438, "restoring foreign user mapping for user @1 and server @2")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 439, "foreign user mapping")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 440, "         writing foreign user mapping option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 441, "    restoring foreign user mapping option @1")
+FB_IMPL_MSG_NO_SYMBOL(GBAK, 442, "foreign user mapping option")
diff --git a/src/include/firebird/impl/msg/isql.h b/src/include/firebird/impl/msg/isql.h
index fc4a9619737..a8710e3c339 100644
--- a/src/include/firebird/impl/msg/isql.h
+++ b/src/include/firebird/impl/msg/isql.h
@@ -208,3 +208,9 @@ FB_IMPL_MSG_SYMBOL(ISQL, 208, HLP_SETAUTOTERM, "    SET AUTOTERM           -- to
 FB_IMPL_MSG_SYMBOL(ISQL, 209, HLP_SETWIRESTATS, "    SET WIRE_stats         -- toggle display of wire (network) statistics")
 FB_IMPL_MSG_SYMBOL(ISQL, 210, USAGE_SEARCH_PATH, "	-(se)arch_path <path>   set schema search path")
 FB_IMPL_MSG_SYMBOL(ISQL, 211, MSG_SCHEMAS, "Schemas:")
+FB_IMPL_MSG_SYMBOL(ISQL, 212, MSG_FOREIGN_SERVERS, "Servers:")
+FB_IMPL_MSG_SYMBOL(ISQL, 213, MSG_FOREIGN_USER_MAPPINGS, "Foreign User Mappings:")
+FB_IMPL_MSG_SYMBOL(ISQL, 214, NO_FOREIGN_SERVER, "There is no server @1 in this database")
+FB_IMPL_MSG_SYMBOL(ISQL, 215, NO_FOREIGN_SERVERS, "There are no servers in this database")
+FB_IMPL_MSG_SYMBOL(ISQL, 216, NO_FOREIGN_USER_MAPPING, "There is no user mappings for @1 in this database")
+FB_IMPL_MSG_SYMBOL(ISQL, 217, NO_FOREIGN_USER_MAPPINGS, "There is no user mappings in this database")
diff --git a/src/include/firebird/impl/msg/jrd.h b/src/include/firebird/impl/msg/jrd.h
index cef871febd6..6724b4de449 100644
--- a/src/include/firebird/impl/msg/jrd.h
+++ b/src/include/firebird/impl/msg/jrd.h
@@ -998,3 +998,5 @@ FB_IMPL_MSG(JRD, 995, missing_value_for_format_pattern, -901, "HY", "000", "Cann
 FB_IMPL_MSG(JRD, 996, invalid_name, -901, "HY", "000", "Invalid name: @1")
 FB_IMPL_MSG(JRD, 997, invalid_unqualified_name_list, -901, "HY", "000", "Invalid list of unqualified names: @1")
 FB_IMPL_MSG(JRD, 998, no_user_att_while_restore, -901, "HY", "000", "User attachments are not allowed for the database being restored")
+FB_IMPL_MSG(JRD, 999, foreign_server, -901, "42", "000", "foreign server @1")
+FB_IMPL_MSG(JRD, 1000, foreign_provider_not_found, -901, "42", "000", "Foreign provider '@1' for server '@2' not found")
diff --git a/src/include/firebird/impl/msg/sqlerr.h b/src/include/firebird/impl/msg/sqlerr.h
index a2687461bcd..7f6b9fd5406 100644
--- a/src/include/firebird/impl/msg/sqlerr.h
+++ b/src/include/firebird/impl/msg/sqlerr.h
@@ -289,3 +289,18 @@ FB_IMPL_MSG(SQLERR, 1049, dsql_drop_schema_failed, -901, "42", "000", "DROP SCHE
 FB_IMPL_MSG(SQLERR, 1050, dsql_recreate_schema_failed, -901, "42", "000", "RECREATE SCHEMA @1 failed")
 FB_IMPL_MSG(SQLERR, 1051, dsql_alter_schema_failed, -901, "42", "000", "ALTER SCHEMA @1 failed")
 FB_IMPL_MSG(SQLERR, 1052, dsql_create_alter_schema_failed, -901, "42", "000", "CREATE OR ALTER SCHEMA @1 failed")
+FB_IMPL_MSG(SQLERR, 1053, dsql_create_foreign_server_failed, -901, "42", "000", "CREATE SERVER @1 failed")
+FB_IMPL_MSG(SQLERR, 1054, dsql_alter_foreign_server_failed, -901, "42", "000", "ALTER SERVER @1 failed")
+FB_IMPL_MSG(SQLERR, 1055, dsql_create_alter_foreign_server_failed, -901, "42", "000", "CREATE OR ALTER SERVER @1 failed")
+FB_IMPL_MSG(SQLERR, 1056, dsql_recreate_foreign_server_failed, -901, "42", "000", "RECREATE SERVER @1 failed")
+FB_IMPL_MSG(SQLERR, 1057, dsql_drop_foreign_server_failed, -901, "42", "000", "DROP SERVER @1 failed")
+FB_IMPL_MSG(SQLERR, 1058, dsql_create_user_mapping_failed, -901, "42", "000", "CREATE USER MAPPING FOR USER @1 AND SERVER @2 failed")
+FB_IMPL_MSG(SQLERR, 1059, dsql_alter_user_mapping_failed, -901, "42", "000", "ALTER USER MAPPING FOR USER @1 AND SERVER @2 failed")
+FB_IMPL_MSG(SQLERR, 1060, dsql_create_alter_user_mapping_failed, -901, "42", "000", "CREATE OR ALTER USER MAPPING FOR USER @1 AND SERVER @2 failed")
+FB_IMPL_MSG(SQLERR, 1061, dsql_recreate_user_mapping_failed, -901, "42", "000", "RECREATE USER MAPPING FOR USER @1 AND SERVER @2 failed")
+FB_IMPL_MSG(SQLERR, 1062, dsql_drop_user_mapping_failed, -901, "42", "000", "DROP USER MAPPING FOR USER @1 AND SERVER @2 failed")
+FB_IMPL_MSG(SQLERR, 1063, dsql_foreign_table_not_found, -607, "42", "S02", "Foreign table @1 does not exist")
+FB_IMPL_MSG(SQLERR, 1064, dsql_create_foreign_table_failed, -901, "42", "000", "CREATE FOREIGN TABLE @1 failed")
+FB_IMPL_MSG(SQLERR, 1065, dsql_alter_foreign_table_failed, -901, "42", "000", "ALTER FOREIGN TABLE @1 failed")
+FB_IMPL_MSG(SQLERR, 1066, dsql_drop_foreign_table_failed, -901, "42", "000", "DROP FOREIGN TABLE @1 failed")
+FB_IMPL_MSG(SQLERR, 1067, dsql_recreate_foreign_table_failed, -901, "42", "000", "RECREATE FOREIGN TABLE @1 failed")
diff --git a/src/include/gen/Firebird.pas b/src/include/gen/Firebird.pas
index 0bef5dea26a..401cdf56895 100644
--- a/src/include/gen/Firebird.pas
+++ b/src/include/gen/Firebird.pas
@@ -4134,6 +4134,7 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	isc_dpb_search_path = byte(105);
 	isc_dpb_blr_request_search_path = byte(106);
 	isc_dpb_gbak_restore_has_schema = byte(107);
+	isc_dpb_foreign_options = byte(108);
 	isc_dpb_address = byte(1);
 	isc_dpb_addr_protocol = byte(1);
 	isc_dpb_addr_endpoint = byte(2);
@@ -4604,6 +4605,7 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	fb_info_wire_roundtrips = byte(158);
 	fb_info_max_blob_cache_size = byte(159);
 	fb_info_max_inline_blob_size = byte(160);
+	fb_info_sql_features = byte(161);
 	fb_info_crypt_encrypted = $01;
 	fb_info_crypt_process = $02;
 	fb_feature_multi_statements = byte(1);
@@ -4613,6 +4615,10 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	fb_feature_read_consistency = byte(5);
 	fb_feature_statement_timeout = byte(6);
 	fb_feature_statement_long_life = byte(7);
+	fb_feature_prepared_input_types = byte(8);
+	fb_feature_sql_op_concatenate = byte(1);
+	fb_feature_sql_op_equiv = byte(2);
+	fb_feature_sql_op_null_ordering = byte(3);
 	fb_info_replica_none = byte(0);
 	fb_info_replica_read_only = byte(1);
 	fb_info_replica_read_write = byte(2);
@@ -5840,6 +5846,8 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	 isc_invalid_name = 335545316;
 	 isc_invalid_unqualified_name_list = 335545317;
 	 isc_no_user_att_while_restore = 335545318;
+	 isc_foreign_server = 335545319;
+	 isc_foreign_provider_not_found = 335545320;
 	 isc_gfix_db_name = 335740929;
 	 isc_gfix_invalid_sw = 335740930;
 	 isc_gfix_incmp_sw = 335740932;
@@ -6003,6 +6011,10 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	 isc_dyn_cannot_mod_obj_sys_schema = 336068927;
 	 isc_dyn_cannot_create_reserved_schema = 336068928;
 	 isc_dyn_cannot_infer_schema = 336068929;
+	 isc_dyn_foreign_server_not_found = 336068931;
+	 isc_dyn_user_mapping_not_found = 336068932;
+	 isc_dyn_foreign_server_already_exists = 336068933;
+	 isc_dyn_foreign_server_not_exist = 336068934;
 	 isc_gbak_unknown_switch = 336330753;
 	 isc_gbak_page_size_missing = 336330754;
 	 isc_gbak_page_size_toobig = 336330755;
@@ -6237,6 +6249,21 @@ 	IProfilerStatsImpl = class(IProfilerStats)
 	 isc_dsql_recreate_schema_failed = 336397338;
 	 isc_dsql_alter_schema_failed = 336397339;
 	 isc_dsql_create_alter_schema_failed = 336397340;
+	 isc_dsql_create_foreign_server_failed = 336397341;
+	 isc_dsql_alter_foreign_server_failed = 336397342;
+	 isc_dsql_create_alter_foreign_server_failed = 336397343;
+	 isc_dsql_recreate_foreign_server_failed = 336397344;
+	 isc_dsql_drop_foreign_server_failed = 336397345;
+	 isc_dsql_create_user_mapping_failed = 336397346;
+	 isc_dsql_alter_user_mapping_failed = 336397347;
+	 isc_dsql_create_alter_user_mapping_failed = 336397348;
+	 isc_dsql_recreate_user_mapping_failed = 336397349;
+	 isc_dsql_drop_user_mapping_failed = 336397350;
+	 isc_dsql_foreign_table_not_found = 336397351;
+	 isc_dsql_create_foreign_table_failed = 336397352;
+	 isc_dsql_alter_foreign_table_failed = 336397353;
+	 isc_dsql_drop_foreign_table_failed = 336397354;
+	 isc_dsql_recreate_foreign_table_failed = 336397355;
 	 isc_gsec_cant_open_db = 336723983;
 	 isc_gsec_switches_error = 336723984;
 	 isc_gsec_no_op_spec = 336723985;
diff --git a/src/isql/FrontendParser.cpp b/src/isql/FrontendParser.cpp
index 64218057132..28a47810a07 100644
--- a/src/isql/FrontendParser.cpp
+++ b/src/isql/FrontendParser.cpp
@@ -468,6 +468,7 @@ FrontendParser::AnyShowNode FrontendParser::parseShow()
 	static constexpr std::string_view TOKEN_DOMAINS("DOMAINS");
 	static constexpr std::string_view TOKEN_EXCEPTIONS("EXCEPTIONS");
 	static constexpr std::string_view TOKEN_FILTERS("FILTERS");
+	static constexpr std::string_view TOKEN_SERVERS("SERVERS");
 	static constexpr std::string_view TOKEN_FUNCTIONS("FUNCTIONS");
 	static constexpr std::string_view TOKEN_INDEXES("INDEXES");
 	static constexpr std::string_view TOKEN_INDICES("INDICES");
@@ -486,6 +487,7 @@ FrontendParser::AnyShowNode FrontendParser::parseShow()
 	static constexpr std::string_view TOKEN_TABLES("TABLES");
 	static constexpr std::string_view TOKEN_TRIGGERS("TRIGGERS");
 	static constexpr std::string_view TOKEN_USERS("USERS");
+	static constexpr std::string_view TOKEN_USER_MAPPINGS("USER_MAPPINGS");
 	static constexpr std::string_view TOKEN_VER("VER");
 	static constexpr std::string_view TOKEN_VERSION("VERSION");
 	static constexpr std::string_view TOKEN_VIEWS("VIEWS");
@@ -586,6 +588,8 @@ FrontendParser::AnyShowNode FrontendParser::parseShow()
 				if (parseEof())
 					return node;
 			}
+			else if (const auto parsed = parseShowOptName<ShowForeignServersNode>(text, TOKEN_SERVERS, 6))
+				return parsed.value();
 			else if (const auto parsed = parseShowOptQualifiedName<ShowGeneratorsNode>(text, TOKEN_SEQUENCES, 3))
 				return parsed.value();
 			else if (text == TOKEN_SQL)
@@ -642,6 +646,8 @@ FrontendParser::AnyShowNode FrontendParser::parseShow()
 				if (parseEof())
 					return ShowUsersNode();
 			}
+			else if (const auto parsed = parseShowOptName<ShowForeignUserMappingsNode>(text, TOKEN_USER_MAPPINGS, 8))
+				return parsed.value();
 			else if (text == TOKEN_VER || text == TOKEN_VERSION)
 			{
 				if (parseEof())
diff --git a/src/isql/FrontendParser.h b/src/isql/FrontendParser.h
index 28a1b9cc3ba..aaa172bfde6 100644
--- a/src/isql/FrontendParser.h
+++ b/src/isql/FrontendParser.h
@@ -100,6 +100,8 @@ class FrontendParser
 	struct ShowDependenciesNode { std::optional<Firebird::QualifiedMetaString> name; };
 	struct ShowExceptionsNode { std::optional<Firebird::QualifiedMetaString> name; };
 	struct ShowFiltersNode { std::optional<Firebird::MetaString> name; };
+	struct ShowForeignServersNode { std::optional<Firebird::MetaString> name; };
+	struct ShowForeignUserMappingsNode { std::optional<Firebird::MetaString> name; };
 	struct ShowFunctionsNode { std::optional<Firebird::QualifiedMetaString> name; };
 	struct ShowGeneratorsNode { std::optional<Firebird::QualifiedMetaString> name; };
 	struct ShowGrantsNode { std::optional<Firebird::QualifiedMetaString> name; };
@@ -165,6 +167,8 @@ class FrontendParser
 		ShowDependenciesNode,
 		ShowExceptionsNode,
 		ShowFiltersNode,
+		ShowForeignServersNode,
+		ShowForeignUserMappingsNode,
 		ShowFunctionsNode,
 		ShowGeneratorsNode,
 		ShowGrantsNode,
diff --git a/src/isql/extract.epp b/src/isql/extract.epp
index 52f4876a5a9..f339bbab443 100644
--- a/src/isql/extract.epp
+++ b/src/isql/extract.epp
@@ -99,6 +99,14 @@ static void list_procedure_bodies(GetDefaultCharSetForSchemaFunc getDefaultCharS
 static void list_procedure_headers(GetDefaultCharSetForSchemaFunc getDefaultCharSetForSchemaFunc);
 static void list_schemas();
 static void list_views();
+static void list_foreign_servers();
+static bool extract_foreign_server_options(const MetaString& serverName);
+static void list_foreign_user_mappings();
+static bool extract_foreign_mapping_options(const MetaString& userName, const MetaString& serverName);
+static bool extract_foreign_table_field_options(const QualifiedMetaString& table, const MetaString& fieldName);
+static bool extract_foreign_table_options(const QualifiedMetaString& table);
+static void print_foreign_option(ExternalValueType type, const MetaString& optionName,
+	const Firebird::string& optionValue);
 
 static const char* const Procterm = "^";	// TXNN: script use only
 
@@ -204,6 +212,8 @@ int EXTRACT_ddl(LegacyTables flag, const QualifiedMetaString& tabname)
 		list_create_db();
 		list_filters();
 		list_schemas();
+		list_foreign_servers();
+		list_foreign_user_mappings();
 		list_charsets();
 		list_collations();
 		list_generators();
@@ -334,6 +344,7 @@ int EXTRACT_list_table(const QualifiedMetaString& relation_name,
 	string char_sets;
 	rel_t rel_type = rel_persistent;
 	char ss[28] = "";
+	MetaString foreignServerName;
 
 	// Query to obtain relation detail information
 
@@ -373,6 +384,8 @@ int EXTRACT_list_table(const QualifiedMetaString& relation_name,
 
 			if (rel_type == rel_global_temp_preserve || rel_type == rel_global_temp_delete)
 				isqlGlob.printf("CREATE GLOBAL TEMPORARY TABLE ");
+			else if (rel_type == rel_foreign)
+				isqlGlob.printf("CREATE FOREIGN TABLE ");
 			else
 				isqlGlob.printf("CREATE TABLE ");
 
@@ -392,6 +405,13 @@ int EXTRACT_list_table(const QualifiedMetaString& relation_name,
 				isqlGlob.printf("EXTERNAL FILE %s ", SQL_identifier2);
 			}
 
+			if (!REL.RDB$FOREIGN_SERVER_NAME.NULL)
+			{
+				fb_utils::exact_name(REL.RDB$FOREIGN_SERVER_NAME);
+				IUTILS_copy_SQL_id (REL.RDB$FOREIGN_SERVER_NAME, SQL_identifier, DBL_QUOTE);
+				foreignServerName.printf("SERVER %s", SQL_identifier);
+			}
+
 			isqlGlob.printf("(");
 		}
 		else
@@ -602,6 +622,12 @@ int EXTRACT_list_table(const QualifiedMetaString& relation_name,
 				isqlGlob.prints(char_sets.c_str());
 			}
 		}
+
+		if (rel_type == rel_foreign)
+		{
+			if (!extract_foreign_table_field_options(relation_name, columnName))
+				return FINI_ERROR;
+		}
 	}
 	END_FOR
 	ON_ERROR
@@ -628,11 +654,359 @@ int EXTRACT_list_table(const QualifiedMetaString& relation_name,
 	else
 		isqlGlob.printf(")");
 
+	if (rel_type == rel_foreign)
+	{
+		isqlGlob.printf("%s%s", NEWLINE, foreignServerName.c_str());
+		if (!extract_foreign_table_options(relation_name))
+			return FINI_ERROR;
+	}
+
 	isqlGlob.printf("%s%s", isqlGlob.global_Term, NEWLINE);
 	return FINI_OK;
 }
 
 
+static bool extract_foreign_table_field_options(const QualifiedMetaString& table, const MetaString& fieldName)
+{
+/**************************************************
+ *
+ *	e x t r a c t _ f o r e i g n _ t a b l e _ f i e l d _ o p t i o n s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function extracts the foreign table field options.
+ *
+ **************************************/
+
+	bool first = true;
+
+	FOR FTFO IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+			WITH FTFO.RDB$SCHEMA_NAME EQ table.schema.c_str() AND
+			FTFO.RDB$TABLE_NAME EQ table.object.c_str() AND
+			FTFO.RDB$FIELD_NAME EQ fieldName.c_str()
+	{
+		const MetaString optionName(FTFO.RDB$FOREIGN_OPTION_NAME);
+		const Firebird::string optionValue(FTFO.RDB$FOREIGN_OPTION_VALUE);
+		ExternalValueType type = ExternalValueType::TYPE_STRING;
+
+		if (first)
+		{
+			isqlGlob.printf(" OPTIONS(");
+			first = false;
+		}
+		else
+			isqlGlob.printf(", ");
+
+		print_foreign_option(type, optionName, optionValue);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return false;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf(")");
+
+	return true;
+}
+
+
+static bool extract_foreign_table_options(const QualifiedMetaString& table)
+{
+/**************************************************
+ *
+ *	e x t r a c t _ f o r e i g n _ t a b l e _ o p t i o n s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function extracts the foreign table options.
+ *
+ **************************************/
+
+	bool first = true;
+
+	FOR FTO IN RDB$FOREIGN_TABLE_OPTIONS
+			WITH FTO.RDB$SCHEMA_NAME EQ table.schema.c_str() AND
+			FTO.RDB$TABLE_NAME EQ table.object.c_str()
+	{
+		const MetaString optionName(FTO.RDB$FOREIGN_OPTION_NAME);
+		const Firebird::string optionValue(FTO.RDB$FOREIGN_OPTION_VALUE);
+		ExternalValueType type = ExternalValueType::TYPE_STRING;
+
+		if (first)
+		{
+			isqlGlob.printf(" OPTIONS(");
+			first = false;
+		}
+		else
+			isqlGlob.printf(", ");
+
+		print_foreign_option(type, optionName, optionValue);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return false;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf(")");
+
+	return true;
+}
+
+
+static void list_foreign_servers()
+{
+/**************************************************
+ *
+ *	l i s t _ f o r e i g n _ s e r v e r s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	List all foreign servers defined in the database.
+ *
+ **************************************/
+
+	if (isqlGlob.major_ods < ODS_VERSION14)
+		return;
+
+	bool first = true;
+
+	FOR FS IN RDB$FOREIGN_SERVERS
+		SORTED BY FS.RDB$FOREIGN_SERVER_NAME
+	{
+		const MetaString serverName(FS.RDB$FOREIGN_SERVER_NAME);
+		const MetaString ownerName(FS.RDB$OWNER_NAME);
+
+		if (first)
+		{
+			isqlGlob.printf("%s/* Foreign server definitions */%s", NEWLINE, NEWLINE);
+			first = false;
+		}
+
+		isqlGlob.printf("%s/* Foreign server: %s, Owner: %s */%s",
+				 NEWLINE,
+				 IUTILS_name_to_string(serverName).c_str(),
+				 IUTILS_name_to_string(ownerName).c_str(),
+				 NEWLINE);
+
+		isqlGlob.printf(
+			"CREATE SERVER %s",	IUTILS_name_to_string(serverName).c_str());
+
+		if (!FS.RDB$FOREIGN_SERVER_WRAPPER.NULL)
+		{
+			const MetaString wrapper(FS.RDB$FOREIGN_SERVER_WRAPPER);
+
+			IUTILS_copy_SQL_id (FS.RDB$FOREIGN_SERVER_WRAPPER, SQL_identifier, DBL_QUOTE);
+
+			isqlGlob.printf(
+				" FOREIGN DATA WRAPPER %s",
+				SQL_identifier);
+		}
+
+		if (!extract_foreign_server_options(serverName))
+			return;
+
+		isqlGlob.printf("%s%s", isqlGlob.global_Term, NEWLINE);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf("%sCOMMIT WORK%s%s", NEWLINE, isqlGlob.global_Term, NEWLINE);
+}
+
+
+static bool extract_foreign_server_options(const MetaString& serverName)
+{
+/**************************************************
+ *
+ *	e x t r a c t _ f o r e i g n _ s e r v e r _ o p t i o n s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function extracts the foreign server options.
+ *
+ **************************************/
+
+	bool first = true;
+
+	FOR FSO IN RDB$FOREIGN_SERVER_OPTIONS
+			WITH FSO.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+	{
+		const MetaString optionName(FSO.RDB$FOREIGN_OPTION_NAME);
+		const Firebird::string optionValue(FSO.RDB$FOREIGN_OPTION_VALUE);
+		ExternalValueType type = ExternalValueType::TYPE_STRING;
+		if (!FSO.RDB$FOREIGN_OPTION_TYPE.NULL)
+			type = ExternalValueType(FSO.RDB$FOREIGN_OPTION_TYPE);
+
+		if (first)
+		{
+			isqlGlob.printf(" OPTIONS(");
+			first = false;
+		}
+		else
+			isqlGlob.printf(", ");
+
+		print_foreign_option(type, optionName, optionValue);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return false;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf(")");
+
+	return true;
+}
+
+static void list_foreign_user_mappings()
+{
+/**************************************************
+ *
+ *	l i s t _ f o r e i g n _ u s e r _ m a p p i n g s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	List all foreign user mappings defined in the database.
+ *
+ **************************************/
+
+	if (isqlGlob.major_ods < ODS_VERSION14)
+		return;
+
+	bool first = true;
+
+	FOR FM IN RDB$FOREIGN_USER_MAPPINGS
+	{
+		const MetaString userName(FM.RDB$USER);
+		const MetaString serverName(FM.RDB$FOREIGN_SERVER_NAME);
+
+		if (first)
+		{
+			isqlGlob.printf("%s/* Foreign user mapping definitions */%s", NEWLINE, NEWLINE);
+			first = false;
+		}
+
+		isqlGlob.printf("%s/* Foreign user mapping for User: %s, Server: %s */%s",
+				 NEWLINE,
+				 IUTILS_name_to_string(userName).c_str(),
+				 IUTILS_name_to_string(serverName).c_str(),
+				 NEWLINE);
+
+		isqlGlob.printf(
+			"CREATE USER MAPPING FOR %s SERVER %s",	IUTILS_name_to_string(userName).c_str(),
+			IUTILS_name_to_string(serverName).c_str());
+
+		if (!extract_foreign_mapping_options(userName, serverName))
+			return;
+
+		isqlGlob.printf("%s%s", isqlGlob.global_Term, NEWLINE);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf("%sCOMMIT WORK%s%s", NEWLINE, isqlGlob.global_Term, NEWLINE);
+}
+
+
+static bool extract_foreign_mapping_options(const MetaString& userName, const MetaString& serverName)
+{
+/**************************************************
+ *
+ *	e x t r a c t _ f o r e i g n _ m a p p i n g _ o p t i o n s
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function extracts the foreign user mapping options.
+ *
+ **************************************/
+
+	bool first = true;
+
+	FOR FMO IN RDB$FOREIGN_MAPPING_OPTIONS
+			WITH FMO.RDB$USER EQ userName.c_str() AND
+			FMO.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+	{
+		const MetaString optionName(FMO.RDB$FOREIGN_OPTION_NAME);
+		const Firebird::string optionValue(FMO.RDB$FOREIGN_OPTION_VALUE);
+		ExternalValueType type = ExternalValueType::TYPE_STRING;
+		if (!FMO.RDB$FOREIGN_OPTION_TYPE.NULL)
+			type = ExternalValueType(FMO.RDB$FOREIGN_OPTION_TYPE);
+
+		if (first)
+		{
+			isqlGlob.printf(" OPTIONS(");
+			first = false;
+		}
+		else
+			isqlGlob.printf(", ");
+
+		print_foreign_option(type, optionName, optionValue);
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return false;
+	END_ERROR
+
+	if (!first)
+		isqlGlob.printf(")");
+
+	return true;
+}
+
+
+static void print_foreign_option(ExternalValueType type, const MetaString& optionName,
+	const Firebird::string& optionValue)
+{
+/**************************************************
+ *
+ *	p r i n t _ f o r e i g n _ o p t i o n
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function prints the option with value for foreign object.
+ *
+ **************************************/
+	const char* stringType = NULL;
+	switch (type)
+	{
+	case ExternalValueType::TYPE_ENV:
+		stringType = " ENV";
+		break;
+
+	case ExternalValueType::TYPE_FILE:
+		stringType = " FILE";
+		break;
+
+	default:
+		break;
+	}
+
+	isqlGlob.printf("%s%s \'%s\'", IUTILS_name_to_string(optionName).c_str(), stringType ? stringType : " =",
+		optionValue.c_str());
+}
+
+
 static bool extract_rel_constraints(const QualifiedMetaString& relation_name)
 {
 /**************************************************
diff --git a/src/isql/show.epp b/src/isql/show.epp
index 6f190c5bac6..68f9395f173 100644
--- a/src/isql/show.epp
+++ b/src/isql/show.epp
@@ -98,6 +98,8 @@ static processing_state show_dependencies(const QualifiedMetaString& name, int o
 static processing_state show_dialect();
 static processing_state show_domains(const std::optional<QualifiedMetaString>& name);
 static processing_state show_exceptions(const std::optional<QualifiedMetaString>& name);
+static processing_state show_foreign_servers(const std::optional<MetaString>& name, const char* msg = nullptr);
+static processing_state show_foreign_user_mappings(const std::optional<MetaString>& name, const char* msg = nullptr);
 static processing_state show_filters(const std::optional<MetaString>& name);
 static processing_state show_functions(const std::optional<QualifiedMetaString>& name,
 	bool system, const char* msg = nullptr);
@@ -118,6 +120,8 @@ static processing_state show_trigger(const std::optional<QualifiedMetaString>& n
 static processing_state show_users();
 static processing_state show_users12();
 static processing_state show_wireStats();
+static void print_foreign_option(ExternalValueType type, const MetaString& optionName,
+	const Firebird::string& optionValue);
 
 const char* const spaces = "                                ";
 static TEXT Print_buffer[512];
@@ -1846,7 +1850,9 @@ processing_state SHOW_metadata(const FrontendParser::AnyShowNode& node)
 		{0, "COLLATES", 7},				// COLLATE
 		{0, "COLLATIONS", 9},			// COLLATION
 		{0, "SECCLASSES", 6},			// SECCLA
+		{0, "SERVERS", 6},				// SERVER
 		{0, "USERS", 0},
+		{0, "USER_MAPPINGS", 8},		// USER_MAP
 		{0, "PACKAGES", 4},				// PACK
 		{0, "SCHEMAS", 4},				// SCHE
 		{0, "MAPPINGS", 3},				// MAP
@@ -2015,6 +2021,42 @@ processing_state SHOW_metadata(const FrontendParser::AnyShowNode& node)
 			return ret;
 		},
 
+		[&](const FrontendParser::ShowForeignServersNode& node)
+		{
+			const auto ret = show_foreign_servers(node.name);
+
+			if (ret == OBJECT_NOT_FOUND)
+			{
+				if (node.name)
+				{
+					key = NO_FOREIGN_SERVER;
+					notFoundName.object = node.name.value();
+				}
+				else
+					key = NO_FOREIGN_SERVERS;
+			}
+
+			return ret;
+		},
+
+		[&](const FrontendParser::ShowForeignUserMappingsNode& node)
+		{
+			const auto ret = show_foreign_user_mappings(node.name);
+
+			if (ret == OBJECT_NOT_FOUND)
+			{
+				if (node.name)
+				{
+					key = NO_FOREIGN_USER_MAPPING;
+					notFoundName.object = node.name.value();
+				}
+				else
+					key = NO_FOREIGN_USER_MAPPINGS;
+			}
+
+			return ret;
+		},
+
 		[&](const FrontendParser::ShowFunctionsNode& node)
 		{
 			const auto ret = show_functions(node.name, false);
@@ -4126,6 +4168,202 @@ static processing_state show_filters(const std::optional<MetaString>& name)
 }
 
 
+static processing_state show_foreign_servers(const std::optional<MetaString>& name, const char* msg)
+{
+/**************************************
+ *
+ *	s h o w _ f o r e i g n _ s e r v e r s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Show foreign servers in general or for the named filters
+ *
+ **************************************/
+	bool first = true;
+
+	// Show all servers
+	if (!name)
+	{
+		FOR FS IN RDB$FOREIGN_SERVERS
+		SORTED BY FS.RDB$FOREIGN_SERVER_NAME
+		{
+			const MetaString serverName(FS.RDB$FOREIGN_SERVER_NAME);
+			if (first && msg)
+				isqlGlob.printf("%s%s", msg, NEWLINE);
+
+			first = false;
+			isqlGlob.printf("%s%s", IUTILS_name_to_string(serverName).c_str(), NEWLINE);
+		}
+		END_FOR
+		ON_ERROR
+			ISQL_errmsg(fbStatus);
+			return ps_ERR;
+		END_ERROR
+
+		if (!first)
+		{
+			isqlGlob.printf(NEWLINE);
+			return (SKIP);
+		}
+
+		return OBJECT_NOT_FOUND;
+	}
+
+	// We have a server name, so expand on it
+	FOR FS IN RDB$FOREIGN_SERVERS WITH
+	   FS.RDB$FOREIGN_SERVER_NAME EQ name->c_str()
+	{
+		const MetaString serverName(FS.RDB$FOREIGN_SERVER_NAME);
+		const MetaString ownerName(FS.RDB$OWNER_NAME);
+
+		first = false;
+
+		isqlGlob.printf("%s%s", serverName.c_str(), NEWLINE);
+		isqlGlob.printf("Owner: %s%s", ownerName.c_str(), NEWLINE);
+
+		if (!FS.RDB$FOREIGN_SERVER_WRAPPER.NULL)
+		{
+			const MetaString wrapper(FS.RDB$FOREIGN_SERVER_WRAPPER);
+
+			isqlGlob.printf("Foreign Data Wrapper: %s%s", wrapper.c_str(), NEWLINE);
+		}
+
+		bool firstOption = true;
+
+		FOR FSO IN RDB$FOREIGN_SERVER_OPTIONS
+				WITH FSO.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+		{
+			const MetaString optionName(FSO.RDB$FOREIGN_OPTION_NAME);
+			const Firebird::string optionValue(FSO.RDB$FOREIGN_OPTION_VALUE);
+			ExternalValueType type = ExternalValueType::TYPE_STRING;
+			if (!FSO.RDB$FOREIGN_OPTION_TYPE.NULL)
+				type = ExternalValueType(FSO.RDB$FOREIGN_OPTION_TYPE);
+
+			if (firstOption)
+			{
+				isqlGlob.printf("Options: %s", NEWLINE);
+				firstOption = false;
+			}
+			else
+				isqlGlob.printf("%s", NEWLINE);
+
+			print_foreign_option(type, optionName, optionValue);
+		}
+		END_FOR
+		ON_ERROR
+			ISQL_errmsg(fbStatus);
+			return ps_ERR;
+		END_ERROR
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return ps_ERR;
+	END_ERROR
+
+	if (first)
+		return (OBJECT_NOT_FOUND);
+
+	return (SKIP);
+}
+
+
+static processing_state show_foreign_user_mappings(const std::optional<MetaString>& name, const char* msg)
+{
+/**************************************
+ *
+ *	s h o w _ f o r e i g n _ u s e r _ m a p p i n g s
+ *
+ **************************************
+ *
+ * Functional description
+ *	Show foreign user mappings in general or for the named filters
+ *
+ **************************************/
+	bool first = true;
+
+	// Show all foreing user mappings
+	if (!name)
+	{
+		FOR FM IN RDB$FOREIGN_USER_MAPPINGS
+		SORTED BY FM.RDB$USER
+		{
+			const MetaString userName(FM.RDB$USER);
+				if (first && msg)
+					isqlGlob.printf("%s%s", msg, NEWLINE);
+
+				first = false;
+				isqlGlob.printf("User mapping for %s%s", IUTILS_name_to_string(userName).c_str(), NEWLINE);
+		}
+		END_FOR
+		ON_ERROR
+			ISQL_errmsg(fbStatus);
+			return ps_ERR;
+		END_ERROR
+
+		if (!first)
+		{
+			isqlGlob.printf(NEWLINE);
+			return (SKIP);
+		}
+
+		return OBJECT_NOT_FOUND;
+	}
+
+	// Show user mappings for giver user
+	FOR FM IN RDB$FOREIGN_USER_MAPPINGS WITH
+	   FM.RDB$USER EQ name->c_str()
+	{
+		const MetaString userName(FM.RDB$USER);
+		const MetaString serverName(FM.RDB$FOREIGN_SERVER_NAME);
+
+		first = false;
+
+		isqlGlob.printf("User: %s%s", userName.c_str(), NEWLINE);
+		isqlGlob.printf("Server: %s%s", serverName.c_str(), NEWLINE);
+
+		bool firstOption = true;
+
+		FOR FMO IN RDB$FOREIGN_MAPPING_OPTIONS
+			WITH FMO.RDB$USER EQ userName.c_str() AND
+			FMO.RDB$FOREIGN_SERVER_NAME EQ serverName.c_str()
+		{
+			const MetaString optionName(FMO.RDB$FOREIGN_OPTION_NAME);
+			const Firebird::string optionValue(FMO.RDB$FOREIGN_OPTION_VALUE);
+			ExternalValueType type = ExternalValueType::TYPE_STRING;
+			if (!FMO.RDB$FOREIGN_OPTION_TYPE.NULL)
+				type = ExternalValueType(FMO.RDB$FOREIGN_OPTION_TYPE);
+
+			if (firstOption)
+			{
+				isqlGlob.printf("Options: %s", NEWLINE);
+				firstOption = false;
+			}
+			else
+				isqlGlob.printf("%s", NEWLINE);
+
+			print_foreign_option(type, optionName, optionValue);
+		}
+		END_FOR
+		ON_ERROR
+			ISQL_errmsg(fbStatus);
+			return ps_ERR;
+		END_ERROR
+	}
+	END_FOR
+	ON_ERROR
+		ISQL_errmsg(fbStatus);
+		return ps_ERR;
+	END_ERROR
+
+	if (first)
+		return (OBJECT_NOT_FOUND);
+
+	return (SKIP);
+}
+
+
 static processing_state show_functions(const std::optional<QualifiedMetaString>& name, bool system, const char* msg)
 {
 /**************************************
@@ -6018,6 +6256,7 @@ static processing_state show_table(const QualifiedMetaString& name, bool isView)
 		WITH REL.RDB$RELATION_NAME EQ name.object.c_str()
 		SORTED BY REL.RDB$SCHEMA_NAME
 	{
+		bool isForeign = false;
 		const QualifiedMetaString relationName(REL.RDB$RELATION_NAME, REL.RDB$SCHEMA_NAME);
 
 		if (name.schema.hasData() && name.schema != relationName.schema)
@@ -6043,6 +6282,40 @@ static processing_state show_table(const QualifiedMetaString& name, bool isView)
 		if (!REL.RDB$EXTERNAL_FILE.NULL)
 			isqlGlob.printf("External file: %s%s", REL.RDB$EXTERNAL_FILE, NEWLINE);
 
+		if (!REL.RDB$FOREIGN_SERVER_NAME.NULL)
+		{
+			isForeign = true;
+			fb_utils::exact_name(REL.RDB$FOREIGN_SERVER_NAME);
+			isqlGlob.printf("Server: %s%s", REL.RDB$FOREIGN_SERVER_NAME, NEWLINE);
+
+			// Foreign table options
+			bool firstOption = true;
+
+			FOR FTO IN RDB$FOREIGN_TABLE_OPTIONS
+					WITH FTO.RDB$SCHEMA_NAME EQ relationName.schema.c_str() AND
+					FTO.RDB$TABLE_NAME EQ relationName.object.c_str()
+			{
+				const MetaString optionName(FTO.RDB$FOREIGN_OPTION_NAME);
+				const Firebird::string optionValue(FTO.RDB$FOREIGN_OPTION_VALUE);
+				ExternalValueType type = ExternalValueType::TYPE_STRING;
+
+				if (firstOption)
+				{
+					isqlGlob.printf("Options: %s", NEWLINE);
+					firstOption = false;
+				}
+				else
+					isqlGlob.printf("%s", NEWLINE);
+
+				print_foreign_option(type, optionName, optionValue);
+			}
+			END_FOR
+			ON_ERROR
+				ISQL_errmsg(fbStatus);
+				return ps_ERR;
+			END_ERROR
+		}
+
 	// TODO: indent
 
 	FOR RFR IN RDB$RELATION_FIELDS CROSS
@@ -6174,6 +6447,37 @@ static processing_state show_table(const QualifiedMetaString& name, bool isView)
 			SHOW_print_metadata_text_blob (isqlGlob.Out, &FLD.RDB$VALIDATION_SOURCE);
 			isqlGlob.printf(NEWLINE);
 		}
+
+		// Field options for foreign table
+		if (isForeign)
+		{
+			bool firstOption = true;
+
+			FOR FTFO IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+			WITH FTFO.RDB$SCHEMA_NAME EQ relationName.schema.c_str() AND
+			FTFO.RDB$TABLE_NAME EQ relationName.object.c_str() AND
+			FTFO.RDB$FIELD_NAME EQ columnName.c_str()
+			{
+				const MetaString optionName(FTFO.RDB$FOREIGN_OPTION_NAME);
+				const Firebird::string optionValue(FTFO.RDB$FOREIGN_OPTION_VALUE);
+				ExternalValueType type = ExternalValueType::TYPE_STRING;
+
+				if (firstOption)
+				{
+					isqlGlob.printf("Options: %s", NEWLINE);
+					firstOption = false;
+				}
+				else
+					isqlGlob.printf("%s", NEWLINE);
+
+				print_foreign_option(type, optionName, optionValue);
+			}
+			END_FOR
+			ON_ERROR
+				ISQL_errmsg(fbStatus);
+				return ps_ERR;
+			END_ERROR
+		}
 	}
 	END_FOR
 	ON_ERROR
@@ -6736,3 +7040,39 @@ static processing_state show_wireStats()
 
 	return SKIP;
 }
+
+static void print_foreign_option(ExternalValueType type, const MetaString& optionName,
+	const Firebird::string& optionValue)
+{
+/**************************************************
+ *
+ *	p r i n t _ f o r e i g n _ o p t i o n
+ *
+ **************************************************
+ *
+ * Functional description
+ *	This function prints the option with value for foreign object.
+ *
+ **************************************/
+	const char* stringType = NULL;
+	switch (type)
+	{
+	case ExternalValueType::TYPE_ENV:
+		stringType = "ENV";
+		break;
+
+	case ExternalValueType::TYPE_FILE:
+		stringType = "FILE";
+		break;
+
+	default:
+		stringType = "STRING";
+		break;
+	}
+
+	isqlGlob.printf("%sOption: %s, Type: %s,  Value: \'%s\'", TAB_AS_SPACES,
+		IUTILS_name_to_string(optionName).c_str(), stringType,
+		optionValue.c_str());
+
+	isqlGlob.printf("%s", NEWLINE);
+}
diff --git a/src/jrd/Attachment.cpp b/src/jrd/Attachment.cpp
index 3222bb1a742..5180396d1ed 100644
--- a/src/jrd/Attachment.cpp
+++ b/src/jrd/Attachment.cpp
@@ -56,6 +56,8 @@
 #include "../common/isc_proto.h"
 #include "../common/classes/RefMutex.h"
 
+#include "../jrd/ForeignServer.h"
+
 
 using namespace Jrd;
 using namespace Firebird;
@@ -925,6 +927,12 @@ void Jrd::Attachment::releaseRelations(thread_db* tdbb)
 				if (relation->rel_file)
 					EXT_fini(relation, false);
 
+				if (relation->rel_foreign_adapter)
+				{
+					delete relation->rel_foreign_adapter;
+					relation->rel_foreign_adapter = NULL;
+				}
+
 				delete relation;
 			}
 		}
diff --git a/src/jrd/ForeignServer.cpp b/src/jrd/ForeignServer.cpp
new file mode 100644
index 00000000000..a87da6394a0
--- /dev/null
+++ b/src/jrd/ForeignServer.cpp
@@ -0,0 +1,864 @@
+/*
+ *  The contents of this file are subject to the Initial
+ *  Developer's Public License Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the
+ *  License. You may obtain a copy of the License at
+ *  http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
+ *
+ *  Software distributed under the License is distributed AS IS,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing rights
+ *  and limitations under the License.
+ *
+ *  The Original Code was created by Vasiliy Yashkov
+ *  for the Firebird Open Source RDBMS project.
+ *
+ *  Copyright (c) 2025 Vasiliy Yashkov <vasiliy.yashkov13@gmail.com>
+ *  and all contributors signed below.
+ *
+ *  All Rights Reserved.
+ *  Contributor(s): ______________________________________.
+ */
+
+#include "firebird.h"
+
+#include "../auth/SecureRemotePassword/Message.h"
+#include "../common/os/path_utils.h"
+#include "../jrd/jrd.h"
+#include "../jrd/req.h"
+#include "../jrd/cmp_proto.h"
+#include "../jrd/met_proto.h"
+#include "../jrd/mov_proto.h"
+#include "../jrd/vio_proto.h"
+#include "../jrd/intl_proto.h"
+#include "../jrd/Mapping.h"
+#include "../dsql/make_proto.h"
+
+using namespace Firebird;
+using namespace Jrd;
+
+// It's necessary to specify old parameters twice,
+// because each parameter is set twice in the condition
+// '(<field> = <param> or (<field> is null or <param> is null))'.
+const USHORT OLD_PARAMS_MULTIPLIER = 2;
+
+namespace Jrd
+{
+
+	[[noreturn]] void throwError(const Firebird::string& message, const Firebird::string& value)
+	{
+		Firebird::string msg;
+		msg.printf("%s specifies: %s", message.c_str(), value.c_str());
+		(Firebird::Arg::Gds(isc_random) << Firebird::Arg::Str(msg)).raise();
+	}
+
+	bool getExternalValue(const Firebird::string& value, ExternalValueType type, Firebird::string& output)
+	{
+		Firebird::string temp;
+
+		switch (type)
+		{
+		case ExternalValueType::TYPE_ENV:
+			fb_utils::readenv(value.c_str(), temp);
+			if (temp.isEmpty())
+				throwError("missing environment variable", value);
+			break;
+
+		case ExternalValueType::TYPE_FILE:
+			{
+				Firebird::PathName filename = value.c_str();
+				PathUtils::fixupSeparators(filename);
+				if (PathUtils::isRelative(filename))
+					filename = fb_utils::getPrefix(Firebird::IConfigManager::DIR_CONF, filename.c_str());
+
+				Firebird::AutoPtr<FILE> file(os_utils::fopen(filename.c_str(), "rt"));
+				if (!file)
+					throwError("missing or inaccessible file", value);
+
+				if (temp.LoadFromFile(file))
+					temp.alltrim("\r");
+
+				if (temp.isEmpty())
+					throwError("first empty line of file", value);
+				break;
+			}
+		default:
+			return false; // just string value
+		}
+
+		output = temp;
+
+		return true;
+	}
+
+	bool getBooleanValue(const string& value)
+	{
+		string low(value);
+		low.lower();
+
+		if (low == "true" || low == "yes" || low == "1")
+			return true;
+
+		return false;
+	}
+
+}
+
+void ForeignServer::addOption(const MetaName& name, const string& value, ExternalValueType type)
+{
+	ForeignOption* option = options.getOrPut(name);
+	option->m_name = name;
+	option->m_value = value;
+	option->m_type = type;
+}
+
+const Firebird::GenericMap<MetaStringOptionPair>& ForeignServer::getOptions() const
+{
+	return options;
+}
+
+ForeignTableConnection* ForeignTableProvider::createForeignConnection(thread_db* tdbb, ForeignServer* server)
+{
+	Jrd::Attachment* attachment = tdbb->getAttachment();
+	const string& currentUser = attachment->getEffectiveUserName().c_str();
+	const string& fServer = server->getServerName().c_str();
+
+	string connectionString;
+	string user;
+	string password;
+	string role;
+
+	// If there is mapping for user and foreign server,
+	// get a map of the connection parameters.
+	Mapping mapping(Mapping::MAP_NO_FLAGS, NULL);
+	GenericMap<MetaStringOptionPair>* foreignMap;
+	ForeignOption option(*getDefaultMemoryPool());
+	if (mapping.getForeignUserMap(attachment, currentUser, fServer, foreignMap))
+	{
+		if (foreignMap->get(FOREIGN_SERVER_CONNECTION_STRING, option))
+			connectionString = option.getActualValue();
+		if (foreignMap->get(FOREIGN_SERVER_USER, option))
+			user = option.getActualValue();
+		if (foreignMap->get(FOREIGN_SERVER_PASSWORD, option))
+			password = option.getActualValue();
+		if (foreignMap->get(FOREIGN_SERVER_ROLE, option))
+			role = option.getActualValue();
+	}
+
+	// If there was no mapping for user and server,
+	// or any properties were not specified in it, use server options.
+	const auto& options = server->getOptions();
+
+	if (connectionString.isEmpty() && options.get(FOREIGN_SERVER_CONNECTION_STRING, option))
+		connectionString = option.getActualValue();
+	if (user.isEmpty() && options.get(FOREIGN_SERVER_USER, option))
+		user = option.getActualValue();
+	if (password.isEmpty() && options.get(FOREIGN_SERVER_PASSWORD, option))
+		password = option.getActualValue();
+	if (role.isEmpty() && options.get(FOREIGN_SERVER_ROLE, option))
+		role = option.getActualValue();
+
+	ClumpletWriter dpb(ClumpletReader::dpbList, MAX_DPB_SIZE);
+	generateDPB(tdbb, dpb, user, password, role);
+
+	// Add additional server options, excluding generic ones that have specific isc tags
+	fillOptionsDPB(options, dpb);
+
+	if (server->getPluginName().hasData())
+	{
+		PathName providers(server->getPluginName());
+		providers.insert(0, "Providers=");
+		dpb.insertString(isc_dpb_config, providers);
+	}
+
+	if (connectionString.isEmpty())
+		connectionString = tdbb->getDatabase()->dbb_database_name.c_str();
+
+	ForeignTableConnection* connection = static_cast<ForeignTableConnection*>(
+		EDS::Manager::getProviderConnection(tdbb, this, dpb, connectionString, user, password, role,
+			EDS::TraScope::traCommon));
+
+	fb_assert(connection != NULL);
+
+	connection->getProviderInfo(tdbb);
+
+	return connection;
+}
+
+// Add server options to existing database parameter buffer,
+// but exclude adding options that should be added with separate isc_ tags
+void ForeignTableProvider::fillOptionsDPB(const Firebird::GenericMap<MetaStringOptionPair>& options, ClumpletWriter& dpb)
+{
+	string buffer;
+	for (const auto& option: options)
+	{
+		// Skip general options
+		if (isGenericOption(option.first))
+			continue;
+
+		buffer.append(option.first.c_str());
+		buffer.append(";");
+		buffer.append(option.second.getActualValue());
+		buffer.append(";");
+	}
+
+	if (buffer.hasData())
+		dpb.insertString(isc_dpb_foreign_options, buffer.c_str(), buffer.length());
+}
+
+// Check if the option is generic, i.e. it has a separate isc tag
+bool ForeignTableProvider::isGenericOption(const MetaName& option)
+{
+	for (const auto value : FOREIGN_GENERAL_OPTIONS)
+	{
+		if (strcmp(value, option.c_str()) == 0)
+			return true;
+	}
+
+	return false;
+}
+
+void ForeignTableStatement::setSql(const string& foreignSql)
+{
+	m_sql = foreignSql;
+}
+
+void ForeignTableConnection::getProviderInfo(thread_db* tdbb)
+{
+	info_db_provider dbProvider = info_db_provider::isc_info_db_code_last_value;
+	memset(m_sqlFeatures, false, sizeof(m_sqlFeatures));
+
+	FbLocalStatus status;
+	unsigned char buff[BUFFER_TINY];
+	{
+		EDS::EngineCallbackGuard guard(tdbb, *this, FB_FUNCTION);
+
+		const unsigned char info[] = {isc_info_db_provider, isc_info_end};
+		m_iscProvider.isc_database_info(&status, &m_handle, sizeof(info), info, sizeof(buff), buff);
+	}
+	if (status->getState() & IStatus::STATE_ERRORS)
+		raise(&status, tdbb, "isc_info_db_provider");
+
+	for (ClumpletReader p(ClumpletReader::InfoResponse, buff, sizeof(buff)); !p.isEof(); p.moveNext())
+	{
+		switch (p.getClumpTag())
+		{
+			case isc_info_db_provider:
+				dbProvider = static_cast<info_db_provider>(p.getInt());
+				break;
+		}
+	}
+
+	if (dbProvider == isc_info_db_code_firebird)
+	{
+		memset(m_sqlFeatures, true, sizeof(m_sqlFeatures));
+	}
+	else
+	{
+		{
+			EDS::EngineCallbackGuard guard(tdbb, *this, FB_FUNCTION);
+
+			const unsigned char info[] = {fb_info_sql_features, isc_info_end};
+			m_iscProvider.isc_database_info(&status, &m_handle, sizeof(info), info, sizeof(buff), buff);
+		}
+		if (status->getState() & IStatus::STATE_ERRORS)
+			raise(&status, tdbb, "fb_info_sql_features");
+
+		for (ClumpletReader p(ClumpletReader::InfoResponse, buff, sizeof(buff)); !p.isEof(); p.moveNext())
+		{
+			const UCHAR* b = p.getBytes();
+			switch (p.getClumpTag())
+			{
+				case fb_info_sql_features:
+					for (unsigned i = 0; i < p.getClumpLength(); i++)
+					{
+						if (b[i] == 0)
+							ERR_post(Arg::Gds(isc_random) << Arg::Str("Bad provider SQL feature value"));
+
+						if (b[i] < fb_feature_sql_max)
+							setSqlFeature(static_cast<info_sql_features>(b[i]));
+					}
+					break;
+			}
+		}
+	}
+}
+
+void ForeignTableStatement::openInternal(thread_db* tdbb, EDS::IscTransaction* transaction)
+{
+	fb_assert(isAllocated() && m_stmt_selectable);
+	fb_assert(!m_error);
+	fb_assert(!m_active);
+
+	m_transaction = transaction;
+
+	doOpen(tdbb);
+
+	m_active = true;
+	m_fetched = false;
+}
+
+void ForeignTableStatement::executeInternal(thread_db* tdbb, EDS::IscTransaction* transaction, record_param* org_rpb,
+	record_param* new_rpb, const Array<int>* skippedOrgRpb, const Array<int>* skippedNewRpb)
+{
+	fb_assert(isAllocated() && !m_stmt_selectable);
+	fb_assert(!m_active);
+
+	m_transaction = transaction;
+
+	// If the foreign provider didn't return the input parameters metadata,
+	// let's create it from the record descriptors
+	if (!m_connection.testFeature(fb_feature_prepared_input_types))
+	{
+		auto count = 0;
+
+		if (new_rpb)
+		{
+			count = new_rpb->rpb_record->getFormat()->fmt_count;
+			if (skippedNewRpb && skippedNewRpb->getCount() > 0)
+				count -= skippedNewRpb->getCount();
+		}
+		if (org_rpb)
+		{
+			count += org_rpb->rpb_record->getFormat()->fmt_count;
+			if (skippedOrgRpb && skippedOrgRpb->getCount() > 0)
+				count -= skippedOrgRpb->getCount() * OLD_PARAMS_MULTIPLIER;
+		}
+
+		DescList sqldaDescs(count);
+
+		if (new_rpb)
+			addRecordDescs(sqldaDescs, new_rpb->rpb_record, skippedNewRpb);
+
+		if (org_rpb)
+			addRecordDescs(sqldaDescs, org_rpb->rpb_record, skippedOrgRpb, OLD_PARAMS_MULTIPLIER);
+
+		remakeInputSQLDA(tdbb, count, sqldaDescs.begin());
+	}
+
+	if (new_rpb)
+	{
+		// New values should be set with 0 offset
+		setInParamsInternal(tdbb, new_rpb, 0, skippedNewRpb);
+	}
+
+	if (org_rpb)
+	{
+		USHORT offset = 0;
+		if (new_rpb)
+		{
+			offset = new_rpb->rpb_record->getFormat()->fmt_count;
+			if (skippedNewRpb && skippedNewRpb->getCount() > 0)
+				offset -= skippedNewRpb->getCount();
+		}
+		// The old value should be set after new ones (if they exist).
+		setInParamsInternal(tdbb, org_rpb, offset, skippedOrgRpb, OLD_PARAMS_MULTIPLIER);
+	}
+
+	doExecute(tdbb);
+}
+
+void ForeignTableStatement::addRecordDescs(DescList& outDescs, Record* record,
+	const Array<int>* skippedParameters, const USHORT multiplier)
+{
+	const Jrd::Format* format = record->getFormat();
+	USHORT count = format->fmt_count;
+
+	for (FB_SIZE_T i = 0; i < count; ++i)
+	{
+		if (skippedParameters && skippedParameters->exist(i))
+			continue;
+
+		for (USHORT j = 0; j < multiplier; ++j)
+		{
+			dsc src = format->fmt_desc[i];
+			src.dsc_address += (IPTR)record->getData();
+
+			outDescs.add(src);
+		}
+	}
+}
+
+void ForeignTableStatement::setInParamsInternal(thread_db* tdbb,
+	record_param* rpb,
+	const USHORT offset,
+	const Array<int>* skippedParameters,
+	const USHORT multiplier)
+{
+	Record* const record = rpb->rpb_record;
+	const Jrd::Format* format = record->getFormat();
+
+	USHORT skipped = 0;
+	for (USHORT i = 0; i < format->fmt_count; ++i)
+	{
+		if (skippedParameters && skippedParameters->exist(i))
+		{
+			++skipped;
+			continue;
+		}
+
+		dsc src = format->fmt_desc[i];
+		src.dsc_address += (IPTR)record->getData();
+		const USHORT pos = offset + multiplier * (i - skipped);
+		dsc& validDestDesc = m_inDescs[pos * 2];
+
+		for (USHORT j = pos; j < pos + multiplier; ++j)
+		{
+			dsc& dst = m_inDescs[j * 2];
+			dsc& null = m_inDescs[j * 2 + 1];
+
+			const bool srcNull = record->isNull(i);
+			*((SSHORT*) null.dsc_address) = (srcNull ? -1 : 0);
+
+			if (srcNull)
+			{
+				memset(dst.dsc_address, 0, dst.dsc_length);
+			}
+			else
+			{
+				// Parameter can be set multiple times,
+				// so it's necessary to copy properties from valid destination descriptor
+				if (j > pos)
+				{
+					dst.dsc_dtype = validDestDesc.dsc_dtype;
+					dst.dsc_length = validDestDesc.dsc_length;
+					dst.dsc_flags = validDestDesc.dsc_flags;
+					dst.dsc_scale = validDestDesc.dsc_scale;
+					dst.dsc_sub_type = validDestDesc.dsc_sub_type;
+				}
+
+				if (dst.isBlob())
+				{
+					dsc srcBlob;
+					srcBlob.clear();
+					ISC_QUAD srcBlobID;
+
+					if (src.isBlob())
+					{
+						srcBlob = src;
+					}
+					else
+					{
+						srcBlob.makeBlob(dst.getBlobSubType(), dst.getTextType(), &srcBlobID);
+						MOV_move(tdbb, &src, &srcBlob);
+					}
+
+					putExtBlob(tdbb, srcBlob, dst);
+				}
+				else
+					MOV_move(tdbb, &src, &dst);
+			}
+		}
+	}
+}
+
+bool ForeignTableStatement::fetchInternal(thread_db* tdbb, Record* record)
+{
+	fb_assert(isAllocated() && m_stmt_selectable);
+	fb_assert(!m_error);
+	fb_assert(m_active);
+
+	if (!doFetch(tdbb))
+		return false;
+
+	m_fetched = true;
+
+	const Jrd::Format* format = record->getFormat();
+	record->nullify();
+
+	USHORT recordIdx = 0;
+	for (unsigned int outIdx = 0; outIdx < m_outDescs.getCount() / 2; ++outIdx, ++recordIdx)
+	{
+		dsc toDesc = format->fmt_desc[recordIdx];
+		if (toDesc.isUnknown())
+		{
+			--outIdx;
+			continue;
+		}
+
+		toDesc.dsc_address += (IPTR)record->getData();
+
+		dsc& fromDesc = m_outDescs[outIdx * 2];
+		const dsc& null = m_outDescs[outIdx * 2 + 1];
+		dsc* local = &fromDesc;
+		dsc localDsc;
+		bid localBlobID;
+
+		const bool srcNull = (*(SSHORT*) null.dsc_address) == -1;
+		if (fromDesc.isBlob() && !srcNull)
+		{
+			localDsc = fromDesc;
+			localDsc.dsc_address = (UCHAR*) &localBlobID;
+			getExtBlob(tdbb, fromDesc, localDsc);
+			local = &localDsc;
+		}
+
+		if (!srcNull)
+		{
+			MOV_move(tdbb, local, &toDesc);
+			record->clearNull(recordIdx);
+		}
+	}
+
+	if (m_singleton)
+	{
+		if (doFetch(tdbb))
+		{
+			FbLocalStatus status;
+			Arg::Gds(isc_sing_select_err).copyTo(&status);
+			raise(&status, tdbb, "isc_dsql_fetch");
+		}
+		return false;
+	}
+
+	return true;
+}
+
+void ForeignTableAdapter::ensureConnect(thread_db* tdbb)
+{
+	if (!m_provider)
+		m_provider = static_cast<ForeignTableProvider*>(EDS::Manager::getProvider("Firebird"));
+
+	if (!m_connection || !m_connection->getAPIHandle())
+		m_connection = static_cast<ForeignTableConnection*>(m_provider->createForeignConnection(tdbb, m_server));
+}
+
+EDS::Statement* ForeignTableAdapter::createStatement(thread_db* tdbb, record_param* org_rpb, record_param* new_rpb,
+	const string& filter, const string& order)
+{
+	ensureConnect(tdbb);
+
+	// Prepare index array for a new record that contains read-only field indexes
+	// to exclude from the insert, update, and delete statements
+	if (new_rpb)
+		processRecord(m_skippedNewRpbIdx, new_rpb, true);
+
+	// Prepare index array for the original record
+	// whose fields shouldn't be used in the update or delete statements
+	if (org_rpb)
+		processRecord(m_skippedOrgRpbIdx, org_rpb);
+
+	Firebird::string sql;
+	getSql(sql, filter, order, org_rpb, new_rpb);
+
+	// Create a statement and return it for later use
+	ForeignTableStatement* statement = static_cast<ForeignTableStatement*>(m_connection->createStatement(sql));
+	statement->setSql(sql);
+	return statement;
+}
+
+void ForeignTableAdapter::execute(thread_db* tdbb, EDS::Statement* statement, record_param* org_rpb,
+	record_param* new_rpb)
+{
+	EDS::IscTransaction* transaction = static_cast<EDS::IscTransaction*>(
+		EDS::Transaction::getTransaction(tdbb, m_connection, EDS::TraScope::traCommon));
+
+	ForeignTableStatement* ftStatement = (ForeignTableStatement*)statement;
+	const string sql = ftStatement->getSql();
+
+	ftStatement->prepare(tdbb, transaction, sql, false);
+
+	const TimeoutTimer* timer = tdbb->getTimeoutTimer();
+	if (timer)
+		ftStatement->setTimeout(tdbb, timer->timeToExpire());
+
+	if (ftStatement->isSelectable())
+		ftStatement->openInternal(tdbb, transaction);
+	else
+		ftStatement->executeInternal(tdbb, transaction, org_rpb, new_rpb, &m_skippedOrgRpbIdx, &m_skippedNewRpbIdx);
+}
+
+bool ForeignTableAdapter::fetch(thread_db* tdbb, EDS::Statement* statement, Record* record)
+{
+	ForeignTableStatement* ftStatement = (ForeignTableStatement*)statement;
+
+	return ftStatement->fetchInternal(tdbb, record);
+}
+
+bool ForeignTableAdapter::testSqlFeature(thread_db* tdbb, info_sql_features value)
+{
+	ensureConnect(tdbb);
+	return m_connection->testSqlFeature(value);
+}
+
+void ForeignTableAdapter::getSql(string& sql, const string& filter, const string& order, record_param* org_rpb,
+	record_param* new_rpb) const
+{
+	vec<jrd_fld*>* vector = m_relation->rel_fields;
+	vec<jrd_fld*>::iterator fieldIter = vector->begin();
+	SSHORT id;
+
+	string schemaQualifiedName = "";
+
+	if (m_tableOptions.exist(MetaName(FOREIGN_TABLE_SCHEMA_NAME)))
+	{
+		schemaQualifiedName += m_tableOptions.get(MetaName(FOREIGN_TABLE_SCHEMA_NAME))->m_value;
+		schemaQualifiedName += ".";
+	}
+
+	if (m_tableOptions.exist(MetaName(FOREIGN_TABLE_NAME)))
+	{
+		schemaQualifiedName += m_tableOptions.get(MetaName(FOREIGN_TABLE_NAME))->m_value;
+	}
+	else
+	{
+		schemaQualifiedName += m_relation->rel_name.toQuotedString();
+	}
+
+	if (!org_rpb && !new_rpb)
+	{
+		sql += "select ";
+		sql += getRelationFieldsSql(true);
+		sql += " from ";
+		sql += schemaQualifiedName;
+
+		if (filter.hasData())
+		{
+			sql += " where 1 = 1 ";
+			sql += filter;
+		}
+
+		if (order.hasData())
+		{
+			sql += " ";
+			sql += order;
+		}
+		else if (m_foreignPKNames.hasData())
+		{
+			string orderPK(" order by ");
+			for (const MetaName& pkName : m_foreignPKNames)
+			{
+				ForeignField* field = nullptr;
+				m_foreignFields.get(pkName, field);
+				if (field)
+				{
+					orderPK.append(getOriginalFieldName(field->name));
+					orderPK.append(", ");
+				}
+			}
+			orderPK.rtrim(", ");
+			sql += orderPK;
+		}
+	}
+	else if (!org_rpb && new_rpb)
+	{
+		sql += "insert into ";
+		sql += schemaQualifiedName;
+		sql += "(";
+		sql += getRelationFieldsSql(false);
+		sql += ") ";
+		sql += "values";
+		sql += "(";
+
+		fieldIter = vector->begin();
+		for (const vec<jrd_fld*>::const_iterator end = vector->end(); fieldIter < end; ++fieldIter)
+		{
+			if (*fieldIter)
+			{
+				const jrd_fld* field = *fieldIter;
+				if (!isFieldReadOnlyOrComputed(field))
+				{
+					sql += "?, ";
+				}
+			}
+		}
+
+		sql.rtrim(", ");
+		sql += ") ";
+	}
+	else if (org_rpb && new_rpb)
+	{
+		sql += "update ";
+		sql += schemaQualifiedName;
+		sql += " set ";
+
+		for (const vec<jrd_fld*>::const_iterator end = vector->end(); fieldIter < end; ++fieldIter)
+		{
+			if (*fieldIter)
+			{
+				const jrd_fld* field = *fieldIter;
+				if (!isFieldReadOnlyOrComputed(field))
+				{
+					sql += getOriginalFieldName(field->fld_name);
+					sql += " = ?, ";
+				}
+			}
+		}
+
+		sql.rtrim(", ");
+
+		sql += getWhereClauseSql();
+	}
+	else
+	{
+		fb_assert(org_rpb && !new_rpb);
+		sql += "delete from ";
+		sql += schemaQualifiedName;
+
+		sql += getWhereClauseSql();
+	}
+}
+
+// Get a list of fields to access the foreign table.
+// In case of insertion into an external table, exclude read-only fields.
+string ForeignTableAdapter::getRelationFieldsSql(bool select) const
+{
+	vec<jrd_fld*>* vector = m_relation->rel_fields;
+	vec<jrd_fld*>::iterator fieldIter = vector->begin();
+
+	string fields = "";
+
+	for (const vec<jrd_fld*>::const_iterator end = vector->end(); fieldIter < end; ++fieldIter)
+	{
+		if (*fieldIter)
+		{
+			jrd_fld* field = *fieldIter;
+			if (!isFieldReadOnlyOrComputed(field) || select)
+			{
+				fields += getOriginalFieldName(field->fld_name);
+				fields += ", ";
+			}
+		}
+	}
+
+	fields.rtrim(", ");
+
+	return fields;
+}
+
+const string ForeignTableAdapter::getWhereClauseSql() const
+{
+	vec<jrd_fld*>* vector = m_relation->rel_fields;
+	vec<jrd_fld*>::iterator fieldIter = vector->begin();
+	SSHORT id = 0;
+
+	string where = " where 1 = 1 ";
+
+	const FB_BOOLEAN useKeys = m_foreignPKNames.getCount() > 0;
+
+	for (const vec<jrd_fld*>::const_iterator end = vector->end();
+		fieldIter < end;
+		++fieldIter, ++id)
+	{
+		if (*fieldIter)
+		{
+			jrd_fld* field = *fieldIter;
+			const MetaName name = field->fld_name;
+			if (!useKeys || m_foreignPKNames.exist(name))
+			{
+				if (!m_skippedOrgRpbIdx.exist(id))
+				{
+					const string origName = getOriginalFieldName(field->fld_name);
+					where += " and (";
+					where += origName;
+					where += " = ? or (";
+					where += origName;
+					where += " is null and ? is null)) ";
+				}
+			}
+		}
+	}
+
+	return where;
+}
+
+void ForeignTableAdapter::addTableOption(const MetaName& name, const string& value,
+	const ExternalValueType type)
+{
+	ForeignOption* option = m_tableOptions.put(name);
+	option->m_name = name;
+	option->m_value = value;
+	option->m_type = type;
+
+}
+
+void ForeignTableAdapter::addTableField(const MetaName& fieldName, const MetaName& optionName, const string& value,
+	const ExternalValueType type)
+{
+	ForeignField* field;
+	if (!m_foreignFields.get(fieldName, field))
+	{
+		field = FB_NEW_POOL(*m_relation->rel_pool) ForeignField(*m_relation->rel_pool);
+		field->name = fieldName;
+		m_foreignFields.put(fieldName, field);
+	}
+
+	ForeignOption* option = field->options.getOrPut(optionName);
+	option->m_name = optionName;
+	option->m_value = value;
+	option->m_type = type;
+
+	if (optionName == FOREIGN_TABLE_COLUMN_PK && getBooleanValue(value))
+		m_foreignPKNames.add(fieldName);
+	else if (optionName == FOREIGN_TABLE_COLUMN_READONLY && getBooleanValue(value))
+		m_readOnlyNames.add(fieldName);
+}
+
+const string ForeignTableAdapter::getOriginalFieldName(const MetaName& name) const
+{
+	string origName = name.c_str();
+
+	ForeignField* field = nullptr;
+	m_foreignFields.get(name, field);
+	if (field)
+	{
+		Firebird::GenericMap<MetaStringOptionPair>::Accessor accessor(&field->options);
+		for (bool found = accessor.getFirst(); found; found = accessor.getNext())
+		{
+			if (accessor.current()->second.m_name == FOREIGN_TABLE_COLUMN_NAME)
+		 		origName = accessor.current()->second.m_value;
+		}
+	}
+
+	return origName;
+}
+
+// In the case of a new record, read-only field indexes are saved
+// to exclude them from data change statements.
+// In the case of an original record, if at least one primary key is specified
+// in the field parameters, the condition will use the primary key(s).
+// If no primary keys are specified, the condition will contain all fields except blobs.
+void ForeignTableAdapter::processRecord(Array<int>& outSkippedRpbIdx, record_param* rpb, bool isNewRecord)
+{
+	vec<jrd_fld*>* vector = m_relation->rel_fields;
+	vec<jrd_fld*>::iterator fieldIter = vector->begin();
+	SSHORT id = 0;
+	const FB_BOOLEAN useKeys = m_foreignPKNames.getCount() > 0;
+
+	for (const vec<jrd_fld*>::const_iterator end = vector->end();
+		fieldIter < end;
+		++fieldIter, ++id)
+	{
+		if (outSkippedRpbIdx.exist(id))
+			continue;
+
+		if (*fieldIter)
+		{
+			jrd_fld* field = *fieldIter;
+			if (isNewRecord)
+			{
+				if (isFieldReadOnlyOrComputed(field))
+					outSkippedRpbIdx.add(id);
+			}
+			else
+			{
+				if (!useKeys || m_foreignPKNames.exist(field->fld_name))
+				{
+					const Jrd::Format* format = nullptr;
+					if (rpb)
+						format = rpb->rpb_record->getFormat();
+
+					if ((format && format->fmt_desc[id].isBlob()) || isFieldReadOnlyOrComputed(field))
+						outSkippedRpbIdx.add(id);
+				}
+				else
+					outSkippedRpbIdx.add(id);
+			}
+		}
+	}
+}
+
+bool ForeignTableAdapter::isFieldReadOnlyOrComputed(const jrd_fld* field) const
+{
+	return m_readOnlyNames.exist(field->fld_name) || field->fld_computation;
+}
diff --git a/src/jrd/ForeignServer.h b/src/jrd/ForeignServer.h
new file mode 100644
index 00000000000..3cab565d18c
--- /dev/null
+++ b/src/jrd/ForeignServer.h
@@ -0,0 +1,251 @@
+/*
+ *  The contents of this file are subject to the Initial
+ *  Developer's Public License Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the
+ *  License. You may obtain a copy of the License at
+ *  http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
+ *
+ *  Software distributed under the License is distributed AS IS,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing rights
+ *  and limitations under the License.
+ *
+ *  The Original Code was created by Vasiliy Yashkov
+ *  for the Firebird Open Source RDBMS project.
+ *
+ *  Copyright (c) 2025 Vasiliy Yashkov <vasiliy.yashkov13@gmail.com>
+ *  and all contributors signed below.
+ *
+ *  All Rights Reserved.
+ *  Contributor(s): ______________________________________.
+ */
+
+#ifndef JRD_FOREIGN_SERVER_H
+#define JRD_FOREIGN_SERVER_H
+
+#include "../common/utils_proto.h"
+#include "../common/classes/ClumpletWriter.h"
+#include "../jrd/jrd.h"
+#include "../jrd/recsrc/RecordSource.h"
+#include "../dsql/Nodes.h"
+#include "../jrd/extds/IscDS.h"
+
+// Foreign server option constants
+const char* const FOREIGN_SERVER_PROVIDER			= "PROVIDER";
+const char* const FOREIGN_SERVER_CONNECTION_STRING	= "CONNECTION_STRING";
+const char* const FOREIGN_SERVER_USER				= "USER";
+const char* const FOREIGN_SERVER_PASSWORD			= "PASSWORD";
+const char* const FOREIGN_SERVER_ROLE				= "ROLE";
+const char* const FOREIGN_SERVER_CHARSET			= "CHARSET";
+
+// Foreign table option constants
+const char* const FOREIGN_TABLE_SCHEMA_NAME			= "SCHEMA_NAME";
+const char* const FOREIGN_TABLE_NAME				= "TABLE_NAME";
+
+// Foreign table column option constants
+const char* const FOREIGN_TABLE_COLUMN_NAME			= "COLUMN_NAME";
+const char* const FOREIGN_TABLE_COLUMN_PK			= "PRIMARY_KEY";
+// Marks the field as read-only. The value of this field is computed by a foreign server.
+// Insert, update and delete operations are prohibited for this field.
+const char* const FOREIGN_TABLE_COLUMN_READONLY		= "READONLY";
+
+static const char* FOREIGN_GENERAL_OPTIONS[] =
+{
+	FOREIGN_SERVER_CONNECTION_STRING,
+	FOREIGN_SERVER_USER,
+	FOREIGN_SERVER_PASSWORD,
+	FOREIGN_SERVER_ROLE
+};
+
+namespace Jrd
+{
+	bool getExternalValue(const Firebird::string& value, const ExternalValueType type, Firebird::string& output);
+
+	struct ForeignOption
+	{
+		ForeignOption(MemoryPool& p)
+			: m_name(p),
+			  m_value(p),
+			  m_type(ExternalValueType::TYPE_STRING)
+		{}
+
+		ForeignOption(MemoryPool& p, const ForeignOption& o)
+			: m_name(p, o.m_name),
+			  m_value(p, o.m_value),
+			  m_type(o.m_type)
+		{}
+
+		Firebird::string getActualValue() const
+		{
+			Firebird::string out;
+			if (getExternalValue(m_value, m_type, out))
+				return out;
+
+			return m_value;
+		}
+
+		Firebird::MetaString m_name;
+		Firebird::string m_value;
+		ExternalValueType m_type;
+	};
+
+	typedef Firebird::FullPooledPair<Firebird::MetaString, ForeignOption> MetaStringOptionPair;
+
+	class ForeignServer
+	{
+	public:
+		explicit ForeignServer(MemoryPool& p, const MetaName& aName, const MetaName& aPlugin,
+			const MetaName& aSecurityClass)
+			: name(p, aName), plugin(p, aPlugin), securityClass(p, aSecurityClass), options(p)
+		{}
+
+		void addOption(const MetaName& name, const Firebird::string& value, const ExternalValueType type);
+		const Firebird::GenericMap<MetaStringOptionPair>& getOptions() const;
+
+		const MetaName& getServerName() const
+		{
+			return name;
+		}
+
+		const MetaName& getPluginName() const
+		{
+			return plugin;
+		}
+
+		const MetaName& getSecurityClass() const
+		{
+			return securityClass;
+		}
+
+	private:
+		const MetaName name;
+		const MetaName plugin;
+		const MetaName securityClass;
+		Firebird::GenericMap<MetaStringOptionPair> options;
+	};
+
+	class ForeignTableConnection : public EDS::IscConnection
+	{
+	public:
+		void getProviderInfo(thread_db* tdbb);
+		// Test specified SQL feature flag
+		bool testSqlFeature(info_sql_features value) const { return m_sqlFeatures[value]; }
+
+	private:
+		// Set specified SQL feature flag
+		void setSqlFeature(info_sql_features value) { m_sqlFeatures[value] = true; }
+
+		bool m_sqlFeatures[fb_feature_sql_max];
+	};
+
+	class ForeignTableProvider : public EDS::IscProvider
+	{
+	public:
+		ForeignTableConnection* createForeignConnection(thread_db* tdbb, ForeignServer* server);
+
+	private:
+		// Add extra options to database parameter buffer
+		void fillOptionsDPB(const Firebird::GenericMap<MetaStringOptionPair>& options, Firebird::ClumpletWriter& dpb);
+		// Test if an option is general
+		bool isGenericOption(const MetaName& option);
+	};
+
+	class ForeignTableStatement : public EDS::IscStatement
+	{
+	public:
+		void setSql(const Firebird::string& sql);
+		void openInternal(thread_db* tdbb, EDS::IscTransaction* transaction);
+		void executeInternal(thread_db* tdbb, EDS::IscTransaction* transaction, record_param* org_rpb,
+			record_param* new_rpb, const Firebird::Array<int>* skippedOrgRpb = nullptr,
+			const Firebird::Array<int>* skippedNewRpb = nullptr);
+		bool fetchInternal(thread_db* tdbb, Record* record);
+
+	private:
+		void addRecordDescs(DescList& outDescs,
+			Record* record,
+			const Firebird::Array<int>* skippedParameters = nullptr,
+			const USHORT multiplier = 1);
+		void setInParamsInternal(thread_db* tdbb,
+			record_param* rpb,
+			const USHORT offset,
+			const Firebird::Array<int>* skippedParameters = nullptr,
+			const USHORT multiplier = 1);
+	};
+
+	class ForeignTableAdapter
+	{
+	public:
+		class ForeignField
+		{
+		public:
+			explicit ForeignField(MemoryPool& p)
+				: name(p),
+				options(p)
+			{
+			}
+
+			MetaName name;
+			Firebird::GenericMap<MetaStringOptionPair> options;
+		};
+
+		explicit ForeignTableAdapter(MemoryPool& pool, jrd_rel* relation, ForeignServer* server)
+			: m_relation(relation),
+			m_server(server),
+			m_tableOptions(pool),
+			m_foreignFields(pool),
+			m_foreignPKNames(pool),
+			m_readOnlyNames(pool),
+			m_skippedNewRpbIdx(pool),
+			m_skippedOrgRpbIdx(pool)
+		{ }
+
+		~ForeignTableAdapter()
+		{
+			Firebird::LeftPooledMap<Firebird::MetaString, ForeignField*>::Accessor accessor(&m_foreignFields);
+			for (bool found = accessor.getFirst(); found; found = accessor.getNext())
+			{
+				Firebird::AutoPtr<ForeignField> field(accessor.current()->second);
+			}
+			m_foreignFields.clear();
+		}
+
+		EDS::Statement* createStatement(thread_db* tdbb, record_param* org_rpb = NULL, record_param* new_rpb = NULL,
+			const Firebird::string& filter = "", const Firebird::string& order = "");
+		void execute(thread_db* tdbb, EDS::Statement* statement, record_param* org_rpb = NULL,
+			record_param* new_rpb = NULL);
+		bool fetch(thread_db* tdbb, EDS::Statement* statement, Record* record);
+		bool testSqlFeature(thread_db* tdbb, info_sql_features value);
+
+		void addTableOption(const MetaName& name, const Firebird::string& value,
+			const ExternalValueType type);
+		void addTableField(const MetaName& fieldName, const MetaName& optionName, const Firebird::string& value,
+			const ExternalValueType type);
+		const Firebird::string getOriginalFieldName(const MetaName& name) const;
+
+		const ForeignServer* getServer() { return m_server; }
+
+	private:
+		void ensureConnect(thread_db* tdbb);
+		void getSql(Firebird::string& sql, const Firebird::string& filter, const Firebird::string& order,
+			record_param* org_rpb, record_param* new_rpb) const;
+		Firebird::string getRelationFieldsSql(bool select) const;
+		const Firebird::string getWhereClauseSql() const;
+		void processRecord(Firebird::Array<int>& outSkippedRpbIdx, record_param* rpb, bool isNewRecord = false);
+		bool isFieldReadOnlyOrComputed(const jrd_fld* field) const;
+
+		jrd_rel* m_relation;
+		Firebird::AutoPtr<ForeignServer> m_server;
+
+		ForeignTableProvider* m_provider = NULL;
+		ForeignTableConnection* m_connection = NULL;
+
+		Firebird::GenericMap<MetaStringOptionPair> m_tableOptions;
+		Firebird::LeftPooledMap<Firebird::MetaString, ForeignField*> m_foreignFields;
+		Firebird::SortedArray<MetaName> m_foreignPKNames;
+		Firebird::SortedArray<MetaName> m_readOnlyNames;
+		Firebird::Array<int> m_skippedNewRpbIdx;
+		Firebird::Array<int> m_skippedOrgRpbIdx;
+	};
+}
+
+#endif // JRD_FOREIGN_SERVER_H
diff --git a/src/jrd/Mapping.cpp b/src/jrd/Mapping.cpp
index 208d058ffcb..e0000da23cb 100644
--- a/src/jrd/Mapping.cpp
+++ b/src/jrd/Mapping.cpp
@@ -1040,6 +1040,13 @@ class SysPrivCache : public PermanentStorage
 		return c && (*c)->getPrivileges(name, sqlRole, trusted_role, system_privileges);
 	}
 
+	bool getForeignUserOptions(Jrd::Attachment* att, const string& name, const string& server,
+		GenericMap<MetaStringOptionPair>*& options)
+	{
+		AutoPtr<DbCache>* c = databases.get(att->att_database->dbb_filename);
+		return c && (*c)->getForeignUserOptions(name, server, options);
+	}
+
 	void populate(const PathName& db, Mapping::DbHandle& iDb, const string& name, const string* sqlRole,
 		const string& trusted_role)
 	{
@@ -1060,6 +1067,25 @@ class SysPrivCache : public PermanentStorage
 		setupIpc();
 	}
 
+	void populateForeignUserOptions(Jrd::Attachment* att, const string& name, const string& server)
+	{
+		AutoPtr<DbCache>* ptr = databases.get(att->att_database->dbb_filename);
+		DbCache* c = nullptr;
+		if (ptr)
+		{
+			c = ptr->get();
+			fb_assert(c);
+		}
+		else
+		{
+			c = FB_NEW_POOL(getPool()) DbCache(getPool());
+			*(databases.put(att->att_database->dbb_filename)) = c;
+		}
+		c->populateForeignUserOptions(att, name, server);
+
+		setupIpc();
+	}
+
 	void invalidate(const PathName& db)
 	{
 		AutoPtr<DbCache>* c = databases.get(db);
@@ -1074,7 +1100,8 @@ class SysPrivCache : public PermanentStorage
 		DbCache(MemoryPool& p)
 			: logins(p, userSql),
 			  roles(p, roleSql),
-			  pairs(p)
+			  pairs(p),
+			  users(p)
 		{ }
 
 		bool getPrivileges(const string& name, const string* sqlRole, const string& trusted_role,
@@ -1094,6 +1121,23 @@ class SysPrivCache : public PermanentStorage
 			return roles.getPrivileges((granted ? *sqlRole : trusted_role), system_privileges);
 		}
 
+		bool getForeignUserOptions(const string& name, const string& server,
+			GenericMap<MetaStringOptionPair>*& options)
+		{
+			string key;
+			key.append(name);
+			key.append(server);
+
+			UserOptions* userOptions;
+			if (users.get(key, userOptions))
+			{
+				options = userOptions->getOptions();
+				if (options && !options->isEmpty())
+					return true;
+			}
+			return false;
+		}
+
 		void populate(Mapping::DbHandle& iDb, const string& name, const string* sqlRole,
 			const string& trusted_role)
 		{
@@ -1104,11 +1148,17 @@ class SysPrivCache : public PermanentStorage
 			pairs.populate(name, sqlRole, iDb);
 		}
 
+		void populateForeignUserOptions(Jrd::Attachment* att, const string& name, const string& server)
+		{
+			users.populate(name, server, att);
+		}
+
 		void invalidate()
 		{
 			logins.invalidate();
 			roles.invalidate();
 			pairs.invalidate();
+			users.invalidate();
 		}
 
 	private:
@@ -1256,8 +1306,117 @@ class SysPrivCache : public PermanentStorage
 			}
 		};
 
+		class UserOptions
+		{
+		public:
+			UserOptions(MemoryPool& p)
+				:options(p)
+			{ }
+
+			void addOption(MetaString& name, string& value, ExternalValueType type)
+			{
+				ForeignOption* option = options.getOrPut(name);
+				option->m_name = name;
+				option->m_value = value;
+				option->m_type = type;
+			}
+
+			FullPooledMap<MetaString, ForeignOption>* getOptions()
+			{
+				return &options;
+			}
+
+		private:
+			FullPooledMap<MetaString, ForeignOption> options;
+		};
+
+		class UserMappingCache : public GenericMap<LeftPooledPair<string, UserOptions* > >
+		{
+		public:
+			UserMappingCache(MemoryPool& p)
+				: GenericMap(p)
+			{ }
+
+			~UserMappingCache()
+			{
+				deleteOptions();
+			}
+
+			void populate(const MetaString& name, const MetaName& server, Jrd::Attachment* att)
+			{
+				MAP_DEBUG(fprintf(stderr, "populate user mapping options for %s server %s\n",
+					name.c_str(), server.c_str()));
+				if (name.isEmpty() || server.isEmpty())
+					return;
+
+				IAttachment* attachment = att->getInterface();
+				ThrowLocalStatus st;
+				RefPtr<ITransaction> tra(REF_NO_INCR, attachment->startTransaction(&st, 0, nullptr));
+
+				Message par;
+				Field<Varying> user(par, MAX_SQL_IDENTIFIER_SIZE);
+				Field<Varying> foreignServer(par, MAX_SQL_IDENTIFIER_SIZE);
+				user = name.c_str();
+				foreignServer = server.c_str();
+
+				Message cols;
+				Field<Varying> option(cols, MAX_SQL_IDENTIFIER_SIZE);
+				Field<Varying> value(cols, MAX_VARY_COLUMN_SIZE);
+				Field<SSHORT> type(cols);
+
+				const char* sql = "select RDB$FOREIGN_OPTION_NAME, RDB$FOREIGN_OPTION_VALUE, "
+					"RDB$FOREIGN_OPTION_TYPE "
+					"from RDB$FOREIGN_MAPPING_OPTIONS "
+					"where RDB$USER = ? and RDB$FOREIGN_SERVER_NAME = ?";
+
+				RefPtr<IResultSet> curs(REF_NO_INCR, attachment->openCursor(&st, tra, 0, sql, 3,
+					par.getMetadata(), par.getBuffer(), cols.getMetadata(), nullptr, 0));
+
+				void* buffer = cols.getBuffer();
+
+				UserOptions* options = FB_NEW_POOL(getPool()) UserOptions(getPool());
+
+				while (curs->fetchNext(&st, buffer) == IStatus::RESULT_OK)
+				{
+					MetaString optionName = (const char*) option;
+					string optionValue = (const char*) value;
+					optionValue.trim();
+					ExternalValueType optionType = ExternalValueType::TYPE_STRING;
+					if (!type.null)
+						optionType = ExternalValueType(SSHORT(type));
+
+					MAP_DEBUG(fprintf(stderr, "populate user mapping option %s - '%s' with type %d\n",
+						optionName.c_str(), optionValue.c_str(), optionType));
+
+					options->addOption(optionName, optionValue, optionType);
+				}
+
+				string key;
+				key.append(name.c_str());
+				key.append(server.c_str());
+
+				put(key, options);
+			}
+
+			void invalidate()
+			{
+				deleteOptions();
+
+				clear();
+			}
+
+			void deleteOptions()
+			{
+				Accessor accessor(this);
+				for (bool found = accessor.getFirst(); found; found = accessor.getNext())
+					delete accessor.current()->second;
+			}
+		};
+
+
 		NameCache logins, roles;
 		RoleCache pairs;
+		UserMappingCache users;
 	};
 
 	SyncObject sync;
@@ -1654,6 +1813,33 @@ ULONG Mapping::mapUser(string& name, string& trustedRole)
 	return rc;
 }
 
+bool Mapping::getForeignUserMap(Jrd::Attachment* att, const string& name, const string& server,
+	GenericMap<MetaStringOptionPair>*& options)
+{
+	Sync sync(spCache().getSync(), FB_FUNCTION);
+	sync.lock(SYNC_SHARED);
+
+	MAP_DEBUG(fprintf(stderr, "Get user mapping: name=%s server=%s\n",
+		name.c_str(), server.c_str()));
+
+	bool res = spCache().getForeignUserOptions(att, name, server, options);
+
+	if (!res)
+	{
+		sync.unlock();
+		sync.lock(SYNC_EXCLUSIVE);
+
+		res = spCache().getForeignUserOptions(att, name, server, options);
+		if (!res)
+		{
+			spCache().populateForeignUserOptions(att, name, server);
+			res = spCache().getForeignUserOptions(att, name, server, options);
+		}
+	}
+
+	return res;
+}
+
 void Mapping::clearCache(const char* dbName, USHORT index)
 {
 	mappingIpc->clearCache(dbName, index);
diff --git a/src/jrd/Mapping.h b/src/jrd/Mapping.h
index bbbe21badd7..1a7a130fd64 100644
--- a/src/jrd/Mapping.h
+++ b/src/jrd/Mapping.h
@@ -35,6 +35,7 @@
 #include "../common/classes/Hash.h"
 #include "../common/classes/GenericMap.h"
 #include "../jrd/recsrc/RecordSource.h"
+#include "../jrd/ForeignServer.h"
 #include "../jrd/Monitoring.h"
 #include "../jrd/scl.h"
 
@@ -72,6 +73,9 @@ class Mapping
 	static constexpr ULONG MAP_DOWN = 2;
 	// Now mapper is ready to perform main task and provide mapped login and trusted role.
 	ULONG mapUser(Firebird::string& name, Firebird::string& trustedRole);
+	// Get option map for connecting to an foreign server for user.
+	bool getForeignUserMap(Jrd::Attachment* att, const Firebird::string& name, const Firebird::string& server,
+		Firebird::GenericMap<Jrd::MetaStringOptionPair>*& options);
 
 	// Do not keep mainHandle opened longer than needed
 	void clearMainHandle();
diff --git a/src/jrd/RecordSourceNodes.cpp b/src/jrd/RecordSourceNodes.cpp
index cd72088503e..ba9c466718c 100644
--- a/src/jrd/RecordSourceNodes.cpp
+++ b/src/jrd/RecordSourceNodes.cpp
@@ -314,6 +314,22 @@ SortNode* SortNode::pass2(thread_db* tdbb, CompilerScratch* csb)
 	return this;
 }
 
+void SortNode::collectStreams(SortedStreamList& streamList) const
+{
+	for (const NestConst<ValueExprNode>* i = expressions.begin(); i != expressions.end(); ++i)
+		(*i)->collectStreams(streamList);
+}
+
+bool SortNode::containsStream(StreamType stream, bool only) const
+{
+	SortedStreamList nodeStreams;
+	collectStreams(nodeStreams);
+
+	return only ?
+		nodeStreams.getCount() == 1 && nodeStreams[0] == stream :
+		nodeStreams.exist(stream);
+}
+
 bool SortNode::computable(CompilerScratch* csb, StreamType stream, bool allowOnlyCurrentStream)
 {
 	for (NestConst<ValueExprNode>* i = expressions.begin(); i != expressions.end(); ++i)
diff --git a/src/jrd/RecordSourceNodes.h b/src/jrd/RecordSourceNodes.h
index 7630539a20c..c405090e344 100644
--- a/src/jrd/RecordSourceNodes.h
+++ b/src/jrd/RecordSourceNodes.h
@@ -68,6 +68,9 @@ class SortNode : public Firebird::PermanentStorage, public Printable
 	SortNode* copy(thread_db* tdbb, NodeCopier& copier) const;
 	SortNode* pass1(thread_db* tdbb, CompilerScratch* csb);
 	SortNode* pass2(thread_db* tdbb, CompilerScratch* csb);
+
+	void collectStreams(SortedStreamList& streamList) const;
+	bool containsStream(StreamType stream, bool only = false) const;
 	bool computable(CompilerScratch* csb, StreamType stream, bool allowOnlyCurrentStream);
 	void findDependentFromStreams(const CompilerScratch* csb,
 		StreamType currentStream, SortedStreamList* streamList);
diff --git a/src/jrd/Relation.h b/src/jrd/Relation.h
index 63dd4256e86..d7b3d5a97c9 100644
--- a/src/jrd/Relation.h
+++ b/src/jrd/Relation.h
@@ -270,11 +270,15 @@ class jrd_rel : public pool_alloc<type_rel>
 
 	Firebird::Mutex rel_drop_mutex;
 
+	ForeignTableAdapter* rel_foreign_adapter;
+
 	bool isSystem() const noexcept;
 	bool isTemporary() const noexcept;
-	bool isVirtual() const noexcept ;
+	bool isVirtual() const noexcept;
 	bool isView() const noexcept;
 
+	bool isPageBased() const noexcept;
+
 	ObjectType getObjectType() const noexcept
 	{
 		return isView() ? obj_view : obj_relation;
@@ -436,6 +440,11 @@ inline bool jrd_rel::isView() const noexcept
 	return (rel_flags & REL_jrd_view);
 }
 
+inline bool jrd_rel::isPageBased() const noexcept
+{
+	return (!rel_file && !rel_view_rse && !isVirtual() && !rel_foreign_adapter);
+}
+
 inline RelationPages* jrd_rel::getPages(thread_db* tdbb, TraNumber tran, bool allocPages)
 {
 	if (!isTemporary())
diff --git a/src/jrd/constants.h b/src/jrd/constants.h
index 54102cb4a54..a6c95cf34a4 100644
--- a/src/jrd/constants.h
+++ b/src/jrd/constants.h
@@ -110,6 +110,7 @@ inline constexpr const char* REL_SCOPE_GTT_DELETE	= "global temporary table %s o
 inline constexpr const char* REL_SCOPE_EXTERNAL		= "external table %s";
 inline constexpr const char* REL_SCOPE_VIEW			= "view %s";
 inline constexpr const char* REL_SCOPE_VIRTUAL		= "virtual table %s";
+inline constexpr const char* REL_SCOPE_FOREIGN		= "foreign table %s";
 
 // literal strings in rdb$ref_constraints to be used to identify
 // the cascade actions for referential constraints. Used
@@ -234,7 +235,8 @@ enum rel_t {
 	rel_external = 2,
 	rel_virtual = 3,
 	rel_global_temp_preserve = 4,
-	rel_global_temp_delete = 5
+	rel_global_temp_delete = 5,
+	rel_foreign = 6
 };
 
 // procedure types
@@ -412,7 +414,13 @@ static inline constexpr const char* DDL_TRIGGER_ACTION_NAMES[][2] =
 	{"DROP", "MAPPING"},
 	{"CREATE", "SCHEMA"},
 	{"ALTER", "SCHEMA"},
-	{"DROP", "SCHEMA"}
+	{"DROP", "SCHEMA"},
+	{"CREATE", "SERVER"},
+	{"ALTER", "SERVER"},
+	{"DROP", "SERVER"},
+	{"CREATE", "USER MAPPING FOR"},
+	{"ALTER", "USER MAPPING FOR"},
+	{"DROP", "USER MAPPING FOR"}
 };
 
 inline constexpr int DDL_TRIGGER_BEFORE	= 0;
@@ -468,6 +476,12 @@ inline constexpr int DDL_TRIGGER_DROP_MAPPING			= 47;
 inline constexpr int DDL_TRIGGER_CREATE_SCHEMA			= 48;
 inline constexpr int DDL_TRIGGER_ALTER_SCHEMA			= 49;
 inline constexpr int DDL_TRIGGER_DROP_SCHEMA			= 50;
+inline constexpr int DDL_TRIGGER_CREATE_FOREIGN_SERVER		= 51;
+inline constexpr int DDL_TRIGGER_ALTER_FOREIGN_SERVER		= 52;
+inline constexpr int DDL_TRIGGER_DROP_FOREIGN_SERVER		= 53;
+inline constexpr int DDL_TRIGGER_CREATE_USER_MAPPING		= 54;
+inline constexpr int DDL_TRIGGER_ALTER_USER_MAPPING		= 55;
+inline constexpr int DDL_TRIGGER_DROP_USER_MAPPING		= 56;
 
 // that's how database trigger action types are encoded
 //    (TRIGGER_TYPE_DB | type)
@@ -497,7 +511,8 @@ inline constexpr unsigned OPT_STATIC_STREAMS = 64;
 						 fb_feature_session_reset, \
 						 fb_feature_read_consistency, \
 						 fb_feature_statement_timeout, \
-						 fb_feature_statement_long_life}
+						 fb_feature_statement_long_life, \
+						 fb_feature_prepared_input_types}
 
 inline constexpr int WITH_GRANT_OPTION = 1;
 inline constexpr int WITH_ADMIN_OPTION = 2;
@@ -505,4 +520,11 @@ inline constexpr int WITH_ADMIN_OPTION = 2;
 // Max length of the string returned by ERROR_TEXT context variable
 inline constexpr USHORT MAX_ERROR_MSG_LENGTH = 1024 * METADATA_BYTES_PER_CHAR; // 1024 UTF-8 characters
 
+enum ExternalValueType
+{
+	TYPE_STRING = 0,
+	TYPE_ENV = 1,
+	TYPE_FILE = 2
+};
+
 #endif // JRD_CONSTANTS_H
diff --git a/src/jrd/dfw.epp b/src/jrd/dfw.epp
index 8c0cf546351..2e9691dc138 100644
--- a/src/jrd/dfw.epp
+++ b/src/jrd/dfw.epp
@@ -128,6 +128,7 @@
 #include "../jrd/CryptoManager.h"
 #include "../jrd/Mapping.h"
 #include "../jrd/shut_proto.h"
+#include "../jrd/ForeignServer.h"
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
@@ -500,6 +501,7 @@ static bool set_linger(thread_db*, SSHORT, DeferredWork*, jrd_tra*);
 static bool clear_cache(thread_db*, SSHORT, DeferredWork*, jrd_tra*);
 static bool change_repl_state(thread_db*, SSHORT, DeferredWork*, jrd_tra*);
 static string remove_icu_info_from_attributes(const QualifiedName&, const string&);
+static bool delete_foreign_server(thread_db*, SSHORT, DeferredWork*, jrd_tra*);
 
 // ----------------------------------------------------------------
 
@@ -563,6 +565,9 @@ static ISC_STATUS getErrorCodeByObjectType(int obj_type)
 	case obj_package_body:
 		err_code = isc_package_name;
 		break;
+	case obj_foreign_server:
+		err_code = isc_foreign_server;
+		break;
 	default:
 		fb_assert(false);
 	}
@@ -1333,6 +1338,7 @@ static inline constexpr deferred_task task_table[] =
 	{ dfw_set_linger, set_linger },
 	{ dfw_clear_cache, clear_cache },
 	{ dfw_change_repl_state, change_repl_state },
+	{ dfw_delete_foreign_server, delete_foreign_server },
 	{ dfw_null, NULL }
 };
 
@@ -5069,10 +5075,16 @@ static bool delete_relation(thread_db* tdbb, SSHORT phase, DeferredWork* work, j
 
 		// if this is a view (or even if we don't know), delete dependency lists
 
-		if (relation->rel_view_rse || !(relation->rel_flags & REL_scanned)) {
+		if (relation->rel_foreign_adapter || relation->rel_view_rse || !(relation->rel_flags & REL_scanned)) {
 			MET_delete_dependencies(tdbb, work->getQualifiedName(), obj_view, transaction);
 		}
 
+		if (relation->rel_foreign_adapter)
+		{
+			delete relation->rel_foreign_adapter;
+			relation->rel_foreign_adapter = NULL;
+		}
+
 		// Now that the data, pointer, and index pages are gone,
 		// get rid of the relation itself
 
@@ -5394,6 +5406,9 @@ static bool find_depend_in_dfw(thread_db*	tdbb,
 	case obj_udf:
 		dfw_type = dfw_delete_function;
 		break;
+	case obj_foreign_server:
+		dfw_type = dfw_delete_foreign_server;
+		break;
 	default:
 		fb_assert(false);
 		break;
@@ -6835,3 +6850,29 @@ static string get_string(const dsc* desc)
 
 	return string(str, length);
 }
+
+static bool delete_foreign_server(thread_db* tdbb, SSHORT phase, DeferredWork* work, jrd_tra* transaction)
+{
+/**************************************
+ *
+ *	d e l e t e _ f o r e i g n _ s e r v e r
+ *
+ **************************************
+ *
+ * Functional description
+ *	Check if it is allowable to delete
+ *	an foreign server, and if so, clean up after it.
+ *
+ **************************************/
+
+	SET_TDBB(tdbb);
+
+	switch (phase)
+	{
+	case 1:
+		check_dependencies(tdbb, work->getQualifiedName(), {}, obj_foreign_server, transaction);
+		break;
+	}
+
+	return false;
+}
diff --git a/src/jrd/drq.h b/src/jrd/drq.h
index 1f8e344d3b0..c42993c60ee 100644
--- a/src/jrd/drq.h
+++ b/src/jrd/drq.h
@@ -242,6 +242,26 @@ enum drq_type_t
 	drq_e_pub_tab_all,		// erase relation from all publication
 	drq_l_rel_con,			// lookup relation constraint
 	drq_l_rel_fld_name,		// lookup relation field name
+	drq_l_f_server_name,		// lookup foreign server name
+	drq_f_server_exist,		// check if foreign server exists
+	drq_s_f_server,			// store foreign server (CreateAlterForeignServerNode)
+	drq_m_f_server,			// modify foreign server (CreateAlterForeignServerNode)
+	drq_drop_f_server,		// drop foreign server
+	drq_s_f_server_opt,		// store foreign server options (CreateAlterForeignServerNode)
+	drq_drop_f_server_opt,		// drop foreign server option
+	drq_drop_f_server_opts,		// drop foreign server options
+	drq_s_f_tbl_opt,		// store foreign table options (RelationNode)
+	drq_drop_f_tbl_opt,		// drop foreign table option
+	drq_drop_f_tbl_opts,		// drop foreign table options
+	drq_u_mapping_exist,		// check if user mapping exists
+	drq_s_u_mapping,		// store user mapping (CreateAlterUserMappingNode)
+	drq_m_u_mapping,		// modify user mapping (CreateAlterUserMappingNode)
+	drq_drop_u_mapping,		// drop user mapping
+	drq_s_u_mapping_opt,		// store user mapping options (CreateAlterUserMappingNode)
+	drq_drop_u_mapping_opt,		// drop user mapping option
+	drq_drop_u_m_opts,		// drop user mapping options
+	drq_s_f_tbl_f_opt,		// store foreign field option (RelationNode)
+	drq_drop_f_tbl_f_opt,		// drop foreign field option
 
 	drq_MAX
 };
diff --git a/src/jrd/dyn_util.epp b/src/jrd/dyn_util.epp
index 7c962d9223c..69d17c7c54e 100644
--- a/src/jrd/dyn_util.epp
+++ b/src/jrd/dyn_util.epp
@@ -301,6 +301,19 @@ bool DYN_UTIL_check_unique_name_nothrow(thread_db* tdbb, jrd_tra* transaction,
 			break;
 		}
 
+		case obj_foreign_server:
+			requestHandle.reset(tdbb, drq_l_f_server_name, DYN_REQUESTS);
+
+			FOR(REQUEST_HANDLE requestHandle TRANSACTION_HANDLE transaction)
+				FS IN RDB$FOREIGN_SERVERS
+				WITH FS.RDB$FOREIGN_SERVER_NAME EQ object_name.object.c_str()
+			{
+				*errorCode = 325;	// isc_dyn_foreign_server_already_exists
+			}
+			END_FOR
+
+			break;
+
 		default:
 			fb_assert(false);
 	}
diff --git a/src/jrd/extds/ExtDS.cpp b/src/jrd/extds/ExtDS.cpp
index 660c10aa6b5..1a4b3f28a6d 100644
--- a/src/jrd/extds/ExtDS.cpp
+++ b/src/jrd/extds/ExtDS.cpp
@@ -195,7 +195,7 @@ static bool isCurrentAccount(UserId* currUserID,
 }
 
 Connection* Manager::getConnection(thread_db* tdbb, const string& dataSource,
-	const string& user, const string& pwd, const string& role, TraScope tra_scope)
+	const string& user, const string& pwd, const string& role, const PathName& providers, TraScope tra_scope)
 {
 	Attachment* att = tdbb->getAttachment();
 	if (att->att_ext_call_depth >= MAX_CALLBACKS)
@@ -214,8 +214,23 @@ Connection* Manager::getConnection(thread_db* tdbb, const string& dataSource,
 	if (!isCurrentAtt)
 		prv->generateDPB(tdbb, dpb, user, pwd, role);
 
+	if (!providers.isEmpty())
+		dpb.insertString(isc_dpb_config, providers);
+
+	return getProviderConnection(tdbb, prv, dpb, dbName.ToString(), user, pwd, role, tra_scope);
+}
+
+Connection* Manager::getProviderConnection(thread_db* tdbb, Provider* prv,
+	ClumpletWriter& dpb, const string& dbName, const string& user,
+	const string& pwd, const string& role, TraScope tra_scope)
+{
+	Attachment* att = tdbb->getAttachment();
+
+	const bool isCurrentAtt = (prv->getName() == INTERNAL_PROVIDER_NAME) &&
+	 	isCurrentAccount(att->att_user, user, pwd, role);
+
 	// look up at connections already bound to current attachment
-	Connection* conn = prv->getBoundConnection(tdbb, dbName, dpb, tra_scope, isCurrentAtt);
+	Connection* conn = prv->getBoundConnection(tdbb, dbName.ToPathName(), dpb, tra_scope, isCurrentAtt);
 	if (conn)
 		return conn;
 
@@ -235,7 +250,7 @@ Connection* Manager::getConnection(thread_db* tdbb, const string& dataSource,
 
 		while (true)
 		{
-			conn = m_connPool->getConnection(tdbb, prv, hash, dbName, dpb, ch);
+			conn = m_connPool->getConnection(tdbb, prv, hash, dbName.ToPathName(), dpb, ch);
 			if (!conn)
 				break;
 
@@ -254,7 +269,7 @@ Connection* Manager::getConnection(thread_db* tdbb, const string& dataSource,
 	if (!conn)
 	{
 		// finally, create new connection
-		conn = prv->createConnection(tdbb, dbName, dpb, tra_scope);
+		conn = prv->createConnection(tdbb, dbName.ToPathName(), dpb, tra_scope);
 		if (!isCurrentAtt)
 			m_connPool->addConnection(tdbb, conn, hash);
 	}
@@ -320,6 +335,10 @@ void Provider::generateDPB(thread_db* tdbb, ClumpletWriter& dpb,
 	if ((getFlags() & prvTrustedAuth) &&
 		isCurrentAccount(attachment->att_user, user, pwd, role))
 	{
+		if (!user.isEmpty()) {
+			dpb.insertString(isc_dpb_user_name, user);
+		}
+
 		attachment->att_user->populateDpb(dpb, true);
 	}
 	else
diff --git a/src/jrd/extds/ExtDS.h b/src/jrd/extds/ExtDS.h
index a5bef54ecd9..11210053264 100644
--- a/src/jrd/extds/ExtDS.h
+++ b/src/jrd/extds/ExtDS.h
@@ -156,7 +156,13 @@ class Manager : public Firebird::PermanentStorage
 	static Provider* getProvider(const Firebird::string& prvName);
 	static Connection* getConnection(Jrd::thread_db* tdbb,
 		const Firebird::string& dataSource, const Firebird::string& user,
-		const Firebird::string& pwd, const Firebird::string& role, TraScope tra_scope);
+		const Firebird::string& pwd, const Firebird::string& role,
+		const Firebird::PathName& providers, TraScope tra_scope);
+	static Connection* getProviderConnection(Jrd::thread_db* tdbb,
+		Provider* provider, Firebird::ClumpletWriter& dpb,
+		const Firebird::string& database, const Firebird::string& user,
+		const Firebird::string& pwd, const Firebird::string& role,
+		TraScope tra_scope);
 
 	static ConnectionsPool* getConnPool(bool create);
 
diff --git a/src/jrd/extds/IscDS.cpp b/src/jrd/extds/IscDS.cpp
index 57f6680f4b4..1194fb86561 100644
--- a/src/jrd/extds/IscDS.cpp
+++ b/src/jrd/extds/IscDS.cpp
@@ -213,6 +213,7 @@ void IscConnection::attach(thread_db* tdbb)
 							m_features[fb_feature_multi_statements] = true;
 							m_features[fb_feature_multi_transactions] = true;
 							m_features[fb_feature_statement_long_life] = true;
+							m_features[fb_feature_prepared_input_types] = true;
 						}
 						break;
 					}
@@ -698,6 +699,38 @@ void IscStatement::doClose(thread_db* tdbb, bool drop)
 void IscStatement::doSetInParams(thread_db* tdbb, unsigned int count, const MetaString* const* names,
 	const NestConst<Jrd::ValueExprNode>* params)
 {
+	// If the foreign provider didn't return the input parameters metadata,
+	// let's create it from the node descriptors
+	if (!m_connection.testFeature(fb_feature_prepared_input_types))
+	{
+		const NestConst<ValueExprNode>* jrdVar = params;
+		NonPooledMap<const ValueExprNode*, dsc*> paramDescs(getPool());
+		DescList sqldaDescs(count);
+
+		Request* request = tdbb->getRequest();
+
+		for (FB_SIZE_T i = 0; i < count; ++i, ++jrdVar)
+		{
+			dsc* src = nullptr;
+
+			if (!paramDescs.get(*jrdVar, src))
+			{
+				src = EVL_expr(tdbb, request, *jrdVar);
+				paramDescs.put(*jrdVar, src);
+			}
+
+			if (src)
+				sqldaDescs.add(*src);
+			else
+			{
+				dsc& dst = sqldaDescs.add();
+				dst.makeNullString();
+			}
+		}
+
+		remakeInputSQLDA(tdbb, count, sqldaDescs.begin());
+	}
+
 	Statement::doSetInParams(tdbb, count, names, params);
 
 	if (names)
@@ -714,6 +747,40 @@ void IscStatement::doSetInParams(thread_db* tdbb, unsigned int count, const Meta
 	}
 }
 
+void IscStatement::remakeInputSQLDA(thread_db* tdbb, FB_SIZE_T count, const dsc* descs)
+{
+	if (count <= 0)
+		return;
+
+	Request* request = tdbb->getRequest();
+
+	m_inDescs.clear();
+	m_in_buffer.clear();
+	delete[] (char*) m_in_xsqlda;
+
+	m_in_xsqlda = (XSQLDA*) FB_NEW_POOL (getPool()) char [XSQLDA_LENGTH(count)];
+	m_in_xsqlda->sqld = (SSHORT) count;
+	m_in_xsqlda->sqln = (SSHORT) count;
+	m_in_xsqlda->version = SQLDA_VERSION1;
+
+	XSQLVAR* xVar = m_in_xsqlda->sqlvar;
+
+	for (FB_SIZE_T i = 0; i < count; ++i, ++xVar)
+	{
+		const dsc& src = descs[i];
+
+		SLONG sqlLen, sqlSubType, sqlScale, sqlType;
+		src.getSqlInfo(&sqlLen, &sqlSubType, &sqlScale, &sqlType);
+
+		xVar->sqllen = sqlLen;
+		xVar->sqlsubtype = sqlSubType;
+		xVar->sqlscale = sqlScale;
+		xVar->sqltype = sqlType;
+	}
+
+	parseSQLDA(m_in_xsqlda, m_in_buffer, m_inDescs);
+}
+
 //  IscBlob
 
 IscBlob::IscBlob(IscConnection& conn) :
diff --git a/src/jrd/extds/IscDS.h b/src/jrd/extds/IscDS.h
index 54744bb9c16..4e3fef6f069 100644
--- a/src/jrd/extds/IscDS.h
+++ b/src/jrd/extds/IscDS.h
@@ -576,6 +576,8 @@ class IscStatement : public Statement
 	friend class IscConnection;
 
 public:
+	typedef Firebird::HalfStaticArray<dsc, 64> DescList;
+
 	FB_API_HANDLE& getAPIHandle() { return m_handle; }
 
 protected:
@@ -593,6 +595,8 @@ class IscStatement : public Statement
 	virtual void doSetInParams(Jrd::thread_db* tdbb, unsigned int count,
 		const Firebird::MetaString* const* names, const NestConst<Jrd::ValueExprNode>* params);
 
+	void remakeInputSQLDA(Jrd::thread_db* tdbb, FB_SIZE_T count, const dsc* descs);
+
 	IscTransaction* getIscTransaction() { return (IscTransaction*) m_transaction; }
 
 	IscProvider& m_iscProvider;
diff --git a/src/jrd/fields.h b/src/jrd/fields.h
index 05e2885456a..9cebd28caa6 100644
--- a/src/jrd/fields.h
+++ b/src/jrd/fields.h
@@ -237,3 +237,10 @@
 
 	FIELD(fld_sch_name		, nam_sch_name		, dtype_text	, MAX_SQL_IDENTIFIER_LEN	, dsc_text_type_metadata	, NULL		, true		, ODS_14_0)
 	FIELD(fld_text_max		, nam_text_max		, dtype_varying, MAX_VARY_COLUMN_SIZE / METADATA_BYTES_PER_CHAR * METADATA_BYTES_PER_CHAR, dsc_text_type_metadata, NULL, true, ODS_14_0)
+
+	FIELD(fld_fs_name				, nam_fs_name			, dtype_text, 		MAX_SQL_IDENTIFIER_LEN	, dsc_text_type_metadata, NULL, true	, ODS_14_0)
+	FIELD(fld_fs_data_wrapper_name	, nam_fs_wrapper_name	, dtype_varying,	MAX_SQL_IDENTIFIER_LEN	, 0						, NULL, true	, ODS_14_0)
+
+	FIELD(fld_fo_name	, nam_fo_name	, dtype_varying	, MAX_SQL_IDENTIFIER_LEN, 0		, NULL	, true	, ODS_14_0)
+	FIELD(fld_fo_value	, nam_fo_value	, dtype_varying	, MAX_VARY_COLUMN_SIZE	, 0		, NULL	, true	, ODS_14_0)
+	FIELD(fld_fo_type	, nam_fo_type	, dtype_short	, sizeof(SSHORT)		, 0 	, NULL	, true	, ODS_14_0)
diff --git a/src/jrd/grant.epp b/src/jrd/grant.epp
index 96c2feb1df5..16931241b8a 100644
--- a/src/jrd/grant.epp
+++ b/src/jrd/grant.epp
@@ -549,6 +549,21 @@ static void get_object_info(thread_db* tdbb,
 		}
 		END_FOR
 	}
+	else if (obj_type == obj_foreign_server)
+	{
+		AutoCacheRequest request(tdbb, irq_grant20, IRQ_REQUESTS);
+
+		FOR(REQUEST_HANDLE request)
+			X IN RDB$FOREIGN_SERVERS WITH
+				X.RDB$FOREIGN_SERVER_NAME EQ object_name.object.c_str()
+		{
+			s_class = X.RDB$SECURITY_CLASS;
+			default_class = "";
+			owner = X.RDB$OWNER_NAME;
+			view = false;
+		}
+		END_FOR
+	}
 	else
 	{
 		s_class = SCL_getDdlSecurityClassName(obj_type, object_name.schema);
diff --git a/src/jrd/idx.h b/src/jrd/idx.h
index 7add255f031..e3c797ada8b 100644
--- a/src/jrd/idx.h
+++ b/src/jrd/idx.h
@@ -355,6 +355,39 @@ static inline constexpr struct ini_idx_t indices[] =
 	INDEX(58, rel_schemas, idx_unique, 1, ODS_14_0)
 		SEGMENT(f_sch_schema, idx_metadata)		// schema name
 	}},
+	// define index RDB$INDEX_59 for RDB$FOREIGN_SERVERS RDB$FOREIGN_SERVER_NAME;
+	INDEX(59, rel_foreign_servers, idx_unique, 1, ODS_14_0)
+		SEGMENT(f_fs_name, idx_metadata),	// foreign server name
+	}},
+	// define index RDB$INDEX_60 for RDB$FOREIGN_SERVERS_OPTIONS RDB$FOREIGN_SERVER_NAME, RDB$FOREIGN_OPTION_NAME;
+	INDEX(60, rel_foreign_server_options, idx_unique, 2, ODS_14_0)
+		SEGMENT(f_fso_server_name, idx_metadata),	// foreign server name
+		SEGMENT(f_fso_name, idx_metadata),	// foreign server option name
+	}},
+	// define index RDB$INDEX_61 for RDB$FOREIGN_TABLE_OPTIONS RDB$TABLE_NAME, RDB$FOREIGN_TABLE_OPTION;
+	INDEX(61, rel_foreign_tbl_options, idx_unique, 3, ODS_14_0)
+		SEGMENT(f_fto_sch_name, idx_metadata),	// foreign table schema
+		SEGMENT(f_fto_tbl_name, idx_metadata),	// foreign table name
+		SEGMENT(f_fto_name, idx_metadata),	// foreign table option name
+	}},
+	// define index RDB$INDEX_62 for RDB$FOREIGN_USER_MAPPINGS RDB$USER, RDB$FOREIGN_SERVER_NAME;
+	INDEX(62, rel_foreign_user_mappings, idx_unique, 2, ODS_14_0)
+		SEGMENT(f_fum_user, idx_metadata),	// user
+		SEGMENT(f_fum_server_name, idx_metadata),	// foreign server name
+	}},
+	// define index RDB$INDEX_63 for RDB$FOREIGN_MAPPING_OPTIONS RDB$USER, RDB$FOREIGN_SERVER_NAME, RDB$FOREIGN_OPTION_NAME;
+	INDEX(63, rel_foreign_mapping_options, idx_unique, 3, ODS_14_0)
+		SEGMENT(f_fmo_user, idx_metadata),	// user
+		SEGMENT(f_fmo_server_name, idx_metadata),	// foreign server name
+		SEGMENT(f_fmo_name, idx_metadata),	// user mapping option name
+	}},
+	// define index RDB$INDEX_64 for RDB$FOREIGN_TABLE_FIELD_OPTIONS RDB$TABLE_NAME, RDB$FIELD_NAME, RDB$FOREIGN_OPTION_NAME;
+	INDEX(64, rel_foreign_tbl_f_options, idx_unique, 4, ODS_14_0)
+		SEGMENT(f_ftfo_sch_name, idx_metadata),	// foreign table schema
+		SEGMENT(f_ftfo_tbl_name, idx_metadata),	// foreign table name
+		SEGMENT(f_ftfo_fld_name, idx_metadata),	// foreign table field name
+		SEGMENT(f_ftfo_name, idx_metadata),	// foreign option name
+	}}
 };
 
 #define SYSTEM_INDEX_COUNT FB_NELEM(indices)
diff --git a/src/jrd/irq.h b/src/jrd/irq.h
index d659cc2401a..f33b2a0cf4a 100644
--- a/src/jrd/irq.h
+++ b/src/jrd/irq.h
@@ -175,6 +175,7 @@ enum irq_type_t
 	irq_grant17,			// process grant option (database)
 	irq_grant18,			// process grant option (filters)
 	irq_grant19,			// process grant option (roles)
+	irq_grant20,			// process grant option (foreign servers)
 	irq_l_curr_format,		// lookup table's current format
 	irq_c_relation3,		// lookup relation in phase 0 to cleanup
 	irq_linger,				// get database linger value
@@ -183,6 +184,12 @@ enum irq_type_t
 	irq_func_param_dep,		// check function parameter dependency
 	irq_l_pub_tab_state,	// lookup publication state for a table
 	irq_l_index_cnstrt,     // lookup index for constraint
+	irq_f_s_security,		// verify security for foreign server
+	irq_find_f_server,		// find foreign server by name
+	irq_find_f_s_opt,		// find foreign server options by server name
+	irq_find_f_server_dep,		// check foreign server dependency
+	irq_find_f_tbl_opt,		// find foreign table options by table name
+	irq_find_f_tbl_f_opt,		// find foreign field options by table and field names
 
 	irq_MAX
 };
diff --git a/src/jrd/jrd.h b/src/jrd/jrd.h
index 2e3644c89cc..a83a866271a 100644
--- a/src/jrd/jrd.h
+++ b/src/jrd/jrd.h
@@ -133,6 +133,8 @@ class dsql_dbb;
 class PreparedStatement;
 class TraceManager;
 class MessageNode;
+class ForeignServer;
+class ForeignTableAdapter;
 
 
 // Relation trigger definition
diff --git a/src/jrd/met.epp b/src/jrd/met.epp
index 09c38b34d04..c243f2f9446 100644
--- a/src/jrd/met.epp
+++ b/src/jrd/met.epp
@@ -93,6 +93,7 @@
 #include "../common/classes/MsgPrint.h"
 #include "../jrd/Function.h"
 #include "../jrd/trace/TraceJrdHelpers.h"
+#include "../jrd/ForeignServer.h"
 #include "firebird/impl/msg_helper.h"
 
 
@@ -4009,6 +4010,27 @@ void MET_scan_relation(thread_db* tdbb, jrd_rel* relation)
 			EXT_file(relation, REL.RDB$EXTERNAL_FILE); //, &REL.RDB$EXTERNAL_DESCRIPTION);
 		}
 
+		if (!REL.RDB$FOREIGN_SERVER_NAME.NULL && REL.RDB$FOREIGN_SERVER_NAME[0])
+		{
+			const MetaName foreignServerName(REL.RDB$FOREIGN_SERVER_NAME);
+			const QualifiedName serverName(foreignServerName);
+
+			ForeignServer* server = MET_get_foreign_server(tdbb, foreignServerName);
+			MemoryPool* pool = relation->rel_pool;
+			relation->rel_foreign_adapter = FB_NEW_POOL(*pool) ForeignTableAdapter(*pool, relation, server);
+
+			if (dependencies)
+			{
+				Array<CompilerScratch::Dependency> dependencies;
+				CompilerScratch::Dependency dependency(obj_foreign_server);
+				dependency.name = &serverName;
+				dependencies.push(dependency);
+
+				const QualifiedName depName(REL.RDB$RELATION_NAME, REL.RDB$SCHEMA_NAME);
+				MET_store_dependencies(tdbb, dependencies, 0, depName, obj_view, depTrans);
+			}
+		}
+
 		if (!REL.RDB$RELATION_TYPE.NULL)
 		{
 			switch (REL.RDB$RELATION_TYPE)
@@ -4035,6 +4057,10 @@ void MET_scan_relation(thread_db* tdbb, jrd_rel* relation)
 					fb_assert(relation->rel_flags & REL_temp_tran);
 					relation->rel_flags |= REL_temp_tran;
 					break;
+				case rel_foreign:
+					if (!attachment->isGbak())
+						fb_assert(relation->rel_foreign_adapter);
+					break;
 				default:
 					fb_assert(false);
 			}
@@ -4218,6 +4244,13 @@ void MET_scan_relation(thread_db* tdbb, jrd_rel* relation)
 				break;
 			}
 		}
+
+		if (relation->rel_foreign_adapter)
+		{
+			// Load table options table field options if present
+			MET_load_table_options(tdbb, relation);
+		}
+
 		blob->BLB_close(tdbb);
 		blob = 0;
 
@@ -4594,6 +4627,8 @@ ULONG MET_get_rel_flags_from_TYPE(USHORT type)
 			break;
 		case rel_external:
 			break;
+		case rel_foreign:
+			break;
 		case rel_view:
 			ret |= REL_jrd_view;
 			break;
@@ -5358,6 +5393,7 @@ void MET_store_dependencies(thread_db* tdbb,
 			dpdo_name = &dependency.function->getName();
 			break;
 		case obj_index:
+		case obj_foreign_server:
 			name = *dependency.name;
 			dpdo_name = &name;
 			break;
@@ -5898,3 +5934,130 @@ bool MET_check_schema_exists(thread_db* tdbb, const MetaName& name)
 
 	return false;
 }
+
+ForeignServer* MET_get_foreign_server(thread_db* tdbb, const MetaName& foreignServerName)
+{
+/**************************************
+ *
+ *	M E T _ g e t _ f o r e i g n _ s e r v e r
+ *
+ **************************************
+ *
+ * Functional description
+ *      Find foreign server by its name in RDB$FOREIGN_SERVERS.
+ *      If not found return NULL.
+ *
+ *      Return a pointer to the foreign server.
+ *
+ **************************************/
+	SET_TDBB(tdbb);
+	Database* dbb = tdbb->getDatabase();
+	CHECK_DBB(dbb);
+
+	Attachment* attachment = tdbb->getAttachment();
+
+	// Find foreign server in system table
+	AutoCacheRequest reqFS(tdbb, irq_find_f_server, IRQ_REQUESTS);
+
+	bool found = false;
+	MetaName foreignServerPlugin;
+	MetaName securityClass;
+
+	FOR(REQUEST_HANDLE reqFS)
+		FSER IN RDB$FOREIGN_SERVERS
+		WITH FSER.RDB$FOREIGN_SERVER_NAME EQ foreignServerName.c_str()
+	{
+		foreignServerPlugin = FSER.RDB$FOREIGN_SERVER_WRAPPER;
+		securityClass = FSER.RDB$SECURITY_CLASS;
+
+		found = true;
+	}
+	END_FOR
+
+	if (!found)
+		status_exception::raise(Arg::Gds(isc_dyn_foreign_server_not_found) << Arg::Str(foreignServerName));
+
+	MemoryPool& pool = *tdbb->getDefaultPool();
+	ForeignServer* foreignServer = FB_NEW_POOL(pool) ForeignServer(pool, foreignServerName, foreignServerPlugin,
+		securityClass);
+
+	// Find foreign server options in system table
+	AutoCacheRequest reqFSOpt(tdbb, irq_find_f_s_opt, IRQ_REQUESTS);
+
+	FOR(REQUEST_HANDLE reqFSOpt)
+		FSOPT IN RDB$FOREIGN_SERVER_OPTIONS
+		WITH FSOPT.RDB$FOREIGN_SERVER_NAME EQ foreignServerName.c_str()
+	{
+		const MetaName optionName(FSOPT.RDB$FOREIGN_OPTION_NAME);
+		const string option = FSOPT.RDB$FOREIGN_OPTION_VALUE;
+		ExternalValueType type = ExternalValueType::TYPE_STRING;
+		if (!FSOPT.RDB$FOREIGN_OPTION_TYPE.NULL)
+			type = ExternalValueType(FSOPT.RDB$FOREIGN_OPTION_TYPE);
+		foreignServer->addOption(optionName, option, type);
+	}
+	END_FOR
+
+	return foreignServer;
+}
+
+void MET_load_table_options(thread_db* tdbb, jrd_rel* relation)
+{
+/**************************************
+ *
+ *	M E T _ l o a d _ t a b l e _ o p t i o n s
+ *
+ **************************************
+ *
+ * Functional description
+ *      Find the foreign table options and foreign field options by table name
+ *      and add to an existing relation object.
+ *
+ **************************************/
+	SET_TDBB(tdbb);
+	Database* dbb = tdbb->getDatabase();
+	CHECK_DBB(dbb);
+
+	Attachment* attachment = tdbb->getAttachment();
+
+	// Find foreign table options in system table
+	AutoCacheRequest request(tdbb, irq_find_f_tbl_opt, IRQ_REQUESTS);
+
+	FOR(REQUEST_HANDLE request)
+		FTOPT IN RDB$FOREIGN_TABLE_OPTIONS
+		WITH FTOPT.RDB$SCHEMA_NAME EQ relation->rel_name.schema.c_str() AND
+			FTOPT.RDB$TABLE_NAME EQ relation->rel_name.object.c_str()
+	{
+		const MetaName optionName(FTOPT.RDB$FOREIGN_OPTION_NAME);
+		const string option = FTOPT.RDB$FOREIGN_OPTION_VALUE;
+		relation->rel_foreign_adapter->addTableOption(optionName, option, ExternalValueType::TYPE_STRING);
+	}
+	END_FOR
+
+	vec<jrd_fld*>* vector = relation->rel_fields;
+
+	if (vector)
+	{
+		for (const auto field : *vector)
+		{
+			if (field)
+			{
+				// Find foreign field options in system table
+				AutoCacheRequest request(tdbb, irq_find_f_tbl_f_opt, IRQ_REQUESTS);
+
+				FOR(REQUEST_HANDLE request)
+					FTFOPT IN RDB$FOREIGN_TABLE_FIELD_OPTIONS
+					WITH FTFOPT.RDB$SCHEMA_NAME EQ relation->rel_name.schema.c_str()AND
+						FTFOPT.RDB$TABLE_NAME EQ relation->rel_name.object.c_str() AND
+						FTFOPT.RDB$FIELD_NAME EQ field->fld_name.c_str()
+				{
+					const MetaName name(FTFOPT.RDB$FOREIGN_OPTION_NAME);
+					const string value = FTFOPT.RDB$FOREIGN_OPTION_VALUE;
+					relation->rel_foreign_adapter->addTableField(field->fld_name, name, value,
+						ExternalValueType::TYPE_STRING);
+				}
+				END_FOR
+			}
+		}
+	}
+}
+
diff --git a/src/jrd/met_proto.h b/src/jrd/met_proto.h
index fba22677afd..8107074c0bc 100644
--- a/src/jrd/met_proto.h
+++ b/src/jrd/met_proto.h
@@ -158,4 +158,7 @@ std::optional<ObjectType> MET_qualify_existing_name(Jrd::thread_db* tdbb, Jrd::Q
 	const Firebird::ObjectsArray<Firebird::MetaString>* schemaSearchPath = nullptr);
 bool MET_check_schema_exists(Jrd::thread_db* tdbb, const Jrd::MetaName& name);
 
+Jrd::ForeignServer* MET_get_foreign_server(Jrd::thread_db* tdbb, const Jrd::MetaName& foreignServerName);
+void MET_load_table_options(Jrd::thread_db* tdbb, Jrd::jrd_rel* relation);
+
 #endif // JRD_MET_PROTO_H
diff --git a/src/jrd/names.h b/src/jrd/names.h
index 661c7974b79..55499096e16 100644
--- a/src/jrd/names.h
+++ b/src/jrd/names.h
@@ -490,3 +490,20 @@ NAME("RDB$TABLE_SCHEMA_NAME", nam_tab_sch_name)
 NAME("RDB$CONST_SCHEMA_NAME_UQ", nam_con_sch_name_uq)
 NAME("MON$SEARCH_PATH", nam_mon_search_path)
 NAME("RDB$TEXT_MAX", nam_text_max)
+
+NAME("RDB$FOREIGN_SERVERS", nam_foreign_servers)
+NAME("RDB$FOREIGN_SERVER_NAME", nam_fs_name)
+NAME("RDB$FOREIGN_SERVER_WRAPPER", nam_fs_wrapper_name)
+
+NAME("RDB$FOREIGN_SERVER_OPTIONS", nam_foreign_server_options)
+NAME("RDB$FOREIGN_OPTION_NAME", nam_fo_name)
+NAME("RDB$FOREIGN_OPTION_VALUE", nam_fo_value)
+NAME("RDB$FOREIGN_OPTION_TYPE", nam_fo_type)
+
+NAME("RDB$FOREIGN_TABLE_OPTIONS", nam_foreign_tbl_options)
+
+NAME("RDB$FOREIGN_USER_MAPPINGS", nam_foreign_user_mappings)
+
+NAME("RDB$FOREIGN_MAPPING_OPTIONS", nam_foreign_mapping_options)
+
+NAME("RDB$FOREIGN_TABLE_FIELD_OPTIONS", nam_foreign_tbl_f_options)
diff --git a/src/jrd/obj.h b/src/jrd/obj.h
index 5246253b90b..c37a6edf261 100644
--- a/src/jrd/obj.h
+++ b/src/jrd/obj.h
@@ -79,7 +79,10 @@ inline constexpr ObjectType obj_index_condition = 37;
 inline constexpr ObjectType obj_schema = 38;
 inline constexpr ObjectType obj_schemas = 39;
 
-inline constexpr ObjectType obj_type_MAX = 40;
+inline constexpr ObjectType obj_foreign_server = 40;
+inline constexpr ObjectType obj_foreign_servers = 41;
+
+inline constexpr ObjectType obj_type_MAX = 42;
 
 // used in the parser only / no relation with obj_type_MAX (should be greater)
 inline constexpr ObjectType obj_user_or_role = 100;
@@ -141,6 +144,7 @@ inline bool isDdlObject(ObjectType objectType, bool* useSchema = nullptr) noexce
 		case obj_jobs:
 		case obj_tablespaces:
 		case obj_schemas:
+		case obj_foreign_servers:
 			return true;
 
 		default:
@@ -185,6 +189,8 @@ inline constexpr const char* getDdlSecurityName(ObjectType object_type) noexcept
 			return "SQL$TABLESPACES";
 		case obj_schemas:
 			return "SQL$SCHEMAS";
+		case obj_foreign_servers:
+			return "SQL$FOREIGN_SERVERS";
 		default:
 			return "";
 	}
@@ -229,6 +235,8 @@ inline const char* getDdlObjectName(ObjectType object_type)
 			return "TABLESPACE";
 		case obj_schemas:
 			return "SCHEMA";
+		case obj_foreign_servers:
+			return "FOREIGN SERVER";
 		default:
 			fb_assert(false);
 			return "<unknown object type>";
diff --git a/src/jrd/optimizer/Optimizer.cpp b/src/jrd/optimizer/Optimizer.cpp
index afec33c3e83..5d06abdb971 100644
--- a/src/jrd/optimizer/Optimizer.cpp
+++ b/src/jrd/optimizer/Optimizer.cpp
@@ -87,6 +87,7 @@
 #include "../jrd/ConfigTable.h"
 
 #include "../jrd/optimizer/Optimizer.h"
+#include "../jrd/ForeignServer.h"
 
 using namespace Jrd;
 using namespace Firebird;
@@ -1205,7 +1206,7 @@ void Optimizer::compileRelation(StreamType stream)
 
 	tail->csb_idx = nullptr;
 
-	if (needIndices && !relation->rel_file && !relation->isVirtual())
+	if (needIndices && !relation->rel_file && !relation->isVirtual() && !relation->rel_foreign_adapter)
 	{
 		const auto relPages = relation->getPages(tdbb);
 		IndexDescList idxList;
@@ -1520,10 +1521,7 @@ SortedStream* Optimizer::generateSort(const StreamList& streams,
 		{
 			const auto* relation = csb->csb_rpt[item.stream].csb_relation;
 
-			if (relation &&
-				!relation->rel_file &&
-				!relation->rel_view_rse &&
-				!relation->isVirtual())
+			if (relation && relation->isPageBased())
 			{
 				item.desc = nullptr;
 				--fieldCount;
@@ -2725,6 +2723,7 @@ RecordSource* Optimizer::generateRetrieval(StreamType stream,
 	// inversion component of the boolean.
 
 	RecordSource* rsb = nullptr;
+	ForeignTableScan* foreignRsb = nullptr;
 	InversionNode* inversion = nullptr;
 	BoolExprNode* condition = nullptr;
 	Array<DbKeyRangeNode*> dbkeyRanges;
@@ -2735,6 +2734,11 @@ RecordSource* Optimizer::generateRetrieval(StreamType stream,
 		// External table
 		rsb = FB_NEW_POOL(getPool()) ExternalTableScan(csb, alias, stream, relation);
 	}
+	else if (relation->rel_foreign_adapter)
+	{
+		// Foreign table
+		rsb = foreignRsb = FB_NEW_POOL(getPool()) ForeignTableScan(csb, alias, stream, relation);
+	}
 	else if (relation->isVirtual())
 	{
 		// Virtual table: monitoring or security
@@ -2810,6 +2814,22 @@ RecordSource* Optimizer::generateRetrieval(StreamType stream,
 		}
 	}
 
+	if (foreignRsb && sortClause)
+	{
+		// If this stream corresponds to a foreign table, check whether the sort
+		// (if locally computable) can be distributed to the foreign server level
+
+		if (const auto sortNode = *sortClause)
+		{
+			if (sortNode->containsStream(stream) &&
+				sortNode->computable(csb, stream, true) &&
+				foreignRsb->applySort(tdbb, sortNode))
+			{
+				*sortClause = nullptr;
+			}
+		}
+	}
+
 	if (outerFlag)
 	{
 		// Now make another pass thru the outer conjuncts only, finding unused,
@@ -2832,13 +2852,29 @@ RecordSource* Optimizer::generateRetrieval(StreamType stream,
 			!(iter->nodFlags & ExprNode::FLAG_RESIDUAL) &&
 			iter->computable(csb, INVALID_STREAM, false))
 		{
+			const bool containsStream = iter->containsStream(stream);
+			const bool locallyComputable = iter->computable(csb, stream, true);
+
+			// If this stream corresponds to a foreign table
+			// and if this conjunct is locally computable,
+			// try applying the condition at the foreign server level
+
+			if (foreignRsb &&
+				containsStream &&
+				locallyComputable &&
+				foreignRsb->applyBoolean(tdbb, *iter))
+			{
+				fb_assert(!inversion);
+				iter |= CONJUNCT_USED;
+				continue;
+			}
+
 			// If inversion is available, utilize all conjuncts that refer to
 			// the stream being retrieved. Otherwise, utilize only conjuncts
 			// that are local to this stream. The remaining ones are left in piece
 			// as possible candidates for a merge/hash join.
 
-			if ((inversion && iter->containsStream(stream)) ||
-				(!inversion && iter->computable(csb, stream, true)))
+			if ((inversion && containsStream) || (!inversion && locallyComputable))
 			{
 				compose(getPool(), &boolean, iter);
 				iter |= CONJUNCT_USED;
diff --git a/src/jrd/optimizer/Optimizer.h b/src/jrd/optimizer/Optimizer.h
index 9e6292f6918..76009fcba6c 100644
--- a/src/jrd/optimizer/Optimizer.h
+++ b/src/jrd/optimizer/Optimizer.h
@@ -528,6 +528,11 @@ class Optimizer final : public Firebird::PermanentStorage
 		return firstRows;
 	}
 
+	SortNode** getSortAddress() const
+	{
+		return rse->rse_sorted.getAddress();
+	}
+
 	RecordSource* applyBoolean(RecordSource* rsb, ConjunctIterator& iter);
 	RecordSource* applyLocalBoolean(RecordSource* rsb,
 									const StreamList& streams,
diff --git a/src/jrd/optimizer/Retrieval.cpp b/src/jrd/optimizer/Retrieval.cpp
index a2a46b3fadc..0f379085ee9 100644
--- a/src/jrd/optimizer/Retrieval.cpp
+++ b/src/jrd/optimizer/Retrieval.cpp
@@ -249,7 +249,7 @@ InversionCandidate* Retrieval::getInversion()
 
 	InversionCandidate* invCandidate = nullptr;
 
-	if (relation && !relation->rel_file && !relation->isVirtual())
+	if (relation && !relation->rel_file && !relation->isVirtual() && !relation->rel_foreign_adapter)
 	{
 		InversionCandidateList inversions;
 
diff --git a/src/jrd/recsrc/ForeignTableScan.cpp b/src/jrd/recsrc/ForeignTableScan.cpp
new file mode 100644
index 00000000000..ebb51dd3aa3
--- /dev/null
+++ b/src/jrd/recsrc/ForeignTableScan.cpp
@@ -0,0 +1,634 @@
+/*
+ *  The contents of this file are subject to the Initial
+ *  Developer's Public License Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the
+ *  License. You may obtain a copy of the License at
+ *  http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
+ *
+ *  Software distributed under the License is distributed AS IS,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing rights
+ *  and limitations under the License.
+ *
+ *  The Original Code was created by Vasiliy Yashkov
+ *  for the Firebird Open Source RDBMS project.
+ *
+ *  Copyright (c) 2025 Vasiliy Yashkov <vasiliy.yashkov13@gmail.com>
+ *  and all contributors signed below.
+ *
+ *  All Rights Reserved.
+ *  Contributor(s): ______________________________________.
+ */
+
+#include "firebird.h"
+#include "../jrd/intl.h"
+#include "../jrd/intl_proto.h"
+#include "../jrd/req.h"
+#include "../jrd/cmp_proto.h"
+#include "../jrd/evl_proto.h"
+#include "../jrd/met_proto.h"
+#include "../jrd/mov_proto.h"
+#include "../jrd/vio_proto.h"
+#include "../dsql/BoolNodes.h"
+#include "../dsql/StmtNodes.h"
+
+#include "../jrd/ForeignServer.h"
+#include "RecordSource.h"
+
+#include "../jrd/optimizer/Optimizer.h"
+
+using namespace Firebird;
+using namespace Jrd;
+
+ForeignTableScan::ForeignTableScan(CompilerScratch* csb, const string& alias,
+									StreamType stream, jrd_rel* relation)
+	: RecordStream(csb, stream),
+	m_relation(relation),
+	m_alias(csb->csb_pool, alias),
+	m_filterNodes(csb->csb_pool),
+	m_sortNode(NULL)
+{
+	m_impure = csb->allocImpure<Impure>();
+	m_cardinality = csb->csb_rpt[stream].csb_cardinality;
+}
+
+void ForeignTableScan::internalOpen(thread_db* tdbb) const
+{
+	Database* const dbb = tdbb->getDatabase();
+	Request* const request = tdbb->getRequest();
+	Impure* const impure = request->getImpure<Impure>(m_impure);
+
+	impure->irsb_flags = irsb_open;
+
+	record_param* const rpb = &request->req_rpb[m_stream];
+	rpb->getWindow(tdbb).win_flags = 0;
+
+	// Append (using AND) priorly approved booleans into the WHERE part of the query.
+	//
+	// Convert FieldNode's with stream == m_stream into field names,
+	// preserve expressions containing those fields "as is"
+	// (transforming them into another syntax, if possible),
+	// other nodes are evaluated and converted into literals.
+	//
+	// Examples (with m_stream == 0):
+	//
+	// ComparativeBoolNode (blr_geq)
+	//   FieldNode(stream == 0)
+	//   LiteralNode (1)
+	//
+	// The original condition looks like T1.ID >= 1
+	// and it should be converted into:
+	//   WHERE ... AND ID >= 1
+
+	if (!impure->statement)
+	{
+		string filterSql;
+		for (const auto boolean : m_filterNodes)
+		{
+			appendFilterValue(" and ", filterSql);
+			decomposeBoolean(tdbb, filterSql, boolean);
+		}
+
+		string orderSql;
+		if (m_sortNode)
+		{
+			orderSql.append(" order by ");
+
+			const USHORT sortCnt = m_sortNode->expressions.getCount();
+			for (USHORT i = 0; i < sortCnt; i++)
+			{
+				const ValueExprNode* node = m_sortNode->expressions[i];
+				processArgument(tdbb, orderSql, node, nodeIs<NotBoolNode>(node));
+				const SortDirection direction = m_sortNode->direction[i];
+				const NullsPlacement nulls = m_sortNode->nullOrder[i];
+
+				if (direction == ORDER_ASC)
+					orderSql.append(" asc ");
+				else if (direction == ORDER_DESC)
+					orderSql.append(" desc ");
+
+				if (nulls == NULLS_FIRST)
+					orderSql.append(" nulls first ");
+				else if (nulls == NULLS_LAST)
+					orderSql.append(" nulls last ");
+
+				orderSql.append(", ");
+			}
+
+			orderSql.rtrim(", ");
+		}
+
+		impure->statement = m_relation->rel_foreign_adapter->createStatement(tdbb, NULL, NULL, filterSql, orderSql);
+	}
+
+	m_relation->rel_foreign_adapter->execute(tdbb, impure->statement);
+
+	VIO_record(tdbb, rpb, MET_current(tdbb, m_relation), request->req_pool);
+
+	rpb->rpb_number.setValue(BOF_NUMBER);
+}
+
+void ForeignTableScan::close(thread_db* tdbb) const
+{
+	Request* const request = tdbb->getRequest();
+
+	invalidateRecords(request);
+
+	Impure* const impure = request->getImpure<Impure>(m_impure);
+
+	if (impure->irsb_flags & irsb_open)
+	{
+		impure->irsb_flags &= ~irsb_open;
+		if (impure->statement)
+		{
+			impure->statement->close(tdbb);
+			impure->statement = nullptr;
+		}
+	}
+}
+
+bool ForeignTableScan::internalGetRecord(thread_db* tdbb) const
+{
+	JRD_reschedule(tdbb);
+
+	Request* const request = tdbb->getRequest();
+	record_param* const rpb = &request->req_rpb[m_stream];
+	Impure* const impure = request->getImpure<Impure>(m_impure);
+
+	if (!(impure->irsb_flags & irsb_open))
+	{
+		rpb->rpb_number.setValid(false);
+		return false;
+	}
+
+	rpb->rpb_runtime_flags &= ~RPB_CLEAR_FLAGS;
+
+	Record* const record = rpb->rpb_record;
+
+	if (m_relation->rel_foreign_adapter->fetch(tdbb, impure->statement, record))
+	{
+		rpb->rpb_number.increment();
+		rpb->rpb_number.setValid(true);
+
+		return true;
+	}
+
+	impure->statement->close(tdbb);
+	impure->statement = nullptr;
+
+	rpb->rpb_number.setValid(false);
+	return false;
+}
+
+bool ForeignTableScan::refetchRecord(thread_db* /*tdbb*/) const
+{
+	return true;
+}
+
+WriteLockResult ForeignTableScan::lockRecord(thread_db* tdbb) const
+{
+	SET_TDBB(tdbb);
+
+	status_exception::raise(Arg::Gds(isc_record_lock_not_supp));
+}
+
+void ForeignTableScan::getLegacyPlan(thread_db* tdbb, string& plan, unsigned level) const
+{
+	if (!level)
+		plan += "(";
+
+	plan += printName(tdbb, m_alias) + " NATURAL";
+
+	if (!level)
+		plan += ")";
+}
+
+void ForeignTableScan::internalGetPlan(thread_db* tdbb, PlanEntry& planEntry, unsigned level, bool recurse) const
+{
+	planEntry.className = "ForeignTableScan";
+
+	planEntry.lines.add().text = "Table " + printName(tdbb, m_relation->rel_name.toQuotedString(), m_alias) + " Full Scan";
+	printOptInfo(planEntry.lines);
+
+	planEntry.objectType = m_relation->getObjectType();
+	planEntry.objectName = m_relation->rel_name;
+
+	if (m_alias.hasData() && m_relation->rel_name.toQuotedString() != m_alias)
+		planEntry.alias = m_alias;
+}
+
+bool ForeignTableScan::applyBoolean(thread_db* tdbb, const BoolExprNode* boolean)
+{
+	// Check whether the boolean can be decoded into a condition
+	// which is computable on the foreign server.
+	//
+	// If so, save it inside the object and return true.
+	//
+	// Maybe also do:
+	//
+	// m_cardinality *= Optimizer::getSelectivity(boolean);
+	//
+	// Beware:	boolean could also be BinaryBoolNode(blr_or) with either value expressions
+	// 			or BinaryBoolNode(blr_or)'s or BinaryBoolNode(blr_and)'s buried inside.
+	//
+	// If the decision whether this boolean can be applied is deferred till the execution time,
+	// return false so that the optimizer would re-check this condition after retrieval.
+
+	if (checkBoolean(tdbb, boolean))
+	{
+		m_cardinality *= Optimizer::getSelectivity(boolean);
+		m_filterNodes.add(boolean);
+
+		return true;
+	}
+
+	return false;
+}
+
+bool ForeignTableScan::checkBoolean(thread_db* tdbb, const BoolExprNode* boolean)
+{
+	if (const auto notNode = nodeAs<NotBoolNode>(boolean))
+	{
+		if (checkBoolean(tdbb, notNode->arg))
+			return true;
+	}
+	else if (const auto binaryNode = nodeAs<BinaryBoolNode>(boolean))
+	{
+		if (checkOperator(tdbb, binaryNode->blrOp) &&
+			checkBoolean(tdbb, binaryNode->arg1) &&
+			checkBoolean(tdbb, binaryNode->arg2))
+		{
+			return true;
+		}
+	}
+	else if (const auto comparativeNode = nodeAs<ComparativeBoolNode>(boolean))
+	{
+		if (checkOperator(tdbb, comparativeNode->blrOp) &&
+			checkArgument(tdbb, comparativeNode->arg1) &&
+			checkArgument(tdbb, comparativeNode->arg2))
+		{
+			if (comparativeNode->arg3)
+				return checkArgument(tdbb, comparativeNode->arg3);
+			return true;
+		}
+	}
+	else if (const auto missingBoolNode = nodeAs<MissingBoolNode>(boolean))
+	{
+		if (checkArgument(tdbb, missingBoolNode->arg))
+			return true;
+	}
+
+	return false;
+}
+
+bool ForeignTableScan::checkArgument(thread_db* tdbb, const ValueExprNode* node)
+{
+	if (const auto arithmeticNone = nodeAs<ArithmeticNode>(node))
+	{
+		if (checkOperator(tdbb, arithmeticNone->blrOp) &&
+			checkArgument(tdbb, arithmeticNone->arg1) &&
+			checkArgument(tdbb, arithmeticNone->arg2))
+		{
+			return true;
+		}
+	}
+	else if (const auto concatenateNode = nodeAs<ConcatenateNode>(node))
+	{
+		if (checkOperator(tdbb, blr_concatenate) &&
+			checkArgument(tdbb, concatenateNode->arg1) &&
+			checkArgument(tdbb, concatenateNode->arg2))
+		{
+			return true;
+		}
+	}
+	else if (const auto negateNode = nodeAs<NegateNode>(node))
+	{
+		if (checkOperator(tdbb, blr_negate) && checkArgument(tdbb, negateNode->arg))
+			return true;
+	}
+	else if (const auto strCaseNode = nodeAs<StrCaseNode>(node))
+	{
+		if (checkOperator(tdbb, strCaseNode->blrOp) && checkArgument(tdbb, strCaseNode->arg))
+			return true;
+	}
+	else if (nodeIs<FieldNode>(node) || nodeIs<LiteralNode>(node) || nodeAs<NullNode>(node) ||
+		nodeAs<ParameterNode> (node))
+	{
+		if (const auto fieldNode = nodeAs<FieldNode>(node))
+		{
+			// If node is a blob field, exclude it
+			const dsc& desc = fieldNode->format->fmt_desc[fieldNode->fieldId];
+			if (desc.isBlob())
+				return false;
+		}
+		return true;
+	}
+
+	return false;
+}
+
+bool ForeignTableScan::checkOperator(thread_db* tdbb, const UCHAR op)
+{
+	switch (op)
+	{
+		case blr_add:
+		case blr_subtract:
+		case blr_multiply:
+		case blr_divide:
+		case blr_negate:
+		case blr_eql:
+		case blr_neq:
+		case blr_gtr:
+		case blr_geq:
+		case blr_lss:
+		case blr_leq:
+		case blr_or:
+		case blr_and:
+		case blr_lowcase:
+		case blr_upcase:
+		case blr_between:
+		case blr_like:
+			return true;
+
+		case blr_concatenate:
+			return externalSqlFeatureSupport(tdbb, fb_feature_sql_op_concatenate);
+
+		case blr_equiv:
+			return externalSqlFeatureSupport(tdbb, fb_feature_sql_op_equiv);
+
+		default:
+			return false;
+	}
+}
+
+void ForeignTableScan::decomposeBoolean(thread_db* tdbb, string& conjunctSql, const BoolExprNode* boolean,
+	const bool isNotBoolNode) const
+{
+	if (const auto notNode = nodeAs<NotBoolNode>(boolean))
+	{
+		decomposeBoolean(tdbb, conjunctSql, notNode->arg, true);
+	}
+	else if (const auto binaryNode = nodeAs<BinaryBoolNode>(boolean))
+	{
+		decomposeBoolean(tdbb, conjunctSql, binaryNode->arg1, isNotBoolNode);
+		processOperation(tdbb, conjunctSql, binaryNode->blrOp, isNotBoolNode);
+		decomposeBoolean(tdbb, conjunctSql, binaryNode->arg2, isNotBoolNode);
+	}
+	else if (const auto comparativeNode = nodeAs<ComparativeBoolNode>(boolean))
+	{
+		processArgument(tdbb, conjunctSql, comparativeNode->arg1, isNotBoolNode);
+		processOperation(tdbb, conjunctSql, comparativeNode->blrOp, isNotBoolNode);
+		processArgument(tdbb, conjunctSql, comparativeNode->arg2, isNotBoolNode);
+		if (comparativeNode->arg3)
+			processOptionalArgument(tdbb, conjunctSql, comparativeNode->arg3, comparativeNode->blrOp, isNotBoolNode);
+	}
+	else if (const auto missingBoolNode = nodeAs<MissingBoolNode>(boolean))
+	{
+		processArgument(tdbb, conjunctSql, missingBoolNode->arg, isNotBoolNode);
+		appendFilterValue(" is ", conjunctSql);
+
+		if (isNotBoolNode)
+			appendFilterValue(" not ", conjunctSql);
+
+		// The specification does not make a distinction between the NULL value of BOOLEAN data type,
+		// and the truth value UNKNOWN that is the result of an SQL predicate, search condition,
+		// or Boolean value expression: they may be used interchangeably to mean exactly the same thing.
+		appendFilterValue(" null ", conjunctSql);
+	}
+}
+
+void ForeignTableScan::processArgument(thread_db* tdbb, string& conjunctSql, const ValueExprNode* node,
+	const bool isNotBoolNode) const
+{
+	if (const auto arithmeticNone = nodeAs<ArithmeticNode>(node))
+	{
+		processArgument(tdbb, conjunctSql, arithmeticNone->arg1, isNotBoolNode);
+		processOperation(tdbb, conjunctSql, arithmeticNone->blrOp, isNotBoolNode);
+		processArgument(tdbb, conjunctSql, arithmeticNone->arg2, isNotBoolNode);
+	}
+	else if (const auto concatenateNode = nodeAs<ConcatenateNode>(node))
+	{
+		processArgument(tdbb, conjunctSql, concatenateNode->arg1, isNotBoolNode);
+		appendFilterValue(" || ", conjunctSql);
+		processArgument(tdbb, conjunctSql, concatenateNode->arg2, isNotBoolNode);
+	}
+	else if (const auto negateNode = nodeAs<NegateNode>(node))
+	{
+		processOperation(tdbb, conjunctSql, blr_negate, isNotBoolNode);
+		processArgument(tdbb, conjunctSql, negateNode->arg, isNotBoolNode);
+	}
+	else if (const auto strCaseNode = nodeAs<StrCaseNode>(node))
+	{
+		string strCaseOpSql;
+		string strCaseArgSql;
+
+		processOperation(tdbb, strCaseOpSql, strCaseNode->blrOp, isNotBoolNode);
+		processArgument(tdbb, strCaseArgSql, strCaseNode->arg, isNotBoolNode);
+		appendFilterValue(strCaseOpSql, conjunctSql);
+		appendFilterValue("(", conjunctSql);
+		appendFilterValue(strCaseArgSql, conjunctSql);
+		appendFilterValue(")", conjunctSql);
+	}
+	else if (const auto fieldNode = nodeAs<FieldNode>(node))
+	{
+		const jrd_fld* field = MET_get_field(m_relation, fieldNode->fieldId);
+		const string value = m_relation->rel_foreign_adapter->getOriginalFieldName(field->fld_name.c_str());
+		appendFilterValue(value, conjunctSql);
+	}
+	else if (const auto literalNode = nodeAs<LiteralNode>(node))
+	{
+		const dsc* desc = &literalNode->litDesc;
+		string value;
+
+		getDescString(tdbb, desc, value, getServerCharset(tdbb));
+		appendFilterValue("'", conjunctSql);
+		appendFilterValue(value, conjunctSql);
+		appendFilterValue("'", conjunctSql);
+	}
+	else if (const auto parameterNode = nodeAs<ParameterNode>(node))
+	{
+		Request* request = tdbb->getRequest();
+		auto message = parameterNode->message;
+		auto argNumber = parameterNode->argNumber;
+		auto paramRequest = parameterNode->getParamRequest(request);
+		dsc desc = message->getFormat(paramRequest)->fmt_desc[argNumber];
+
+		string value;
+
+		desc.dsc_address = message->getBuffer(paramRequest) + (IPTR) desc.dsc_address;
+
+		getDescString(tdbb, &desc, value, getServerCharset(tdbb));
+		appendFilterValue(value, conjunctSql);
+	}
+	else if (nodeIs<NullNode>(node))
+		appendFilterValue("null", conjunctSql);
+}
+
+void ForeignTableScan::processOptionalArgument(thread_db* tdbb, Firebird::string& conjunctSql,
+	const ValueExprNode* node, const UCHAR op, bool isNotBoolNode) const
+{
+	conjunctSql.append(" ");
+
+	switch (op)
+	{
+		case blr_between:
+			conjunctSql.append(" and ");
+			break;
+		case blr_like:
+			conjunctSql.append(" escape ");
+			break;
+		default:
+			fb_assert(false);
+	}
+
+	processArgument(tdbb, conjunctSql, node, isNotBoolNode);
+	conjunctSql.append(" ");
+}
+
+void ForeignTableScan::processOperation(thread_db* /*tdbb*/, string& conjunctSql, const UCHAR op,
+	const bool isNotBoolNode) const
+{
+	conjunctSql.append(" ");
+
+	if (isNotBoolNode && op != blr_equiv)
+		conjunctSql.append(" is not ");
+
+	switch (op)
+	{
+		case blr_add:
+			conjunctSql.append("+");
+			break;
+		case blr_multiply:
+			conjunctSql.append("*");
+			break;
+		case blr_divide:
+			conjunctSql.append("/");
+			break;
+		case blr_subtract:
+		case blr_negate:
+			conjunctSql.append("-");
+			break;
+		case blr_eql:
+			conjunctSql.append("=");
+			break;
+		case blr_neq:
+			conjunctSql.append("!=");
+			break;
+		case blr_gtr:
+			conjunctSql.append(">");
+			break;
+		case blr_geq:
+			conjunctSql.append(">=");
+			break;
+		case blr_lss:
+			conjunctSql.append("<");
+			break;
+		case blr_leq:
+			conjunctSql.append("<=");
+			break;
+		case blr_or:
+			conjunctSql.append("or");
+			break;
+		case blr_and:
+			conjunctSql.append("and");
+			break;
+		case blr_lowcase:
+			conjunctSql.append("lower");
+			break;
+		case blr_upcase:
+			conjunctSql.append("upper");
+			break;
+		case blr_equiv:
+			if (isNotBoolNode)
+				conjunctSql.append("is distinct from");
+			else
+				conjunctSql.append("is not distinct from");
+			break;
+		case blr_between:
+			conjunctSql.append("between");
+			break;
+		case blr_like:
+			conjunctSql.append("like");
+			break;
+		default:
+			fb_assert(false);
+	}
+
+	conjunctSql.append(" ");
+}
+
+ULONG ForeignTableScan::getDescString(thread_db* tdbb, const dsc* desc, Firebird::string& outString,
+	CHARSET_ID toCharset) const
+{
+	UCHAR* ptr = NULL;
+	MoveBuffer temp;
+	ULONG length;
+	if (desc->isText() && desc->getCharSet() == toCharset)
+		length = MOV_get_string(tdbb, desc, &ptr, NULL, 0);
+	else
+		length = MOV_make_string2(tdbb, desc, toCharset, &ptr, temp);
+
+	const string value(ptr, length);
+	appendFilterValue(value, outString);
+
+	return length;
+}
+
+SSHORT ForeignTableScan::getServerCharset(thread_db* tdbb) const
+{
+	string serverCharset;
+	const ForeignServer* server = m_relation->rel_foreign_adapter->getServer();
+	ForeignOption option(*getDefaultMemoryPool());
+	if (server->getOptions().get(MetaName(FOREIGN_SERVER_CHARSET), option))
+		serverCharset = option.getActualValue();
+
+	USHORT charsetId = CS_UTF8;
+	if (serverCharset.hasData())
+	{
+		if (!MET_get_char_coll_subtype(tdbb, &charsetId, QualifiedName(serverCharset)))
+		{
+			// specified character set not found
+			(Arg::Gds(isc_charset_not_found) << Arg::Str(serverCharset)).raise();
+		}
+	}
+
+	return charsetId;
+}
+
+void ForeignTableScan::appendFilterValue(const string& value, string& conjunctSql) const
+{
+	conjunctSql.append(value);
+}
+
+void ForeignTableScan::trimLiteralSingleQuotes(Firebird::string& value) const
+{
+	value = value.substr(1, value.size() - 2);
+}
+
+bool ForeignTableScan::applySort(thread_db* tdbb, const SortNode* sort)
+{
+	const bool extNullOrdering = externalSqlFeatureSupport(tdbb, fb_feature_sql_op_null_ordering);
+	const USHORT sortCnt = sort->expressions.getCount();
+
+	fb_assert(!m_sortNode);
+
+	for (USHORT i = 0; i < sortCnt; i++)
+	{
+		const NullsPlacement nulls = sort->nullOrder[i];
+		if (!extNullOrdering && nulls != NULLS_DEFAULT)
+			return false;
+
+		const ValueExprNode* node = sort->expressions[i];
+		if (!checkArgument(tdbb, node))
+			return false;
+	}
+
+	m_sortNode = sort;
+
+	return true;
+}
+
+const bool ForeignTableScan::externalSqlFeatureSupport(thread_db* tdbb, info_sql_features feature) const
+{
+	return m_relation->rel_foreign_adapter->testSqlFeature(tdbb, feature);
+}
diff --git a/src/jrd/recsrc/RecordSource.h b/src/jrd/recsrc/RecordSource.h
index bc5df3dfed2..80e9c1612f9 100644
--- a/src/jrd/recsrc/RecordSource.h
+++ b/src/jrd/recsrc/RecordSource.h
@@ -1615,6 +1615,59 @@ namespace Jrd
 		NestConst<ValueListNode> m_inputList;
 	};
 
+	class ForeignTableScan final : public RecordStream
+	{
+	private:
+		struct Impure : public RecordSource::Impure
+		{
+			EDS::Statement* statement;
+		};
+
+	public:
+		ForeignTableScan(CompilerScratch* csb, const Firebird::string& alias,
+						  StreamType stream, jrd_rel* relation);
+
+		void close(thread_db* tdbb) const override;
+
+		bool refetchRecord(thread_db* tdbb) const override;
+		WriteLockResult lockRecord(thread_db* tdbb) const override;
+
+		void getLegacyPlan(thread_db* tdbb, Firebird::string& plan, unsigned level) const override;
+
+		bool applyBoolean(thread_db* tdbb, const BoolExprNode* boolean);
+		bool applySort(thread_db* tdbb, const SortNode* sort);
+
+	protected:
+		void internalOpen(thread_db* tdbb) const override;
+		bool internalGetRecord(thread_db* tdbb) const override;
+		void internalGetPlan(thread_db* tdbb, PlanEntry& planEntry, unsigned level, bool recurse) const override;
+
+	private:
+		bool checkBoolean(thread_db* tdbb, const BoolExprNode* boolean);
+		bool checkArgument(thread_db* tdbb, const ValueExprNode* node);
+		bool checkOperator(thread_db* tdbb, const UCHAR op);
+		void decomposeBoolean(thread_db* tdbb, Firebird::string& conjunctSql, const BoolExprNode* boolean,
+			bool isNotBoolNode = false) const;
+		void processArgument(thread_db* tdbb, Firebird::string& conjunctSql, const ValueExprNode* node,
+			bool isNotBoolNode = false) const;
+		void processOptionalArgument(thread_db* tdbb, Firebird::string& conjunctSql, const ValueExprNode* node,
+			const UCHAR op, bool isNotBoolNode = false) const;
+		void processOperation(thread_db* tdbb, Firebird::string& conjunctSql, const UCHAR op,
+			bool isNotBoolNode = false) const;
+		ULONG getDescString(thread_db* tdbb, const dsc* desc, Firebird::string& outString,
+			CHARSET_ID toCharset = CS_UTF8) const;
+		SSHORT getServerCharset(thread_db* tdbb) const;
+		void appendFilterValue(const Firebird::string& value, Firebird::string& conjunctSql) const;
+		// Removes quotes of a string literal
+		void trimLiteralSingleQuotes(Firebird::string& value) const;
+		// Checks sql-feature support by external provider
+		const bool externalSqlFeatureSupport(thread_db* tdbb, info_sql_features feature) const;
+
+		jrd_rel* const m_relation;
+		const Firebird::string m_alias;
+		Firebird::Array<const BoolExprNode*> m_filterNodes; // Stores nodes will be converted to a condition
+		const SortNode* m_sortNode;
+	};
 } // namespace
 
 #endif // JRD_RECORD_SOURCE_H
diff --git a/src/jrd/recsrc/SortedStream.cpp b/src/jrd/recsrc/SortedStream.cpp
index 90a6e54bd8c..78a305a76fa 100644
--- a/src/jrd/recsrc/SortedStream.cpp
+++ b/src/jrd/recsrc/SortedStream.cpp
@@ -392,10 +392,7 @@ void SortedStream::mapData(thread_db* tdbb, Request* request, UCHAR* data) const
 			// So we need to refetch the stream, either immediately or on demand.
 			const auto refetch = (id == ID_TRANS);
 
-			if (refetch && relation &&
-				!relation->rel_file &&
-				!relation->rel_view_rse &&
-				!relation->isVirtual())
+			if (refetch && relation && relation->isPageBased())
 			{
 				if (m_map->flags & FLAG_REFETCH)
 				{
diff --git a/src/jrd/relations.h b/src/jrd/relations.h
index 7aaaa4a88e8..c0914310e24 100644
--- a/src/jrd/relations.h
+++ b/src/jrd/relations.h
@@ -155,6 +155,7 @@ RELATION(nam_relations, rel_relations, ODS_8_0, rel_persistent)
 	FIELD(f_rel_flags, nam_flags, fld_flag_nullable, 0, ODS_8_0)
 	FIELD(f_rel_type, nam_r_type, fld_r_type, 0, ODS_11_1)
 	FIELD(f_rel_sql_security, nam_sql_security, fld_b_sql_security, 1, ODS_13_0)
+	FIELD(f_rel_fs_name, nam_fs_name, fld_fs_name, 1, ODS_14_0)
 	FIELD(f_rel_schema, nam_sch_name, fld_sch_name, 1, ODS_14_0)
 END_RELATION
 
@@ -811,3 +812,52 @@ RELATION(nam_schemas, rel_schemas, ODS_14_0, rel_persistent)
 	FIELD(f_sch_sys_flag, nam_sys_flag, fld_flag, 1, ODS_14_0)
 	FIELD(f_sch_desc, nam_description, fld_description, 1, ODS_14_0)
 END_RELATION
+
+// Relation 57 (RDB$FOREIGN_SERVERS)
+RELATION(nam_foreign_servers, rel_foreign_servers, ODS_14_0, rel_persistent)
+	FIELD(f_fs_name, nam_fs_name, fld_fs_name, 1, ODS_14_0)
+	FIELD(f_fs_data_wrapper_name, nam_fs_wrapper_name, fld_fs_data_wrapper_name, 1, ODS_14_0)
+	FIELD(f_fs_class, nam_class, fld_class, 1, ODS_14_0)
+	FIELD(f_fs_owner, nam_owner, fld_user, 1, ODS_14_0)
+END_RELATION
+
+// Relation 58 (RDB$FOREIGN_SERVER_OPTIONS)
+RELATION(nam_foreign_server_options, rel_foreign_server_options, ODS_14_0, rel_persistent)
+	FIELD(f_fso_server_name, nam_fs_name, fld_fs_name, 1, ODS_14_0)
+	FIELD(f_fso_name, nam_fo_name, fld_fo_name, 1, ODS_14_0)
+	FIELD(f_fso_value, nam_fo_value, fld_fo_value, 1, ODS_14_0)
+	FIELD(f_fso_type, nam_fo_type, fld_fo_type, 1, ODS_14_0)
+END_RELATION
+
+// Relation 59 (RDB$FOREIGN_TABLE_OPTIONS)
+RELATION(nam_foreign_tbl_options, rel_foreign_tbl_options, ODS_14_0, rel_persistent)
+	FIELD(f_fto_sch_name, nam_sch_name, fld_sch_name, 1, ODS_14_0)
+	FIELD(f_fto_tbl_name, nam_tab_name, fld_r_name, 1, ODS_14_0)
+	FIELD(f_fto_name, nam_fo_name, fld_fo_name, 1, ODS_14_0)
+	FIELD(f_fto_value, nam_fo_value, fld_fo_value, 1, ODS_14_0)
+END_RELATION
+
+// Relation 60 (RDB$FOREIGN_USER_MAPPINGS)
+RELATION(nam_foreign_user_mappings, rel_foreign_user_mappings, ODS_14_0, rel_persistent)
+	FIELD(f_fum_user, nam_user, fld_user, 1, ODS_14_0)
+	FIELD(f_fum_server_name, nam_fs_name, fld_fs_name, 1, ODS_14_0)
+END_RELATION
+
+// Relation 61 (RDB$FOREIGN_MAPPING_OPTIONS)
+RELATION(nam_foreign_mapping_options, rel_foreign_mapping_options, ODS_14_0, rel_persistent)
+	FIELD(f_fmo_user, nam_user, fld_user, 1, ODS_14_0)
+	FIELD(f_fmo_server_name, nam_fs_name, fld_fs_name, 1, ODS_14_0)
+	FIELD(f_fmo_name, nam_fo_name, fld_fo_name, 1, ODS_14_0)
+	FIELD(f_fmo_value, nam_fo_value, fld_fo_value, 1, ODS_14_0)
+	FIELD(f_fmo_type, nam_fo_type, fld_fo_type, 1, ODS_14_0)
+END_RELATION
+
+// Relation 62 (RDB$FOREIGN_TABLE_FIELD_OPTIONS)
+RELATION(nam_foreign_tbl_f_options, rel_foreign_tbl_f_options, ODS_14_0, rel_persistent)
+	FIELD(f_ftfo_sch_name, nam_sch_name, fld_sch_name, 1, ODS_14_0)
+	FIELD(f_ftfo_tbl_name, nam_tab_name, fld_r_name, 1, ODS_14_0)
+	FIELD(f_ftfo_fld_name, nam_f_name, fld_f_name, 1, ODS_14_0)
+	FIELD(f_ftfo_name, nam_fo_name, fld_fo_name, 1, ODS_14_0)
+	FIELD(f_ftfo_value, nam_fo_value, fld_fo_value, 1, ODS_14_0)
+END_RELATION
+
diff --git a/src/jrd/scl.epp b/src/jrd/scl.epp
index eeddb594191..c2ee01f3a16 100644
--- a/src/jrd/scl.epp
+++ b/src/jrd/scl.epp
@@ -850,6 +850,42 @@ void SCL_check_role(thread_db* tdbb, const MetaName& name, SecurityClass::flags_
 	SCL_check_access(tdbb, s_class, 0, {}, mask, obj_roles, false, QualifiedName(name));
 }
 
+bool SCL_check_foreign_server(thread_db* tdbb, const MetaName& name, SecurityClass::flags_t mask)
+{
+/**************************************
+ *
+ *	S C L _ c h e c k _ f o r e i g n _ s e r v e r
+ *
+ **************************************
+ *
+ * Functional description
+ *	Given a foreign server name, check for a set of privileges.  The
+ *	foreign server in question may or may not have been created, let alone
+ *	scanned. This is used exclusively for meta-data operations.
+ *
+ **************************************/
+	SET_TDBB(tdbb);
+
+	Jrd::Attachment* const attachment = tdbb->getAttachment();
+
+	const SecurityClass* s_class = NULL;
+	bool found = false;
+	AutoCacheRequest request(tdbb, irq_f_s_security, IRQ_REQUESTS);
+
+	FOR (REQUEST_HANDLE request)
+		FSER IN RDB$FOREIGN_SERVERS
+		WITH FSER.RDB$FOREIGN_SERVER_NAME EQ name.c_str()
+	{
+		if (!FSER.RDB$SECURITY_CLASS.NULL)
+			s_class = SCL_get_class(tdbb, FSER.RDB$SECURITY_CLASS);
+		found = true;
+	}
+	END_FOR
+
+	QualifiedName qName(name);
+	return check_object(tdbb, found, s_class, 0, qName, mask, obj_foreign_servers, qName);
+}
+
 SecurityClass* SCL_get_class(thread_db* tdbb, const MetaName& name)
 {
 /**************************************
diff --git a/src/jrd/scl_proto.h b/src/jrd/scl_proto.h
index 8e0597a4cbf..e1c982a5ec9 100644
--- a/src/jrd/scl_proto.h
+++ b/src/jrd/scl_proto.h
@@ -56,6 +56,7 @@ void SCL_check_relation(Jrd::thread_db* tdbb, const Jrd::QualifiedName& name, Jr
 bool SCL_check_schema(Jrd::thread_db* tdbb, const Jrd::MetaName&, Jrd::SecurityClass::flags_t);
 bool SCL_check_view(Jrd::thread_db* tdbb, const Jrd::QualifiedName& name, Jrd::SecurityClass::flags_t);
 void SCL_check_role(Jrd::thread_db* tdbb, const Jrd::MetaName&, Jrd::SecurityClass::flags_t);
+bool SCL_check_foreign_server(Jrd::thread_db* tdbb, const Jrd::MetaName&, Jrd::SecurityClass::flags_t);
 Jrd::SecurityClass* SCL_get_class(Jrd::thread_db*, const Jrd::MetaName& name);
 Jrd::SecurityClass::flags_t SCL_get_mask(Jrd::thread_db* tdbb, const Jrd::QualifiedName&, const TEXT*);
 void SCL_clear_classes(Jrd::thread_db*, const Jrd::MetaName&);
@@ -90,6 +91,7 @@ inline Jrd::MetaName SCL_getDdlSecurityClassName(ObjectType objectType, const Jr
 		case obj_jobs:
 		case obj_tablespaces:
 		case obj_schemas:
+		case obj_foreign_servers:
 		{
 			Firebird::string str;
 			str.printf(SQL_DDL_SECCLASS_FORMAT, (int) objectType, schema.c_str());
diff --git a/src/jrd/tra.h b/src/jrd/tra.h
index b55ed364dcf..d842f43e963 100644
--- a/src/jrd/tra.h
+++ b/src/jrd/tra.h
@@ -520,6 +520,7 @@ enum dfw_t {
 	dfw_store_view_context_type,
 	dfw_set_generator,
 	dfw_change_repl_state,
+	dfw_delete_foreign_server,
 
 	// deferred works argument types
 	dfw_arg_index_name,		// index name for dfw_delete_index, mandatory
diff --git a/src/jrd/vio.cpp b/src/jrd/vio.cpp
index 1e81339c90f..9d71d065a10 100644
--- a/src/jrd/vio.cpp
+++ b/src/jrd/vio.cpp
@@ -2399,6 +2399,24 @@ bool VIO_erase(thread_db* tdbb, record_param* rpb, jrd_tra* transaction)
 			DFW_post_work(transaction, dfw_change_repl_state, {}, {}, 1);
 			break;
 
+		case rel_foreign_servers:
+			protect_system_table_delupd(tdbb, relation, "DELETE");
+			if (EVL_field(0, rpb->rpb_record, f_fs_name, &desc))
+			{
+				MOV_get_metaname(tdbb, &desc, object_name.object);
+				SCL_check_foreign_server(tdbb, object_name.object, SCL_drop);
+				DFW_post_work(transaction, dfw_delete_foreign_server, &desc, nullptr, 0);
+			}
+			break;
+
+		case rel_foreign_server_options:
+		case rel_foreign_tbl_options:
+		case rel_foreign_tbl_f_options:
+		case rel_foreign_user_mappings:
+		case rel_foreign_mapping_options:
+			protect_system_table_delupd(tdbb, relation, "DELETE");
+			break;
+
 		default:    // Shut up compiler warnings
 			break;
 		}
@@ -3782,6 +3800,20 @@ bool VIO_modify(thread_db* tdbb, record_param* org_rpb, record_param* new_rpb, j
 			check_repl_state(tdbb, transaction, org_rpb, new_rpb, f_pub_active_flag);
 			break;
 
+		case rel_foreign_servers:
+			protect_system_table_delupd(tdbb, relation, "UPDATE");
+			check_class(tdbb, transaction, org_rpb, new_rpb, f_fs_class);
+			check_owner(tdbb, transaction, org_rpb, new_rpb, f_fs_owner);
+			break;
+
+		case rel_foreign_server_options:
+		case rel_foreign_tbl_options:
+		case rel_foreign_tbl_f_options:
+		case rel_foreign_user_mappings:
+		case rel_foreign_mapping_options:
+			protect_system_table_delupd(tdbb, relation, "UPDATE");
+			break;
+
 		default:
 			break;
 		}
@@ -4671,6 +4703,23 @@ void VIO_store(thread_db* tdbb, record_param* rpb, jrd_tra* transaction)
 			DFW_post_work(transaction, dfw_change_repl_state, {}, {}, 1);
 			break;
 
+
+		case rel_foreign_servers:
+			protect_system_table_insert(tdbb, request, relation);
+			EVL_field(0, rpb->rpb_record, f_fs_name, &desc);
+			set_owner_name(tdbb, rpb->rpb_record, f_fs_owner);
+			if (set_security_class(tdbb, rpb->rpb_record, f_fs_class))
+				DFW_post_work(transaction, dfw_grant, &desc, {}, obj_foreign_server);
+			break;
+
+		case rel_foreign_server_options:
+		case rel_foreign_tbl_options:
+		case rel_foreign_tbl_f_options:
+		case rel_foreign_user_mappings:
+		case rel_foreign_mapping_options:
+			protect_system_table_insert(tdbb, request, relation);
+			break;
+
 		default:    // Shut up compiler warnings
 			break;
 		}