Accenture SQL and Database Primer Guide for Freshers

What the SQL primer tests

The SQL primer checks that you understand the relational model and can work with a single query confidently. Expect questions that ask you to predict a query result, choose the correct query for a requirement, spot a syntax error, or identify a concept like a foreign key or a normal form. The data sets are small and the queries are short.

You will not be asked to design a full database or write stored procedures. The aim is foundational fluency: can you read a SELECT statement, follow a join, and reason about what rows come back. Keep your preparation centred on that practical reading-and-reasoning skill.

Relational fundamentals and keys

Start with the basic vocabulary. A table is a collection of rows and columns, a row is a record, and a column is a field with a defined data type. Understand what a primary key is, namely a column or set of columns that uniquely identifies each row, and that it cannot be null or duplicated.

Then learn how tables relate. A foreign key in one table points to the primary key of another, creating a relationship and enforcing referential integrity. Many primer questions hinge on knowing that a foreign key value must exist in the referenced table, so make that rule second nature.

• Primary key: uniquely identifies a row, never null or duplicate
• Foreign key: references another table's primary key
• Referential integrity keeps related data consistent
• Unique, not-null and check constraints enforce data quality

Writing and reading SELECT queries

The SELECT statement is the heart of the primer. Know the logical order of clauses: SELECT chooses columns, FROM names the table, WHERE filters rows, GROUP BY groups them, HAVING filters groups, and ORDER BY sorts the output. A common trap is forgetting that WHERE filters individual rows while HAVING filters grouped results.

Practise reading a query and predicting its output, because this is the most common question style. Watch for DISTINCT removing duplicates, LIKE with wildcards for pattern matching, and the behaviour of NULL, which is neither equal nor unequal to a value and needs IS NULL to test.

• Clause order: SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY
• WHERE filters rows; HAVING filters groups
• DISTINCT removes duplicates; LIKE matches patterns
• NULL needs IS NULL or IS NOT NULL, not equality

Joins explained simply

Joins combine rows from two or more tables and are a guaranteed primer topic. An INNER JOIN returns only the rows that match in both tables. A LEFT JOIN returns all rows from the left table plus matching rows from the right, filling unmatched right-side columns with null. A RIGHT JOIN is the mirror image, and a FULL OUTER JOIN returns matched and unmatched rows from both sides.

The most tested distinction is INNER versus LEFT JOIN. Picture two overlapping circles: INNER JOIN is the overlap, while LEFT JOIN is the whole left circle. If you can predict which rows survive each join type on a small example, you will handle these questions with ease.

• INNER JOIN: only matching rows from both tables
• LEFT JOIN: all left rows, plus matches from the right
• RIGHT JOIN: all right rows, plus matches from the left
• FULL OUTER JOIN: all rows from both, matched or not

Aggregates, grouping and normalisation

Aggregate functions summarise data: COUNT, SUM, AVG, MIN and MAX. They are usually paired with GROUP BY to produce per-group results, such as the count of employees per department. Remember that COUNT(*) counts all rows while COUNT(column) ignores nulls in that column, a detail the primer likes to test.

Normalisation reduces redundancy by organising data into well-structured tables. You should recognise first, second and third normal form at a conceptual level: first removes repeating groups, second removes partial dependencies, and third removes transitive dependencies. You do not need to perform a full normalisation, only identify the idea behind each form.

• COUNT, SUM, AVG, MIN, MAX with GROUP BY for per-group results
• COUNT(*) counts all rows; COUNT(column) skips nulls
• 1NF removes repeating groups
• 2NF removes partial dependencies; 3NF removes transitive ones

A focused prep plan for the SQL primer

Because the topics are well-bounded, the SQL primer responds beautifully to short, structured study. Spend your first session on relational fundamentals and SELECT queries, your second on joins, and your third on aggregates, grouping and normalisation. Hand-write a few small queries so the syntax becomes muscle memory.

After each topic, attempt output-prediction questions immediately, because SQL is best learned by tracing results rather than by reading theory. A topic-wise SQL question bank lets you isolate joins or aggregates, and a timed mock that blends all the areas rehearses the real format. As always, re-attempt only what you got wrong to close gaps quickly.

• Session 1: relational basics, keys, SELECT and WHERE
• Session 2: all join types with small worked examples
• Session 3: aggregates, GROUP BY, HAVING, normalisation
• Drill output-prediction questions, then take a timed mock

Frequently Asked Questions