Lesson Notes By Weeks and Term v5 - Grade 12

Lesson Video

This page supports the lesson note with a companion video and a short classroom-ready summary.

For class groups and homework, share this lesson page so learners also get the summary, objectives, and full lesson context.

Performance objectives

• Differentiate and apply database normalisation forms (1NF, 2NF, 3NF).
• Design and implement efficient SQL queries.
• Analyse and debug object-oriented programming code.
• Evaluate ethical and societal implications of IT in South Africa.
• Explain network architecture and protocols like TCP/IP.

Lesson summary

This week is dedicated to focused revision and examination preparation. In the South African IT landscape, success in Grade 12 IT not only paves the way for tertiary education and future careers in technology but also equips you with critical thinking and problem-solving skills essential for navigating the increasingly digital world. This week's revision covers key areas likely to appear in the final examination. Mastering these topics is crucial for demonstrating a thorough understanding of the IT curriculum and achieving a good result. A strong IT background is important for participating in and contributing to South Africa’s digital economy.

Lesson notes

2.1 Database Normalisation Database normalization is the process of organizing data in a database to reduce redundancy and improve data integrity. It involves dividing databases into tables and defining relationships between the tables. There are several normal forms, each with its own set of rules. 1NF (First Normal Form): A table is in 1NF if all columns contain atomic values (indivisible values). No repeating groups are allowed.

Example: Consider a table `Students` with a column `PhoneNumbers` that can contain multiple phone numbers. To achieve 1NF, you'd create a separate table `StudentPhoneNumbers` with columns like `StudentID` and `PhoneNumber`. 2NF (Second Normal Form): A table is in 2NF if it is in 1NF and all non-key attributes are fully functionally dependent on the primary key. This means that every non-key attribute depends on the entire primary key, not just part of it.

Example: Assume a table `OrderItems` with primary key `(OrderID, ProductID)` and a non-key attribute `ProductName`. If `ProductName` only depends on `ProductID`, then the table is not in 2NF. To achieve 2NF, you would move `ProductName` to a `Products` table with `ProductID` as the primary key. 3NF (Third Normal Form): A table is in 3NF if it is in 2NF and all non-key attributes are non-transitively dependent on the primary key. This means that non-key attributes should not depend on other non-key attributes.

Example: Consider a table `Employees` with columns `EmployeeID`, `DepartmentID`, and `DepartmentName`. If `DepartmentName` depends on `DepartmentID`, which in turn depends on `EmployeeID` (the primary key), then `DepartmentName` is transitively dependent on `EmployeeID`. To achieve 3NF, you would move `DepartmentName` to a `Departments` table with `DepartmentID` as the primary key.

Worked example

Consider a table `SalesOrders` with columns: `OrderID`, `CustomerID`, `CustomerName`, `OrderDate`, `ProductName`, `Quantity`, `UnitPrice`.

1NF: Already in 1NF as all attributes are atomic.

2NF: `CustomerName` depends only on `CustomerID` and `UnitPrice` depends only on `ProductName`. The primary key is `OrderID`. Thus not in 2N

F. Split into:

`Orders` (OrderID, CustomerID, OrderDate)

`Customers` (CustomerID, CustomerName)

`OrderItems` (OrderID, ProductName, Quantity)

`Products` (ProductName, UnitPrice)

3NF: All tables are now in 3NF as there are no transitive dependencies.

2.2 SQL Queries

SQL (Structured Query Language) is used to communicate with a database.

Key concepts include:

SELECT: Retrieves data from one or more tables.

FROM: Specifies the table(s) to retrieve data from.

WHERE: Filters the data based on specified conditions.

JOIN: Combines rows from two or more tables based on a related column.

GROUP BY: Groups rows with the same values in one or more columns into a summary row.

HAVING: Filters the results of a GROUP BY query.

ORDER BY: Sorts the results.

Subqueries: A query nested inside another query.

Aggregate Functions: Functions that operate on a set of values to return a single value (e.g., COUNT, SUM, AVG, MIN, MAX).

Worked

Example:

Assume we have two tables: `Customers` (CustomerID, CustomerName, City) and `Orders` (OrderID, CustomerID, OrderDate, TotalAmount).

Retrieve all customers from Cape Town: