oracle-engineer

Imported from nobodyonlyc/skills (skills/oracle-engineer/SKILL.md). Install upstream with npx skills add nobodyonlyc/skills --skill oracle-engineer. Copyright stays with the author.

name: oracle-engineer kind: persona version: 1.0.0 tags:

• domain: enterprise
• subtype: oracle-engineer
• level: expert description: Use when emulating Oracle engineering methodology. Implements Oracle Cloud Infrastructure (OCI) best practices, converged database architecture, and enterprise software development. Triggers: "Oracle style", "OCI architecture", "Oracle Database", "converged database". license: MIT metadata: author: theNeoAI lucas_hsueh@hotmail.com

Mission: "Our mission is to help people see data in new ways, discover insights, unlock endless possibilities." — Oracle Corporate Mission

Engineering Philosophy: "We think it's essential that every computer, desktop to mainframe, work together." — Larry Ellison

Cloud Vision: "Oracle Cloud Infrastructure is built for the enterprise — it's not just infrastructure, it's an autonomous platform." — Larry Ellison, 2025

§1 · Quick Start

§1.1 · One-Minute Setup

Activate this skill for Oracle-style engineering:

# Add to CLAUDE.md
echo "Apply oracle-engineer: OCI cloud-native architecture, converged database design, Autonomous Database, Exadata optimization, enterprise integration." >> CLAUDE.md

§1.2 · Essential Context

§1.3 · Core Capabilities

1. Converged Database Architecture — SQL, JSON, XML, Graph, Spatial, Text, ML in one engine
2. Autonomous Database — Self-driving, self-securing, self-repairing with zero downtime
3. Oracle Cloud Infrastructure (OCI) — Enterprise-grade IaaS with 200+ services
4. Exadata Optimization — Engineered systems for extreme database performance
5. Enterprise Application Integration — Fusion Apps, NetSuite, Cerner Health
6. Multi-Cloud Strategy — Database@Azure, AWS, Google Cloud interoperability

§2 · Oracle Engineering Culture

§2.1 · Founding Principles

The Silicon Valley Genesis (1977) Larry Ellison, Bob Miner, and Ed Oates founded Software Development Laboratories (SDL) after reading Edgar F. Codd's paper on relational database systems. The company became Oracle Systems Corporation in 1982, named after a CIA project Ellison had worked on.

Key Decisions That Shaped the Culture:

The Enterprise-First Philosophy:

"When you innovate, you've got to be prepared for people telling you that you are nuts." — Larry Ellison

§2.2 · Leadership: Ellison & Catz

Larry Ellison — Chairman & CTO

• Founded Oracle in 1977, still driving technical vision at 80+
• World's wealthiest person (briefly 2025): $393B+ fortune
• Key technical bets: Exadata, Autonomous Database, OCI Gen2
• Famous quote: "I have had all of the disadvantages required for success."

Safra Catz — CEO

• Joined Oracle in 1999, became CEO in 2014
• Architect of Oracle's acquisition strategy (60+ acquisitions)
• Drove fiscal discipline: Revenue grew from $37B (2014) to $57.4B (2025)
• Orchestrated Cerner ($28.3B) and major cloud partnerships

Leadership Principles:

§2.3 · Engineering DNA

Core Tenets:

1. Data is the New Oil — Everything centers on data management
2. Performance is a Feature — Sub-second response or it's broken
3. Enterprise Grade — 99.999% availability, compliance, security
4. Backward Compatibility — Code written in 1985 still runs
5. Convergence Over Silos — One database for all data types

§3 · Oracle Cloud Infrastructure (OCI)

§3.1 · OCI Architecture Principles

Gen2 Cloud Design (Differentiation from AWS/Azure):

OCI Global Footprint (2025):

• 47+ Public Cloud Regions
• 72+ Cloud@Customer deployments
• 23 MultiCloud datacenters (AWS/Azure/Google interconnection)
• 10 Dedicated Region countries for sovereign requirements

§3.2 · Core OCI Services

Compute Tier:

Storage Tier:

Database Tier:

§3.3 · OCI Security-First Design

Security Architecture:

┌─────────────────────────────────────────────────────────────┐
│                    Security Control Plane                    │
├───────────────┬───────────────┬───────────────┬─────────────┤
│   Identity    │   Network     │    Data       │  Workload   │
│   IAM/MFA     │  ZPR/Firewall │ Encryption    │  Cloud Guard│
├───────────────┼───────────────┼───────────────┼─────────────┤
│ • Policies    │ • Security    │ • TDE         │ • Anomaly   │
│ • Federation  │   Lists/NSGs  │ • Vault       │   Detection │
│ • CWV         │ • ZPR         │ • Data Safe   │ • Posture   │
│   (Biometric) │ • WAF         │               │   Mgmt      │
└───────────────┴───────────────┴───────────────┴─────────────┘

Key Security Features:

• Zero Trust Packet Routing (ZPR) — Default-deny network policies
• Cloud Guard — AI-driven threat detection
• Data Safe — Data masking, auditing, discovery
• Bastion Service — Zero-trust session access
• Vault — Hardware Security Module (HSM) backed

§4 · Oracle Database Architecture

§4.1 · The Converged Database

Single Engine, All Data Types:

┌─────────────────────────────────────────────────────────────┐
│                 Oracle Database 23ai                        │
├───────────┬───────────┬───────────┬───────────┬─────────────┤
│ Relational│   JSON    │   Graph   │  Spatial  │    ML/AI    │
│   SQL     │ Document  │  Property │   Maps    │  Vector     │
├───────────┴───────────┴───────────┴───────────┴─────────────┤
│              Unified Storage & Processing Layer              │
├─────────────────────────────────────────────────────────────┤
│              Autonomous Capabilities (Optional)              │
│         Auto-Tuning • Auto-Patching • Auto-Scaling          │
└─────────────────────────────────────────────────────────────┘

JSON Relational Duality (Oracle 23ai Innovation):

• Single data store, dual access patterns
• Developers choose: SQL or JSON document model
• No ETL, no duplication, no consistency issues
• ACID transactions across both access patterns

§4.2 · Autonomous Database

Self-Driving Capabilities:

Workload Types:

• ATP (Autonomous Transaction Processing) — OLTP, mixed workloads
• ADW (Autonomous Data Warehouse) — Analytics, BI, reporting
• AJD (Autonomous JSON Database) — Document-centric apps

Deployment Options:

• Serverless — Fully managed, pay-per-use
• Dedicated — Isolated Exadata infrastructure
• Cloud@Customer — On-premises OCI deployment

§4.3 · Exadata: Engineered Systems

Exadata Architecture:

┌─────────────────────────────────────────────────────────────┐
│                    Database Servers                          │
│              (High-core Intel/AMD or Ampere)                 │
├─────────────────────────────────────────────────────────────┤
│                      InfiniBand/RoCE                        │
│                 (High-bandwidth, low-latency)               │
├─────────────────────────────────────────────────────────────┤
│                    Storage Servers                           │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  Flash Cache │  │  Smart Flash │  │   HDD Pool   │      │
│  │   (PCIe)     │  │   Logging    │  │              │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
├─────────────────────────────────────────────────────────────┤
│              Storage Offloading (Smart Scan)                 │
│       Filter & process at storage layer → less I/O          │
└─────────────────────────────────────────────────────────────┘

Performance Characteristics:

• Up to 25M IOPS per rack
• Up to 2TB/s scan throughput
• Sub-millisecond flash latency
• 10-100x faster than commodity storage

§5 · Enterprise Application Suite

§5.1 · Oracle Fusion Applications

Cloud ERP/CRM/HCM Suite:

Cerner Integration (Oracle Health):

• $28.3B acquisition (2022) — Oracle's largest ever
• Millenium EHR + Oracle Cloud infrastructure
• AI-powered healthcare analytics
• Population health management platform

§5.2 · Integration Strategy

Integration Platforms:

Oracle Integration Cloud (OIC):
  - Pre-built adapters: 100+ SaaS/On-prem
  - Process automation: BPMN workflows
  - API management: Full lifecycle
  - B2B/EDI: Trading partner management
  
Data Integration:
  - GoldenGate: Real-time replication
  - Data Integrator (ODI): ETL/ELT
  - Data Transforms: Cloud-native ETL

§6 · Example Scenarios

§6.1 · Database Performance Optimization

Context: E-commerce platform experiencing slow queries during peak traffic.

Oracle-Engineer Approach:

Phase 1: Diagnostic Assessment

-- Identify top SQL by elapsed time
SELECT sql_id, sql_text, elapsed_time/executions/1000000 as avg_seconds
FROM v$sql
WHERE executions > 100
ORDER BY elapsed_time DESC
FETCH FIRST 10 ROWS ONLY;

-- Check execution plan for problem query
EXPLAIN PLAN FOR
SELECT o.order_id, c.customer_name, p.product_name
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products p ON oi.product_id = p.product_id
WHERE o.order_date > SYSDATE - 30;

SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

Phase 2: Autonomous Database Optimization

-- Enable Automatic Indexing (Autonomous)
BEGIN
  DBMS_AUTO_INDEX.CONFIGURE('AUTO_INDEX_MODE', 'IMPLEMENT');
END;
/

-- Review recommended indexes
SELECT index_name, table_name, index_type
FROM dba_auto_indexes
WHERE status = 'VALID';

Phase 3: Manual Optimization (if not Autonomous)

-- Create composite index based on query pattern
CREATE INDEX idx_orders_cust_date ON orders(customer_id, order_date) 
COMPUTE STATISTICS;

-- Gather optimizer statistics
EXEC DBMS_STATS.GATHER_TABLE_STATS('SCHEMA_NAME', 'ORDERS');

-- Use SQL Profile for complex queries
DECLARE
  sql_tune_task VARCHAR2(100);
BEGIN
  sql_tune_task := DBMS_SQLTUNE.CREATE_TUNING_TASK(
    sql_id => 'a1b2c3d4e5f6',
    scope => DBMS_SQLTUNE.SCOPE_COMPREHENSIVE,
    time_limit => 3600,
    task_name => 'tune_slow_query'
  );
  DBMS_SQLTUNE.EXECUTE_TUNING_TASK(sql_tune_task);
END;
/

Phase 4: Application-Level Improvements

# Connection pooling with Oracle UCP
from ucpsql import create_pool

pool = create_pool(
    user='app_user',
    password='secure_password',
    dsn='mydb_medium',
    min_pool_size=10,
    max_pool_size=50,
    connection_wait_timeout=30000
)

# Batch processing for bulk operations
with pool.acquire() as conn:
    cursor = conn.cursor()
    cursor.executemany(
        "INSERT INTO order_items (order_id, product_id, qty) VALUES (:1, :2, :3)",
        batch_data  # List of tuples
    )
    conn.commit()

Outcome: Query time reduced from 2.5s to 45ms; CPU utilization down 40%.

§6.2 · Cloud Migration to OCI

Context: Migrate 50TB on-premises Oracle Database to OCI with minimal downtime.

Oracle-Engineer Approach:

Phase 1: Migration Strategy Selection

Decision Matrix:
  Downtime Tolerance: <1 hour
  Database Size: 50TB
  Version: 19c on-premises
  Target: Autonomous Dedicated
  
Selected Approach: ZDM (Zero Downtime Migration)
  - Logical migration using Data Pump + GoldenGate
  - Rollback capability maintained
  - Near-zero production impact

Phase 2: Pre-Migration Assessment

# Run OCI Database Migration Assessment Tool
./omadm-cli.sh assess \
  --source-db-host onprem-db.company.com \
  --source-db-name PRODDB \
  --target-cloud-region us-ashburn-1 \
  --output-dir ./assessment

# Review compatibility report
# - Check for unsupported features
# - Identify data type mappings
# - Estimate migration time

Phase 3: Infrastructure Preparation

# Terraform for OCI target infrastructure
resource "oci_database_autonomous_database" "target_db" {
  compartment_id       = var.compartment_id
  db_name              = "PRODDBMIG"
  display_name         = "Production DB Migration"
  db_workload          = "OLTP"
  db_version           = "19c"
  license_model        = "BRING_YOUR_OWN_LICENSE"
  
  # Exadata infrastructure for performance parity
  autonomous_database_infrastructure_type = "DEDICATED"
  
  # Auto-scaling configuration
  cpu_core_count       = 16
  data_storage_size_in_tbs = 100
  is_auto_scaling_enabled = true
}

Phase 4: Migration Execution

# ZDM migration workflow
zdmcli migrate database \
  -sourcedb onprem-db.company.com:1521/PRODDB \
  -sourcenode onprem-db.company.com \
  -targetnode adb-target.oraclecloud.com \
  -backupuser MIGRATION_USER \
  -rspfile ./migration.rsp \
  -eval

# Execute actual migration (after eval success)
zdmcli migrate database \
  -jobid previous_eval_job_id \
  -execute

Phase 5: Cutover and Validation

-- Post-migration validation
SELECT table_name, count(*) as row_count
FROM user_tables
WHERE table_name IN ('ORDERS', 'CUSTOMERS', 'PRODUCTS')
GROUP BY table_name;

-- Performance baseline comparison
SELECT sql_id, plan_hash_value, executions, 
       ROUND(elapsed_time/executions/1000,2) as avg_ms
FROM v$sql
WHERE sql_text LIKE '%orders%'
ORDER BY elapsed_time DESC;

Outcome: Migration completed with 15 minutes downtime; query performance improved 35%.

§6.3 · ERP System Implementation

Context: Implement Oracle Fusion ERP for a manufacturing company with 5,000+ users.

Oracle-Engineer Approach:

Phase 1: Requirements & Fit Analysis

Business Requirements:
  Financial Management:
    - Multi-GAAP reporting (US GAAP, IFRS)
    - 50+ entity consolidation
    - Intercompany elimination automation
  
  Supply Chain:
    - Discrete manufacturing support
    - MRP/APS integration
    - Multi-tier supplier collaboration
  
  Human Capital:
    - Global payroll (12 countries)
    - Talent management
    - Learning management

Oracle Fusion Fit: 95% standard functionality match
Customization Strategy: Configure, don't customize

Phase 2: Technical Architecture

┌─────────────────────────────────────────────────────────────┐
│                      Oracle Cloud Infrastructure            │
├─────────────────────────────────────────────────────────────┤
│  Fusion Applications Tier                                   │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐           │
│  │   ERP Pod   │ │   HCM Pod   │ │   SCM Pod   │           │
│  │  (Primary)  │ │  (Primary)  │ │  (Primary)  │           │
│  └─────────────┘ └─────────────┘ └─────────────┘           │
├─────────────────────────────────────────────────────────────┤
│  Integration Layer                                          │
│  ┌─────────────────────────────────────────────────────┐   │
│  │         Oracle Integration Cloud (OIC)              │   │
│  │  • Legacy ERP adapters  • Banking adapters          │   │
│  │  • PLM integration      • EDI/B2B                  │   │
│  └─────────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────┤
│  Data & Analytics                                           │
│  ┌─────────────────┐  ┌─────────────────────────────────┐  │
│  │ Autonomous DW   │  │ Oracle Analytics Cloud (OAC)    │  │
│  │ (Fusion DW)     │  │ • Financial reporting          │  │
│  │                 │  │ • Operational dashboards       │  │
│  └─────────────────┘  └─────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Phase 3: Security & Compliance Design

Security Architecture:
  Identity Management:
    - Oracle Cloud Identity (OCI IAM)
    - Federation with Azure AD
    - Multi-factor authentication (MFA)
  
  Data Security:
    - Role-Based Access Control (RBAC)
    - Data masking for sensitive fields
    - Audit logging for SOX compliance
  
  Network Security:
    - VPN connectivity from corporate
    - Private endpoints for admin access
    - WAF for customer-facing extensions

Phase 4: Implementation Methodology

Phase 1: Foundation (Months 1-2)
├── Environment provisioning
├── Security baseline
├── Integration framework setup
└── User access provisioning

Phase 2: Core Financials (Months 3-5)
├── Chart of accounts design
├── General Ledger configuration
├── Accounts Payable/Receivable
└── Cash Management

Phase 3: SCM & Manufacturing (Months 6-8)
├── Inventory management
├── Procurement
├── Order management
└── Manufacturing modules

Phase 4: HCM & Extensions (Months 9-10)
├── Core HR
├── Payroll configuration
├── Custom reports/dashboards
└── Mobile app deployment

Phase 5: Testing & Go-Live (Months 11-12)
├── SIT (System Integration Testing)
├── UAT (User Acceptance Testing)
├── Data migration rehearsal
└── Production cutover

Phase 5: Go-Live Readiness Checklist

□ Data migration validated (3 successful rehearsals)
□ User training completed (4,800/5,000 certified)
□ Integration testing passed (52/52 scenarios)
□ Performance benchmarks met
  - Login: <3 seconds
  - Transaction entry: <2 seconds
  - Report generation: <30 seconds
□ Rollback plan tested and documented
□ 24/7 support team staffed
□ Communication plan activated

Outcome: On-time, on-budget delivery; 99.2% user adoption within 30 days.

§6.4 · AI/ML Integration with Oracle Database

Context: Build fraud detection system using ML inside Oracle Database 23ai.

Oracle-Engineer Approach:

Phase 1: Data Preparation

-- Create vector embeddings for transaction patterns
CREATE TABLE transaction_vectors AS
SELECT 
    transaction_id,
    customer_id,
    amount,
    merchant_category,
    time_of_day,
    day_of_week,
    -- Vector representation of transaction pattern
    VECTOR('FLOAT32', 64) as embedding
FROM transactions
WHERE transaction_date > SYSDATE - 365;

-- Create vector index for similarity search
CREATE VECTOR INDEX idx_transaction_embedding
ON transaction_vectors(embedding)
ORGANIZATION NEIGHBOR PARTITIONS
DISTANCE COSINE;

Phase 2: In-Database Model Training

-- Create ML model using AutoML
BEGIN
  DBMS_DATA_MINING.CREATE_MODEL(
    model_name => 'FRAUD_DETECTION_MODEL',
    mining_function => DBMS_DATA_MINING.CLASSIFICATION,
    data_table_name => 'TRANSACTIONS_TRAINING',
    case_id_column_name => 'TRANSACTION_ID',
    target_column_name => 'IS_FRAUD',
    settings_table_name => 'FRAUD_MODEL_SETTINGS'
  );
END;
/

-- Model settings for AutoML
INSERT INTO fraud_model_settings VALUES 
  ('ALGO_NAME', 'ALGO_DECISION_TREE');
INSERT INTO fraud_model_settings VALUES 
  ('ODMS_AUTO_ML', 'ODMS_ENABLE');
INSERT INTO fraud_model_settings VALUES 
  ('ODMS_MAX_MODELS', '20');

Phase 3: Real-Time Scoring

-- Create prediction view for application
CREATE OR REPLACE VIEW transaction_risk_score AS
SELECT 
    t.transaction_id,
    t.customer_id,
    t.amount,
    PREDICTION_PROBABILITY(FRAUD_DETECTION_MODEL, 1 USING *) 
      AS fraud_probability,
    CASE 
      WHEN PREDICTION_PROBABILITY(FRAUD_DETECTION_MODEL, 1 USING *) > 0.8 
      THEN 'HIGH_RISK'
      WHEN PREDICTION_PROBABILITY(FRAUD_DETECTION_MODEL, 1 USING *) > 0.5 
      THEN 'MEDIUM_RISK'
      ELSE 'LOW_RISK'
    END AS risk_category
FROM transactions t
WHERE t.status = 'PENDING';

-- Real-time scoring trigger
CREATE OR REPLACE TRIGGER trg_fraud_check
AFTER INSERT ON transactions
FOR EACH ROW
DECLARE
  fraud_prob NUMBER;
BEGIN
  SELECT PREDICTION_PROBABILITY(FRAUD_DETECTION_MODEL, 1 USING 
    :NEW.amount, :NEW.merchant_id, :NEW.location, :NEW.time_of_day)
  INTO fraud_prob
  FROM DUAL;
  
  IF fraud_prob > 0.85 THEN
    -- Block transaction, notify security team
    RAISE_APPLICATION_ERROR(-20001, 'Transaction flagged for fraud review');
  END IF;
END;
/

Phase 4: Vector Similarity Search for Anomaly Detection

-- Find similar transactions (potential fraud ring)
SELECT 
    t1.transaction_id,
    t1.customer_id,
    t2.transaction_id as similar_transaction,
    t2.customer_id as similar_customer,
    VECTOR_DISTANCE(t1.embedding, t2.embedding, COSINE) as similarity_score
FROM transaction_vectors t1
JOIN transaction_vectors t2 
  ON VECTOR_DISTANCE(t1.embedding, t2.embedding, COSINE) < 0.2
  AND t1.customer_id != t2.customer_id
WHERE t1.transaction_id = :suspicious_transaction_id
ORDER BY similarity_score;

Outcome: 94% fraud detection accuracy, <50ms scoring latency, zero external ML infrastructure.

§6.5 · Multi-Cloud Database Deployment

Context: Deploy Oracle Database across AWS and OCI for disaster recovery.

Oracle-Engineer Approach:

Phase 1: Multi-Cloud Architecture

┌─────────────────────────────────────────────────────────────┐
│                    AWS us-east-1                            │
│  ┌─────────────────────────────────────────────────────┐   │
│  │         Oracle Database@AWS                         │   │
│  │      (Exadata infrastructure in AWS)                │   │
│  │              PRIMARY                                │   │
│  └─────────────────────────────────────────────────────┘   │
└───────────────────────────┬─────────────────────────────────┘
                            │ FastConnect + Direct Connect
                            │ (Encrypted, low-latency)
┌───────────────────────────┼─────────────────────────────────┐
│                    OCI us-ashburn-1                         │
│  ┌────────────────────────┴────────────────────────────┐   │
│  │         Oracle Cloud Infrastructure                  │   │
│  │         Autonomous Database Dedicated                │   │
│  │              STANDBY / DR                            │   │
│  │                                                      │   │
│  │  • Real-time replication via GoldenGate             │   │
│  │  • Automatic failover ( planned/unplanned)          │   │
│  │  • Read-only reporting during normal operation      │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Phase 2: Replication Configuration

-- GoldenGate Extract (on AWS source)
EXTRACT ext1
USERIDALIAS ggs_admin DOMAIN OracleGoldenGate
EXTTRAIL ./dirdat/et
TABLE schema.*;

-- GoldenGate Replicat (on OCI target)
REPLICAT rep1
USERIDALIAS ggs_admin DOMAIN OracleGoldenGate
MAP schema.*, TARGET schema.*;

Phase 3: Failover Automation

# OCI Function for automated failover
import oci
import json

def failover_handler(event, context):
    """Handle database failover from AWS to OCI"""
    
    # Initialize OCI clients
    database_client = oci.database.DatabaseClient({})
    
    # Check primary database health
    health_check = check_primary_health()
    
    if not health_check['healthy']:
        # Promote OCI standby to primary
        response = database_client.switchover_autonomous_database(
            autonomous_database_id="ocid1.autonomousdatabase.oc1..xxx",
            switchover_autonomous_database_details={
                "databaseAdminPassword": get_secret("db_admin_password")
            }
        )
        
        # Update DNS records
        update_dns_records(new_primary="oci")
        
        # Notify operations team
        send_alert("Database failover completed", severity="CRITICAL")
    
    return {"status": "success"}

Phase 4: Monitoring & Validation

-- Cross-platform replication lag monitoring
SELECT 
    'AWS_PRIMARY' as database,
    MAX(scn_to_timestamp(current_scn)) as last_scn_time
FROM v$database@aws_primary
UNION ALL
SELECT 
    'OCI_STANDBY' as database,
    MAX(scn_to_timestamp(current_scn)) as last_scn_time
FROM v$database;

-- Check for data divergence
SELECT table_name, 
       COUNT(*) as row_count,
       MAX(last_modified) as last_update
FROM schema.audit_log
GROUP BY table_name
ORDER BY last_update DESC;

Outcome: RTO <5 minutes, RPO <30 seconds, seamless cross-cloud operation.

§7 · Professional Toolkit

§7.1 · OCI CLI & SDKs

Essential CLI Commands:

# Authentication setup
oci setup config

# Compute management
oci compute instance launch \
  --availability-domain Uocm:PHX-AD-1 \
  --compartment-id ocid1.compartment.oc1..xxx \
  --shape VM.Standard2.1 \
  --image-id ocid1.image.oc1.phx.xxx \
  --subnet-id ocid1.subnet.oc1.phx.xxx

# Database operations
oci db autonomous-database create \
  --compartment-id ocid1.compartment.oc1..xxx \
  --db-name PRODDB \
  --admin-password "SecurePass123!" \
  --cpu-core-count 2 \
  --data-storage-size-in-tbs 1

# Resource monitoring
oci monitoring metric-data summarize-metrics-data \
  --namespace oci_computeagent \
  --query-text 'CpuUtilization[1m].mean()'

SDK Integration:

import oci

# Initialize default config
config = oci.config.from_file()

# Object Storage operations
object_storage = oci.object_storage.ObjectStorageClient(config)
namespace = object_storage.get_namespace().data

# Upload file
with open('data.csv', 'rb') as f:
    object_storage.put_object(
        namespace_name=namespace,
        bucket_name='my-bucket',
        object_name='data.csv',
        put_object_body=f
    )

§7.2 · Database Utilities

§8 · Standards & Reference

§8.1 · OCI Well-Architected Framework

§8.2 · Database Standards

SQL Coding Standards:

-- Use bind variables (performance + security)
SELECT customer_id, customer_name
FROM customers
WHERE customer_id = :customer_id;  -- Good

-- Avoid SELECT *
SELECT customer_id, customer_name, email  -- Good
FROM customers;

-- Use explicit joins
SELECT c.customer_name, o.order_date
FROM customers c
INNER JOIN orders o ON c.customer_id = o.customer_id  -- Good
WHERE o.order_date > SYSDATE - 30;

-- Index strategy
-- Create indexes on foreign keys
CREATE INDEX idx_orders_customer ON orders(customer_id);

-- Composite indexes for query patterns
CREATE INDEX idx_orders_date_status ON orders(order_date, status);

§9 · Risk Disclaimer

⚠️ IMPORTANT LIMITATIONS

1. Vendor Lock-in Risk: Oracle Database deep integration can create migration challenges. Plan exit strategy.

2. Licensing Complexity: Oracle licensing (processor vs. NUP) requires careful audit. Non-compliance penalties are severe.

3. Cost Management: Autonomous Database auto-scaling can lead to unexpected costs. Set budget alerts.

4. Multi-Cloud Complexity: Cross-cloud deployments add operational overhead. Ensure team expertise.

5. Legacy Compatibility: Older Oracle features may not translate to cloud-native equivalents. Assess before migration.

§10 · Integration

§11 · Scope & Limitations

Covers: OCI architecture, Oracle Database (19c/21c/23ai), Autonomous Database, Exadata, Fusion Applications, GoldenGate, Data Pump, PL/SQL development, Multi-cloud deployments.

Does NOT Cover: Oracle E-Business Suite (legacy ERP), Hyperion (separate skill), Primavera (project management), PeopleSoft/JD Edwards (legacy applications), specific pricing/negotiation.

§12 · How to Use This Skill

For Database Administrators

1. Master Autonomous Database capabilities — less tuning, more strategy
2. Understand OCI networking for database connectivity
3. Leverage in-database ML for advanced analytics
4. Implement Data Safe for security compliance

For Cloud Architects

1. Design multi-region OCI architectures
2. Plan hybrid cloud connectivity (FastConnect)
3. Size Exadata Cloud for performance requirements
4. Integrate with existing identity providers

For Application Developers

1. Use converged database features (JSON, Graph, Vector)
2. Implement connection pooling for scalability
3. Leverage PL/SQL for data-intensive operations
4. Design for Autonomous Database auto-scaling

§13 · Quality Verification

Before using outputs, verify:

• Converged approach: Are you using appropriate data types (JSON, Graph, Vector)?
• Performance: Have you considered indexes, partitioning, and query optimization?
• Security: Are credentials externalized? Is encryption enabled?
• Scalability: Is the solution designed for growth (auto-scaling, partitioning)?
• Compliance: Does it meet regulatory requirements (audit, masking)?
• Cost: Have you considered BYOL, reserved capacity, and auto-scaling limits?

§14 · Version History

§15 · License & Author

Author: neo.ai (lucas_hsueh@hotmail.com)
License: MIT — awesome-skills

§16 · Key References

Oracle Official:

• OCI Documentation
• Oracle Database 23ai
• Autonomous Database
• Oracle Investor Relations

Key Learnings:

• Oracle by Walt Boyes (corporate history)
• Softwar by Matthew Symonds (Larry Ellison biography)
• Oracle ACE program technical blogs

End of Skill Document

"The most important aspect of the software industry is that people are the most important asset." — Larry Ellison

Workflow

Phase 1: Assessment

| Done | Phase completed | | Fail | Criteria not met |

• Gather requirements

| Done | All tasks completed | | Fail | Tasks incomplete |

• Analyze current state

Phase 2: Planning

| Done | Phase completed | | Fail | Criteria not met |

• Develop approach

| Done | All tasks completed | | Fail | Tasks incomplete |

• Set timeline

Phase 3: Execution

| Done | Phase completed | | Fail | Criteria not met |

• Implement solution

| Done | All tasks completed | | Fail | Tasks incomplete |

• Verify progress

Phase 4: Review

| Done | Phase completed | | Fail | Criteria not met |

• Validate outcomes

| Done | All tasks completed | | Fail | Tasks incomplete |

• Document lessons

Examples

Example 1: Standard Scenario

Input: Design and implement a oracle engineer solution for a production system Output: Requirements Analysis → Architecture Design → Implementation → Testing → Deployment → Monitoring

Key considerations for oracle-engineer:

• Scalability requirements
• Performance benchmarks
• Error handling and recovery
• Security considerations

Example 2: Edge Case

Input: Optimize existing oracle engineer implementation to improve performance by 40% Output: Current State Analysis:

• Profiling results identifying bottlenecks
• Baseline metrics documented

Optimization Plan:

1. Algorithm improvement
2. Caching strategy
3. Parallelization

Expected improvement: 40-60% performance gain

§ 1.2 · Decision Framework — Weighted Criteria (0-100)

Composite Decision Rule:

• Score ≥85: Proceed
• Score 70-84: Conditional with monitoring
• Score <70: Stop and address issues

§ 1.3 · Thinking Patterns — Mental Models

Domain Benchmarks

Done Criteria

• All tasks completed per specification
• Quality standards met
• Stakeholder approval received

Fail Criteria

• Quality defects detected
• Requirements not met
• Timeline/budget overrun