Oracle Interview Questions 2026

Oracle Overview

Attribute	Details
Founded	1977
Headquarters	Austin, Texas (India HQ: Bangalore, Hyderabad)
Employees in India	40,000+
Core Products	Oracle Database, Cloud Infrastructure, ERP
India Operations	R&D centers, Support, Sales
Hiring Focus	Database, Java, Cloud Technologies

Oracle is the world's largest database company and a major player in cloud infrastructure and enterprise software. Oracle India hires heavily for database administration, Java development, and cloud engineering roles.

---

Oracle Interview Process 2026

Selection Stages

Stage	Duration	Format
Online Assessment	120 mins	Aptitude + Technical + Coding
Technical Round 1	45-60 mins	Core CS, Database concepts
Technical Round 2	45-60 mins	Advanced SQL, Java, System Design
Managerial Round	30-45 mins	Project discussion, Scenarios
HR Interview	20-30 mins	Behavioral, Salary discussion

Assessment Pattern

Section	Questions	Time	Topics
Aptitude	20	25 mins	Quant, Logical, Verbal
DBMS/SQL	15	20 mins	Queries, Normalization, Transactions
Java/C++	15	20 mins	OOPs, Collections, Exceptions
Coding	2-3	45 mins	Data Structures, Algorithms
Cloud/Unix	10	20 mins	AWS basics, Linux commands

---

DBMS & SQL Interview Questions

Question 1: Find Nth Highest Salary

-- Method 1: Using LIMIT/OFFSET
SELECT DISTINCT salary 
FROM employees 
ORDER BY salary DESC 
LIMIT 1 OFFSET N-1;

-- Method 2: Using subquery (Oracle specific - ROWNUM)
SELECT salary 
FROM (
    SELECT DISTINCT salary, ROWNUM as rn
    FROM employees 
    ORDER BY salary DESC
) 
WHERE rn = N;

-- Method 3: Using DENSE_RANK (Oracle)
SELECT salary 
FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) as rnk
    FROM employees
) 
WHERE rnk = N;

-- Method 4: Using correlated subquery
SELECT DISTINCT e1.salary 
FROM employees e1 
WHERE N-1 = (
    SELECT COUNT(DISTINCT e2.salary) 
    FROM employees e2 
    WHERE e2.salary > e1.salary
);

Question 2: SQL Query for Department-wise Top 3 Salaries

-- Oracle solution using ROW_NUMBER()
SELECT department_id, employee_name, salary
FROM (
    SELECT 
        department_id,
        employee_name,
        salary,
        ROW_NUMBER() OVER (
            PARTITION BY department_id 
            ORDER BY salary DESC
        ) as rank
    FROM employees
) ranked
WHERE rank <= 3;

-- Alternative using RANK()
SELECT department_id, employee_name, salary
FROM (
    SELECT 
        department_id,
        employee_name,
        salary,
        RANK() OVER (
            PARTITION BY department_id 
            ORDER BY salary DESC
        ) as salary_rank
    FROM employees
) 
WHERE salary_rank <= 3;

Question 3: Find Employees with Same Salary in Different Departments

SELECT e1.employee_id, e1.name, e1.department_id, e1.salary
FROM employees e1
JOIN employees e2 ON e1.salary = e2.salary 
    AND e1.department_id != e2.department_id
    AND e1.employee_id < e2.employee_id
ORDER BY e1.salary DESC;

-- Alternative using EXISTS
SELECT e1.*
FROM employees e1
WHERE EXISTS (
    SELECT 1 FROM employees e2
    WHERE e2.salary = e1.salary 
    AND e2.department_id != e1.department_id
);

Question 4: Pivot Table Query

-- Convert rows to columns (Sales by month)
SELECT 
    product_id,
    SUM(CASE WHEN month = 'Jan' THEN sales ELSE 0 END) as Jan_Sales,
    SUM(CASE WHEN month = 'Feb' THEN sales ELSE 0 END) as Feb_Sales,
    SUM(CASE WHEN month = 'Mar' THEN sales ELSE 0 END) as Mar_Sales
FROM sales_data
GROUP BY product_id;

-- Oracle PIVOT syntax
SELECT *
FROM (
    SELECT product_id, month, sales
    FROM sales_data
)
PIVOT (
    SUM(sales) FOR month IN ('Jan' AS Jan, 'Feb' AS Feb, 'Mar' AS Mar)
);

Question 5: Database Normalization

Explain 1NF, 2NF, 3NF, BCNF with examples:

UNF (Unnormalized Form):
Student(StudentID, Name, Subjects)
Subjects: "Maths, Physics, Chemistry" - Not atomic

1NF - Atomic values:
Student(StudentID, Name, Subject)
1, "John", "Maths"
1, "John", "Physics"

2NF - Remove partial dependencies (for composite keys):
Student(StudentID, SubjectID, SubjectName) - SubjectName depends only on SubjectID
Split to:
Enrollment(StudentID, SubjectID)
Subject(SubjectID, SubjectName)

3NF - Remove transitive dependencies:
Student(StudentID, Name, DeptID, DeptName) - DeptName depends on DeptID
Split to:
Student(StudentID, Name, DeptID)
Department(DeptID, DeptName)

BCNF - Every determinant is a candidate key:
Student(StudentID, Subject, Professor) 
If Professor determines Subject, split:
Teaching(Professor, Subject)
Enrollment(StudentID, Professor)

Question 6: ACID Properties with Examples

-- Atomicity: All or nothing
BEGIN TRANSACTION;
    UPDATE accounts SET balance = balance - 1000 WHERE id = 1;
    UPDATE accounts SET balance = balance + 1000 WHERE id = 2;
    -- If any fails, entire transaction rolls back
COMMIT;

-- Consistency: Data integrity maintained
-- Constraints, triggers ensure valid state

-- Isolation: Concurrent transactions don't interfere
-- Isolation levels:
-- READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SERIALIZABLE

-- Durability: Committed data persists
-- Write-ahead logging, redo logs

Question 7: Indexing and Query Optimization

-- Create indexes
CREATE INDEX idx_emp_dept ON employees(department_id);
CREATE INDEX idx_emp_salary ON employees(salary DESC);
CREATE COMPOSITE INDEX idx_emp_name ON employees(last_name, first_name);

-- Explain plan
EXPLAIN PLAN FOR
SELECT * FROM employees WHERE department_id = 10;

SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);

-- Covering index
CREATE INDEX idx_covering ON employees(department_id, employee_id, name);
-- Query only needs index, no table access

---

Java Interview Questions

Question 8: Explain Java Collections Framework

import java.util.*;

public class CollectionsDemo {
    
    // ArrayList vs LinkedList
    public void listComparison() {
        // ArrayList - Dynamic array, fast random access O(1)
        List<String> arrayList = new ArrayList<>();
        arrayList.add("A"); // O(1) amortized
        arrayList.get(0);   // O(1)
        arrayList.add(0, "B"); // O(n) - shifts elements
        
        // LinkedList - Doubly linked list, fast insertion O(1)
        List<String> linkedList = new LinkedList<>();
        linkedList.add("A");    // O(1)
        linkedList.add(0, "B"); // O(1) - no shifting
        linkedList.get(0);      // O(n) - traversal
    }
    
    // HashMap implementation details
    public void hashMapInternals() {
        // Default: 16 buckets, load factor 0.75
        Map<String, Integer> map = new HashMap<>();
        
        // Hashing: hashCode() -> index = hash & (n-1)
        // Collision resolution: Separate chaining (Linked List -> Tree)
        
        // Java 8: Treeify threshold = 8, Untreeify = 6
        // Converts linked list to RB tree for O(log n) lookup
        
        map.put("key", 100);
        Integer value = map.get("key"); // O(1) average
    }
    
    // Concurrent collections
    public void concurrentCollections() {
        // Thread-safe alternatives
        Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
        List<String> syncList = Collections.synchronizedList(new ArrayList<>());
        
        // CopyOnWriteArrayList - read-heavy scenarios
        List<String> cowList = new CopyOnWriteArrayList<>();
    }
}

Question 9: Multithreading in Java

import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class ThreadingExamples {
    
    // Ways to create threads
    class MyThread extends Thread {
        public void run() {
            System.out.println("Thread running");
        }
    }
    
    class MyRunnable implements Runnable {
        public void run() {
            System.out.println("Runnable running");
        }
    }
    
    // Thread pool
    ExecutorService executor = Executors.newFixedThreadPool(5);
    
    // Synchronization
    class Counter {
        private int count = 0;
        private Object lock = new Object();
        private ReentrantLock reentrantLock = new ReentrantLock();
        
        // Method synchronization
        public synchronized void increment() {
            count++;
        }
        
        // Block synchronization
        public void incrementBlock() {
            synchronized(lock) {
                count++;
            }
        }
        
        // Lock interface
        public void incrementLock() {
            reentrantLock.lock();
            try {
                count++;
            } finally {
                reentrantLock.unlock();
            }
        }
    }
    
    // Producer-Consumer problem
    class Buffer {
        private List<Integer> list = new ArrayList<>();
        private int capacity = 5;
        
        public synchronized void produce(int value) throws InterruptedException {
            while (list.size() == capacity) {
                wait();
            }
            list.add(value);
            notifyAll();
        }
        
        public synchronized int consume() throws InterruptedException {
            while (list.isEmpty()) {
                wait();
            }
            int value = list.remove(0);
            notifyAll();
            return value;
        }
    }
}

Question 10: JVM Architecture & Garbage Collection

public class JVMExplanation {
    /*
    JVM Architecture:
    
    1. Class Loader Subsystem
       - Loading: .class files loaded
       - Linking: Verification, Preparation, Resolution
       - Initialization: Static variables initialized
    
    2. Runtime Data Areas:
       - Method Area: Class metadata, static variables
       - Heap: Objects, arrays (shared by all threads)
       - Stack: Method frames, local variables (per thread)
       - PC Register: Current instruction (per thread)
       - Native Method Stack: Native method execution
    
    3. Execution Engine:
       - Interpreter: Line-by-line execution
       - JIT Compiler: Hotspot compilation
       - Garbage Collector: Memory management
    
    Garbage Collection:
    
    Heap Structure:
    - Young Generation (Eden, Survivor 0, Survivor 1)
    - Old Generation
    - Permanent Generation (Metaspace in Java 8+)
    
    GC Algorithms:
    - Serial GC: Single thread
    - Parallel GC: Multiple threads for young gen
    - CMS: Concurrent Mark Sweep (low pause)
    - G1 GC: Region-based, predictable pauses
    - ZGC: Ultra-low latency (Java 11+)
    */
    
    // Memory leak example
    public static List<Object> leak = new ArrayList<>();
    
    public void potentialLeak() {
        // Static collections can cause leaks
        leak.add(new byte[1024 * 1024]); // 1MB never freed
    }
}

---

Cloud & Infrastructure Questions

Question 11: Explain Cloud Service Models

Model	Description	Examples	Use Case
IaaS	Infrastructure as a Service	AWS EC2, Azure VMs	Full control over OS
PaaS	Platform as a Service	Heroku, AWS Elastic Beanstalk	Focus on code only
SaaS	Software as a Service	Gmail, Salesforce	End-user applications
FaaS	Function as a Service	AWS Lambda, Azure Functions	Event-driven computing

Question 12: Oracle Cloud Infrastructure (OCI) Basics

# OCI CLI Commands

# List compartments
oci iam compartment list

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

# List buckets
oci os bucket list --compartment-id ocid1.compartment.oc1..xxx

# Create bucket
oci os bucket create --name my-bucket --compartment-id ocid1.compartment.oc1..xxx

Question 13: Container Basics (Docker & Kubernetes)

# Dockerfile example
FROM openjdk:11-jre-slim
COPY target/app.jar /app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

# Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: oracle-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: oracle-app
  template:
    metadata:
      labels:
        app: oracle-app
    spec:
      containers:
      - name: app
        image: oracle-app:latest
        ports:
        - containerPort: 8080

---

System Design Questions

Question 14: Design a Cache System

import java.util.LinkedHashMap;
import java.util.Map;

// LRU Cache using LinkedHashMap
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;
    
    public LRUCache(int capacity) {
        super(capacity, 0.75f, true); // accessOrder = true
        this.capacity = capacity;
    }
    
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

// Design considerations:
// 1. Eviction policy: LRU, LFU, FIFO
// 2. Storage: In-memory, distributed (Redis)
// 3. Consistency: Write-through, Write-behind
// 4. Scaling: Sharding by key hash

Question 15: Design a Rate Limiter

import java.util.concurrent.*;

public class RateLimiter {
    private final int maxRequests;
    private final long windowMillis;
    private final ConcurrentHashMap<String, LinkedList<Long>> userRequests;
    
    public RateLimiter(int maxRequests, long windowMillis) {
        this.maxRequests = maxRequests;
        this.windowMillis = windowMillis;
        this.userRequests = new ConcurrentHashMap<>();
    }
    
    public boolean allowRequest(String userId) {
        long now = System.currentTimeMillis();
        LinkedList<Long> timestamps = userRequests.computeIfAbsent(
            userId, k -> new LinkedList<>()
        );
        
        synchronized (timestamps) {
            // Remove old timestamps
            while (!timestamps.isEmpty() && 
                   now - timestamps.peekFirst() > windowMillis) {
                timestamps.removeFirst();
            }
            
            if (timestamps.size() < maxRequests) {
                timestamps.addLast(now);
                return true;
            }
            return false;
        }
    }
}

---

HR Interview Questions

Q1: Why Oracle?

Sample Answer: "Oracle is the gold standard in database technology, and I've always been passionate about data systems. Working at Oracle would give me exposure to enterprise-scale databases that handle millions of transactions. I'm particularly excited about Oracle's cloud transformation - moving from traditional on-premise databases to autonomous cloud databases shows the company's innovation mindset. I want to be part of building the next generation of data infrastructure."

Q2: Explain a challenging database optimization you did

STAR Format:

• Situation: Application queries taking 10+ seconds
• Task: Optimize to under 1 second
• Action: Added composite indexes, rewrote subqueries as joins, implemented caching
• Result: Query time reduced to 200ms, 50x improvement

Q3: How do you handle conflicts in a team?

Sample Answer: "I believe in addressing conflicts directly but respectfully. In my last project, there was a disagreement about technology choice. I scheduled a meeting where both sides presented pros/cons with data. We created a proof-of-concept for both approaches and measured performance. The data helped us make an objective decision. The key was focusing on the problem, not personalities."

---

You May Also Like

• Stack and Queue Interview Questions 2026
• Top 50 Data Structures Interview Questions 2026
• Intel Interview Questions 2026 - Round-by-Round Guide
• Prompt Engineering Interview Questions 2026, Top 50 Questions with Answers

5 Frequently Asked Questions (FAQs)

Q1: What is the salary for freshers at Oracle in 2026?

A: Oracle offers ₹6-12 LPA for freshers, depending on the role (Database, Java, Cloud).

Q2: Does Oracle focus only on database questions?

A: While databases are emphasized, Oracle also tests Java, cloud concepts, and data structures.

Q3: Is Oracle certification helpful for placement?

A: Oracle certifications (OCA, OCP) add value but aren't mandatory. Strong fundamentals matter more.

Q4: What is Oracle's work culture like?

A: Oracle has a mature, enterprise-focused culture with emphasis on work-life balance and long-term career growth.

Q5: How should I prepare for Oracle technical rounds?

A: Focus on: Advanced SQL, DBMS concepts, Java collections, multithreading, and basic cloud knowledge.

---

Last Updated: March 2026 Source: Oracle Careers, Interview Experiences, Glassdoor

Frequently Asked Questions

What is the typical salary range for Oracle placements in 2026?

Oracle compensation for freshers and early-career roles in India commonly includes a base salary plus performance-linked components, with total offers varying by role (DBMS/Java/Cloud), location, and your interview performance. For 2026 hiring cycles, candidates with strong DBMS fundamentals and cloud exposure often receive higher offers compared to those with only basic programming knowledge.

What are the eligibility criteria for Oracle interview/placement drives?

Most Oracle drives expect a full-time degree in Computer Science/IT or a closely related field, typically with a minimum CGPA/percentage threshold (varies by campus and role). You should also be comfortable with core subjects like Data Structures, DBMS (SQL, normalization, indexing), Java basics, and at least introductory cloud concepts (e.g., fundamentals of IaaS/PaaS).

How difficult are Oracle interviews for DBMS, Java, and Cloud-focused roles?

Oracle interviews are generally considered moderately to highly competitive because they test both fundamentals and practical problem-solving. DBMS rounds often go deeper into SQL correctness, query optimization concepts, and database design trade-offs, while Java and cloud rounds assess coding clarity, debugging ability, and conceptual understanding of cloud services.

What preparation tips work best for Oracle 2026 interviews?

Start with a strong DBMS foundation: SQL (joins, subqueries, window functions), indexing, transactions, normalization, and ER-to-relational mapping. For Java, focus on core topics (OOP, collections, multithreading basics, exception handling) and practice coding with clean logic; for cloud, learn core terms and common architectures rather than memorizing vendor-specific details.

How many interview rounds are typically involved in Oracle placements?

A typical process may include an online assessment (coding and/or aptitude), followed by technical interviews, and then one or more rounds focusing on role fit and system understanding. For DBMS/Cloud roles, you can expect at least one round that heavily emphasizes SQL/database concepts, and another that checks Java fundamentals or cloud concepts depending on the team.

What common topics are asked in Oracle interviews (DBMS, Java, Cloud)?

DBMS topics commonly include SQL query writing, normalization, constraints, transactions (ACID), isolation levels at a conceptual level, indexing, and query execution/optimization basics. Java topics often cover OOP, collections, strings, exception handling, concurrency fundamentals, and coding problems; cloud topics usually include core concepts like virtualization, networking basics, storage, and deployment models (IaaS/PaaS).

How can I apply for Oracle placements or interview opportunities in 2026?

You can apply through Oracle’s official careers portal and filter by location and role keywords like Database, Java, or Cloud. If you’re targeting campus placements, also check your college’s placement cell for Oracle drive announcements and ensure your resume highlights relevant projects in DBMS (SQL-heavy), Java (coding), and cloud (deployments or architecture).

What is the selection rate for Oracle placements, and how can I improve my chances?

Selection rates vary widely by campus, number of applicants, and the specific role, but Oracle drives are competitive due to strong screening in assessments and technical depth. To improve your chances, prioritize accuracy in SQL and Java coding, practice typical interview questions under time constraints, and prepare crisp explanations for DBMS trade-offs and cloud fundamentals.