SQL — Structured Query Language Grade 12

SQL (pronounced "S-Q-L" or "sequel") is the language used to communicate with a database. It lets you retrieve, add, update and delete records. In Delphi, SQL is added to a TADOQuery component.

Anatomy of a SQL Statement

Using SQL in Delphi

SQL goes into the SQL property of a TADOQuery component. Always close the query before changing the SQL, then open it again.

// Method 1: assign as one string
qryStudents.Close;
qryStudents.SQL.Text := 'SELECT * FROM tblStudents WHERE Grade = 12';
qryStudents.Open;

// Method 2: build line-by-line (easier to read for long queries)
qryStudents.Close;
qryStudents.SQL.Clear;
qryStudents.SQL.Add('SELECT Name, Surname, Mark');
qryStudents.SQL.Add('FROM tblStudents');
qryStudents.SQL.Add('WHERE Grade = 12');
qryStudents.SQL.Add('ORDER BY Surname ASC');
qryStudents.Open;

SELECT — Choosing What to Display

SELECT * FROM tblCD;                      -- all fields, all records
SELECT CDName, Artist FROM tblCD;          -- only these two fields
SELECT DISTINCT Genre FROM tblCD;          -- each genre shown once only
SELECT TOP 5 * FROM tblCD;               -- first 5 records only

WHERE — Filtering Records

The WHERE clause is how you filter — like asking "show me only the records that match this condition."

WHERE Genre = "Rock"             -- exact match (text in double quotes)
WHERE Price < 100               -- numbers (no quotes)
WHERE Grade <> 11              -- not equal
WHERE Mark >= 50              -- greater than or equal
WHERE Genre = "Pop" AND Price < 100       -- both must be true
WHERE Genre = "Pop" OR Genre = "Rock"     -- either can be true

Operator Precedence in Compound Conditions

When a WHERE clause mixes AND and OR, SQL doesn't just evaluate left to right — it follows a fixed order of precedence, same as in maths:

AND is evaluated before OR, so a mixed condition may not filter the way you expect unless you add brackets to force the order you want.

WHERE Genre = "Pop" OR Genre = "Rock" AND Price < 100
-- reads as: Genre = "Pop"  OR  (Genre = "Rock" AND Price < 100)
-- ALL Pop CDs are included, regardless of price!

-- To make BOTH genres respect the price limit, use brackets:
WHERE (Genre = "Pop" OR Genre = "Rock") AND Price < 100

Special WHERE Operators

WHERE CDName LIKE "S%"        -- starts with S
WHERE CDName LIKE "%love%"    -- contains the word "love"
WHERE CDName LIKE "%s"        -- ends with s
WHERE Code   LIKE "A__"       -- starts with A followed by exactly 2 chars

ORDER BY — Sorting Results

SELECT * FROM tblCD ORDER BY Artist;             -- ascending (default)
SELECT * FROM tblCD ORDER BY Price DESC;        -- most expensive first
SELECT * FROM tblCD ORDER BY Genre, CDName ASC; -- sort by genre, then name

Calculated Fields & Aliases

You can do maths inside a SELECT and give the result a name using AS.

SELECT Name, Price, Price * 1.15 AS PriceWithVAT FROM tblProducts;
SELECT Name, Mark, ROUND(Mark / 2, 0) AS HalfMark FROM tblStudents;

Aggregate Functions — Calculating Summaries

-- Count students per grade
SELECT Grade, COUNT(*) AS Total
FROM tblStudents
GROUP BY Grade;

-- Only show groups with more than 10 students
SELECT Grade, COUNT(*) AS Total
FROM tblStudents
GROUP BY Grade
HAVING COUNT(*) > 10;

SQL String & Math Functions

Date Functions

SELECT Name, YEAR(BirthDate) AS BirthYear FROM tblStudents;
SELECT * FROM tblOrders WHERE MONTH(OrderDate) = 12;     -- December orders
SELECT * FROM tblStudents WHERE YEAR(BirthDate) = 2008;

INSERT, UPDATE, DELETE

-- Add a new record
INSERT INTO tblStudents (Name, Surname, Grade)
VALUES ("Alice", "Smith", 12);

-- Change existing data
UPDATE tblStudents
SET Grade = 12
WHERE StudentID = 45;

-- Remove a record
DELETE FROM tblStudents
WHERE StudentID = 45;

Building an INSERT String with QuotedStr

Instead of a parameterised query, you will sometimes build the whole SQL statement as one string by joining Delphi variables onto it directly. Text values need quotes around them in the final SQL string — the QuotedStr function wraps a string value in quotes for you, so you don't have to type them by hand.

qryStudents.Close;
qryStudents.SQL.Text := 'INSERT INTO tblStudents (Name, Surname) VALUES (' +
  QuotedStr(edtName.Text) + ', ' + QuotedStr(edtSurname.Text) + ')';
qryStudents.ExecSQL;   // use ExecSQL (not Open) for INSERT/UPDATE/DELETE — they don't return records

Parameterised Queries

Instead of hardcoding a value, use a parameter that is filled in by the user at runtime.

qryStudents.Close;
qryStudents.SQL.Clear;
qryStudents.SQL.Add('SELECT * FROM tblStudents');
qryStudents.SQL.Add('WHERE Grade = :pGrade');   // :pGrade is the parameter
qryStudents.Parameters.ParamByName('pGrade').Value := sedGrade.Value;
qryStudents.Open;

SQL in Delphi — Reading Field Values

// Read a field value from the current record
sName   := qryStudents['Name'];
iGrade  := qryStudents['Grade'];
rMark   := qryStudents['Average'];

// Loop through all records
qryStudents.First;
while not qryStudents.Eof do
begin
  memOut.Lines.Add(qryStudents['Name'] + ' ' + qryStudents['Surname']);
  qryStudents.Next;
end;

Worked Example — A Search Screen

A classic Paper 1 task: the user types (part of) a surname into edtSearch and clicks a button. The program must build a parameterised query from that input, run it, list every match in memOut, and report how many were found. This combines user input, SQL, looping a dataset and string output.

procedure TfrmMain.btnSearchClick(Sender: TObject);
var
  iFound : integer;
begin
  memOut.Clear;
  iFound := 0;

  // 1. Build a parameterised query from the user's input
  qryStudents.Close;
  qryStudents.SQL.Clear;
  qryStudents.SQL.Add('SELECT Name, Surname, Grade, Average');
  qryStudents.SQL.Add('FROM tblStudents');
  qryStudents.SQL.Add('WHERE Surname LIKE :pName');
  qryStudents.SQL.Add('ORDER BY Surname ASC');
  // add a wildcard so 'coe' matches 'Coetzee'
  qryStudents.Parameters.ParamByName('pName').Value := edtSearch.Text + '%';
  qryStudents.Open;

  // 2. Loop through the result set and display each record
  qryStudents.First;
  while not qryStudents.Eof do
  begin
    memOut.Lines.Add(qryStudents['Name'] + ' ' + qryStudents['Surname']
                     + '  (Gr ' + IntToStr(qryStudents['Grade'])
                     + ', ' + FloatToStrF(qryStudents['Average'], ffFixed, 4, 1) + '%)');
    Inc(iFound);
    qryStudents.Next;
  end;

  // 3. Report how many were found
  if iFound = 0 then
    ShowMessage('No learner found starting with "' + edtSearch.Text + '".')
  else
    lblCount.Caption := IntToStr(iFound) + ' learner(s) found';
end;

SQL — Joining Tables Grade 12

In SA IT CAPS, joining two tables is done using the WHERE clause method — listing both tables in FROM and linking them with a matching condition in WHERE. This is the only join method required for CAPS.

Why Join Tables?

A relational database splits related data across tables. For example, a student record stores a ClassID but the class name lives in a separate table. To display both together, you join the tables.

Syntax

SELECT TableA.Field1, TableB.Field2
FROM TableA, TableB
WHERE TableA.KeyField = TableB.KeyField;

Both tables appear in FROM, separated by a comma. The WHERE clause links the tables on their shared key field.

Examples

Example 1 — Students with their class names

SELECT tblStudents.Name, tblStudents.Surname, tblClasses.ClassName
FROM tblStudents, tblClasses
WHERE tblStudents.ClassID = tblClasses.ClassID;

Example 2 — With extra filtering and sorting

SELECT tblStudents.Name, tblStudents.Surname, tblClasses.ClassName
FROM tblStudents, tblClasses
WHERE tblStudents.ClassID = tblClasses.ClassID
AND tblStudents.Grade = 12
ORDER BY tblStudents.Surname ASC;

Example 3 — Join with GROUP BY and COUNT

SELECT tblClasses.ClassName, COUNT(tblStudents.StudentID) AS Total
FROM tblStudents, tblClasses
WHERE tblStudents.ClassID = tblClasses.ClassID
GROUP BY tblClasses.ClassName
ORDER BY Total DESC;

Example 4 — Using LIKE with a join

SELECT tblBooks.Title, tblAuthors.AuthorName, tblBooks.Price
FROM tblBooks, tblAuthors
WHERE tblBooks.AuthorID = tblAuthors.AuthorID
AND tblBooks.Title LIKE "IT%"
ORDER BY tblBooks.Price DESC;

Using a Join in Delphi (TADOQuery)

qryData.Close;
qryData.SQL.Clear;
qryData.SQL.Add('SELECT tblStudents.Name, tblStudents.Surname, tblClasses.ClassName');
qryData.SQL.Add('FROM tblStudents, tblClasses');
qryData.SQL.Add('WHERE tblStudents.ClassID = tblClasses.ClassID');
qryData.SQL.Add('AND tblStudents.Grade = 12');
qryData.Open;

Cartesian Product Warning

Common Mistakes

Object-Oriented Programming (OOP) Grade 12

OOP lets you model real-world things as objects in code. Think of a class as a blueprint (like architectural plans for a house) and an object as the actual building made from that plan. One blueprint, many buildings — one class, many objects.

Core OOP Concepts

One Class, Many Objects

A class is defined once. You can create as many objects (instances) from it as you need — each with its own data.

UML Class Diagram

Before coding a class, design it using a UML (Unified Modeling Language) diagram — a rectangle divided into 3 sections.

Encapsulation

Keep attributes private — hidden from the outside world. Only expose them through controlled public methods (getters and setters). This protects data from accidental or invalid changes.

private
  fName: string;         // hidden from outside — direct access blocked
public
  procedure SetName(s: string);  // controlled write access (can include validation)
  function  GetName: string;     // controlled read access

Inheritance

A child class inherits all attributes and methods from a parent class, and can add or override its own. This avoids repeating code.

type
  TAnimal = class
    procedure Speak; virtual;  // can be overridden in child classes
  end;

  TDog = class(TAnimal)       // inherits everything from TAnimal
    procedure Speak; override;  // replaces TAnimal.Speak
  end;

  TCat = class(TAnimal)
    procedure Speak; override;
  end;

Polymorphism

The same method name (Speak) behaves differently depending on the type of object. "Many forms" — poly = many, morph = form.

procedure TAnimal.Speak;
begin
  ShowMessage('Animal sound...');
end;

procedure TDog.Speak;
begin
  ShowMessage('Woof!');
end;

procedure TCat.Speak;
begin
  ShowMessage('Meow!');
end;

Types of Methods

private
  function FormatWeight(rWeight: real): string;  // auxiliary — helper only, not called from outside the class
public
  function ToString: string;

// ...
function TCat.FormatWeight(rWeight: real): string;
begin
  Result := FloatToStrF(rWeight, ffFixed, 4, 1) + 'kg';  // just formats — doesn't change fWeight
end;

function TCat.ToString: string;
begin
  Result := fName + ', ' + FormatWeight(fWeight);  // ToString calls the auxiliary method
end;

How to Create a Class in Delphi

1. Go to File → New → Unit – Delphi to create a new blank unit.
2. Save it in the same folder as your project (e.g. UCar.pas).
3. Type the class structure in the interface section (see template below).
4. Press Ctrl+Shift+C — Delphi auto-generates the method bodies in the implementation section.
5. Fill in the code inside each method body.
6. In your main form unit, add the unit name to the uses clause (e.g. uses ..., UCar;).

Complete Class Example — TCat

unit UCat;

interface

type
  TCat = class
  private
    fName   : string;
    fAge    : integer;
    fWeight : real;
  public
    constructor Create(sName: string; iAge: integer; rWeight: real);
    function    GetName   : string;
    function    GetAge    : integer;
    function    GetWeight : real;
    procedure   SetName(sNew: string);
    function    ToString  : string;
  end;

implementation

constructor TCat.Create(sName: string; iAge: integer; rWeight: real);
begin
  fName   := sName;
  fAge    := iAge;
  fWeight := rWeight;
end;

function TCat.GetName : string;
begin
  Result := fName;
end;

function TCat.GetAge : integer;
begin
  Result := fAge;
end;

function TCat.GetWeight : real;
begin
  Result := fWeight;
end;

procedure TCat.SetName(sNew: string);
begin
  fName := sNew;
end;

function TCat.ToString : string;
begin
  Result := fName + ', Age: ' + IntToStr(fAge)
          + ', Weight: ' + FloatToStr(fWeight) + 'kg';
end;

end.

Practice Example — TCar Class

This is the kind of class you will write in a Grade 12 exam. Study the pattern carefully — constructor, accessors, mutator, ToString.

unit UCar;

interface

type
  TCar = class
  private
    fMake  : string;    // e.g. 'Toyota'
    fYear  : integer;   // e.g. 2022
  public
    constructor Create(sMake: string; iYear: integer);
    function    GetMake  : string;
    function    GetYear  : integer;
    procedure   SetMake(sNewMake: string);
    function    ToString : string;
  end;

implementation

constructor TCar.Create(sMake: string; iYear: integer);
begin
  fMake := sMake;
  fYear := iYear;
end;

function TCar.GetMake : string;
begin
  Result := fMake;
end;

function TCar.GetYear : integer;
begin
  Result := fYear;
end;

procedure TCar.SetMake(sNewMake: string);
begin
  fMake := sNewMake;    // could add validation here (e.g. check not empty)
end;

function TCar.ToString : string;
begin
  Result := fMake + ' (' + IntToStr(fYear) + ')';
  // Output example: 'Toyota (2022)'
end;

end.

Using TCar in the Main Form

// 1. Add UCar to uses clause of the main form
uses
  ..., UCar;

// 2. Declare object variable (global or local)
var
  objCar : TCar;

// 3. Create the object — in a button click or FormCreate
objCar := TCar.Create('Toyota', 2022);

// 4. Read values using accessors
lblMake.Caption := objCar.GetMake;                 // 'Toyota'
lblYear.Caption := IntToStr(objCar.GetYear);       // '2022'
memOut.Lines.Add(objCar.ToString);                 // 'Toyota (2022)'

// 5. Update a value using mutator
objCar.SetMake('Honda');
lblMake.Caption := objCar.GetMake;                 // 'Honda'

Using a Class in the Main Form

uses
  ..., UCat;

var
  objCat : TCat;

// Create the object
objCat := TCat.Create('Whiskers', 3, 4.2);

// Use its accessors
lblName.Caption := objCat.GetName;           // 'Whiskers'
lblAge.Caption  := IntToStr(objCat.GetAge);  // '3'
memOut.Lines.Add(objCat.ToString);           // 'Whiskers, Age: 3, Weight: 4.2kg'

// Update via mutator
objCat.SetName('Felix');
lblName.Caption := objCat.GetName;           // 'Felix'

Dynamic Components — Creating Controls at Runtime

You already know that every Delphi control is an object of a class (a button is a TButton, a label is a TLabel). Because they are classes, you can create them in code while the program is running using the same Create constructor you use for your own classes — instead of dragging them onto the form at design time.

This is called creating a dynamic component. It is useful when you don't know in advance how many controls you need (e.g. one button per record loaded from a file).

The Four Steps

1. Create the object from its class, passing the owner (usually the form).
2. Set the Parent so Delphi knows where to draw it (which form/panel).
3. Set properties like position, size and caption.
4. Assign an event handler so it actually does something when clicked.

var
  btnDynamic : TButton;
begin
  // 1. Create the object (Form1 is the owner – frees it automatically)
  btnDynamic := TButton.Create(Form1);

  // 2. Set the Parent so it appears on the form
  btnDynamic.Parent := Form1;

  // 3. Set properties
  btnDynamic.Left    := 50;
  btnDynamic.Top     := 50;
  btnDynamic.Width   := 100;
  btnDynamic.Height  := 30;
  btnDynamic.Caption := 'Click Me';

  // 4. Assign an event handler (a procedure you wrote)
  btnDynamic.OnClick := btnDynamicClick;
end;

// The handler the button will run when clicked
procedure TForm1.btnDynamicClick(Sender: TObject);
begin
  ShowMessage('Dynamic button clicked!');
end;

2D Arrays Grade 12

A two-dimensional array stores data in a grid of rows and columns — like a table or spreadsheet. Each element is accessed using two indices: [row, column].

What is a 2D Array?

A two-dimensional (2D) array is a single variable that stores many values arranged in a grid of rows and columns. Where an ordinary (one-dimensional) array is like a single shopping list running down the page, a 2D array is like a whole spreadsheet — a block of cells where every value sits at the crossing point of a row and a column.

Analogy: think of a spreadsheet such as Excel. To find a cell you give a column letter and a row number — for example C5. A 2D array works exactly the same way, except we use two numbers: the first for the row and the second for the column. So myArray[2,3] means "the value in row 2, column 3", just like clicking one cell in a grid.

Why Do We Use 2D Arrays?

• Related data stays together – instead of mark1, mark2, mark3 … you keep every mark in one organised grid.
• Rows and columns have meaning – a row can represent one learner and a column one subject, so the position itself tells you what the value is.
• Loops do the heavy lifting – because the data is regular, two nested loops can fill, display or total the entire table in a few lines.

Declaration

Before you can use a 2D array you must declare it, telling Delphi how many rows and columns it has and what type of data each cell holds. You give two ranges in the square brackets: the first range is the rows and the second is the columns.

var
  arrName : array [rowStart..rowEnd, colStart..colEnd] of DataType;

var
  myArray : array [1..2, 1..3] of Integer;

The example above creates a grid with 2 rows and 3 columns, giving 6 integer cells in total. Note: the ranges can start at any number, but in CAPS we almost always start at 1 so that "row 1" really is the first row.

Visualising a 2D Array

The table below shows how the index numbers map onto the grid. Read it like a spreadsheet: pick a row down the side and a column across the top, and the cell where they meet is the array element you are referring to.

Populating a 2D Array

Populating means putting values into the cells. There are two common ways: assigning each cell one by one (fine for a few known values), or using nested loops to fill the whole grid quickly.

Fixed values

Here we set each cell directly by naming its row and column. This is clear but tedious — imagine doing it for a 30 × 6 register. Use it only when you have a handful of specific values to place.

myArray[1,1] := 10;  myArray[1,2] := 20;  myArray[1,3] := 30;
myArray[2,1] := 40;  myArray[2,2] := 50;  myArray[2,3] := 60;

Nested FOR loops (most common)

This is the technique you will use most often. The outer loop moves through the rows; for each row the inner loop moves through every column. The result is that the inner loop runs completely for each turn of the outer loop, so the code visits every cell, one full row at a time — exactly like reading a spreadsheet left-to-right, then dropping down to the next line.

var
  myArray : array [1..3, 1..4] of Integer;
  r, c    : Integer;
begin
  for r := 1 to 3 do
    for c := 1 to 4 do
      myArray[r, c] := r * c;   // e.g. row 2, col 3 = 6
end;

Displaying a 2D Array

To show the grid neatly we again use nested loops, but this time we build up one line of text per row. For each row we start with an empty string, add every column value to it (padding each so the columns line up), and only then add the finished line to the memo. Important Rule: the line is built inside the inner loop but written out in the outer loop — that is what keeps each row on its own line.

var
  sLine: string;
  r, c:  Integer;
begin
  memOut.Clear;
  for r := 1 to 3 do
  begin
    sLine := '';
    for c := 1 to 4 do
      sLine := sLine + IntToStr(myArray[r,c]).PadLeft(5);
    memOut.Lines.Add(sLine);
  end;
end;

Calculations on 2D Arrays

A big reason for using a grid is to add things up. The trick is knowing which index to fix and which to vary. If you think of the class register again: a row total is one learner's marks added across all subjects, while a column total is one subject's marks added across all learners.

Row total

To total a single row we fix the row number (here row 1) and let the column index c change. The loop walks across that one row, adding each cell to a running total. This answers "what is everything in this row added together?" — for example one learner's total mark.

iTotal := 0;
for c := 1 to 4 do
  iTotal := iTotal + myArray[1, c];

Column total

Now we do the opposite: we fix the column number (here column 2) and let the row index r change. The loop runs straight down that one column, adding each cell. This answers "what is everything in this column added together?" — for example the total of all learners' marks for one subject.

iTotal := 0;
for r := 1 to 3 do
  iTotal := iTotal + myArray[r, 2];

Grand total of all elements

To add up every cell in the whole grid we need nested loops again — the outer loop for rows, the inner loop for columns — so the running total picks up each cell exactly once. This is how you would work out the grand total of all marks for the entire class across all subjects.

iTotal := 0;
for r := 1 to 3 do
  for c := 1 to 4 do
    iTotal := iTotal + myArray[r, c];

Worked Example — Class Register Report

A full exam question ties the pieces together: a 2D array of marks, a parallel 1D array of names, nested loops, and both a row and a column calculation. Here the grid arrMark holds marks for each learner (rows) across 4 subjects (columns), and arrName holds the matching learner names.

const
  LEARNERS = 5;
  SUBJECTS = 4;
var
  arrMark : array[1..LEARNERS, 1..SUBJECTS] of Integer;   // the grid: row = learner, col = subject
  arrName : array[1..LEARNERS] of string;              // parallel to the rows

arrName[r] is the name of the learner whose marks are in arrMark[r, 1..SUBJECTS] — the name array runs parallel to the rows of the grid.

Part (a) — Each learner's average (a row calculation)

Fix the row (one learner) and loop across the columns to total their subjects, then divide.

var
  r, c, iRowTotal : Integer;
  rAvg            : Real;
begin
  for r := 1 to LEARNERS do
  begin
    iRowTotal := 0;
    for c := 1 to SUBJECTS do
      iRowTotal := iRowTotal + arrMark[r, c];
    rAvg := iRowTotal / SUBJECTS;
    memOut.Lines.Add(arrName[r] + ': ' +
                     FloatToStrF(rAvg, ffFixed, 4, 1) + '%');
  end;
end;

Part (b) — The best subject (a column calculation + finding a max)

Now fix each column (one subject) and loop down the rows to average that subject across all learners, keeping track of the highest.

var
  r, c, iColTotal, iBestCol : Integer;
  rColAvg, rBestAvg         : Real;
begin
  iBestCol := 1;
  rBestAvg := 0;
  for c := 1 to SUBJECTS do
  begin
    iColTotal := 0;
    for r := 1 to LEARNERS do
      iColTotal := iColTotal + arrMark[r, c];
    rColAvg := iColTotal / LEARNERS;
    if rColAvg > rBestAvg then
    begin
      rBestAvg := rColAvg;
      iBestCol := c;               // remember WHICH subject
    end;
  end;
  ShowMessage('Best subject: column ' + IntToStr(iBestCol) +
              ' (average ' + FloatToStrF(rBestAvg, ffFixed, 4, 1) + '%)');
end;

Recursion in Delphi Grade 12

Recursion is when a function or procedure calls itself repeatedly until a base condition is met. It is a powerful technique for problems that can be broken down into smaller versions of the same problem.

What is Recursion?

Recursion is when a function calls itself to solve a smaller version of the same problem, again and again, until the problem becomes so small it can be answered directly.

Analogy: picture a set of Russian nesting dolls. You open the biggest doll and find a smaller doll inside, open that and find a smaller one still, and you keep going until you reach the tiny doll that does not open. Recursion works the same way — each call opens up a slightly smaller version of the problem, and the smallest doll (the one that does not open) is the point where you stop.

A recursive routine is one that calls itself. Every recursive solution must have two parts:

• Base case — the condition that stops the recursion (essential — without it you get infinite recursion)
• Recursive case — the part where the function calls itself with a simpler input

Example 1 — Factorial

Factorial of n (written n!) = n × (n-1) × (n-2) × … × 1. Example: 5! = 5 × 4 × 3 × 2 × 1 = 120

function Factorial(n: Integer): Integer;
begin
  if n <= 1 then           // base case: factorial of 0 or 1 is 1
    Result := 1
  else                      // recursive case
    Result := n * Factorial(n - 1);
end;

// Calling it:
lblResult.Caption := IntToStr(Factorial(5));  // = 120

Trace — how Factorial(4) executes

Factorial(4)
  = 4 * Factorial(3)
      = 3 * Factorial(2)
          = 2 * Factorial(1)
              = 1        ← base case reached
          = 2 * 1 = 2
      = 3 * 2 = 6
  = 4 * 6 = 24

Example 2 — Sum of 1 to N

function SumToN(n: Integer): Integer;
begin
  if n <= 0 then
    Result := 0           // base case
  else
    Result := n + SumToN(n - 1);  // recursive case
end;

// SumToN(4) = 4 + 3 + 2 + 1 + 0 = 10

Example 3 — Power (x to the power of n)

function PowerOf(base, exp: Integer): Integer;
begin
  if exp = 0 then
    Result := 1                            // base case: x^0 = 1
  else
    Result := base * PowerOf(base, exp - 1); // recursive
end;

// PowerOf(2, 4) = 2*2*2*2 = 16

Example 4 — Fibonacci Sequence

Each number is the sum of the previous two: 0, 1, 1, 2, 3, 5, 8, 13…

function Fibonacci(n: Integer): Integer;
begin
  if n <= 1 then
    Result := n                            // base cases: F(0)=0, F(1)=1
  else
    Result := Fibonacci(n - 1) + Fibonacci(n - 2);
end;

Recursion vs Iteration

Key Rules for Writing Recursive Functions

1. Always define a base case that returns a value without calling itself
2. Each recursive call must move toward the base case (e.g. decrease n by 1)
3. Test with small values first — trace through manually
4. Use a function (not procedure) so it can return a value

Data Collection & Warehousing Grade 12

Modern databases are fed by many automated data collection methods. Large organisations store historical data in warehouses for analysis and decision-making.

Methods of Data Collection

Data collection is the process of gathering raw facts and figures from many different sources so that they can be stored, processed and turned into useful information. In the old days a person sat with a clipboard and wrote everything down by hand. Today most data is collected automatically — every time you swipe a card, drive under an e-toll gantry or tap a website, data is being captured about you without anyone writing a single thing.

Example: When you scan your Pick n Pay Smart Shopper card at the till, the shop instantly records what you bought, when, where and for how much — that single swipe feeds a database that the shop later uses to send you targeted specials.

Static vs Dynamic Location Data

Data Warehousing

A data warehouse is a large central storage system that collects and consolidates historical data from many separate source databases into one single place, so that it can be analysed for trends and decision-making.

Think of it like this: a normal database is like the till at one Pick n Pay branch — it records today's sales as they happen. A data warehouse is like head office in Cape Town, where the sales from every branch in the country, going back many years, are all poured into one giant store. Head office does not use this to ring up a sale; they use it to spot the big picture — which products sell best in winter, which branches are growing, where to open the next store.

Note: Because a warehouse holds so much data from so many sources, the data must first be cleaned and put into a consistent format before it is loaded in — otherwise the same customer might appear three different ways and the analysis would be wrong.

Data Mining

Data mining is the process of analysing very large datasets to discover hidden patterns, trends and useful relationships that a human could never spot by eye. The name is a good clue: just as a gold miner digs through tonnes of rock to find a few grams of gold, data mining digs through millions of records to find the valuable nuggets of knowledge buried inside.

Why Do Companies Mine Data?

Companies collect enormous amounts of data, but raw data on its own is useless — it is just numbers and words. Data mining turns that raw data into insight they can act on. For example, Pick n Pay's Smart Shopper data might reveal that customers who buy nappies on a Friday evening also tend to buy snacks — so the shop places those products near each other and increases sales. Nobody told the computer to look for that link; the pattern was mined out of the data.

Process

1. Extract relevant data — use SQL to pull only the required subset
2. Look for patterns — analyse for trends, correlations, anomalies
3. Discover knowledge — turn patterns into actionable insights

Applications

• Marketing: target campaigns based on customer age, interests, behaviour
• Healthcare: predict patient risk factors from historical data
• Government: determine social grant thresholds
• Social media: Facebook mines your likes to suggest friends and content

Caring for Data

Caring for data means protecting the accuracy, security and availability of an organisation's data throughout its life. Data is one of the most valuable assets a company owns — often worth more than its buildings or equipment — because decisions, money and reputations all depend on it. Poor data leads to poor decisions, and lost data can shut a business down completely.

Below are the main ways an organisation looks after its data. Notice how each one protects against a different danger — wrong data, lost data, or stolen data.

• Validation — ensure entered data meets rules (format, range, type)
• Verification — ensure data is correct and intentional (double entry, confirmation)
• Logging — audit trail recording who changed what and when
• Access control — passwords, user rights, encryption
• Parallel data sets — duplicate copies in separate locations for disaster recovery

Relational Databases & Normalisation Grade 12

A relational database stores data in structured tables linked together. Normalisation is the process of cleaning up a database design to remove repetition and prevent errors.

What is a Relational Database?

A relational database stores data in tables (also called relations). Each table represents one type of thing — for example, a table for students, a separate table for subjects. Tables are then linked together using key fields.

Key Fields

Referential Integrity

Referential integrity is a rule that ensures relationships between tables remain consistent. It means: a foreign key value must always match an existing primary key value in the related table.

Entity Relationship Diagram (ERD)

An ERD is a diagram that shows the entities (tables) in a database and the relationships between them. Each box is a table; the line between boxes shows how they relate. You are often asked to draw one in the exam, so practise the crow's-foot notation below.

The relationship is created by putting the primary key of the "one" table into the "many" table as a foreign key (here BookID links tblBooks to tblLoans).

Types of Relationships

Physical vs Logical Integrity

Database Anomalies

When a database is poorly designed (not normalised), three types of errors can occur when working with data:

Normalisation — The Three Normal Forms

Normalisation is the systematic process of organising the fields and tables of a relational database, by applying a set of rules called normal forms, in order to reduce data redundancy and prevent insertion, deletion and modification anomalies.

First Normal Form (1NF)

A table is in 1NF when:

• Every cell contains a single value (no lists of values in one cell)
• There are no repeating groups of columns
• Every record is unique (has a primary key)

Not in 1NF:

❌ Problem: Three values in one cell (Subjects column)

In 1NF:

Second Normal Form (2NF)

A table is in 2NF when it is in 1NF AND every non-key field depends on the whole primary key (not just part of it). This only matters when the primary key is a composite key.

Example violation:

❌ Problem: StudentName only depends on StudentID, not on (StudentID + SubjectID) together

In 2NF — split the table:

Third Normal Form (3NF)

A table is in 3NF when it is in 2NF AND no non-key field depends on another non-key field (no transitive dependency).

Example violation:

❌ Problem: GradeDescription depends on GradeLevel (a non-key field), not on StudentID

In 3NF — split it:

Quick Normalisation Checklist

Good Database Characteristics

Hardware & Performance Grade 12

Mobile device hardware, factors that affect computer performance, and choosing the right system for a user's needs.

Mobile Technology Hardware

Smartphones have similar hardware to desktops but in miniaturised form. Key differences:

Mobile Constraints

• Battery life: limited capacity must last the whole day; processing power directly affects battery drain
• Form factor: miniaturised components mean less cooling and tighter power limits
• Screen size: limited display area affects usability for complex tasks
• Input limitations: touchscreen less precise than physical keyboard/mouse for complex input

Factors Influencing Computer Performance

HDD vs SSD — Summary

Motivating a Computer System for a User

When recommending a computer, match the components to the user's needs:

Cloud Computing, AI, VR & AR Grade 12

Grade 12 Term 2 theory: cloud computing, Artificial Intelligence, Virtual Reality, Augmented Reality, Mixed Reality and virtualisation — all new Software topics in the updated CAPS.

Artificial Intelligence (AI)

AI refers to computer systems that can perform tasks that normally require human intelligence — such as learning, reasoning, decision-making and pattern recognition.

What is AI used for?

• Virtual assistants (Siri, Google Assistant, Alexa)
• Recommendations (Netflix, Spotify, YouTube suggest content)
• Fraud detection in banking
• Medical diagnosis support
• Autonomous vehicles (self-driving cars)
• Chatbots for customer service
• Image and facial recognition

Advantages of AI

• Processes vast amounts of data faster than humans
• Works 24/7 without breaks or fatigue
• Reduces human error in repetitive tasks
• Enables automation of complex processes

Disadvantages and Limitations of AI

• Can be biased if trained on biased data
• Job displacement — automating roles previously done by humans
• No true understanding or common sense — only pattern matching
• Security risks — AI can be used to create deepfakes or power cyberattacks
• Expensive to develop and maintain
• Privacy concerns with data collection required for AI training

Cloud Computing

Software, storage and computing power delivered as a service over the Internet, rather than installed locally.

SaaS — Software as a Service

Applications accessed via browser with no local installation. Examples: Google Docs, Microsoft 365, Gmail.

Effect on Hardware

Cloud reduces the need for powerful local hardware — thin clients and low-spec devices can run complex software via the cloud. Businesses no longer need to buy expensive servers.

Virtualisation

Running multiple virtual machines on a single physical computer. Each VM has its own OS, RAM, storage and apps, isolated from others.

Benefits

• Cost savings — fewer physical servers needed
• Test operating systems safely without affecting main computer
• Disaster recovery — VM images can be backed up and restored
• Green IT — fewer machines, less power and cooling

Virtual Reality (VR)

A fully artificial, immersive 3D environment created by software. The user is completely cut off from the real world.

Hardware Requirements for VR

• VR headset (e.g. Meta Quest, PlayStation VR)
• Powerful GPU for real-time 3D rendering
• Motion controllers / tracking sensors
• High-speed processor and sufficient RAM
• Input devices: joysticks, tracking balls, controller wands, data gloves, trackpads, motion trackers and treadmills — used to navigate and interact within the virtual environment
• Output devices: present VR content back to the user through visual (headset display), auditory (headphones) and even haptic (touch/vibration feedback) displays

Limitations of VR

• Software constraints — VR software has limited flexibility beyond what it was originally built to do
• Cannot simulate dynamic environments well — VR struggles to replicate the constantly changing nature of a real classroom or real-world situation
• Potential for addiction and social detachment — excessive VR use can become addictive and reduce real-world social connection because the experience feels artificial but immersive

Augmented Reality (AR)

Overlays computer-generated content on the real world — you still see reality, with digital elements added.

Hardware Requirements for AR

• Battery life sufficient for extended use
• Bluetooth / Wi-Fi connectivity
• Wide field of view for realistic 3D overlay
• On-board storage capacity and an operating system or web browser to run the AR software
• Inputs/outputs such as buttons, eye tracking and an accelerometer, plus a microphone and speakers
• Visual tracking capabilities — so the device knows where to anchor digital objects in the real world

Limitations of AR

• Rendering meaningful, realistic graphics is challenging
• Scaling digital objects to the correct perspective is difficult
• Smartphones have limited storage, processing power and battery

Internet Technologies Grade 12

How the web works under the hood — search technologies, web technologies, online applications, and how data is stored and processed online.

Search Technologies

Static vs Dynamic Websites

Web Technologies

Storing Data Online

• Cookies — small text files stored on the user's device by a website. Remember preferences, login sessions, shopping carts.
• Online databases — data stored on remote servers. Examples: Gmail messages, your social media posts.
• Online applications — programs that run over the internet rather than being installed on your local computer; they store data, execute instructions and present output entirely through the browser or app. Examples: Google Docs, Gmail, internet banking apps.

Running Instructions

HTTP vs HTTPS

Networks & Remote Access Grade 12

Essential network components, internet connection methods, file sharing, and remote access technologies.

Essential Network Hardware

Wired Communication Media

Connecting to the Internet

File and Folder Sharing

On a network, users can share resources. Access can be restricted by permission level:

Remote Access

Accessing a device or network from a physically different location.

Cloud Storage and Sharing

• Store and access files from any device, anywhere
• Automatic backup and version history
• Collaboration: multiple users edit the same file simultaneously
• Examples: Google Drive, OneDrive, Dropbox

BitTorrent (Peer-to-Peer Sharing)

Files are split into small pieces and downloaded simultaneously from many peers.

• Legal uses: distributing Linux distros, large software updates
• Risks: often used for piracy; your IP is visible to all peers

Communication Technologies Grade 12

This page focuses on how data is kept safe as it travels across a network — VPNs, encryption, digital certificates and authentication. For network hardware, internet access technologies and general remote access, see Networks & Remote Access.

VPN — Virtual Private Network

A VPN creates an encrypted tunnel over the Internet, allowing secure remote access to a private network. (See Networks & Remote Access for the armoured-van analogy and a worked example.)

• Hides your IP address and location
• All data is encrypted — safe on public Wi-Fi
• Used by companies for remote workers to securely access internal systems

Encryption & Security

Email & Messaging Security

Cybercrime & Safeguards Grade 12

Types of cybercrime, the people who commit them, their effects on individuals and organisations, and the safeguards used to prevent them.

Computer Criminals

Types of Cybercrime

Effects of Cybercrime

On Individuals

• Financial loss — stolen money or fraudulent accounts opened in your name
• Emotional distress and reputational damage
• Legal complications if identity is used for crimes
• Loss of private data (photos, documents)

On Businesses

• Financial loss from stolen funds, ransom payments, or system recovery
• Loss of competitive advantage if trade secrets are stolen
• Reputational damage and loss of customer trust
• Legal penalties for failing to protect customer data
• Operational downtime while systems are restored

Safeguards Against Cybercrime

SA Legal Context

In South Africa, cybercrime is covered by:

• Cybercrimes Act, 2020: criminalises hacking, ransomware, online fraud, malicious communications
• POPIA (Protection of Personal Information Act): governs how personal data must be collected, stored and protected
• Electronic Communications and Transactions (ECT) Act: regulates e-commerce and online transactions

Social Implications Grade 12

How Big Data, data warehousing, globalisation and the 4IR affect society — privacy, employment, social media and the evolution of the web.

Social Implications of Big Data & Data Mining

Big Data is the term for datasets so enormous, fast-moving and varied that ordinary database tools cannot store or process them — think of every Facebook post, every WhatsApp message and every e-toll swipe in the country, all at once. When companies and governments mine this Big Data, the results affect real people's lives, and that brings both wonderful benefits and serious dangers.

Why Should We Care?

The same data that lets a hospital predict and prevent illness can also let an insurance company refuse you cover because your shopping habits suggest you eat unhealthily. The technology is neutral — it is how the data is used that creates the social problem. As IT students you must be able to argue both sides.

Globalisation and the 4IR

Decision-making & Knowledge Systems

As the amount of data in the world explodes, organisations increasingly rely on software not just to store data, but to help people make decisions with it. Two related kinds of system come up in the exam, and they are easy to confuse.

Computer Management (Gr 12)

Key factors affecting computer performance and maintenance:

• Software: outdated software causes security risks and slower performance
• Security: antivirus, firewall, strong passwords
• Housekeeping: disk cleanup, defragmentation, archiving, compression
• Hard drive space: insufficient space causes performance issues (virtual memory relies on it)
• Corrupt files: use Disk Check (chkdsk) to detect and fix file-system errors; use S.M.A.R.T. to monitor drive health and predict failure before it happens

Distributed Computing Power — Solving Global Problems

Some problems are too big for any single computer — modelling climate change, searching for new medicines, or analysing astronomical data. Distributed computing splits one enormous task into many small pieces and shares them across thousands of computers (or cloud servers) that work on them at the same time, then combines the results.

• How it helps: harnesses spare processing power worldwide to tackle scientific and humanitarian problems no single organisation could afford alone.
• Examples: volunteer/grid projects where the public donate idle CPU time to disease, climate or space research; large cloud platforms renting out combined power on demand.
• Trade-offs: needs reliable network connectivity, raises questions about who controls the data, and the combined energy use can be significant.

Evolution of Social Media and its Effects

• Information overload: constant exposure to content makes it hard to focus or verify facts
• Personal data exposure: users voluntarily share location, habits, preferences
• Social engineering: attackers use social platforms to manipulate users into revealing information
• Wikis: collaborative knowledge (e.g. Wikipedia) — useful but reliability varies
• Cultural effects: global connectivity promotes exchange but can dilute local traditions

Privacy and Information Sharing

Protecting Your Online Identity

• Use strong, unique passwords for every account
• Enable Two-Factor Authentication (2FA)
• Avoid posting sensitive personal information publicly
• Verify links before clicking — beware of phishing
• Keep software and antivirus updated
• Only connect to trusted Wi-Fi networks
• Periodically search your own name to see your digital footprint

Grade 12 — Year Planner Grade 12

Based on the 2026 IT CAPS. Grade 12 introduces SQL (Term 1), OOP & 2D arrays (Term 2). Paper 2 is cumulative across all Grades 10–12.

Exam Extras Out-of-CAPS

These topics are not explicitly required by CAPS but have appeared in NSC past papers (2015–2024). Knowing them can mean the difference between a pass and a distinction.

The Software Development Process

CAPS never teaches "how to plan a whole program" as one topic — instead it hands you the individual planning tools (IPO tables, TOE charts, pseudocode) at different points across Grade 10 and 11. Strung together in order, those tools form a complete process for turning a vague idea into a finished, working program. None of this is examinable on its own, but following it will make your PAT — and any open-ended practical question — far less overwhelming.

1. Pin down exactly what the program must do. A one-line description ("a till program") is not enough to start coding from — write out every input the program will receive, every calculation or decision it must make, and every output it must produce. This is the same information an IPO table asks for (Grade 10 T1, Algorithms & Problem Solving), just applied to the whole program instead of one calculation.
2. Sketch the interface before placing a single component. Decide which forms the user will see, what components sit on each one, and how the user moves between them. Keep the same layout, colours and button placement on every form — a program that looks different from screen to screen feels unfinished even when the code is solid.
3. Map out which event triggers which task. For every button, checkbox or form event, list precisely what must happen when it fires — this is exactly what a TOE (Task–Object–Event) chart is for (also covered on the Algorithms & Problem Solving page). Doing this before writing code stops the common mistake of half-remembering what a button was supposed to do halfway through typing its handler.
4. Break the plan into procedures and functions before typing the body of any of them. Decide which pieces of logic will repeat, which need a return value and which don't, and what needs to pass between them as parameters — this is where the Procedures & Functions (Grade 11 T2) content and the local-vs-global variable rules on that page earn their keep.
5. Write the code in small, testable pieces rather than the whole program at once — build and run after every procedure or two so that when something breaks, you know it's in the last few lines you typed, not buried somewhere in 200 lines you haven't tested yet.
6. Test with data designed to break it, not just data that works. Run the program with an empty text box, a negative number, the largest and smallest values it should accept, and anything else a careless user might type — this is the mindset behind the Input Validation content (Grade 10 T2). Where something goes wrong before you can even see the output, Delphi's debugger (breakpoints, F8 stepping, the Watch List — see Data Types & Variables) will show you exactly which line is responsible.

Practical Extras — Paper 1 (Delphi)

These Delphi functions, components and techniques are not listed in CAPS but appear regularly in exam questions or are needed to solve exam problems efficiently.

Theory Extras — Paper 2

These theory topics have appeared in NSC Theory papers but sit at the edge of or outside the formal CAPS scope. They typically appear in social implications or "current technology" questions.

Complete Delphi Functions Quick Reference

A comprehensive reference of all Delphi functions you need to know — both CAPS-required and commonly appearing in exams.

String Functions

Math Functions

Type Conversion Functions

Past Paper Patterns & Tips

Paper 1 (Practical) — What Always Appears

Paper 2 (Theory) — What Always Appears

General Exam Advice