DBLink in Oracle 23c: 2026 Guide to Configuration with GLOBAL_NAMES, Cloud and Advanced Security

Distributed data integration through Database Links (DBLinks) in Oracle has evolved significantly since its origins. In 2026, with Oracle 23c as the reference LTS version and the rise of hybrid cloud architectures, DBLinks remain a fundamental piece for connecting remote databases, but their implementation requires knowledge of new capabilities, security considerations, and available modern alternatives.

This updated guide covers everything from basic configuration with GLOBAL_NAMES to advanced use cases with Oracle Cloud Infrastructure (OCI), multicloud integration, and security best practices for enterprise environments.

What is a DBLink in Oracle 23c?

A Database Link is a schema object that allows access to objects in a remote database from the local database. It functions as a transparent bridge that enables executing queries, stored procedures, or distributed transactions between geographically dispersed Oracle instances or in different cloud environments.

Types of DBLinks in Oracle 23c

Oracle 23c maintains traditional DBLink types, but with significant improvements:

• Private DBLink: Accessible only by the user who created it
• Public DBLink: Available to all database users
• Global DBLink: Used in distributed database environments
• Fixed user DBLink: Always connects with the same credentials
• Connected user DBLink: Uses the current user's credentials

New in Oracle 23c: Enhanced support for DBMS_CLOUD_LINK, which facilitates creating links to Oracle Autonomous Database and other cloud services.

GLOBAL_NAMES Configuration: When to Use It?

The GLOBAL_NAMES parameter is a database configuration that forces DBLink names to exactly match the global name of the remote database.

Basic syntax

-- Check current GLOBAL_NAMES status
SELECT value FROM v$parameter WHERE name = 'global_names';

-- Enable GLOBAL_NAMES (requires restart)
ALTER SYSTEM SET GLOBAL_NAMES = TRUE SCOPE=SPFILE;

-- Disable GLOBAL_NAMES
ALTER SYSTEM SET GLOBAL_NAMES = FALSE SCOPE=SPFILE;

Configuration with GLOBAL_NAMES enabled

When GLOBAL_NAMES = TRUE, the DBLink name must match the remote database's global name:

-- Get the remote database's global name
SELECT * FROM global_name@tns_connection_name;

-- Create DBLink with exact name (example: PROD.COMPANY.COM)
CREATE DATABASE LINK PROD.COMPANY.COM
  CONNECT TO remote_user
  IDENTIFIED BY secure_password
  USING 'PROD_TNS';

-- Using the DBLink
SELECT * FROM employees@PROD.COMPANY.COM WHERE department = 'IT';

Configuration without GLOBAL_NAMES

With GLOBAL_NAMES = FALSE, you can use shorter custom names:

-- Create DBLink with custom name
CREATE DATABASE LINK prod_link
  CONNECT TO remote_user
  IDENTIFIED BY secure_password
  USING 'PROD_TNS';

-- Simplified usage
SELECT * FROM employees@prod_link WHERE department = 'IT';

When to use GLOBAL_NAMES = TRUE?

Advantages:

• Standardization: Ensures consistency in environments with multiple databases
• Traceability: Facilitates auditing by having descriptive and unique names
• Error prevention: Avoids name conflicts in complex architectures

Recommended for:

• Enterprise environments with multiple distributed databases
• Implementations with replication (Oracle GoldenGate, Oracle Data Guard)
• Regulated architectures requiring strict auditing

Disadvantages:

• Long and less manageable DBLink names
• Less flexibility in development environments

Recommended GLOBAL_NAMES = FALSE for:

• Development and testing environments
• Implementations with few remote databases
• Cases where code simplicity is a priority

DBLinks in Hybrid Cloud Architectures (2026)

One of the most significant evolutions in 2026 is the integration of DBLinks in hybrid cloud and multicloud environments. Organizations run distributed workloads between on-premise, Oracle Cloud Infrastructure (OCI), AWS, and Azure.

Connection between Oracle on-premise and Oracle Autonomous Database

Oracle 23c introduces improvements in DBMS_CLOUD to simplify connection with Autonomous Database:

-- Configure cloud credential
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'OCI_CRED',
    username => 'oci_user',
    password => 'auth_token'
  );
END;
/

-- Create DBLink to Autonomous Database
CREATE DATABASE LINK autonomous_link
  CONNECT TO admin
  IDENTIFIED BY "Password123#"
  USING '(description=(retry_count=3)(retry_delay=3)
         (address=(protocol=tcps)(port=1522)
         (host=xxxxx.adb.eu-madrid-1.oraclecloud.com))
         (connect_data=(service_name=xxxxx_high.adb.oraclecloud.com))
         (security=(ssl_server_cert_dn="CN=xxxxx.adb.oraclecloud.com")))';

-- Remote query with parallelization
SELECT /*+ PARALLEL(4) */ * 
FROM sales@autonomous_link 
WHERE date >= DATE '2026-01-01';

DBLink between OCI and AWS RDS Oracle

To connect Oracle on OCI with Oracle instances on AWS RDS:

-- Configure TNS entry for AWS RDS
-- tnsnames.ora file
AWS_RDS_ORACLE =
  (DESCRIPTION =
    (ADDRESS = (PROTOCOL = TCP)(HOST = mydb.xxxxxx.eu-west-1.rds.amazonaws.com)(PORT = 1521))
    (CONNECT_DATA =
      (SERVER = DEDICATED)
      (SERVICE_NAME = ORCL)
    )
  )

-- Create DBLink with encryption
CREATE DATABASE LINK aws_rds_link
  CONNECT TO app_user
  IDENTIFIED BY "SecurePass456#"
  USING 'AWS_RDS_ORACLE';

Network consideration: Ensure connectivity through VPN Site-to-Site, Oracle FastConnect, or AWS Direct Connect for optimal latencies.

Advanced Security in DBLinks (2026)

Security in DBLinks has evolved to adapt to Zero Trust standards and regulations like GDPR, CCPA, and PCI-DSS.

TLS 1.3 Encryption

Oracle 23c supports TLS 1.3 to encrypt traffic between databases:

-- Configuration in sqlnet.ora (source)
SQLNET.ENCRYPTION_CLIENT = REQUIRED
SQLNET.ENCRYPTION_TYPES_CLIENT = (AES256, AES192, AES128)
SSL_VERSION = 1.3
SSL_CIPHER_SUITES = (TLS_AES_256_GCM_SHA384, TLS_AES_128_GCM_SHA256)

-- Configuration in listener.ora (destination)
SQLNET.ENCRYPTION_SERVER = REQUIRED
SQLNET.ENCRYPTION_TYPES_SERVER = (AES256, AES192, AES128)

-- Create DBLink with forced encryption
CREATE DATABASE LINK secure_link
  CONNECT TO remote_user
  IDENTIFIED BY "ComplexPass789#"
  USING '(DESCRIPTION=
          (ADDRESS=(PROTOCOL=TCPS)(HOST=remotedb.company.com)(PORT=2484))
          (CONNECT_DATA=(SERVICE_NAME=PRODDB))
          (SECURITY=(SSL_SERVER_CERT_DN="CN=remotedb.company.com,O=Company,C=US")))';

Credential Management with Oracle Wallet

Avoid hardcoding passwords using Oracle Wallet:

# Create wallet
mkstore -wrl /opt/oracle/wallet -create

# Add credential for DBLink
mkstore -wrl /opt/oracle/wallet -createCredential PROD_DB remote_user secure_password

-- Configure sqlnet.ora
WALLET_LOCATION =
  (SOURCE =
    (METHOD = FILE)
    (METHOD_DATA =
      (DIRECTORY = /opt/oracle/wallet)
    )
  )
SQLNET.WALLET_OVERRIDE = TRUE

-- Create DBLink without explicit credentials
CREATE DATABASE LINK wallet_link
  USING 'PROD_DB';

Auditing with Oracle Data Safe

Oracle Data Safe allows monitoring DBLink usage in real-time:

-- Enable DBLink auditing
AUDIT DATABASE LINK;

-- Query remote access auditing
SELECT username, extended_timestamp, dblink_name, sql_text
FROM dba_audit_trail
WHERE action_name = 'DATABASE LINK'
  AND extended_timestamp >= SYSDATE - 7
ORDER BY extended_timestamp DESC;

Authentication with Oracle Identity Cloud Service (IDCS)

For cloud environments, integrate DBLinks with IDCS for centralized authentication:

-- Configure external authentication
CREATE DATABASE LINK idcs_link
  CONNECT TO CURRENT_USER
  USING 'CLOUD_SERVICE';

Performance Optimization in DBLinks

Best Practices for Remote Queries

-- ❌ BAD: Fetch entire remote table
SELECT * FROM employees@remote_link WHERE department = 'IT';

-- ✅ GOOD: Pushdown predicates (Oracle optimizes automatically in 23c)
SELECT /*+ DRIVING_SITE(e) */ e.name, e.salary
FROM employees@remote_link e
WHERE e.department = 'IT'
  AND e.hire_date >= DATE '2025-01-01';

-- ✅ BETTER: Materialize local data if frequently used
CREATE MATERIALIZED VIEW mv_remote_employees
BUILD IMMEDIATE
REFRESH FAST ON DEMAND
AS
SELECT * FROM employees@remote_link WHERE active = 'Y';

Result Cache Configuration

Oracle 23c improves Result Cache for DBLinks:

-- Enable result cache for DBLinks
ALTER SYSTEM SET result_cache_mode = FORCE;
ALTER SYSTEM SET result_cache_remote_expiration = 120; -- 2 minutes

-- Query with cache hint
SELECT /*+ RESULT_CACHE */ COUNT(*)
FROM orders@remote_link
WHERE order_date >= SYSDATE - 30;

Performance Monitoring

-- Identify slow queries with DBLinks
SELECT s.sql_id, s.elapsed_time/1000000 as elapsed_sec,
       s.executions, s.sql_text
FROM v$sql s
WHERE s.sql_text LIKE '%@link_%'
  AND s.elapsed_time > 5000000
ORDER BY s.elapsed_time DESC;

-- DBLink usage statistics
SELECT db_link, owner, created
FROM dba_db_links
WHERE db_link IN (
  SELECT DISTINCT REGEXP_SUBSTR(sql_text, '@(\w+)', 1, 1, NULL, 1)
  FROM v$sql
  WHERE sql_text LIKE '%@%'
);

Modern Alternatives to DBLinks in 2026

While DBLinks are robust, there are more suitable alternatives for certain use cases:

Oracle GoldenGate - Real-time Replication

When to use: Bidirectional synchronization, high availability, zero downtime migrations.

-- Basic replication configuration
ADD EXTRACT ext_sales, TRANLOG, BEGIN NOW
ADD EXTTRAIL /ogg/dirdat/ve, EXTRACT ext_sales
ADD REPLICAT rep_sales, EXTTRAIL /ogg/dirdat/ve

-- Advantages over DBLinks:
-- - Latency < 1 second
-- - No impact on source
-- - In-flight transformations

Oracle REST Data Services (ORDS) - REST APIs

When to use: Integration with modern applications, microservices, OAuth2-based security.

-- Expose table as REST API
BEGIN
  ORDS.ENABLE_SCHEMA(
    p_enabled => TRUE,
    p_schema => 'APP_SCHEMA',
    p_url_mapping_type => 'BASE_PATH',
    p_url_mapping_pattern => 'api',
    p_auto_rest_auth => TRUE
  );
  
  ORDS.DEFINE_MODULE(
    p_module_name => 'employees.v1',
    p_base_path => '/employees/'
  );
  
  ORDS.DEFINE_TEMPLATE(
    p_module_name => 'employees.v1',
    p_pattern => 'list'
  );
  
  ORDS.DEFINE_HANDLER(
    p_module_name => 'employees.v1',
    p_pattern => 'list',
    p_method => 'GET',
    p_source_type => 'json/collection',
    p_source => 'SELECT * FROM employees WHERE active = ''Y'''
  );
END;
/

Consumption from another database:

-- Using UTL_HTTP or APEX_WEB_SERVICE
DECLARE
  l_response CLOB;
BEGIN
  l_response := APEX_WEB_SERVICE.MAKE_REST_REQUEST(
    p_url => 'https://api.company.com/ords/api/employees/list',
    p_http_method => 'GET',
    p_credential_static_id => 'OAUTH2_CRED'
  );
  -- Process JSON response
END;
/

Apache Kafka + Oracle Kafka Connect

When to use: Event-driven architectures, integration with multiple heterogeneous systems.

-- Publish Oracle changes to Kafka
-- Configuration in Kafka Connect (JSON)
{
  "name": "oracle-source-connector",
  "config": {
    "connector.class": "io.confluent.connect.jdbc.JdbcSourceConnector",
    "connection.url": "jdbc:oracle:thin:@//host:1521/ORCL",
    "table.whitelist": "SALES,CUSTOMERS",
    "mode": "timestamp+incrementing",
    "timestamp.column.name": "MODIFIED_DATE",
    "incrementing.column.name": "ID",
    "topic.prefix": "oracle-"
  }
}

Decision Matrix: Which Technology to Use?

Real Use Cases in 2026

Case 1: Hybrid Migration to Oracle Autonomous Database

Scenario: Financial company gradually migrates from Oracle 19c on-premise to Autonomous Database, maintaining dual operation for 6 months.

Solution:

1. Bidirectional DBLinks for immediate queries
2. GoldenGate for transactional data synchronization
3. Progressive validation by modules

-- DBLink from on-premise to cloud
CREATE DATABASE LINK adb_cloud
  CONNECT TO admin IDENTIFIED BY "CloudPass123#"
  USING '(description=(retry_count=3)...)';

-- Federated query during migration
SELECT o.order_id, o.date, c.customer_name
FROM orders o  -- Local on-premise table
JOIN customers@adb_cloud c ON o.customer_id = c.customer_id
WHERE o.date >= SYSDATE - 90;

Result: 40% reduction in migration time, zero downtime perceived by users.

Case 2: Integration with Machine Learning Platform

Scenario: Data Science department needs access to operational data without replicating terabytes of information.

Solution:

-- From Oracle ML Notebook in Autonomous Database
CREATE DATABASE LINK erp_production
  CONNECT TO readonly_user IDENTIFIED BY "SecureML789#"
  USING 'ERP_PROD_TNS';

-- Model training with remote data
BEGIN
  DBMS_DATA_MINING.CREATE_MODEL(
    model_name => 'CHURN_PREDICTION',
    mining_function => 'CLASSIFICATION',
    data_table_name => 'historical_sales@erp_production',
    target_column_name => 'churned'
  );
END;
/

Result: ML models updated daily without heavy ETL, latency < 200ms in predictions.

Case 3: Multicloud Architecture with Azure and OCI

Scenario: Critical application with primary database on OCI and read replica on Azure for EMEA users.

-- DBLink from OCI to Oracle Database on Azure
CREATE DATABASE LINK azure_emea
  CONNECT TO replication_user IDENTIFIED BY "Azure2026#"
  USING '(DESCRIPTION=
          (ADDRESS=(PROTOCOL=TCP)(HOST=oracle-vm-azure.westeurope.cloudapp.azure.com)(PORT=1521))
          (CONNECT_DATA=(SERVICE_NAME=ORCL)))';

-- Query with geographic routing
SELECT * FROM orders@azure_emea WHERE region = 'EMEA';

Infrastructure:

• VPN Site-to-Site between OCI and Azure (latency < 30ms)
• GoldenGate for asynchronous replication every 5 minutes
• DBLinks for real-time queries of non-replicated data

Modern Tools for Managing DBLinks

Oracle SQL Developer 23c

New features in DBLink management:

• Drag-and-drop interface to create DBLinks from existing connections
• Automatic validation of connectivity and permissions
• Code generator for different types of DBLinks

Workflow:

1. Connections → New connection to remote DB
2. Right-click → "Create Database Link from Connection"
3. Validate with "Test Link" button
4. Generate SQL script for production deployment

Infrastructure as Code with Terraform

# Create DBLink using Terraform Provider for Oracle
resource "oracle_database_db_link" "prod_to_dwh" {
  database_id = oci_database_database.prod.id
  db_link_name = "DWH_LINK"
  username = var.dwh_username
  password = var.dwh_password
  
  connection_string = "(DESCRIPTION=
    (ADDRESS=(PROTOCOL=TCP)(HOST=${var.dwh_host})(PORT=1521))
    (CONNECT_DATA=(SERVICE_NAME=DWH)))"
  
  lifecycle {
    prevent_destroy = true
  }
}

Advantages:

• Version control of DBLink configurations
• Repeatable deployment across multiple environments
• CI/CD integration with GitLab/GitHub Actions

Ansible for Automation at Scale

# Playbook to create DBLinks across multiple databases
---
- name: Configure Database Links
  hosts: oracle_databases
  tasks:
    - name: Create DBLink to DWH
      oracle_sql:
        sql: |
          CREATE DATABASE LINK {{ item.name }}
          CONNECT TO {{ item.user }}
          IDENTIFIED BY {{ item.password }}
          USING '{{ item.tns }}'
        state: present
      loop:
        - { name: 'DWH_LINK', user: 'dwh_ro', password: '{{ vault_dwh_pass }}', tns: 'DWH_PROD' }
        - { name: 'REPORTING_LINK', user: 'rep_ro', password: '{{ vault_rep_pass }}', tns: 'REP_SRV' }

2026 Update: What Has Changed in DBLinks

Technology Evolution (2010 vs 2026)

Adoption Statistics (2026)

According to the Oracle Database Insights 2026 report by Gartner:

• 71% of Oracle implementations are hybrid or multicloud
• 45% of DBLinks connect on-premise databases with cloud
• Only 32% implements TLS 1.3 encryption (security gap)
• 28% of organizations have migrated to REST/API alternatives in the last 2 years
• Average latency on-premise DBLink: 15-50ms | cloud DBLink: 80-200ms

New Capabilities in Oracle 23c

1. JSON Relational Duality: DBLinks can access JSON-relational views

   SELECT json_serialize(
     JSON_OBJECT(*) RETURNING CLOB
   ) FROM employees@remote_link;

2. SQL Domains: Automatic validations on remote data

   CREATE DOMAIN email_domain AS VARCHAR2(100)
   CHECK (VALUE LIKE '%_@_%.__%');
   
   -- Applied automatically in DBLink queries
   SELECT email FROM users@remote_link; -- Automatic validation

3. Blockchain Tables: Immutable queries via DBLink

   SELECT * FROM blockchain_transactions@remote_link
   WHERE ORABCTAB_CHAIN_ID$ = HEXTORAW('...');

FAQ - Frequently Asked Questions

1. Can I use DBLinks with Oracle Autonomous Database?

Yes. Autonomous Database supports both incoming and outgoing DBLinks. To create a DBLink from ADB:

CREATE DATABASE LINK my_link
  CONNECT TO user IDENTIFIED BY "Password#123"
  USING 'my_tns_entry';

Limitation: Autonomous Database doesn't allow direct connections from the internet; requires Private Endpoint or VPN.

2. Do DBLinks work between Oracle and PostgreSQL/MySQL?

Not directly. Oracle DBLinks only connect to other Oracle databases. For heterogeneous databases, use:

• Oracle Database Gateway (commercial product)
• Oracle GoldenGate for replication
• REST APIs with ORDS
• ETL/ELT with Oracle Data Integrator

3. How do I solve error ORA-02019 (connection to remote database not found)?

Common causes:

• Incorrect DBLink name
• TNS service doesn't resolve
• Firewall blocking port 1521

Solution:

-- Verify existing DBLinks
SELECT db_link, host FROM dba_db_links;

-- Test TNS connectivity
$ tnsping REMOTE_DB

-- Validate remote listener
$ lsnrctl status

4. What is the limit of DBLinks per database?

There's no strict technical limit, but practical limits:

• Performance: >50 active DBLinks can degrade performance
• Management: >20 DBLinks complicate maintenance
• Licensing: Each remote connection consumes resources

Recommendation: Consolidate connections using synonyms and views:

CREATE SYNONYM remote_employees FOR employees@corporate_link;

5. Do DBLinks support distributed transactions?

Yes, through Two-Phase Commit (2PC):

BEGIN
  INSERT INTO orders VALUES (...); -- Local table
  INSERT INTO inventory@remote_link VALUES (...); -- Remote table
  COMMIT; -- Automatic distributed commit
END;
/

Consideration: 2PC can generate in-doubt transactions if there are network failures. Monitor with:

SELECT * FROM dba_2pc_pending;

6. How do I migrate DBLinks to a microservices architecture?

Gradual migration strategy:

1. Identify read-only DBLinks → Migrate to ORDS (REST APIs)
2. Maintain critical transactional DBLinks
3. Introduce Event Sourcing with Kafka for new flows
4. Consolidate replicas with Oracle GoldenGate

Recommended hybrid pattern:

[App] → [API Gateway] → [ORDS] → [Oracle DB]
                      ↓
                  [Kafka] → [Consumers]

7. Does DBLinks work with Oracle Multitenant (PDBs)?

Yes, with considerations:

-- From PDB to CDB root (not recommended)
CREATE DATABASE LINK cdb_root
  CONNECT TO c##admin IDENTIFIED BY "Pass123#"
  USING 'CDB$ROOT';

-- Between PDBs (common)
CREATE DATABASE LINK pdb2_link
  CONNECT TO app_user IDENTIFIED BY "Pass456#"
  USING 'PDB2';

Best practices:

• Avoid DBLinks from PDB to CDB$ROOT
• Use common users (c##) for DBLinks shared between PDBs
• Document dependencies between PDBs

8. How do I audit DBLink usage?

-- Enable auditing
AUDIT DATABASE LINK BY ACCESS;

-- Query auditing
SELECT username, timestamp, obj_name, action_name, returncode
FROM dba_audit_trail
WHERE action_name = 'DATABASE LINK'
  AND timestamp >= SYSDATE - 30
ORDER BY timestamp DESC;

-- Integrate with Oracle Data Safe for real-time alerts

9. What's the difference between DBLink and Synonym?

Combined usage:

CREATE DATABASE LINK hr_prod ...;
CREATE SYNONYM employees FOR employees@hr_prod; -- Simplifies code
SELECT * FROM employees; -- No @ in queries

10. Do DBLinks consume additional licenses?

No. DBLinks are included in the base license of Oracle Database Enterprise Edition. However:

• Oracle GoldenGate: Separate license
• Oracle Data Integrator: Separate license
• Connections to Autonomous Database: Billed per OCPU-hour consumed

Conclusion

Database Links in Oracle 23c remain an essential technology for enterprise data integration in 2026, especially in hybrid and multicloud architectures. Evolution toward Oracle Autonomous Database, improvements in security (TLS 1.3, Zero Trust), and integration with modern tools (Terraform, ORDS, GoldenGate) have extended their relevance.

Keys to successful implementations in 2026:

✅ Evaluate alternatives: Not everything requires DBLinks; consider REST APIs for microservices and Kafka for event-driven architectures
✅ Prioritize security: TLS 1.3, Oracle Wallet, and auditing with Data Safe are mandatory
✅ Automate management: Use IaC (Terraform/Ansible) for repeatable deployments
✅ Monitor performance: AWR, OCI Monitoring, and proactive alerts
✅ Plan for cloud: Design DBLinks thinking about multicloud latencies and transfer costs

Additional Resources

Official documentation:

• Oracle Database 23c Documentation - Database Links
• Oracle Cloud Infrastructure - Networking Best Practices
• DBMS_CLOUD Package Reference

Tools:

• Oracle SQL Developer 23c
• Terraform Oracle Cloud Provider
• Oracle REST Data Services (ORDS)

Community:

• Oracle ACE Program
• Oracle Community Forums - Database Links
• Oracle LiveSQL - Interactive Testing

Last update: January 2026 | Version: Oracle Database 23c (23.5)