1Z0-071 — Oracle Database SQL Study Plan
A practical Study Plan for Oracle Database SQL (1Z0-071), with 7-, 14-, 30-, and 60/90-day schedules, SQL practice, mock exams, and review checkpoints.
Who this Study Plan is for
This Study Plan is for candidates preparing for Oracle Database SQL (1Z0-071), exam code 1Z0-071. It is designed for practical preparation: write SQL, review Oracle-specific behavior, complete mixed practice, and turn missed questions into repeatable fixes.
Use the current Oracle exam page and your registration materials as the source of truth for official scope, timing, and policies. This plan does not assume an official pass mark or weighting. It focuses on how to prepare effectively with the time you have.
Which plan should you use?
| Time until exam | Best plan | Daily time target | Main goal | Mock exam approach |
|---|---|---|---|---|
| 7 days | Final review sprint | 2 to 4 hours | Stabilize weak areas and reduce repeat mistakes | 1 to 2 timed mocks, reviewed deeply |
| 14 days | Focused recovery plan | 90 minutes to 3 hours | Cover high-value SQL topics and drill weaknesses | Diagnostic early, timed mock in week 2 |
| 30 days | Balanced plan | 60 to 120 minutes | Build coverage across SQL concepts and syntax | 2 to 3 timed mocks |
| 60 days | Full preparation path | 45 to 90 minutes | Learn, practice, and review with less cramming | Mock every 2 to 3 weeks near midpoint onward |
| 90 days | Extended full path | 30 to 75 minutes | Build durable SQL fluency with repeated review | More spaced practice, fewer cram sessions |
Choose the shorter plan only if you already have SQL experience. If you are new to Oracle SQL, use the 60/90-day path even if you know general SQL from another database platform.
Core 1Z0-071 study areas
Organize your study around skills you can demonstrate by writing and explaining SQL. Reading syntax is not enough for Oracle Database SQL (1Z0-071).
| Study area | What to practice | Common traps to review |
|---|---|---|
Basic SELECT statements | Column selection, aliases, expressions, concatenation, DISTINCT | Alias visibility, expression evaluation, duplicate handling |
| Filtering and sorting | WHERE, ORDER BY, comparison operators, LIKE, IN, BETWEEN, IS NULL | NULL comparisons, logical precedence, character/date comparisons |
| Single-row functions | Character, number, date, conversion, and general functions | Implicit conversion, date arithmetic, nested function results |
| Conditional expressions | CASE, DECODE, NVL, NVL2, NULLIF, COALESCE | Return data types, NULL behavior, evaluation logic |
| Aggregate functions | COUNT, SUM, AVG, MIN, MAX, GROUP BY, HAVING | WHERE vs HAVING, grouped columns, COUNT(*) vs COUNT(column) |
| Joins | Inner joins, outer joins, self-joins, join conditions | Missing join predicates, outer join filter placement, duplicate rows |
| Subqueries | Single-row, multiple-row, correlated, EXISTS, IN, ANY, ALL | Multi-row subquery errors, NULL effects, correlation logic |
| Set operators | UNION, UNION ALL, INTERSECT, MINUS | Column count/order, compatible data types, final ORDER BY |
| DML and transactions | INSERT, UPDATE, DELETE, transaction control | Conditional updates, rollback/commit effects, subqueries in DML |
| DDL and schema objects | Tables, constraints, views, sequences, indexes, synonyms | Constraint timing, object dependencies, sequence behavior |
| Privileges and access basics | Object access and SQL permissions at a conceptual level | Confusing object ownership with granted access |
Daily practice rhythm
Use the same rhythm regardless of plan length. The difference is how much time you spend in each block.
Standard 90-minute session
| Block | Time | What to do |
|---|---|---|
| Warm-up recall | 10 min | Rewrite yesterday’s hardest syntax from memory |
| Focused concept review | 20 min | Study one topic: joins, subqueries, functions, DDL, etc. |
| Hands-on SQL | 25 min | Run queries and modify them until behavior is clear |
| Practice questions | 25 min | Complete a focused or mixed set without checking answers early |
| Missed-question log | 10 min | Record why each miss happened and how to prevent it |
Longer 2- to 3-hour session
| Block | Time | What to do |
|---|---|---|
| Review old misses | 20 min | Redo missed questions from 2 to 4 days ago |
| Topic study | 35 min | Read notes and build a concise syntax sheet |
| SQL lab | 40 min | Write queries from prompts, not from examples |
| Timed practice set | 35 to 50 min | Use exam-style questions under time pressure |
| Error analysis | 25 min | Classify mistakes and create follow-up drills |
Short 45-minute session
| Block | Time | What to do |
|---|---|---|
| Recall | 5 min | Write one syntax pattern from memory |
| Drill | 25 min | Complete a small focused practice set |
| Review | 15 min | Fix misses and add one note to your error log |
Start with a diagnostic
Before choosing what to study first, take a mixed diagnostic practice set. Do not spend the first several days rereading everything.
After the diagnostic, sort every miss into one of these buckets:
| Bucket | Meaning | What to do next |
|---|---|---|
| Syntax gap | You did not know the correct syntax | Write the syntax from memory 3 times across 3 days |
| Oracle behavior gap | You expected behavior from another SQL dialect | Reproduce the result in an Oracle SQL environment |
| Logic gap | You misunderstood the query result | Draw the row flow: filter, join, group, sort |
| Careless read | You missed words like NOT, NULL, ALL, or outer join direction | Slow down and underline requirement words |
| Time pressure | You knew the topic but rushed | Add timed mini-sets before the next mock |
Your diagnostic result should decide the order of your study. For example, if you missed many join and subquery questions, do not spend two days polishing basic SELECT syntax.
7-day final review sprint
Use this plan if your exam is one week away. The goal is not to learn every topic from scratch. The goal is to remove high-risk weaknesses, improve timing, and avoid repeat mistakes.
| Day | Focus | Study actions |
|---|---|---|
| 1 | Diagnostic and triage | Take a mixed timed set. Build a ranked weak-area list. Review every miss before studying new material. |
| 2 | Filtering, sorting, functions | Drill WHERE, ORDER BY, NULL, date functions, conversion functions, and conditional expressions. |
| 3 | Aggregates and grouping | Practice GROUP BY, HAVING, nested functions, aggregate edge cases, and grouped result interpretation. |
| 4 | Joins and subqueries | Write inner/outer joins, self-joins, single-row and multi-row subqueries, EXISTS, IN, ANY, and ALL. |
| 5 | Set operators, DML, DDL | Review UNION, UNION ALL, INTERSECT, MINUS, transactions, constraints, views, sequences, indexes, and synonyms. |
| 6 | Timed mock and deep review | Take one full timed mock using current exam timing from your registration materials. Spend at least as long reviewing as testing. |
| 7 | Light final review | Redo only missed topics, review syntax sheets, stop heavy new material, and prepare exam-day logistics. |
7-day rules
- Stop adding broad new material after Day 5.
- On Day 6, the review of missed mock questions is more important than taking another mock.
- On Day 7, do short recall and light practice only.
- If you repeatedly miss the same topic, write and run SQL for it instead of rereading notes.
14-day focused plan
Use this plan if you have two weeks and need both coverage and exam conditioning.
| Day | Focus | Output by end of day |
|---|---|---|
| 1 | Mixed diagnostic | Error log with ranked weak areas |
| 2 | Basic SELECT, aliases, expressions | One-page syntax sheet for query structure |
| 3 | Filtering and sorting | Drill set for NULL, LIKE, IN, BETWEEN, logical operators |
| 4 | Single-row functions | Notes for character, number, date, conversion, and general functions |
| 5 | Conditional expressions | Practice CASE, DECODE, NVL, COALESCE, NULLIF scenarios |
| 6 | Aggregates and grouping | Drill GROUP BY, HAVING, and aggregate result questions |
| 7 | Mixed review checkpoint | Timed mixed set; update weak-area ranking |
| 8 | Joins | Practice inner, outer, and self-joins; explain row preservation |
| 9 | Subqueries | Drill single-row, multi-row, correlated, and EXISTS patterns |
| 10 | Set operators | Practice column compatibility, duplicate handling, and ordering |
| 11 | DML and transactions | Practice INSERT, UPDATE, DELETE, commit/rollback concepts |
| 12 | DDL and schema objects | Review constraints, views, sequences, indexes, synonyms |
| 13 | Timed mock | Complete a full timed mock and review every miss |
| 14 | Final weak-area sprint | Redo misses, review syntax sheets, avoid new broad topics |
14-day emphasis
Spend the first week repairing foundations. Spend the second week integrating topics in mixed practice. Many 1Z0-071 questions test more than one concept at once, such as a join combined with filtering, grouping, or a subquery.
30-day balanced plan
Use this plan if you want enough time for concept coverage, hands-on SQL, and multiple review cycles.
| Week | Main focus | Practice targets | Checkpoint |
|---|---|---|---|
| Week 1 | Query basics, filtering, sorting, functions | Daily focused drills and SQL labs | End-week mixed quiz |
| Week 2 | Aggregates, joins, subqueries | Hands-on query writing from prompts | Timed section-style practice |
| Week 3 | Set operators, DML, DDL, schema objects | Mixed drills with explanation writing | First full timed mock |
| Week 4 | Weak-area sprint and final mocks | Redo misses, timed mixed sets, final syntax review | Final readiness check |
30-day schedule
| Days | Focus | What to complete |
|---|---|---|
| 1 | Diagnostic | Mixed practice, error log, topic ranking |
| 2-4 | SELECT, filtering, sorting | Drill predicates, NULL, logical precedence, aliases, ORDER BY |
| 5-7 | Functions | Character, number, date, conversion, conditional, and NULL functions |
| 8-10 | Aggregates | GROUP BY, HAVING, aggregate edge cases |
| 11-14 | Joins | Inner joins, outer joins, self-joins, join filters |
| 15-18 | Subqueries | Single-row, multi-row, correlated, EXISTS, IN, ANY, ALL |
| 19-20 | Set operators | Combine result sets and review ordering/data-type rules |
| 21-23 | DML, transactions, DDL | Data changes, transaction behavior, table creation, constraints |
| 24 | Timed mock 1 | Full mock and deep review |
| 25-26 | Schema objects | Views, sequences, indexes, synonyms, object behavior |
| 27 | Weak-area drill | Top 3 weak topics only |
| 28 | Timed mock 2 | Full mock under exam-like conditions |
| 29 | Final review | Redo missed questions, rewrite syntax sheets |
| 30 | Light review | Short mixed set, logistics, rest, no cramming |
60/90-day full preparation path
Use this path if you are newer to SQL, coming from another database platform, or want durable Oracle SQL fluency before taking Oracle Database SQL (1Z0-071).
| Phase | 60-day timing | 90-day timing | Goal |
|---|---|---|---|
| Foundation | Days 1-10 | Days 1-15 | Learn query structure, filtering, sorting, and basic functions |
| Function fluency | Days 11-18 | Days 16-28 | Build comfort with Oracle functions, conversions, dates, and NULL handling |
| Aggregation and joins | Days 19-30 | Days 29-45 | Master grouped results and multi-table queries |
| Subqueries and sets | Days 31-40 | Days 46-60 | Practice nested logic, correlated logic, and set operators |
| Data and objects | Days 41-48 | Days 61-72 | Review DML, transactions, DDL, constraints, views, sequences, indexes, synonyms |
| Mixed practice | Days 49-55 | Days 73-82 | Complete mixed timed sets and close topic gaps |
| Final readiness | Days 56-60 | Days 83-90 | Timed mock, final weak-area sprint, light review |
Weekly rhythm for 60/90 days
| Day type | What to do |
|---|---|
| 3 days per week | Learn or review one SQL topic, then run hands-on examples |
| 2 days per week | Complete focused practice questions |
| 1 day per week | Mixed review across all prior topics |
| 1 day per week | Rest or light recall only |
Mock placement for longer plans
| Plan length | Recommended mock timing |
|---|---|
| 60 days | Diagnostic at start, full mock around Day 40 to 45, final mock in the last week |
| 90 days | Diagnostic at start, mixed timed checkpoint around Day 45, full mock around Day 70, final mock in the last week |
Do not take a mock exam if you do not have time to review it. For this exam, the review is where much of the learning happens.
Hands-on SQL practice method
For Oracle Database SQL (1Z0-071), hands-on practice should be part of every study week. Use an Oracle SQL environment such as Oracle Live SQL, Oracle SQL Developer with a local database, or another Oracle-compatible practice setup.
When you miss a question, reproduce the behavior. Adapt table and column names to your practice schema.
-- NULL comparison drill
SELECT employee_id, commission_pct
FROM employees
WHERE commission_pct = NULL;
SELECT employee_id, commission_pct
FROM employees
WHERE commission_pct IS NULL;
-- GROUP BY and HAVING drill
SELECT department_id, COUNT(*) AS employee_count
FROM employees
WHERE department_id IS NOT NULL
GROUP BY department_id
HAVING COUNT(*) > 5
ORDER BY employee_count DESC;
-- Subquery behavior drill
SELECT employee_id, last_name, salary
FROM employees
WHERE salary > (
SELECT AVG(salary)
FROM employees
);
For each drill, answer these questions:
- What rows are filtered before grouping?
- What rows remain after grouping?
- Which expressions are allowed in the
SELECTlist? - What would change if
NULLvalues were present? - What would happen if the subquery returned more than one row?
Missed-question review method
A missed-question log is more valuable than a large pile of unreviewed practice questions.
| Field | What to record |
|---|---|
| Date | When you missed it |
| Topic | Example: joins, NULL, date conversion, GROUP BY, subquery |
| Question type | Syntax, output prediction, best query, concept, DDL/DML behavior |
| Why I missed it | Be specific: “used = NULL” or “forgot HAVING applies after grouping” |
| Correct rule | One sentence you can remember |
| SQL proof | Query you ran to confirm the behavior |
| Redo date | 2 to 4 days later |
| Status | Fixed, shaky, or repeat miss |
The 4-pass review cycle
| Pass | When | Action |
|---|---|---|
| Pass 1 | Immediately | Read explanation and identify the exact rule |
| Pass 2 | Same day | Recreate the concept with a small SQL example |
| Pass 3 | 2 to 4 days later | Redo the question without looking at notes |
| Pass 4 | Final week | Redo only repeat misses and shaky topics |
If a question is missed twice, do not just mark it wrong again. Create a small custom drill for that exact issue.
Timed mock exam strategy
Timed mocks are useful only when they simulate pressure and produce review data.
| Plan | When to use timed mocks | What to do after |
|---|---|---|
| 7 days | Day 1 diagnostic and Day 6 full mock if possible | Review every miss before doing more questions |
| 14 days | Day 1 diagnostic, Day 13 full mock | Use Day 14 for targeted correction |
| 30 days | Around Days 24 and 28, with smaller timed sets earlier | Compare repeated weak areas across mocks |
| 60/90 days | One midpoint checkpoint and one final-week mock | Use spaced review instead of cramming |
Mock rules
- Use the timing and question count shown in your current Oracle exam registration materials.
- Take the mock in one sitting.
- Do not pause to check syntax.
- Mark uncertain questions so you can review both wrong and lucky-correct answers.
- Spend at least the same amount of time reviewing the mock as you spent taking it.
- Track repeated topics, not just the final score.
Final-week rules
Use the final week to stabilize, not to expand endlessly.
| Rule | Why it matters |
|---|---|
| Stop broad new material 3 to 5 days before the exam | New topics can displace stronger knowledge |
| Keep writing SQL | Syntax recall improves when you produce queries, not just read them |
| Redo repeat misses | Repeat errors are more dangerous than one-time misses |
| Practice mixed sets | The real exam will not announce the topic before each question |
| Review Oracle-specific behavior | Avoid carrying assumptions from other SQL platforms |
| Protect sleep and timing | Fatigue increases misreads on SQL output questions |
Exam-readiness checks
You are closer to ready when you can do the following without relying on explanations:
- Write basic
SELECT, join, aggregate, subquery, and set-operator queries from prompts. - Explain why
NULLchanges comparison, grouping, and function results. - Predict whether a query fails because of grouping, data type, or subquery return rules.
- Distinguish
WHEREfromHAVINGin output questions. - Choose correct join types based on required row preservation.
- Identify when a subquery must return one row versus multiple rows.
- Explain duplicate handling in set operators.
- Describe the effect of DML and transaction control statements.
- Recognize how constraints, views, sequences, indexes, and synonyms are used.
- Review a missed question and state the corrected rule in one sentence.
If you are still missing many questions from the same two or three areas, delay full-mock repetition and spend a focused session on those topics.
Practical next step
Pick the plan that matches your remaining time, take a mixed diagnostic practice set, and build your missed-question log before doing more review. For Oracle Database SQL (1Z0-071), the fastest improvement usually comes from combining short concept review with hands-on SQL and disciplined review of every missed question.