English:Databases and Structured Querying
Databases and Structured Querying
Introduction
A database is an organized collection of data that can be stored, searched, connected, updated, and checked efficiently. Databases are behind many everyday systems: school libraries, online shops, transport apps, games, hospitals, streaming services, sports statistics, and social networks. In this aiMOOC, you will learn how relational databases organize information in tables and how Structured Query Language (SQL) lets you ask precise questions about that information.
This course is designed for Grades 9–10. You do not need previous database experience. You should already be comfortable with simple tables, logical comparisons such as greater than or equal to, and basic computer use. You will move from reading tables to designing a small database, writing SQL queries, connecting related tables, and thinking critically about data quality, privacy, and security.
By the end, you should be able to explain why structured data matters, identify rows and columns, choose useful keys, model relationships, read and write introductory SQL, interpret query results, and design a small relational database for a realistic problem.
The image above represents the relational model: data is organized into tables whose rows describe individual records and whose columns describe attributes. As you work through the course, return to this idea often: a good database separates information into useful structures while preserving meaningful connections.
The following CS50 lecture introduces tables, databases, SQLite, SELECT, WHERE, ORDER BY, and aggregate functions. For a Grades 9–10 course, your teacher may select shorter sections rather than assign the whole lecture at once.
Learning Goals
After completing this aiMOOC, you can:
- Explain databases: Describe how a database differs from an ordinary document or spreadsheet and explain the role of a database management system.
- Interpret relational tables: Identify tables, rows, columns, records, fields, data types, primary keys, and foreign keys.
- Model information: Turn a real-world situation into entities, attributes, relationships, and a simple schema.
- Write structured queries: Use SELECT, FROM, WHERE, ORDER BY, LIMIT, DISTINCT, and basic aggregate functions.
- Combine related data: Explain why joins are needed and read or write a simple INNER JOIN.
- Protect data quality: Use ideas such as unique identifiers, required values, valid types, and referential integrity.
- Use data responsibly: Distinguish useful data collection from unnecessary collection and follow permission, privacy, and security rules.
What Is a Database?
Data are recorded facts or measurements. A person's name, a book title, a temperature reading, a bus arrival time, or a game score can all be data. A database stores related data in an organized way so that software can retrieve and change it systematically.
A database management system or DBMS is software that manages databases. It handles tasks such as storing data, finding records, applying rules, controlling access, and coordinating updates. Examples of relational database systems include SQLite, PostgreSQL, MySQL, MariaDB, Microsoft SQL Server, and Oracle Database. Their SQL dialects differ in some details, but the core ideas in this course transfer between systems.
A database is especially useful when data grows, when many records must be searched, when different pieces of information are connected, or when multiple users need reliable access. A spreadsheet is excellent for many small calculations and lists, but a relational database is designed to manage structured relationships and repeated queries at larger or more complex scales.
Tables, Rows, and Columns
A table stores data about one general kind of thing. For example, a school database might have one table for students and another for clubs.
A row represents one record. In a Students table, one row might represent one student. A column represents one attribute or field, such as StudentID, Name, GradeLevel, or ClubID.
| StudentID | Name | GradeLevel | ClubID |
|---|---|---|---|
| 101 | Amira | 9 | 2 |
| 102 | Leo | 10 | 1 |
| 103 | Priya | 9 | 2 |
| 104 | Mateo | 10 | 3 |
A table should have a clear purpose. Mixing unrelated facts into one large table often creates repetition and confusion. Good database design tries to store each fact in an appropriate place.
Fields and Data Types
A database usually gives each column a data type. A type tells the DBMS what kind of value belongs in that column. Common ideas include text, integers, decimal numbers, dates, and Boolean values such as true or false.
Types matter because they help the database interpret, validate, sort, and compare values. A numeric column can be ordered mathematically; a date column can be compared chronologically. If every value is stored as free-form text, mistakes become harder to detect.
Consider these fields in a library database:
- BookID: An integer identifier such as 501.
- Title: Text such as The Hobbit.
- PublishedDate: A date value.
- Available: A true or false value indicating whether a copy can currently be borrowed.
Different database systems provide different exact type names. The important idea at this level is to choose a type that matches the meaning of the data.
Database, Spreadsheet, or Plain File?
The best tool depends on the task. A plain text file may be enough for a short note. A spreadsheet is useful for calculations, charts, and small tables that people edit directly. A database becomes especially useful when the structure is stable, relationships matter, queries repeat, or consistency rules must be enforced.
Imagine a school library with thousands of books and hundreds of borrowers. A spreadsheet could list everything, but repeated borrower details would appear many times. A relational database can store borrowers separately from loans and connect them using keys. That reduces repeated data and makes questions such as "Which books are currently borrowed by Grade 10 students?" much easier to express.
The Relational Model
A relational database stores data in relations, commonly presented as tables. The word "relational" does not simply mean "things are related." It refers to a mathematical model in which tables represent relations and operations can derive new result sets from stored data.
For school-level work, focus on three practical ideas:
- Tables: Each table represents one main type of entity or relationship.
- Keys: Keys identify records and connect tables.
- Queries: SQL describes what data you want the DBMS to return or change.
Primary Keys
A primary key is a column, or sometimes a combination of columns, chosen to identify each row uniquely. A good primary key does not repeat within its table.
In the Students table, StudentID can be a primary key. Two students might share the same name, but they should not share the same StudentID. This is why names, birthdays, or room numbers are often poor identifiers: they can repeat or change.
A primary key supports two important goals: uniqueness and stable reference. Other tables can point to a row through that key.
Foreign Keys and Relationships
A foreign key is a column whose values refer to a key in another table. Foreign keys create connections between tables.
Suppose the Clubs table is:
| ClubID | ClubName | Room |
|---|---|---|
| 1 | Robotics | Lab A |
| 2 | Eco Club | Room 204 |
| 3 | Debate | Room 118 |
The ClubID column in Students can refer to ClubID in Clubs. Student 101 has ClubID 2, so Amira belongs to Eco Club. Storing the club name only once in the Clubs table avoids repeating "Eco Club" in every student record. If the meeting room changes, one club record can be updated instead of many student rows.
The diagram above is an example of an entity-relationship design. An entity-relationship diagram or ER diagram helps you visualize entities, their attributes, and their relationships before creating tables.
One-to-One, One-to-Many, and Many-to-Many
A one-to-one relationship means one row in one table corresponds to at most one row in another. A one-to-many relationship means one record can connect to many records in another table. For example, one club can have many students.
A many-to-many relationship means many records on each side can connect. Students can enroll in many courses, and each course can have many students. Relational databases usually represent this using a third table, sometimes called a junction table. A StudentCourses table could contain StudentID and CourseID, with one row for each enrollment.
This design is powerful because it represents the relationship directly rather than adding a growing list of course columns to every student.
The next video explains relationships, ER diagrams, keys, subqueries, joins, sets, and groups.
Designing a Small Database
Database design begins before SQL. First decide what information the system needs, what real-world things the information describes, and how those things relate.
Imagine you are designing a database for a school library. Possible entities include Books, Authors, Students, and Loans. Each entity needs useful attributes.
A first draft might look like this:
| Entity | Possible attributes | Possible key |
|---|---|---|
| Books | Title, PublicationYear, ShelfCode | BookID |
| Students | Name, GradeLevel | StudentID |
| Loans | BorrowedDate, DueDate, ReturnedDate | LoanID |
The Loans table can also contain BookID and StudentID as foreign keys. That lets one query connect a loan to both the book and the borrower.
From Real-World Rules to a Schema
A schema describes the structure of a database: its tables, columns, types, keys, and relationships. Before building the schema, write simple rules in everyday language.
For the library example:
- A book copy: Each book copy has one BookID.
- A student: Each student has one StudentID.
- A loan: Each loan refers to one student and one book copy.
- A due date: Every active loan has a due date.
- A return: ReturnedDate may be empty until the book is returned.
These rules can be translated into table definitions and constraints.
Reducing Repetition Through Normalization
Normalization is a family of design principles used to reduce unnecessary repetition and certain update problems. At this level, you do not need to memorize every formal normal form. Instead, learn to notice repeated groups and facts stored in the wrong place.
Suppose a Loans table stores StudentID, StudentName, StudentEmail, BookID, BookTitle, and DueDate in every loan row. If one student borrows ten books, the student's name and email appear ten times. If the email changes, multiple rows must be updated. Missing one row creates inconsistent data.
A better design stores student details in Students, book details in Books, and loan-specific facts in Loans. Loans keeps only the keys needed to connect those tables plus dates that describe the loan itself.
This does not mean "never repeat any value." Repetition can be legitimate. The goal is to avoid storing the same independent fact in many places when one authoritative location would be clearer.
Seeing a Large Real Schema
Real production databases can contain many tables and relationships. The following MediaWiki schema image is far more complex than the database you need to build in Grades 9–10. Use it to notice scale: the same ideas of tables, columns, keys, and relationships can grow into a large information system.
The next CS50 lecture focuses on database design, normalization, CREATE TABLE, data types, and constraints.
Structured Query Language
SQL is a language for working with relational databases. SQL statements can define structures, retrieve data, insert records, update values, and delete records. This course emphasizes querying because it gives you a safe way to learn the logic of structured data.
SQL keywords are often written in uppercase for readability, although many systems accept lowercase keywords too. Table and column names depend on the schema.
The SELECT Statement
The basic shape of a query is:
SELECT column_name FROM table_name;
To retrieve student names:
SELECT Name FROM Students;
To retrieve more than one column:
SELECT Name, GradeLevel FROM Students;
The asterisk can request all columns:
SELECT * FROM Students;
For learning and quick inspection, SELECT * is convenient. In larger applications, selecting only the columns you need is often clearer and can reduce unnecessary data transfer.
Filtering with WHERE
A WHERE clause keeps only rows that satisfy a condition.
SELECT Name, GradeLevel FROM Students WHERE GradeLevel = 9;
Common comparison operators include =, <, >, <=, >=, and <>. Some systems also support != for "not equal." Text values are usually written inside single quotation marks.
SELECT ClubName FROM Clubs WHERE Room = 'Lab A';
You can combine conditions with AND and OR:
SELECT Name FROM Students WHERE GradeLevel = 10 AND ClubID = 3;
Parentheses can make mixed AND and OR logic clearer. Always read the condition as a logical statement before running it.
Sorting, Limiting, and Removing Duplicates
ORDER BY sorts query results.
SELECT Name, GradeLevel FROM Students ORDER BY Name;
DESC requests descending order:
SELECT Name, GradeLevel FROM Students ORDER BY GradeLevel DESC;
LIMIT can restrict the number of returned rows in systems such as SQLite, PostgreSQL, and MySQL:
SELECT Name FROM Students ORDER BY Name LIMIT 3;
DISTINCT removes duplicate result values:
SELECT DISTINCT GradeLevel FROM Students;
Remember that a query result is not automatically a permanent new table. It is a result set produced from the stored data.
Working with Missing Values
SQL uses NULL to represent a missing or unknown value. NULL is not the same as zero and not the same as an empty text string.
You normally test for NULL using IS NULL or IS NOT NULL:
SELECT LoanID FROM Loans WHERE ReturnedDate IS NULL;
That query can identify loans without a recorded return date. Writing ReturnedDate = NULL does not express the intended comparison in standard SQL logic.
Pattern Matching with LIKE
LIKE can match text patterns. In many SQL systems, the percent sign represents any sequence of characters.
SELECT Name FROM Students WHERE Name LIKE 'A%';
This searches for names beginning with A. The exact behavior of letter case can depend on the database system and settings, so test your environment rather than assuming every SQL engine behaves identically.
Aggregating Data
An aggregate function combines values from multiple rows into a summary. Common examples include COUNT, SUM, AVG, MIN, and MAX.
To count students:
SELECT COUNT(*) FROM Students;
To find the average value in a numeric Score column:
SELECT AVG(Score) FROM Results;
GROUP BY can calculate summaries for categories:
SELECT GradeLevel, COUNT(*) FROM Students GROUP BY GradeLevel;
This returns one row per grade level with a count for each group.
A HAVING clause can filter groups after aggregation, while WHERE filters individual rows before grouping. That distinction becomes important in more advanced queries.
Joining Tables
A join combines rows from related tables. Joins are necessary because good database design often stores different kinds of facts in separate tables.
Suppose Students contains ClubID and Clubs contains ClubID and ClubName. An INNER JOIN can connect them:
SELECT Students.Name, Clubs.ClubName FROM Students INNER JOIN Clubs ON Students.ClubID = Clubs.ClubID;
Read this query in steps:
- SELECT: Return the student's name and the club's name.
- FROM: Start with Students.
- JOIN: Connect the Clubs table.
- ON: Match rows whose ClubID values are equal.
The output might contain Amira with Eco Club, Leo with Robotics, Priya with Eco Club, and Mateo with Debate.
The diagram above compares several SQL join ideas using sets. At this level, master INNER JOIN first. A LEFT JOIN is a useful next step because it can keep every row from the left table even when no matching row exists on the right.
Why Joins Matter
Without joins, you might copy club names into the Students table. That seems easy at first, but copied values can become inconsistent. A join allows the database to store the relationship once through a key and assemble readable information when needed.
A join is also a reasoning task. Before writing SQL, ask:
- Which entities: Which tables contain the facts I need?
- Which key: What column connects the tables?
- Which output: Which columns should appear in the result?
- Which conditions: Do I need only some rows?
If you cannot answer these questions in words, the SQL is likely to be confusing.
Creating and Changing Data
SQL can also define tables and change stored data. These commands are powerful, so practice them only in a teacher-approved sandbox database.
A simple table definition might look like:
CREATE TABLE Clubs (
ClubID INTEGER PRIMARY KEY,
ClubName TEXT NOT NULL,
Room TEXT
);
INSERT adds a row:
INSERT INTO Clubs (ClubID, ClubName, Room) VALUES (4, 'Chess', 'Room 110');
UPDATE changes existing rows:
UPDATE Clubs SET Room = 'Room 112' WHERE ClubID = 4;
DELETE removes rows:
DELETE FROM Clubs WHERE ClubID = 4;
The WHERE clause is especially important in UPDATE and DELETE. Without an appropriate WHERE condition, many or all rows may be changed. In a learning environment, make backups or work with disposable practice data.
Constraints and Data Integrity
Data integrity means data remains accurate, consistent, and valid enough for its intended use. A database can enforce rules called constraints.
Useful constraint ideas include:
- PRIMARY KEY: Identifies rows uniquely.
- NOT NULL: Requires a value in a column.
- UNIQUE: Prevents duplicate values where duplicates are not allowed.
- FOREIGN KEY: Links a value to an existing row in another table when referential integrity is enforced.
- CHECK: Requires values to satisfy a condition in systems that support the rule.
Constraints do not guarantee that every fact is true. A database cannot automatically know whether a student typed the wrong birth date if the value still looks like a valid date. Good data quality also depends on careful collection, clear definitions, validation, and review.
Query Results and Evidence
A query result is evidence produced by applying rules to stored data. To interpret it well, check the schema, the query, the dataset, and the meaning of missing values.
For example, a query that counts "active club members" is only meaningful if the database defines what active means. Does a missing end date mean active? Does every membership have a status field? Database questions are partly technical and partly about definitions.
When presenting query results, include enough context that another person can understand what was counted, filtered, grouped, or joined. Do not treat a number as self-explanatory.
Debugging SQL
Errors are normal when learning SQL. Debugging means finding the reason a query does not work or does not return the intended result.
A useful process is:
- Check syntax: Look for missing commas, quotation marks, keywords, or semicolons.
- Check names: Verify table and column names against the schema.
- Check types: Make sure comparisons use suitable values.
- Check conditions: Read WHERE logic in plain English.
- Check joins: Confirm that the ON clause connects matching keys.
- Test small: Run a simpler SELECT first, then add one clause at a time.
Consider this incorrect query:
SELECT Name GradeLevel FROM Student WHERE GradeLevel = 'nine'
Possible problems include a missing comma, a table name that may not match the schema, and a value whose type may not match the GradeLevel column. Good debugging does not guess blindly; it checks each assumption against the database design.
Database Security, Privacy, and Ethics
Database skills come with responsibility. You should query or change only data and systems you have permission to use. A classroom database should contain safe practice data or properly authorized information.
Privacy asks whether personal data should be collected, who may use it, how long it should be kept, and whether people understand the purpose. Security focuses on protecting data and systems from unauthorized access, alteration, or loss. Ethics asks broader questions about fairness, necessity, consequences, and power.
For a student project, collect the minimum data needed. If you are tracking library books, you probably do not need students' home addresses. If you conduct a survey, explain how the data will be used and follow your school's rules.
Passwords should not be stored as ordinary readable text in a real authentication system. Professional systems use carefully designed password-hashing practices and access controls. You do not need to implement authentication in this introductory course, but you should recognize that storing sensitive information safely requires specialized security knowledge.
SQL Injection as a Security Idea
SQL injection is a class of vulnerability that can occur when an application treats untrusted input as part of an SQL command instead of as data. The safe design principle is to keep user input separate from SQL structure by using parameterized queries or prepared statements in application code.
This course does not ask you to attack systems. Learn the defensive lesson: never test security weaknesses on a system without explicit authorization, and do not build SQL commands by blindly combining raw user input with query text.
A Guided Mini-Project: School Clubs Database
You will now connect the main ideas in one small model. Imagine a school wants to record students, clubs, and memberships. Because one student can join several clubs and one club can have several students, the relationship is many-to-many.
Use three tables:
| Table | Key | Important fields |
|---|---|---|
| Students | StudentID | Name, GradeLevel |
| Clubs | ClubID | ClubName, Room |
| Memberships | MembershipID | StudentID, ClubID, JoinedDate |
Memberships is the junction table. StudentID and ClubID act as foreign keys. A row such as StudentID 101 and ClubID 2 means that student 101 belongs to club 2.
Guided Query One: Find Grade 9 Students
SELECT StudentID, Name FROM Students WHERE GradeLevel = 9 ORDER BY Name;
Before running it, predict the result. Then compare your prediction with the actual output. If they differ, inspect both the data and your assumptions.
Guided Query Two: Count Members in Each Club
A join plus grouping can count memberships by club:
SELECT Clubs.ClubName, COUNT(*) AS MemberCount FROM Memberships INNER JOIN Clubs ON Memberships.ClubID = Clubs.ClubID GROUP BY Clubs.ClubName ORDER BY MemberCount DESC;
The alias MemberCount gives the calculated column a readable name. This query demonstrates an important idea: a database can combine stored facts to create new summaries without storing those summaries as permanent duplicated data.
Guided Query Three: Find a Student's Clubs
SELECT Students.Name, Clubs.ClubName FROM Memberships INNER JOIN Students ON Memberships.StudentID = Students.StudentID INNER JOIN Clubs ON Memberships.ClubID = Clubs.ClubID WHERE Students.Name = 'Amira';
This query joins three tables. Do not memorize it as a block. Trace the path: Memberships connects StudentID to Students and ClubID to Clubs. The WHERE clause then selects one student's rows.
From Small Models to Real Systems
Real database work adds many topics: indexes for faster lookup, transactions for reliable groups of changes, views for reusable queries, permissions for access control, backups for recovery, and application code that communicates with the database.
At Grades 9–10, the goal is not to master every feature. The goal is to build a strong mental model: structured data lives in a schema; keys create reliable connections; queries express questions; and results must be interpreted in context.
The following full university-level course is optional enrichment. Use chapters selectively if you want to continue beyond this aiMOOC.
Interactive Tasks
Quiz: Test Your Knowledge
What is the main purpose of a primary key in a table? (To identify each row uniquely) (!To sort every query automatically) (!To store only text values) (!To hide the table from users)
Which SQL clause filters rows according to a condition? (WHERE) (!ORDER BY) (!FROM) (!CREATE)
What does one row in a well-designed Students table usually represent? (One student record) (!One database server) (!One SQL language) (!One column name)
What is a foreign key used for? (To connect a row to related data in another table) (!To encrypt every value in a table) (!To rename all columns automatically) (!To replace every primary key)
Which statement retrieves the Name column from the Students table? (SELECT Name FROM Students) (!WHERE Name FROM Students) (!SELECT Students INTO Name) (!ORDER Name BY Students)
What does ORDER BY do in a query? (It sorts the result) (!It deletes duplicate tables) (!It creates a new database) (!It changes a primary key)
Which expression correctly checks for a missing SQL value? (IS NULL) (!EQUALS NULL) (!LIKE EMPTY) (!IS ZERO)
Why is a junction table useful? (It can represent a many to many relationship) (!It converts every number to text) (!It removes the need for keys) (!It stores only one row)
Which function is commonly used to count rows? (COUNT) (!SORT) (!MATCH) (!NUMBER)
What is the safest rule for classroom database practice? (Use only data and systems you are authorized to use) (!Test public systems without permission) (!Store real passwords as readable text) (!Collect as much personal data as possible)
Memory Game
| Table | A structured set of related rows and columns |
| Record | One complete row describing an instance |
| Column | A named attribute stored for many records |
| Primary key | A value chosen to identify each row uniquely |
| Foreign key | A field that refers to a related row in another table |
| Query | A structured request for data or a database action |
Drag and Drop
| Match the correct terms. | Topic |
|---|---|
| SELECT | Chooses the columns or expressions to return |
| FROM | Names the source table |
| WHERE | Filters rows using a condition |
| ORDER BY | Sorts a query result |
| JOIN | Combines related rows from tables |
...
Crossword Puzzle
| Schema | What word names the planned structure of tables, columns, keys, and relationships? |
| Query | What word means a structured request sent to a database? |
| Record | What word commonly describes one complete row of stored data? |
| Column | What word describes a vertical field category in a table? |
| Index | What database structure can help speed up certain lookups? |
| Join | What SQL operation combines related rows from tables? |
LearningApps
Cloze Text
Open-Ended Tasks
Easy
- Database Detective: Identify three databases you interact with during an ordinary week, describe what data each one might store, and explain why a database is more suitable than a plain text file for each case.
- Paper Table Model: Create two small paper tables for Students and Clubs with at least four sample records, underline the primary keys, circle the foreign key, and explain one relationship in two or three sentences.
- Query Translation: Write five everyday questions about the sample Students table and translate each question into a SELECT query using at least one of WHERE, ORDER BY, DISTINCT, or LIMIT.
- Data Ethics Poster: Design a one-page image or poster showing the difference between useful data collection and unnecessary personal data collection in a school project.
Standard
- Mini Library Schema: Design a three-table database for Books, Students, and Loans, choose primary and foreign keys, and create an ER diagram that another learner can understand without explanation.
- SQL Practice Lab: In a teacher-approved SQLite practice database, create sample data and run at least eight read-only queries that demonstrate filtering, sorting, counting, grouping, and one join; annotate what each query is meant to answer.
- Interview a Data User: Interview a librarian, teacher, coach, office worker, or another person who regularly works with structured information; ask how they search, update, validate, and protect data, then summarize the interview in a short report.
- ER Diagram Video: Record a two- to four-minute explanatory video in which you walk through an ER diagram, identify its entities and keys, and explain one one-to-many or many-to-many relationship.
Advanced
- Normalization Challenge: Start with one deliberately repetitive table that mixes students, clubs, rooms, and membership dates; redesign it into several related tables and write a before-and-after explanation of which update problems your design reduces.
- Query Performance Experiment: Create a teacher-approved SQLite table with a sufficiently large set of generated non-personal records, compare the execution plan or observed timing of selected lookups before and after adding a suitable index, and explain why small datasets may not show a clear difference.
- Community Data Audit: Visit a library, school office, museum, sports club, or other approved place that manages structured information; document which fields seem essential, which could be sensitive, and how a carefully designed schema could support the work without collecting unnecessary data.
- Database Capstone: Build a small relational database for a realistic problem such as equipment loans, club memberships, garden observations, or media collections; submit the schema, ER diagram, sample data, at least ten useful queries, a short demonstration video, and a reflection on privacy and data quality.
Learning Assessment
- Schema Reasoning Assessment: Given a single table that repeats author and publisher information for many books, identify at least two risks of the design and propose a clearer set of related tables with keys.
- Query Construction Assessment: Given a new dataset and five natural-language questions, write SQL queries that answer them and explain how each clause changes the result.
- Join Explanation Assessment: Use two related tables to predict the result of an INNER JOIN before running it, then compare your prediction with the output and explain any difference.
- Data Quality Assessment: Review a sample dataset containing duplicates, missing values, inconsistent spellings, and impossible values; classify the problems and recommend database rules or collection practices that could reduce them.
- Privacy Transfer Assessment: Compare two database proposals for a school event app, decide which fields are necessary and which are excessive, and justify your decision using privacy and data-minimization principles.
- Database Design Transfer Assessment: Choose a new domain not used in the course, such as sports fixtures or science experiments, and produce a schema that includes at least three entities, a meaningful relationship, primary keys, foreign keys, and two example queries.
Evidence of Learning
Strong evidence of learning includes both what you know and what you can create or explain.
Knowledge evidence includes accurate explanations of tables, rows, columns, data types, schemas, keys, relationships, SQL clauses, joins, NULL, aggregation, constraints, privacy, and data integrity.
Skill evidence includes turning a real-world problem into entities and relationships, choosing sensible keys, reading an ER diagram, writing and debugging introductory SQL, predicting query results, and explaining how a join connects tables.
Product evidence can include a working practice database, a schema diagram, a set of documented queries, a data-quality audit, an interview report, a poster, a short tutorial video, or a capstone project.
Transfer evidence means you can apply the same ideas to a new context. For example, you can recognize that a sports league, museum collection, laboratory log, or equipment-loan system can also be modeled using entities, keys, relationships, and queries.
Responsible-use evidence includes working only with authorized systems, minimizing personal data, explaining how privacy affects design choices, and recognizing why real authentication and security systems require stronger safeguards than a classroom project.
OERs on the Topic
The English Wikipedia article on databases provides an open reference for extending your understanding of database concepts, models, and systems.
You can also use the embedded Wikimedia Commons diagrams in this aiMOOC as visual study aids. When comparing diagrams, ask which entities are represented, how keys are shown, and whether the visual structure helps you understand the relationships.
Linked Learning Areas
The central idea of this course is that structured information becomes more useful when its meaning is modeled clearly. Tables organize records, keys identify and connect them, SQL expresses questions, joins reconstruct related information, constraints support integrity, and responsible design protects people and data.
Related learning areas include Computer science, Information technology, Data literacy, Programming, Statistics, Cybersecurity, Digital citizenship, and Information management. These connections matter because databases are not isolated tools: they support software, research, organizations, and evidence-based decisions.
aiMOOC Projects
MOOCwiki · Deutsch
Nach dem Lernen ist vor dem Lernen
Entdecke direkt den nächsten Lernkurs. Weitere Inhalte erscheinen, wenn Du weiter nach unten scrollst.
Zur MOOCwiki-HauptseiteMediathek
Mediathek
Mediathek wird aus dem Wiki geladen ...
Keine passenden Inhalte gefunden. Bitte ändere Suche oder Filter.